forked from mirrors/gecko-dev
2e45b3450f
Initial implementation for <iframe loading=lazy> Also cleaned up some image lazy loading to be generalised (sharing an intersection observer and some enums/funcs in Element). Unimplemented details: - Window load should not wait for in view lazy loading iframes. Unplanned for this patch and ship for now. (Chromium fail, WebKit pass) We also pass some other WPTs other engines do not too already too. Also added a WPT to ensure using parse-time base URI for lazy -> eager iframes. Differential Revision: https://phabricator.services.mozilla.com/D190662
378 lines
12 KiB
C++
378 lines
12 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "mozilla/dom/DOMIntersectionObserver.h"
|
|
#include "mozilla/dom/HTMLIFrameElement.h"
|
|
#include "mozilla/dom/ContentChild.h"
|
|
#include "mozilla/dom/Document.h"
|
|
#include "mozilla/dom/HTMLIFrameElementBinding.h"
|
|
#include "mozilla/dom/FeaturePolicy.h"
|
|
#include "mozilla/MappedDeclarationsBuilder.h"
|
|
#include "mozilla/NullPrincipal.h"
|
|
#include "mozilla/StaticPrefs_dom.h"
|
|
#include "nsAttrValueInlines.h"
|
|
#include "nsError.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsSandboxFlags.h"
|
|
#include "nsNetUtil.h"
|
|
|
|
NS_IMPL_NS_NEW_HTML_ELEMENT_CHECK_PARSER(IFrame)
|
|
|
|
namespace mozilla::dom {
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(HTMLIFrameElement)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(HTMLIFrameElement,
|
|
nsGenericHTMLFrameElement)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mFeaturePolicy)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSandbox)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(HTMLIFrameElement,
|
|
nsGenericHTMLFrameElement)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mFeaturePolicy)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mSandbox)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
|
|
|
NS_IMPL_ADDREF_INHERITED(HTMLIFrameElement, nsGenericHTMLFrameElement)
|
|
NS_IMPL_RELEASE_INHERITED(HTMLIFrameElement, nsGenericHTMLFrameElement)
|
|
|
|
NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(HTMLIFrameElement)
|
|
NS_INTERFACE_MAP_END_INHERITING(nsGenericHTMLFrameElement)
|
|
|
|
// static
|
|
const DOMTokenListSupportedToken HTMLIFrameElement::sSupportedSandboxTokens[] =
|
|
{
|
|
#define SANDBOX_KEYWORD(string, atom, flags) string,
|
|
#include "IframeSandboxKeywordList.h"
|
|
#undef SANDBOX_KEYWORD
|
|
nullptr};
|
|
|
|
HTMLIFrameElement::HTMLIFrameElement(
|
|
already_AddRefed<mozilla::dom::NodeInfo>&& aNodeInfo,
|
|
FromParser aFromParser)
|
|
: nsGenericHTMLFrameElement(std::move(aNodeInfo), aFromParser) {
|
|
// We always need a featurePolicy, even if not exposed.
|
|
mFeaturePolicy = new mozilla::dom::FeaturePolicy(this);
|
|
nsCOMPtr<nsIPrincipal> origin = GetFeaturePolicyDefaultOrigin();
|
|
MOZ_ASSERT(origin);
|
|
mFeaturePolicy->SetDefaultOrigin(origin);
|
|
}
|
|
|
|
HTMLIFrameElement::~HTMLIFrameElement() = default;
|
|
|
|
NS_IMPL_ELEMENT_CLONE(HTMLIFrameElement)
|
|
|
|
void HTMLIFrameElement::BindToBrowsingContext(BrowsingContext*) {
|
|
RefreshFeaturePolicy(true /* parse the feature policy attribute */);
|
|
}
|
|
|
|
bool HTMLIFrameElement::ParseAttribute(int32_t aNamespaceID, nsAtom* aAttribute,
|
|
const nsAString& aValue,
|
|
nsIPrincipal* aMaybeScriptedPrincipal,
|
|
nsAttrValue& aResult) {
|
|
if (aNamespaceID == kNameSpaceID_None) {
|
|
if (aAttribute == nsGkAtoms::marginwidth) {
|
|
return aResult.ParseNonNegativeIntValue(aValue);
|
|
}
|
|
if (aAttribute == nsGkAtoms::marginheight) {
|
|
return aResult.ParseNonNegativeIntValue(aValue);
|
|
}
|
|
if (aAttribute == nsGkAtoms::width) {
|
|
return aResult.ParseHTMLDimension(aValue);
|
|
}
|
|
if (aAttribute == nsGkAtoms::height) {
|
|
return aResult.ParseHTMLDimension(aValue);
|
|
}
|
|
if (aAttribute == nsGkAtoms::frameborder) {
|
|
return ParseFrameborderValue(aValue, aResult);
|
|
}
|
|
if (aAttribute == nsGkAtoms::scrolling) {
|
|
return ParseScrollingValue(aValue, aResult);
|
|
}
|
|
if (aAttribute == nsGkAtoms::align) {
|
|
return ParseAlignValue(aValue, aResult);
|
|
}
|
|
if (aAttribute == nsGkAtoms::sandbox) {
|
|
aResult.ParseAtomArray(aValue);
|
|
return true;
|
|
}
|
|
if (aAttribute == nsGkAtoms::loading) {
|
|
return ParseLoadingAttribute(aValue, aResult);
|
|
}
|
|
}
|
|
|
|
return nsGenericHTMLFrameElement::ParseAttribute(
|
|
aNamespaceID, aAttribute, aValue, aMaybeScriptedPrincipal, aResult);
|
|
}
|
|
|
|
void HTMLIFrameElement::MapAttributesIntoRule(
|
|
MappedDeclarationsBuilder& aBuilder) {
|
|
// frameborder: 0 | 1 (| NO | YES in quirks mode)
|
|
// If frameborder is 0 or No, set border to 0
|
|
// else leave it as the value set in html.css
|
|
const nsAttrValue* value = aBuilder.GetAttr(nsGkAtoms::frameborder);
|
|
if (value && value->Type() == nsAttrValue::eEnum) {
|
|
auto frameborder = static_cast<FrameBorderProperty>(value->GetEnumValue());
|
|
if (FrameBorderProperty::No == frameborder ||
|
|
FrameBorderProperty::Zero == frameborder) {
|
|
aBuilder.SetPixelValueIfUnset(eCSSProperty_border_top_width, 0.0f);
|
|
aBuilder.SetPixelValueIfUnset(eCSSProperty_border_right_width, 0.0f);
|
|
aBuilder.SetPixelValueIfUnset(eCSSProperty_border_bottom_width, 0.0f);
|
|
aBuilder.SetPixelValueIfUnset(eCSSProperty_border_left_width, 0.0f);
|
|
}
|
|
}
|
|
|
|
nsGenericHTMLElement::MapImageSizeAttributesInto(aBuilder);
|
|
nsGenericHTMLElement::MapImageAlignAttributeInto(aBuilder);
|
|
nsGenericHTMLElement::MapCommonAttributesInto(aBuilder);
|
|
}
|
|
|
|
NS_IMETHODIMP_(bool)
|
|
HTMLIFrameElement::IsAttributeMapped(const nsAtom* aAttribute) const {
|
|
static const MappedAttributeEntry attributes[] = {
|
|
{nsGkAtoms::width},
|
|
{nsGkAtoms::height},
|
|
{nsGkAtoms::frameborder},
|
|
{nullptr},
|
|
};
|
|
|
|
static const MappedAttributeEntry* const map[] = {
|
|
attributes,
|
|
sImageAlignAttributeMap,
|
|
sCommonAttributeMap,
|
|
};
|
|
|
|
return FindAttributeDependence(aAttribute, map);
|
|
}
|
|
|
|
nsMapRuleToAttributesFunc HTMLIFrameElement::GetAttributeMappingFunction()
|
|
const {
|
|
return &MapAttributesIntoRule;
|
|
}
|
|
|
|
void HTMLIFrameElement::AfterSetAttr(int32_t aNameSpaceID, nsAtom* aName,
|
|
const nsAttrValue* aValue,
|
|
const nsAttrValue* aOldValue,
|
|
nsIPrincipal* aMaybeScriptedPrincipal,
|
|
bool aNotify) {
|
|
AfterMaybeChangeAttr(aNameSpaceID, aName, aNotify);
|
|
|
|
if (aNameSpaceID == kNameSpaceID_None) {
|
|
if (aName == nsGkAtoms::loading) {
|
|
if (aValue && Loading(aValue->GetEnumValue()) == Loading::Lazy) {
|
|
SetLazyLoading();
|
|
} else if (aOldValue &&
|
|
Loading(aOldValue->GetEnumValue()) == Loading::Lazy) {
|
|
StopLazyLoading();
|
|
}
|
|
}
|
|
|
|
// If lazy loading and src set, set lazy loading again as we are doing a new
|
|
// load (lazy loading is unset after a load is complete).
|
|
if ((aName == nsGkAtoms::src || aName == nsGkAtoms::srcdoc) &&
|
|
LoadingState() == Loading::Lazy) {
|
|
SetLazyLoading();
|
|
}
|
|
|
|
if (aName == nsGkAtoms::sandbox) {
|
|
if (mFrameLoader) {
|
|
// If we have an nsFrameLoader, apply the new sandbox flags.
|
|
// Since this is called after the setter, the sandbox flags have
|
|
// alreay been updated.
|
|
mFrameLoader->ApplySandboxFlags(GetSandboxFlags());
|
|
}
|
|
}
|
|
|
|
if (aName == nsGkAtoms::allow || aName == nsGkAtoms::src ||
|
|
aName == nsGkAtoms::srcdoc || aName == nsGkAtoms::sandbox) {
|
|
RefreshFeaturePolicy(true /* parse the feature policy attribute */);
|
|
} else if (aName == nsGkAtoms::allowfullscreen) {
|
|
RefreshFeaturePolicy(false /* parse the feature policy attribute */);
|
|
}
|
|
}
|
|
|
|
return nsGenericHTMLFrameElement::AfterSetAttr(
|
|
aNameSpaceID, aName, aValue, aOldValue, aMaybeScriptedPrincipal, aNotify);
|
|
}
|
|
|
|
void HTMLIFrameElement::OnAttrSetButNotChanged(
|
|
int32_t aNamespaceID, nsAtom* aName, const nsAttrValueOrString& aValue,
|
|
bool aNotify) {
|
|
AfterMaybeChangeAttr(aNamespaceID, aName, aNotify);
|
|
|
|
return nsGenericHTMLFrameElement::OnAttrSetButNotChanged(aNamespaceID, aName,
|
|
aValue, aNotify);
|
|
}
|
|
|
|
void HTMLIFrameElement::AfterMaybeChangeAttr(int32_t aNamespaceID,
|
|
nsAtom* aName, bool aNotify) {
|
|
if (aNamespaceID == kNameSpaceID_None) {
|
|
if (aName == nsGkAtoms::srcdoc) {
|
|
// Don't propagate errors from LoadSrc. The attribute was successfully
|
|
// set/unset, that's what we should reflect.
|
|
LoadSrc();
|
|
}
|
|
}
|
|
}
|
|
|
|
uint32_t HTMLIFrameElement::GetSandboxFlags() const {
|
|
const nsAttrValue* sandboxAttr = GetParsedAttr(nsGkAtoms::sandbox);
|
|
// No sandbox attribute, no sandbox flags.
|
|
if (!sandboxAttr) {
|
|
return SANDBOXED_NONE;
|
|
}
|
|
return nsContentUtils::ParseSandboxAttributeToFlags(sandboxAttr);
|
|
}
|
|
|
|
JSObject* HTMLIFrameElement::WrapNode(JSContext* aCx,
|
|
JS::Handle<JSObject*> aGivenProto) {
|
|
return HTMLIFrameElement_Binding::Wrap(aCx, this, aGivenProto);
|
|
}
|
|
|
|
mozilla::dom::FeaturePolicy* HTMLIFrameElement::FeaturePolicy() const {
|
|
return mFeaturePolicy;
|
|
}
|
|
|
|
void HTMLIFrameElement::MaybeStoreCrossOriginFeaturePolicy() {
|
|
if (!mFrameLoader) {
|
|
return;
|
|
}
|
|
|
|
// If the browsingContext is not ready (because docshell is dead), don't try
|
|
// to create one.
|
|
if (!mFrameLoader->IsRemoteFrame() && !mFrameLoader->GetExistingDocShell()) {
|
|
return;
|
|
}
|
|
|
|
RefPtr<BrowsingContext> browsingContext = mFrameLoader->GetBrowsingContext();
|
|
|
|
if (!browsingContext || !browsingContext->IsContentSubframe()) {
|
|
return;
|
|
}
|
|
|
|
if (ContentChild* cc = ContentChild::GetSingleton()) {
|
|
Unused << cc->SendSetContainerFeaturePolicy(browsingContext,
|
|
mFeaturePolicy);
|
|
}
|
|
}
|
|
|
|
already_AddRefed<nsIPrincipal>
|
|
HTMLIFrameElement::GetFeaturePolicyDefaultOrigin() const {
|
|
nsCOMPtr<nsIPrincipal> principal;
|
|
|
|
if (HasAttr(nsGkAtoms::srcdoc)) {
|
|
principal = NodePrincipal();
|
|
return principal.forget();
|
|
}
|
|
|
|
nsCOMPtr<nsIURI> nodeURI;
|
|
if (GetURIAttr(nsGkAtoms::src, nullptr, getter_AddRefs(nodeURI)) && nodeURI) {
|
|
principal = BasePrincipal::CreateContentPrincipal(
|
|
nodeURI, BasePrincipal::Cast(NodePrincipal())->OriginAttributesRef());
|
|
}
|
|
|
|
if (!principal) {
|
|
principal = NodePrincipal();
|
|
}
|
|
|
|
return principal.forget();
|
|
}
|
|
|
|
void HTMLIFrameElement::RefreshFeaturePolicy(bool aParseAllowAttribute) {
|
|
if (aParseAllowAttribute) {
|
|
mFeaturePolicy->ResetDeclaredPolicy();
|
|
|
|
// The origin can change if 'src' and 'srcdoc' attributes change.
|
|
nsCOMPtr<nsIPrincipal> origin = GetFeaturePolicyDefaultOrigin();
|
|
MOZ_ASSERT(origin);
|
|
mFeaturePolicy->SetDefaultOrigin(origin);
|
|
|
|
nsAutoString allow;
|
|
GetAttr(nsGkAtoms::allow, allow);
|
|
|
|
if (!allow.IsEmpty()) {
|
|
// Set or reset the FeaturePolicy directives.
|
|
mFeaturePolicy->SetDeclaredPolicy(OwnerDoc(), allow, NodePrincipal(),
|
|
origin);
|
|
}
|
|
}
|
|
|
|
if (AllowFullscreen()) {
|
|
mFeaturePolicy->MaybeSetAllowedPolicy(u"fullscreen"_ns);
|
|
}
|
|
|
|
mFeaturePolicy->InheritPolicy(OwnerDoc()->FeaturePolicy());
|
|
MaybeStoreCrossOriginFeaturePolicy();
|
|
}
|
|
|
|
void HTMLIFrameElement::UpdateLazyLoadState() {
|
|
// Store current base URI and referrer policy in the lazy load state.
|
|
mLazyLoadState.mBaseURI = GetBaseURI();
|
|
mLazyLoadState.mReferrerPolicy = GetReferrerPolicyAsEnum();
|
|
}
|
|
|
|
nsresult HTMLIFrameElement::BindToTree(BindContext& aContext,
|
|
nsINode& aParent) {
|
|
// Update lazy load state on bind to tree again if lazy loading, as the
|
|
// loading attribute could be set before others.
|
|
if (mLazyLoading) {
|
|
UpdateLazyLoadState();
|
|
}
|
|
|
|
return nsGenericHTMLFrameElement::BindToTree(aContext, aParent);
|
|
}
|
|
|
|
void HTMLIFrameElement::SetLazyLoading() {
|
|
if (mLazyLoading) {
|
|
return;
|
|
}
|
|
|
|
if (!StaticPrefs::dom_iframe_lazy_loading_enabled()) {
|
|
return;
|
|
}
|
|
|
|
// https://html.spec.whatwg.org/multipage/urls-and-fetching.html#will-lazy-load-element-steps
|
|
// "If scripting is disabled for element, then return false."
|
|
Document* doc = OwnerDoc();
|
|
if (!doc->IsScriptEnabled() || doc->IsStaticDocument()) {
|
|
return;
|
|
}
|
|
|
|
doc->EnsureLazyLoadObserver().Observe(*this);
|
|
mLazyLoading = true;
|
|
|
|
UpdateLazyLoadState();
|
|
}
|
|
|
|
void HTMLIFrameElement::StopLazyLoading() {
|
|
if (!mLazyLoading) {
|
|
return;
|
|
}
|
|
|
|
mLazyLoading = false;
|
|
|
|
Document* doc = OwnerDoc();
|
|
if (auto* obs = doc->GetLazyLoadObserver()) {
|
|
obs->Unobserve(*this);
|
|
}
|
|
|
|
LoadSrc();
|
|
|
|
mLazyLoadState.Clear();
|
|
}
|
|
|
|
void HTMLIFrameElement::NodeInfoChanged(Document* aOldDoc) {
|
|
nsGenericHTMLElement::NodeInfoChanged(aOldDoc);
|
|
|
|
if (mLazyLoading) {
|
|
aOldDoc->GetLazyLoadObserver()->Unobserve(*this);
|
|
mLazyLoading = false;
|
|
SetLazyLoading();
|
|
}
|
|
}
|
|
|
|
} // namespace mozilla::dom
|