mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-18 15:55:36 +00:00
18fae65f38
This requires replacing inclusions of it with inclusions of more specific prefs files. The exception is that StaticPrefsAll.h, which is equivalent to StaticPrefs.h, and is used in `Codegen.py` because doing something smarter is tricky and suitable for a follow-up. As a result, any change to StaticPrefList.yaml will still trigger recompilation of all the generated DOM bindings files, but that's still a big improvement over trigger recompilation of every file that uses static prefs. Most of the changes in this commit are very boring. The only changes that are not boring are modules/libpref/*, Codegen.py, and ServoBindings.toml. Differential Revision: https://phabricator.services.mozilla.com/D39138 --HG-- extra : moz-landing-system : lando
438 lines
14 KiB
C++
438 lines
14 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 "nsGenericHTMLFrameElement.h"
|
|
|
|
#include "mozilla/dom/HTMLIFrameElement.h"
|
|
#include "mozilla/dom/XULFrameElement.h"
|
|
#include "mozilla/dom/WindowProxyHolder.h"
|
|
#include "mozilla/Preferences.h"
|
|
#include "mozilla/PresShell.h"
|
|
#include "mozilla/StaticPrefs_dom.h"
|
|
#include "mozilla/ErrorResult.h"
|
|
#include "GeckoProfiler.h"
|
|
#include "nsAttrValueInlines.h"
|
|
#include "nsContentUtils.h"
|
|
#include "nsIDocShell.h"
|
|
#include "nsIFrame.h"
|
|
#include "nsIInterfaceRequestorUtils.h"
|
|
#include "nsIPermissionManager.h"
|
|
#include "nsIScrollable.h"
|
|
#include "nsPresContext.h"
|
|
#include "nsServiceManagerUtils.h"
|
|
#include "nsSubDocumentFrame.h"
|
|
#include "nsAttrValueOrString.h"
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::dom;
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_CLASS(nsGenericHTMLFrameElement)
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(nsGenericHTMLFrameElement,
|
|
nsGenericHTMLElement)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mFrameLoader)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOpenerWindow)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mBrowserElementAPI)
|
|
NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(nsGenericHTMLFrameElement,
|
|
nsGenericHTMLElement)
|
|
if (tmp->mFrameLoader) {
|
|
tmp->mFrameLoader->Destroy();
|
|
}
|
|
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mFrameLoader)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mOpenerWindow)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK(mBrowserElementAPI)
|
|
NS_IMPL_CYCLE_COLLECTION_UNLINK_END
|
|
|
|
NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED(
|
|
nsGenericHTMLFrameElement, nsGenericHTMLElement, nsFrameLoaderOwner,
|
|
nsIDOMMozBrowserFrame, nsIMozBrowserFrame, nsGenericHTMLFrameElement)
|
|
|
|
NS_IMETHODIMP
|
|
nsGenericHTMLFrameElement::GetMozbrowser(bool* aValue) {
|
|
*aValue = GetBoolAttr(nsGkAtoms::mozbrowser);
|
|
return NS_OK;
|
|
}
|
|
NS_IMETHODIMP
|
|
nsGenericHTMLFrameElement::SetMozbrowser(bool aValue) {
|
|
return SetBoolAttr(nsGkAtoms::mozbrowser, aValue);
|
|
}
|
|
|
|
int32_t nsGenericHTMLFrameElement::TabIndexDefault() { return 0; }
|
|
|
|
nsGenericHTMLFrameElement::~nsGenericHTMLFrameElement() {
|
|
if (mFrameLoader) {
|
|
mFrameLoader->Destroy();
|
|
}
|
|
}
|
|
|
|
Document* nsGenericHTMLFrameElement::GetContentDocument(
|
|
nsIPrincipal& aSubjectPrincipal) {
|
|
RefPtr<BrowsingContext> bc = GetContentWindowInternal();
|
|
if (!bc) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsPIDOMWindowOuter* window = bc->GetDOMWindow();
|
|
if (!window) {
|
|
// Either our browsing context contents are out-of-process (in which case
|
|
// clearly this is a cross-origin call and we should return null), or our
|
|
// browsing context is torn-down enough to no longer have a window or a
|
|
// document, and we should still return null.
|
|
return nullptr;
|
|
}
|
|
Document* doc = window->GetDoc();
|
|
if (!doc) {
|
|
return nullptr;
|
|
}
|
|
|
|
// Return null for cross-origin contentDocument.
|
|
if (!aSubjectPrincipal.SubsumesConsideringDomain(doc->NodePrincipal())) {
|
|
return nullptr;
|
|
}
|
|
return doc;
|
|
}
|
|
|
|
BrowsingContext* nsGenericHTMLFrameElement::GetContentWindowInternal() {
|
|
EnsureFrameLoader();
|
|
|
|
if (!mFrameLoader) {
|
|
return nullptr;
|
|
}
|
|
|
|
if (mFrameLoader->DepthTooGreat()) {
|
|
// Claim to have no contentWindow
|
|
return nullptr;
|
|
}
|
|
|
|
RefPtr<BrowsingContext> bc = mFrameLoader->GetBrowsingContext();
|
|
return bc;
|
|
}
|
|
|
|
Nullable<WindowProxyHolder> nsGenericHTMLFrameElement::GetContentWindow() {
|
|
RefPtr<BrowsingContext> bc = GetContentWindowInternal();
|
|
if (!bc) {
|
|
return nullptr;
|
|
}
|
|
return WindowProxyHolder(bc);
|
|
}
|
|
|
|
void nsGenericHTMLFrameElement::EnsureFrameLoader() {
|
|
if (!IsInComposedDoc() || mFrameLoader || mFrameLoaderCreationDisallowed) {
|
|
// If frame loader is there, we just keep it around, cached
|
|
return;
|
|
}
|
|
|
|
// Strangely enough, this method doesn't actually ensure that the
|
|
// frameloader exists. It's more of a best-effort kind of thing.
|
|
mFrameLoader = nsFrameLoader::Create(this, mOpenerWindow, mNetworkCreated);
|
|
}
|
|
|
|
void nsGenericHTMLFrameElement::DisallowCreateFrameLoader() {
|
|
MOZ_ASSERT(!mFrameLoader);
|
|
MOZ_ASSERT(!mFrameLoaderCreationDisallowed);
|
|
mFrameLoaderCreationDisallowed = true;
|
|
}
|
|
|
|
void nsGenericHTMLFrameElement::AllowCreateFrameLoader() {
|
|
MOZ_ASSERT(!mFrameLoader);
|
|
MOZ_ASSERT(mFrameLoaderCreationDisallowed);
|
|
mFrameLoaderCreationDisallowed = false;
|
|
}
|
|
|
|
void nsGenericHTMLFrameElement::CreateRemoteFrameLoader(
|
|
BrowserParent* aBrowserParent) {
|
|
MOZ_ASSERT(!mFrameLoader);
|
|
EnsureFrameLoader();
|
|
if (NS_WARN_IF(!mFrameLoader)) {
|
|
return;
|
|
}
|
|
mFrameLoader->InitializeFromBrowserParent(aBrowserParent);
|
|
|
|
if (nsSubDocumentFrame* subdocFrame = do_QueryFrame(GetPrimaryFrame())) {
|
|
// The reflow for this element already happened while we were waiting
|
|
// for the iframe creation. Therefore the subdoc frame didn't have a
|
|
// frameloader when UpdatePositionAndSize was supposed to be called in
|
|
// ReflowFinished, and we need to do it properly now.
|
|
mFrameLoader->UpdatePositionAndSize(subdocFrame);
|
|
}
|
|
}
|
|
|
|
void nsGenericHTMLFrameElement::PresetOpenerWindow(
|
|
const Nullable<WindowProxyHolder>& aOpenerWindow, ErrorResult& aRv) {
|
|
MOZ_ASSERT(!mFrameLoader);
|
|
mOpenerWindow =
|
|
aOpenerWindow.IsNull() ? nullptr : aOpenerWindow.Value().get();
|
|
}
|
|
|
|
void nsGenericHTMLFrameElement::SwapFrameLoaders(
|
|
HTMLIFrameElement& aOtherLoaderOwner, ErrorResult& rv) {
|
|
if (&aOtherLoaderOwner == this) {
|
|
// nothing to do
|
|
return;
|
|
}
|
|
|
|
aOtherLoaderOwner.SwapFrameLoaders(this, rv);
|
|
}
|
|
|
|
void nsGenericHTMLFrameElement::SwapFrameLoaders(
|
|
XULFrameElement& aOtherLoaderOwner, ErrorResult& rv) {
|
|
aOtherLoaderOwner.SwapFrameLoaders(this, rv);
|
|
}
|
|
|
|
void nsGenericHTMLFrameElement::SwapFrameLoaders(
|
|
nsFrameLoaderOwner* aOtherLoaderOwner, mozilla::ErrorResult& rv) {
|
|
if (RefPtr<Document> doc = GetComposedDoc()) {
|
|
// SwapWithOtherLoader relies on frames being up-to-date.
|
|
doc->FlushPendingNotifications(FlushType::Frames);
|
|
}
|
|
|
|
RefPtr<nsFrameLoader> loader = GetFrameLoader();
|
|
RefPtr<nsFrameLoader> otherLoader = aOtherLoaderOwner->GetFrameLoader();
|
|
if (!loader || !otherLoader) {
|
|
rv.Throw(NS_ERROR_NOT_IMPLEMENTED);
|
|
return;
|
|
}
|
|
|
|
rv = loader->SwapWithOtherLoader(otherLoader, this, aOtherLoaderOwner);
|
|
}
|
|
|
|
void nsGenericHTMLFrameElement::LoadSrc() {
|
|
EnsureFrameLoader();
|
|
|
|
if (!mFrameLoader) {
|
|
return;
|
|
}
|
|
|
|
bool origSrc = !mSrcLoadHappened;
|
|
mSrcLoadHappened = true;
|
|
mFrameLoader->LoadFrame(origSrc);
|
|
}
|
|
|
|
nsresult nsGenericHTMLFrameElement::BindToTree(BindContext& aContext,
|
|
nsINode& aParent) {
|
|
nsresult rv = nsGenericHTMLElement::BindToTree(aContext, aParent);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (IsInComposedDoc()) {
|
|
NS_ASSERTION(!nsContentUtils::IsSafeToRunScript(),
|
|
"Missing a script blocker!");
|
|
|
|
AUTO_PROFILER_LABEL("nsGenericHTMLFrameElement::BindToTree", OTHER);
|
|
|
|
// We're in a document now. Kick off the frame load.
|
|
LoadSrc();
|
|
}
|
|
|
|
// We're now in document and scripts may move us, so clear
|
|
// the mNetworkCreated flag.
|
|
mNetworkCreated = false;
|
|
return rv;
|
|
}
|
|
|
|
void nsGenericHTMLFrameElement::UnbindFromTree(bool aNullParent) {
|
|
if (mFrameLoader) {
|
|
// This iframe is being taken out of the document, destroy the
|
|
// iframe's frame loader (doing that will tear down the window in
|
|
// this iframe).
|
|
// XXXbz we really want to only partially destroy the frame
|
|
// loader... we don't want to tear down the docshell. Food for
|
|
// later bug.
|
|
mFrameLoader->Destroy();
|
|
mFrameLoader = nullptr;
|
|
}
|
|
|
|
nsGenericHTMLElement::UnbindFromTree(aNullParent);
|
|
}
|
|
|
|
/* static */
|
|
int32_t nsGenericHTMLFrameElement::MapScrollingAttribute(
|
|
const nsAttrValue* aValue) {
|
|
int32_t mappedValue = nsIScrollable::Scrollbar_Auto;
|
|
if (aValue && aValue->Type() == nsAttrValue::eEnum) {
|
|
switch (aValue->GetEnumValue()) {
|
|
case NS_STYLE_FRAME_OFF:
|
|
case NS_STYLE_FRAME_NOSCROLL:
|
|
case NS_STYLE_FRAME_NO:
|
|
mappedValue = nsIScrollable::Scrollbar_Never;
|
|
break;
|
|
}
|
|
}
|
|
return mappedValue;
|
|
}
|
|
|
|
static bool PrincipalAllowsBrowserFrame(nsIPrincipal* aPrincipal) {
|
|
nsCOMPtr<nsIPermissionManager> permMgr =
|
|
mozilla::services::GetPermissionManager();
|
|
NS_ENSURE_TRUE(permMgr, false);
|
|
uint32_t permission = nsIPermissionManager::DENY_ACTION;
|
|
nsresult rv = permMgr->TestPermissionFromPrincipal(
|
|
aPrincipal, NS_LITERAL_CSTRING("browser"), &permission);
|
|
NS_ENSURE_SUCCESS(rv, false);
|
|
return permission == nsIPermissionManager::ALLOW_ACTION;
|
|
}
|
|
|
|
/* virtual */
|
|
nsresult nsGenericHTMLFrameElement::AfterSetAttr(
|
|
int32_t aNameSpaceID, nsAtom* aName, const nsAttrValue* aValue,
|
|
const nsAttrValue* aOldValue, nsIPrincipal* aMaybeScriptedPrincipal,
|
|
bool aNotify) {
|
|
if (aValue) {
|
|
nsAttrValueOrString value(aValue);
|
|
AfterMaybeChangeAttr(aNameSpaceID, aName, &value, aMaybeScriptedPrincipal,
|
|
aNotify);
|
|
} else {
|
|
AfterMaybeChangeAttr(aNameSpaceID, aName, nullptr, aMaybeScriptedPrincipal,
|
|
aNotify);
|
|
}
|
|
|
|
if (aNameSpaceID == kNameSpaceID_None) {
|
|
if (aName == nsGkAtoms::scrolling) {
|
|
if (mFrameLoader) {
|
|
nsIDocShell* docshell = mFrameLoader->GetExistingDocShell();
|
|
nsCOMPtr<nsIScrollable> scrollable = do_QueryInterface(docshell);
|
|
if (scrollable) {
|
|
int32_t cur;
|
|
scrollable->GetDefaultScrollbarPreferences(
|
|
nsIScrollable::ScrollOrientation_X, &cur);
|
|
int32_t val = MapScrollingAttribute(aValue);
|
|
if (cur != val) {
|
|
scrollable->SetDefaultScrollbarPreferences(
|
|
nsIScrollable::ScrollOrientation_X, val);
|
|
scrollable->SetDefaultScrollbarPreferences(
|
|
nsIScrollable::ScrollOrientation_Y, val);
|
|
RefPtr<nsPresContext> presContext = docshell->GetPresContext();
|
|
PresShell* presShell =
|
|
presContext ? presContext->GetPresShell() : nullptr;
|
|
nsIFrame* rootScroll =
|
|
presShell ? presShell->GetRootScrollFrame() : nullptr;
|
|
if (rootScroll) {
|
|
presShell->FrameNeedsReflow(
|
|
rootScroll, IntrinsicDirty::StyleChange, NS_FRAME_IS_DIRTY);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (aName == nsGkAtoms::mozbrowser) {
|
|
mReallyIsBrowser = !!aValue &&
|
|
StaticPrefs::dom_mozBrowserFramesEnabled() &&
|
|
PrincipalAllowsBrowserFrame(NodePrincipal());
|
|
}
|
|
}
|
|
|
|
return nsGenericHTMLElement::AfterSetAttr(
|
|
aNameSpaceID, aName, aValue, aOldValue, aMaybeScriptedPrincipal, aNotify);
|
|
}
|
|
|
|
nsresult nsGenericHTMLFrameElement::OnAttrSetButNotChanged(
|
|
int32_t aNamespaceID, nsAtom* aName, const nsAttrValueOrString& aValue,
|
|
bool aNotify) {
|
|
AfterMaybeChangeAttr(aNamespaceID, aName, &aValue, nullptr, aNotify);
|
|
|
|
return nsGenericHTMLElement::OnAttrSetButNotChanged(aNamespaceID, aName,
|
|
aValue, aNotify);
|
|
}
|
|
|
|
void nsGenericHTMLFrameElement::AfterMaybeChangeAttr(
|
|
int32_t aNamespaceID, nsAtom* aName, const nsAttrValueOrString* aValue,
|
|
nsIPrincipal* aMaybeScriptedPrincipal, bool aNotify) {
|
|
if (aNamespaceID == kNameSpaceID_None) {
|
|
if (aName == nsGkAtoms::src) {
|
|
mSrcTriggeringPrincipal = nsContentUtils::GetAttrTriggeringPrincipal(
|
|
this, aValue ? aValue->String() : EmptyString(),
|
|
aMaybeScriptedPrincipal);
|
|
if (!IsHTMLElement(nsGkAtoms::iframe) ||
|
|
!HasAttr(kNameSpaceID_None, nsGkAtoms::srcdoc)) {
|
|
// Don't propagate error here. The attribute was successfully
|
|
// set or removed; that's what we should reflect.
|
|
LoadSrc();
|
|
}
|
|
} else if (aName == nsGkAtoms::name) {
|
|
// Propagate "name" to the docshell to make browsing context names live,
|
|
// per HTML5.
|
|
nsIDocShell* docShell =
|
|
mFrameLoader ? mFrameLoader->GetExistingDocShell() : nullptr;
|
|
if (docShell) {
|
|
if (aValue) {
|
|
docShell->SetName(aValue->String());
|
|
} else {
|
|
docShell->SetName(EmptyString());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void nsGenericHTMLFrameElement::DestroyContent() {
|
|
if (mFrameLoader) {
|
|
mFrameLoader->Destroy();
|
|
mFrameLoader = nullptr;
|
|
}
|
|
|
|
nsGenericHTMLElement::DestroyContent();
|
|
}
|
|
|
|
nsresult nsGenericHTMLFrameElement::CopyInnerTo(Element* aDest) {
|
|
nsresult rv = nsGenericHTMLElement::CopyInnerTo(aDest);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
Document* doc = aDest->OwnerDoc();
|
|
if (doc->IsStaticDocument() && mFrameLoader) {
|
|
nsGenericHTMLFrameElement* dest =
|
|
static_cast<nsGenericHTMLFrameElement*>(aDest);
|
|
nsFrameLoader* fl = nsFrameLoader::Create(dest, nullptr, false);
|
|
NS_ENSURE_STATE(fl);
|
|
dest->mFrameLoader = fl;
|
|
mFrameLoader->CreateStaticClone(fl);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
bool nsGenericHTMLFrameElement::IsHTMLFocusable(bool aWithMouse,
|
|
bool* aIsFocusable,
|
|
int32_t* aTabIndex) {
|
|
if (nsGenericHTMLElement::IsHTMLFocusable(aWithMouse, aIsFocusable,
|
|
aTabIndex)) {
|
|
return true;
|
|
}
|
|
|
|
*aIsFocusable = nsContentUtils::IsSubDocumentTabbable(this);
|
|
|
|
if (!*aIsFocusable && aTabIndex) {
|
|
*aTabIndex = -1;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Return true if this frame element really is a mozbrowser. (It
|
|
* needs to have the right attributes, and its creator must have the right
|
|
* permissions.)
|
|
*/
|
|
/* [infallible] */
|
|
nsresult nsGenericHTMLFrameElement::GetReallyIsBrowser(bool* aOut) {
|
|
*aOut = mReallyIsBrowser;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsGenericHTMLFrameElement::InitializeBrowserAPI() {
|
|
MOZ_ASSERT(mFrameLoader);
|
|
InitBrowserElementAPI();
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsGenericHTMLFrameElement::DestroyBrowserFrameScripts() {
|
|
MOZ_ASSERT(mFrameLoader);
|
|
DestroyBrowserElementFrameScripts();
|
|
return NS_OK;
|
|
}
|