nsILoadInfo* aLoadInfo) {

MOZ_ASSERT(aBrowsingContext);

MOZ_ASSERT(aLoadInfo);

if (aLoadInfo->GetExternalContentPolicyType() !=

ExtContentPolicy::TYPE_DOCUMENT) {

return false;

}

return aBrowsingContext->IsTopContent();

nsILoadInfo* aLoadInfo, uint32_t aLoadType) {

MOZ_ASSERT(aBrowsingContext);

MOZ_ASSERT(aLoadInfo);

if (!IsTopLevelDoc(aBrowsingContext, aLoadInfo)) {

return false;

}

if (aLoadType &

(nsIDocShell::LOAD_CMD_NORMAL | nsIDocShell::LOAD_CMD_HISTORY)) {

return true;

}

return aBrowsingContext->IsActive();

uint64_t aContentWindowID)

: nsDocLoader(true),

mContentWindowID(aContentWindowID),

mBrowsingContext(aBrowsingContext),

mParentCharset(nullptr),

mTreeOwner(nullptr),

mScrollbarPref(ScrollbarPreference::Auto),

mCharsetReloadState(eCharsetReloadInit),

mParentCharsetSource(0),

mFrameMargins(-1, -1),

mItemType(aBrowsingContext->IsContent() ? typeContent : typeChrome),

mPreviousEntryIndex(-1),

mLoadedEntryIndex(-1),

mBusyFlags(BUSY_FLAGS_NONE),

mAppType(nsIDocShell::APP_TYPE_UNKNOWN),

mLoadType(0),

mFailedLoadType(0),

mChannelToDisconnectOnPageHide(0),

mCreatingDocument(false),

#ifdef DEBUG

mInEnsureScriptEnv(false),

#endif

mInitialized(false),

mAllowSubframes(true),

mAllowMetaRedirects(true),

mAllowImages(true),

mAllowMedia(true),

mAllowDNSPrefetch(true),

mAllowWindowControl(true),

mCSSErrorReportingEnabled(false),

mAllowAuth(mItemType == typeContent),

mAllowKeywordFixup(false),

mDisableMetaRefreshWhenInactive(false),

mWindowDraggingAllowed(false),

mInFrameSwap(false),

mFiredUnloadEvent(false),

mEODForCurrentDocument(false),

mURIResultedInDocument(false),

mIsBeingDestroyed(false),

mIsExecutingOnLoadHandler(false),

mSavingOldViewer(false),

mInvisible(false),

mHasLoadedNonBlankURI(false),

mBlankTiming(false),

mTitleValidForCurrentURI(false),

mWillChangeProcess(false),

mIsNavigating(false),

mForcedAutodetection(false),

mCheckingSessionHistory(false),

mNeedToReportActiveAfterLoadingBecomesActive(false) {

// If no outer window ID was provided, generate a new one.

if (aContentWindowID == 0) {

mContentWindowID = nsContentUtils::GenerateWindowId();

}

MOZ_LOG(gDocShellLeakLog, LogLevel::Debug, ("DOCSHELL %p created\n", this));

#ifdef DEBUG

mDocShellID = gDocshellIDCounter++;

// We're counting the number of |nsDocShells| to help find leaks

++gNumberOfDocShells;

MOZ_LOG(gDocShellAndDOMWindowLeakLogging, LogLevel::Info,

("++DOCSHELL %p == %ld [pid = %d] [id = %" PRIu64 "]\n", (void*)this,

gNumberOfDocShells, getpid(), mDocShellID));

#endif

if (mInitialized) {

// We've already been initialized.

return true;

}

NS_ASSERTION(mItemType == typeContent || mItemType == typeChrome,

"Unexpected item type in docshell");

NS_ENSURE_TRUE(Preferences::GetRootBranch(), false);

mInitialized = true;

mDisableMetaRefreshWhenInactive =

Preferences::GetBool("browser.meta_refresh_when_inactive.disabled",

mDisableMetaRefreshWhenInactive);

if (nsCOMPtr<nsIObserverService> serv = services::GetObserverService()) {

const char* msg = mItemType == typeContent ? NS_WEBNAVIGATION_CREATE

: NS_CHROME_WEBNAVIGATION_CREATE;

serv->NotifyWhenScriptSafe(GetAsSupports(this), msg, nullptr);

}

return true;

BrowsingContext* aBrowsingContext, uint64_t aContentWindowID) {

MOZ_ASSERT(aBrowsingContext, "DocShell without a BrowsingContext!");

nsresult rv;

RefPtr<nsDocShell> ds = new nsDocShell(aBrowsingContext, aContentWindowID);

// Initialize the underlying nsDocLoader.

rv = ds->nsDocLoader::InitWithBrowsingContext(aBrowsingContext);

if (NS_WARN_IF(NS_FAILED(rv))) {

return nullptr;

}

// Create our ContentListener

ds->mContentListener = new nsDSURIContentListener(ds);

// We enable if we're in the parent process in order to support non-e10s

// configurations.

// Note: This check is duplicated in SharedWorkerInterfaceRequestor's

// constructor.

if (XRE_IsParentProcess()) {

ds->mInterceptController = new ServiceWorkerInterceptController();

}

// We want to hold a strong ref to the loadgroup, so it better hold a weak

// ref to us... use an InterfaceRequestorProxy to do this.

nsCOMPtr<nsIInterfaceRequestor> proxy = new InterfaceRequestorProxy(ds);

ds->mLoadGroup->SetNotificationCallbacks(proxy);

// XXX(nika): We have our BrowsingContext, so we might be able to skip this.

// It could be nice to directly set up our DocLoader tree?

rv = nsDocLoader::AddDocLoaderAsChildOfRoot(ds);

if (NS_WARN_IF(NS_FAILED(rv))) {

return nullptr;

}

// Add |ds| as a progress listener to itself. A little weird, but simpler

// than reproducing all the listener-notification logic in overrides of the

// various methods via which nsDocLoader can be notified. Note that this

// holds an nsWeakPtr to |ds|, so it's ok.

rv = ds->AddProgressListener(ds, nsIWebProgress::NOTIFY_STATE_DOCUMENT |

nsIWebProgress::NOTIFY_STATE_NETWORK |

nsIWebProgress::NOTIFY_LOCATION);

if (NS_WARN_IF(NS_FAILED(rv))) {

return nullptr;

}

// If our BrowsingContext has private browsing enabled, update the number of

// private browsing docshells.

if (aBrowsingContext->UsePrivateBrowsing()) {

ds->NotifyPrivateBrowsingChanged();

}

// If our parent window is present in this process, set up our parent now.

RefPtr<WindowContext> parentWC = aBrowsingContext->GetParentWindowContext();

if (parentWC && parentWC->IsInProcess()) {

// If we don't have a parent element anymore, we can't finish this load!

// How'd we get here?

RefPtr<Element> parentElement = aBrowsingContext->GetEmbedderElement();

if (!parentElement) {

MOZ_ASSERT_UNREACHABLE("nsDocShell::Create() - !parentElement");

return nullptr;

}

// We have an in-process parent window, but don't have a parent nsDocShell?

// How'd we get here!

nsCOMPtr<nsIDocShell> parentShell =

parentElement->OwnerDoc()->GetDocShell();

if (!parentShell) {

MOZ_ASSERT_UNREACHABLE("nsDocShell::Create() - !parentShell");

return nullptr;

}

parentShell->AddChild(ds);

}

// Make |ds| the primary DocShell for the given context.

aBrowsingContext->SetDocShell(ds);

// Set |ds| default load flags on load group.

ds->SetLoadGroupDefaultLoadFlags(aBrowsingContext->GetDefaultLoadFlags());

if (XRE_IsParentProcess()) {

aBrowsingContext->Canonical()->MaybeAddAsProgressListener(ds);

}

return ds.forget();

for (auto* child : mChildList.ForwardRange()) {

nsCOMPtr<nsIDocShellTreeItem> shell = do_QueryObject(child);

NS_ASSERTION(shell, "docshell has null child");

if (shell) {

shell->SetTreeOwner(nullptr);

}

}

nsDocLoader::DestroyChildren();

MOZ_ASSERT(aSink, "null out param");

*aSink = nullptr;

if (aIID.Equals(NS_GET_IID(nsICommandManager))) {

NS_ENSURE_SUCCESS(EnsureCommandHandler(), NS_ERROR_FAILURE);

*aSink = static_cast<nsICommandManager*>(mCommandManager.get());

} else if (aIID.Equals(NS_GET_IID(nsIURIContentListener))) {

*aSink = mContentListener;

} else if ((aIID.Equals(NS_GET_IID(nsIScriptGlobalObject)) ||

aIID.Equals(NS_GET_IID(nsIGlobalObject)) ||

aIID.Equals(NS_GET_IID(nsPIDOMWindowOuter)) ||

aIID.Equals(NS_GET_IID(mozIDOMWindowProxy)) ||

aIID.Equals(NS_GET_IID(nsIDOMWindow))) &&

NS_SUCCEEDED(EnsureScriptEnvironment())) {

return mScriptGlobal->QueryInterface(aIID, aSink);

} else if (aIID.Equals(NS_GET_IID(Document)) &&

NS_SUCCEEDED(EnsureDocumentViewer())) {

RefPtr<Document> doc = mDocumentViewer->GetDocument();

doc.forget(aSink);

return *aSink ? NS_OK : NS_NOINTERFACE;

} else if (aIID.Equals(NS_GET_IID(nsIPrompt)) &&

NS_SUCCEEDED(EnsureScriptEnvironment())) {

nsresult rv;

nsCOMPtr<nsIWindowWatcher> wwatch =

do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv);

NS_ENSURE_SUCCESS(rv, rv);

// Get the an auth prompter for our window so that the parenting

// of the dialogs works as it should when using tabs.

nsIPrompt* prompt;

rv = wwatch->GetNewPrompter(mScriptGlobal, &prompt);

NS_ENSURE_SUCCESS(rv, rv);

*aSink = prompt;

return NS_OK;

} else if (aIID.Equals(NS_GET_IID(nsIAuthPrompt)) ||

aIID.Equals(NS_GET_IID(nsIAuthPrompt2))) {

return NS_SUCCEEDED(GetAuthPrompt(PROMPT_NORMAL, aIID, aSink))

? NS_OK

: NS_NOINTERFACE;

} else if (aIID.Equals(NS_GET_IID(nsISHistory))) {

// This is deprecated, you should instead directly get

// ChildSHistory from the browsing context.

MOZ_DIAGNOSTIC_ASSERT(

false, "Do not try to get a nsISHistory interface from nsIDocShell");

return NS_NOINTERFACE;

} else if (aIID.Equals(NS_GET_IID(nsIWebBrowserFind))) {

nsresult rv = EnsureFind();

if (NS_FAILED(rv)) {

return rv;

}

*aSink = mFind;

NS_ADDREF((nsISupports*)*aSink);

return NS_OK;

} else if (aIID.Equals(NS_GET_IID(nsISelectionDisplay))) {

if (PresShell* presShell = GetPresShell()) {

return presShell->QueryInterface(aIID, aSink);

}

} else if (aIID.Equals(NS_GET_IID(nsIDocShellTreeOwner))) {

nsCOMPtr<nsIDocShellTreeOwner> treeOwner;

nsresult rv = GetTreeOwner(getter_AddRefs(treeOwner));

if (NS_SUCCEEDED(rv) && treeOwner) {

return treeOwner->QueryInterface(aIID, aSink);

}

} else if (aIID.Equals(NS_GET_IID(nsIBrowserChild))) {

*aSink = GetBrowserChild().take();

return *aSink ? NS_OK : NS_ERROR_FAILURE;

} else {

return nsDocLoader::GetInterface(aIID, aSink);

}

NS_IF_ADDREF(((nsISupports*)*aSink));

return *aSink ? NS_OK : NS_NOINTERFACE;

// Note: this gets called fairly early (before a pageload actually starts).

// We could probably defer this even longer.

nsCOMPtr<nsIBrowserChild> browserChild = GetBrowserChild();

static_cast<BrowserChild*>(browserChild.get())

->SetCancelContentJSEpoch(aEpoch);

return NS_OK;

nsDocShellLoadState* aLoadState) {

if (!aLoadState->URI()->SchemeIs("javascript")) {

return NS_OK;

}

if (nsCOMPtr<nsIPrincipal> targetPrincipal =

GetInheritedPrincipal(/* aConsiderCurrentDocument */ true)) {

if (!aLoadState->TriggeringPrincipal()->Subsumes(targetPrincipal)) {

return NS_ERROR_DOM_BAD_CROSS_ORIGIN_URI;

}

return NS_OK;

}

return NS_ERROR_DOM_BAD_CROSS_ORIGIN_URI;

bool aSetNavigating,

bool aContinueHandlingSubframeHistory) {

MOZ_ASSERT(aLoadState, "Must have a valid load state!");

// NOTE: This comparison between what appears to be internal/external load

// flags is intentional, as it's ensuring that the caller isn't using any of

// the flags reserved for implementations by the `nsIWebNavigation` interface.

// In the future, this check may be dropped.

MOZ_ASSERT(

(aLoadState->LoadFlags() & INTERNAL_LOAD_FLAGS_LOADURI_SETUP_FLAGS) == 0,

"Should not have these flags set");

MOZ_ASSERT(aLoadState->TargetBrowsingContext().IsNull(),

"Targeting doesn't occur until InternalLoad");

if (!aLoadState->TriggeringPrincipal()) {

MOZ_ASSERT(false, "LoadURI must have a triggering principal");

return NS_ERROR_FAILURE;

}

MOZ_TRY(CheckDisallowedJavascriptLoad(aLoadState));

bool oldIsNavigating = mIsNavigating;

auto cleanupIsNavigating =

MakeScopeExit([&]() { mIsNavigating = oldIsNavigating; });

if (aSetNavigating) {

mIsNavigating = true;

}

PopupBlocker::PopupControlState popupState = PopupBlocker::openOverridden;

if (aLoadState->HasLoadFlags(LOAD_FLAGS_ALLOW_POPUPS)) {

popupState = PopupBlocker::openAllowed;

// If we allow popups as part of the navigation, ensure we fake a user

// interaction, so that popups can, in fact, be allowed to open.

if (WindowContext* wc = mBrowsingContext->GetCurrentWindowContext()) {

wc->NotifyUserGestureActivation();

}

}

AutoPopupStatePusher statePusher(popupState);

if (aLoadState->GetCancelContentJSEpoch().isSome()) {

SetCancelContentJSEpoch(*aLoadState->GetCancelContentJSEpoch());

}

// Note: we allow loads to get through here even if mFiredUnloadEvent is

// true; that case will get handled in LoadInternal or LoadHistoryEntry,

// so we pass false as the second parameter to IsNavigationAllowed.

// However, we don't allow the page to change location *in the middle of*

// firing beforeunload, so we do need to check if *beforeunload* is currently

// firing, so we call IsNavigationAllowed rather than just IsPrintingOrPP.

if (!IsNavigationAllowed(true, false)) {

return NS_OK; // JS may not handle returning of an error code

}

nsLoadFlags defaultLoadFlags = mBrowsingContext->GetDefaultLoadFlags();

if (aLoadState->HasLoadFlags(LOAD_FLAGS_FORCE_TRR)) {

defaultLoadFlags |= nsIRequest::LOAD_TRR_ONLY_MODE;

} else if (aLoadState->HasLoadFlags(LOAD_FLAGS_DISABLE_TRR)) {

defaultLoadFlags |= nsIRequest::LOAD_TRR_DISABLED_MODE;

}

MOZ_ALWAYS_SUCCEEDS(mBrowsingContext->SetDefaultLoadFlags(defaultLoadFlags));

if (!StartupTimeline::HasRecord(StartupTimeline::FIRST_LOAD_URI) &&

mItemType == typeContent && !NS_IsAboutBlank(aLoadState->URI())) {

StartupTimeline::RecordOnce(StartupTimeline::FIRST_LOAD_URI);

}

// LoadType used to be set to a default value here, if no LoadInfo/LoadState

// object was passed in. That functionality has been removed as of bug

// 1492648. LoadType should now be set up by the caller at the time they

// create their nsDocShellLoadState object to pass into LoadURI.

MOZ_LOG(

gDocShellLeakLog, LogLevel::Debug,

("nsDocShell[%p]: loading %s with flags 0x%08x", this,

aLoadState->URI()->GetSpecOrDefault().get(), aLoadState->LoadFlags()));

if ((!aLoadState->LoadIsFromSessionHistory() &&

!LOAD_TYPE_HAS_FLAGS(aLoadState->LoadType(),

LOAD_FLAGS_REPLACE_HISTORY)) ||

aContinueHandlingSubframeHistory) {

// This is possibly a subframe, so handle it accordingly.

//

// If history exists, it will be loaded into the aLoadState object, and the

// LoadType will be changed.

if (MaybeHandleSubframeHistory(aLoadState,

aContinueHandlingSubframeHistory)) {

// MaybeHandleSubframeHistory returns true if we need to continue loading

// asynchronously.

return NS_OK;

}

}

if (aLoadState->LoadIsFromSessionHistory()) {

MOZ_LOG(gSHLog, LogLevel::Debug,

("nsDocShell[%p]: loading from session history", this));

if (!mozilla::SessionHistoryInParent()) {

nsCOMPtr<nsISHEntry> entry = aLoadState->SHEntry();

return LoadHistoryEntry(entry, aLoadState->LoadType(),

aLoadState->HasValidUserGestureActivation());

}

// FIXME Null check aLoadState->GetLoadingSessionHistoryInfo()?

return LoadHistoryEntry(*aLoadState->GetLoadingSessionHistoryInfo(),

aLoadState->LoadType(),

aLoadState->HasValidUserGestureActivation());

}

// On history navigation via Back/Forward buttons, don't execute

// automatic JavaScript redirection such as |location.href = ...| or

// |window.open()|

//

// LOAD_NORMAL: window.open(...) etc.

// LOAD_STOP_CONTENT: location.href = ..., location.assign(...)

if ((aLoadState->LoadType() == LOAD_NORMAL ||

aLoadState->LoadType() == LOAD_STOP_CONTENT) &&

ShouldBlockLoadingForBackButton()) {

return NS_OK;

}

BrowsingContext::Type bcType = mBrowsingContext->GetType();

// Set up the inheriting principal in LoadState.

nsresult rv = aLoadState->SetupInheritingPrincipal(

bcType, mBrowsingContext->OriginAttributesRef());

NS_ENSURE_SUCCESS(rv, rv);

rv = aLoadState->SetupTriggeringPrincipal(

mBrowsingContext->OriginAttributesRef());

NS_ENSURE_SUCCESS(rv, rv);

aLoadState->CalculateLoadURIFlags();

MOZ_ASSERT(aLoadState->TypeHint().IsVoid(),

"Typehint should be null when calling InternalLoad from LoadURI");

MOZ_ASSERT(aLoadState->FileName().IsVoid(),

"FileName should be null when calling InternalLoad from LoadURI");

MOZ_ASSERT(!aLoadState->LoadIsFromSessionHistory(),

"Shouldn't be loading from an entry when calling InternalLoad "

"from LoadURI");

// If we have a system triggering principal, we can assume that this load was

// triggered by some UI in the browser chrome, such as the URL bar or

// bookmark bar. This should count as a user interaction for the current sh

// entry, so that the user may navigate back to the current entry, from the

// entry that is going to be added as part of this load.

nsCOMPtr<nsIPrincipal> triggeringPrincipal =

aLoadState->TriggeringPrincipal();

if (triggeringPrincipal && triggeringPrincipal->IsSystemPrincipal()) {

if (mozilla::SessionHistoryInParent()) {

WindowContext* topWc = mBrowsingContext->GetTopWindowContext();

if (topWc && !topWc->IsDiscarded()) {

MOZ_ALWAYS_SUCCEEDS(topWc->SetSHEntryHasUserInteraction(true));

}

} else {

bool oshe = false;

nsCOMPtr<nsISHEntry> currentSHEntry;

GetCurrentSHEntry(getter_AddRefs(currentSHEntry), &oshe);

if (currentSHEntry) {

currentSHEntry->SetHasUserInteraction(true);

}

}

}

rv = InternalLoad(aLoadState);

NS_ENSURE_SUCCESS(rv, rv);

if (aLoadState->GetOriginalURIString().isSome()) {

// Save URI string in case it's needed later when

// sending to search engine service in EndPageLoad()

mOriginalUriString = *aLoadState->GetOriginalURIString();

}

return NS_OK;

public:

StopDetector() = default;

NS_DECL_ISUPPORTS

NS_DECL_NSIREQUEST

bool Canceled() { return mCanceled; }

private:

~StopDetector() = default;

bool mCanceled = false;

nsDocShellLoadState* aLoadState, bool aContinueHandlingSubframeHistory) {

// First, verify if this is a subframe.

// Note, it is ok to rely on docshell here and not browsing context since when

// an iframe is created, it has first in-process docshell.

nsCOMPtr<nsIDocShellTreeItem> parentAsItem;

GetInProcessSameTypeParent(getter_AddRefs(parentAsItem));

nsCOMPtr<nsIDocShell> parentDS(do_QueryInterface(parentAsItem));

if (!parentDS || parentDS == static_cast<nsIDocShell*>(this)) {

if (mBrowsingContext && mBrowsingContext->IsTop()) {

// This is the root docshell. If we got here while

// executing an onLoad Handler,this load will not go

// into session history.

// XXX Why is this code in a method which deals with iframes!

if (aLoadState->IsFormSubmission()) {

#ifdef DEBUG

if (!mEODForCurrentDocument) {

const MaybeDiscarded<BrowsingContext>& targetBC =

aLoadState->TargetBrowsingContext();

MOZ_ASSERT_IF(GetBrowsingContext() == targetBC.get(),

aLoadState->LoadType() == LOAD_NORMAL_REPLACE);

}

#endif

} else {

bool inOnLoadHandler = false;

GetIsExecutingOnLoadHandler(&inOnLoadHandler);

if (inOnLoadHandler) {

aLoadState->SetLoadType(LOAD_NORMAL_REPLACE);

}

}

}

return false;

}

/* OK. It is a subframe. Checkout the parent's loadtype. If the parent was