/* -*- 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 "nsDocShell.h"

#include <algorithm>

#ifdef XP_WIN

# include <process.h>

# define getpid _getpid

#else

# include <unistd.h> // for getpid()

#endif

#include "mozilla/ArrayUtils.h"

#include "mozilla/Attributes.h"

#include "mozilla/AutoRestore.h"

#include "mozilla/BasePrincipal.h"

#include "mozilla/Casting.h"

#include "mozilla/Components.h"

#include "mozilla/DebugOnly.h"

#include "mozilla/Encoding.h"

#include "mozilla/EventStateManager.h"

#include "mozilla/HTMLEditor.h"

#include "mozilla/LoadInfo.h"

#include "mozilla/Logging.h"

#include "mozilla/MediaFeatureChange.h"

#include "mozilla/Preferences.h"

#include "mozilla/PresShell.h"

#include "mozilla/ResultExtensions.h"

#include "mozilla/ScrollTypes.h"

#include "mozilla/Services.h"

#include "mozilla/StaticPrefs_browser.h"

#include "mozilla/StaticPrefs_dom.h"

#include "mozilla/StaticPrefs_extensions.h"

#include "mozilla/StaticPrefs_privacy.h"

#include "mozilla/StaticPrefs_ui.h"

#include "mozilla/StartupTimeline.h"

#include "mozilla/StorageAccess.h"

#include "mozilla/Telemetry.h"

#include "mozilla/Unused.h"

#include "mozilla/WidgetUtils.h"

#include "mozilla/dom/ClientChannelHelper.h"

#include "mozilla/dom/ClientHandle.h"

#include "mozilla/dom/ClientInfo.h"

#include "mozilla/dom/ClientManager.h"

#include "mozilla/dom/ClientSource.h"

#include "mozilla/dom/ContentChild.h"

#include "mozilla/dom/ContentFrameMessageManager.h"

#include "mozilla/dom/DocGroup.h"

#include "mozilla/dom/Element.h"

#include "mozilla/dom/HTMLAnchorElement.h"

#include "mozilla/dom/PerformanceNavigation.h"

#include "mozilla/dom/PermissionMessageUtils.h"

#include "mozilla/dom/PopupBlocker.h"

#include "mozilla/dom/ProfileTimelineMarkerBinding.h"

#include "mozilla/dom/ScreenOrientation.h"

#include "mozilla/dom/ScriptSettings.h"

#include "mozilla/dom/ServiceWorkerInterceptController.h"

#include "mozilla/dom/ServiceWorkerUtils.h"

#include "mozilla/dom/SessionStorageManager.h"

#include "mozilla/dom/BrowserChild.h"

#include "mozilla/dom/TabGroup.h"

#include "mozilla/dom/ToJSValue.h"

#include "mozilla/dom/ChildSHistory.h"

#include "mozilla/dom/nsCSPContext.h"

#include "mozilla/dom/LoadURIOptionsBinding.h"

#include "mozilla/net/ReferrerPolicy.h"

#include "mozilla/net/UrlClassifierFeatureFactory.h"

#include "ReferrerInfo.h"

#include "nsIApplicationCacheChannel.h"

#include "nsIApplicationCacheContainer.h"

#include "nsIAppShell.h"

#include "nsIAsyncVerifyRedirectCallback.h"

#include "nsIAuthPrompt.h"

#include "nsIAuthPrompt2.h"

#include "nsICachingChannel.h"

#include "nsICaptivePortalService.h"

#include "nsIChannel.h"

#include "nsIChannelEventSink.h"

#include "nsIClassOfService.h"

#include "nsIConsoleReportCollector.h"

#include "nsIContent.h"

#include "nsIContentInlines.h"

#include "nsIContentSecurityPolicy.h"

#include "nsIContentViewer.h"

#include "nsIController.h"

#include "nsICookieService.h"

#include "nsIDocShellTreeItem.h"

#include "nsIDocShellTreeOwner.h"

#include "mozilla/dom/Document.h"

#include "nsIDocumentLoaderFactory.h"

#include "nsIDOMWindow.h"

#include "nsIEditingSession.h"

#include "nsIExternalProtocolService.h"

#include "nsIFormPOSTActionChannel.h"

#include "nsIFrame.h"

#include "nsIGlobalObject.h"

#include "nsIHttpChannel.h"

#include "nsIHttpChannelInternal.h"

#include "nsIIDNService.h"

#include "nsIInputStreamChannel.h"

#include "nsIInterfaceRequestorUtils.h"

#include "nsIJARChannel.h"

#include "nsILayoutHistoryState.h"

#include "nsILoadInfo.h"

#include "nsIMultiPartChannel.h"

#include "nsINestedURI.h"

#include "nsINetworkPredictor.h"

#include "nsINode.h"

#include "nsINSSErrorsService.h"

#include "nsIObserverService.h"

#include "nsIOService.h"

#include "nsIPrincipal.h"

#include "nsIPrivacyTransitionObserver.h"

#include "nsIPrompt.h"

#include "nsIPromptFactory.h"

#include "nsIReflowObserver.h"

#include "nsIScriptChannel.h"

#include "nsIScriptObjectPrincipal.h"

#include "nsIScriptSecurityManager.h"

#include "nsIScrollableFrame.h"

#include "nsIScrollObserver.h"

#include "nsISecureBrowserUI.h"

#include "nsISecurityUITelemetry.h"

#include "nsISeekableStream.h"

#include "nsISelectionDisplay.h"

#include "nsISHEntry.h"

#include "nsISHistory.h"

#include "nsISiteSecurityService.h"

#include "nsISocketProvider.h"

#include "nsIStringBundle.h"

#include "nsIStructuredCloneContainer.h"

#include "nsISupportsPrimitives.h"

#include "nsIBrowserChild.h"

#include "nsITextToSubURI.h"

#include "nsITimedChannel.h"

#include "nsITimer.h"

#include "nsITransportSecurityInfo.h"

#include "nsIUploadChannel.h"

#include "nsIURIFixup.h"

#include "nsIURILoader.h"

#include "nsIURIMutator.h"

#include "nsIURL.h"

#include "nsIViewSourceChannel.h"

#include "nsIWebBrowserChrome.h"

#include "nsIWebBrowserChrome3.h"

#include "nsIWebBrowserChromeFocus.h"

#include "nsIWebBrowserFind.h"

#include "nsIWebProgress.h"

#include "nsIWidget.h"

#include "nsIWindowWatcher.h"

#include "nsIWritablePropertyBag2.h"

#include "nsCommandManager.h"

#include "nsPIDOMWindow.h"

#include "nsPIWindowRoot.h"

#include "IHistory.h"

#include "IUrlClassifierUITelemetry.h"

#include "mozIThirdPartyUtil.h"

#include "nsArray.h"

#include "nsArrayUtils.h"

#include "nsAutoPtr.h"

#include "nsCExternalHandlerService.h"

#include "nsContentDLF.h"

#include "nsContentPolicyUtils.h" // NS_CheckContentLoadPolicy(...)

#include "nsContentSecurityManager.h"

#include "nsContentUtils.h"

#include "nsCURILoader.h"

#include "nsDocShellCID.h"

#include "nsDocShellEditorData.h"

#include "nsDocShellEnumerator.h"

#include "nsDocShellLoadState.h"

#include "nsDocShellLoadTypes.h"

#include "nsDOMCID.h"

#include "nsDOMNavigationTiming.h"

#include "nsDSURIContentListener.h"

#include "nsEditingSession.h"

#include "nsError.h"

#include "nsEscape.h"

#include "nsFocusManager.h"

#include "nsGlobalWindow.h"

#include "nsISearchService.h"

#include "nsJSEnvironment.h"

#include "nsNetCID.h"

#include "nsNetUtil.h"

#include "nsObjectLoadingContent.h"

#include "nsPingListener.h"

#include "nsPoint.h"

#include "nsQueryObject.h"

#include "nsRect.h"

#include "nsRefreshTimer.h"

#include "nsSandboxFlags.h"

#include "nsSHistory.h"

#include "nsStructuredCloneContainer.h"

#include "nsSubDocumentFrame.h"

#include "nsView.h"

#include "nsViewManager.h"

#include "nsViewSourceHandler.h"

#include "nsWebBrowserFind.h"

#include "nsWhitespaceTokenizer.h"

#include "nsWidgetsCID.h"

#include "nsXULAppAPI.h"

#include "GeckoProfiler.h"

#include "mozilla/NullPrincipal.h"

#include "Navigator.h"

#include "prenv.h"

#include "URIUtils.h"

#include "timeline/JavascriptTimelineMarker.h"

#ifdef MOZ_PLACES

# include "nsIFaviconService.h"

# include "mozIPlacesPendingOperation.h"

#endif

#if NS_PRINT_PREVIEW

# include "nsIDocumentViewerPrint.h"

# include "nsIWebBrowserPrint.h"

#endif

#ifdef MOZ_GECKO_PROFILER

# include "ProfilerMarkerPayload.h"

#endif

using namespace mozilla;

using namespace mozilla::dom;

using namespace mozilla::net;

// Threshold value in ms for META refresh based redirects

#define REFRESH_REDIRECT_TIMER 15000

// Hint for native dispatch of events on how long to delay after

// all documents have loaded in milliseconds before favoring normal

// native event dispatch priorites over performance

// Can be overridden with docshell.event_starvation_delay_hint pref.

#define NS_EVENT_STARVATION_DELAY_HINT 2000

static NS_DEFINE_CID(kAppShellCID, NS_APPSHELL_CID);

// Number of documents currently loading

static int32_t gNumberOfDocumentsLoading = 0;

// Global count of existing docshells.

static int32_t gDocShellCount = 0;

// Global count of docshells with the private attribute set

static uint32_t gNumberOfPrivateDocShells = 0;

#ifdef DEBUG

static mozilla::LazyLogModule gDocShellLog("nsDocShell");

#endif

static mozilla::LazyLogModule gDocShellLeakLog("nsDocShellLeak");

extern mozilla::LazyLogModule gPageCacheLog;

const char kBrandBundleURL[] = "chrome://branding/locale/brand.properties";

const char kAppstringsBundleURL[] =

"chrome://global/locale/appstrings.properties";

// Global reference to the URI fixup service.

nsIURIFixup* nsDocShell::sURIFixup = nullptr;

static void FavorPerformanceHint(bool aPerfOverStarvation) {

nsCOMPtr<nsIAppShell> appShell = do_GetService(kAppShellCID);

if (appShell) {

appShell->FavorPerformanceHint(

aPerfOverStarvation,

Preferences::GetUint("docshell.event_starvation_delay_hint",

NS_EVENT_STARVATION_DELAY_HINT));

}

}

static void IncreasePrivateDocShellCount() {

gNumberOfPrivateDocShells++;

if (gNumberOfPrivateDocShells > 1 || !XRE_IsContentProcess()) {

return;

}

mozilla::dom::ContentChild* cc = mozilla::dom::ContentChild::GetSingleton();

cc->SendPrivateDocShellsExist(true);

}

static void DecreasePrivateDocShellCount() {

MOZ_ASSERT(gNumberOfPrivateDocShells > 0);

gNumberOfPrivateDocShells--;

if (!gNumberOfPrivateDocShells) {

if (XRE_IsContentProcess()) {

dom::ContentChild* cc = dom::ContentChild::GetSingleton();

cc->SendPrivateDocShellsExist(false);

return;

}

nsCOMPtr<nsIObserverService> obsvc = services::GetObserverService();

if (obsvc) {

obsvc->NotifyObservers(nullptr, "last-pb-context-exited", nullptr);

}

}

}

nsDocShell::nsDocShell(BrowsingContext* aBrowsingContext,

uint64_t aContentWindowID)

: nsDocLoader(),

mContentWindowID(aContentWindowID),

mBrowsingContext(aBrowsingContext),

mForcedCharset(nullptr),

mParentCharset(nullptr),

mTreeOwner(nullptr),

mDefaultScrollbarPref(Scrollbar_Auto, Scrollbar_Auto),

mCharsetReloadState(eCharsetReloadInit),

mOrientationLock(hal::eScreenOrientation_None),

mParentCharsetSource(0),

mMarginWidth(-1),

mMarginHeight(-1),

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

mPreviousEntryIndex(-1),

mLoadedEntryIndex(-1),

mChildOffset(0),

mSandboxFlags(0),

mBusyFlags(BUSY_FLAGS_NONE),

mAppType(nsIDocShell::APP_TYPE_UNKNOWN),

mLoadType(0),

mDefaultLoadFlags(nsIRequest::LOAD_NORMAL),

mFailedLoadType(0),

mFrameType(FRAME_TYPE_REGULAR),

mPrivateBrowsingId(0),

mDisplayMode(nsIDocShell::DISPLAY_MODE_BROWSER),

mJSRunToCompletionDepth(0),

mTouchEventsOverride(nsIDocShell::TOUCHEVENTS_OVERRIDE_NONE),

mMetaViewportOverride(nsIDocShell::META_VIEWPORT_OVERRIDE_NONE),

mFullscreenAllowed(CHECK_ATTRIBUTES),

mCreatingDocument(false),

#ifdef DEBUG

mInEnsureScriptEnv(false),

#endif

mCreated(false),

mAllowSubframes(true),

mAllowPlugins(true),

mAllowJavascript(true),

mAllowMetaRedirects(true),

mAllowImages(true),

mAllowMedia(true),

mAllowDNSPrefetch(true),

mAllowWindowControl(true),

mAllowContentRetargeting(true),

mAllowContentRetargetingOnChildren(true),

mUseErrorPages(false),

mUseStrictSecurityChecks(false),

mObserveErrorPages(true),

mCSSErrorReportingEnabled(false),

mAllowAuth(mItemType == typeContent),

mAllowKeywordFixup(false),

mIsOffScreenBrowser(false),

mIsActive(true),

mDisableMetaRefreshWhenInactive(false),

mIsAppTab(false),

mUseGlobalHistory(false),

mUseRemoteTabs(false),

mUseRemoteSubframes(false),

mUseTrackingProtection(false),

mDeviceSizeIsPageSize(false),

mWindowDraggingAllowed(false),

mInFrameSwap(false),

mInheritPrivateBrowsingId(true),

mCanExecuteScripts(false),

mFiredUnloadEvent(false),

mEODForCurrentDocument(false),

mURIResultedInDocument(false),

mIsBeingDestroyed(false),

mIsExecutingOnLoadHandler(false),

mIsPrintingOrPP(false),

mSavingOldViewer(false),

mDynamicallyCreated(false),

mAffectPrivateSessionLifetime(true),

mInvisible(false),

mHasLoadedNonBlankURI(false),

mBlankTiming(false),

mTitleValidForCurrentURI(false),

mIsFrame(false),

mSkipBrowsingContextDetachOnDestroy(false),

mWatchedByDevtools(false),

mIsNavigating(false) {

mHistoryID.m0 = 0;

mHistoryID.m1 = 0;

mHistoryID.m2 = 0;

AssertOriginAttributesMatchPrivateBrowsing();

nsContentUtils::GenerateUUIDInPlace(mHistoryID);

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

if (aContentWindowID == 0) {

mContentWindowID = nsContentUtils::GenerateWindowId();

}

if (gDocShellCount++ == 0) {

NS_ASSERTION(sURIFixup == nullptr,

"Huh, sURIFixup not null in first nsDocShell ctor!");

nsCOMPtr<nsIURIFixup> uriFixup = components::URIFixup::Service();

uriFixup.forget(&sURIFixup);

}

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

#ifdef DEBUG

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

++gNumberOfDocShells;

if (!PR_GetEnv("MOZ_QUIET")) {

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

gNumberOfDocShells, getpid(),

nsIDToCString(mHistoryID).get());

}

#endif

}

nsDocShell::~nsDocShell() {

MOZ_ASSERT(!mObserved);

// Avoid notifying observers while we're in the dtor.

mIsBeingDestroyed = true;

#ifdef MOZ_GECKO_PROFILER

profiler_unregister_pages(mHistoryID);

#endif

Destroy();

if (mSessionHistory) {

mSessionHistory->LegacySHistory()->ClearRootDocShell();

}

if (--gDocShellCount == 0) {

NS_IF_RELEASE(sURIFixup);

}

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

#ifdef DEBUG

nsAutoCString url;

if (mLastOpenedURI) {

url = mLastOpenedURI->GetSpecOrDefault();

// Data URLs can be very long, so truncate to avoid flooding the log.

const uint32_t maxURLLength = 1000;

if (url.Length() > maxURLLength) {

url.Truncate(maxURLLength);

}

}

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

--gNumberOfDocShells;

if (!PR_GetEnv("MOZ_QUIET")) {

printf_stderr("--DOCSHELL %p == %ld [pid = %d] [id = %s] [url = %s]\n",

(void*)this, gNumberOfDocShells, getpid(),

nsIDToCString(mHistoryID).get(), url.get());

}

#endif

}

/* static */

already_AddRefed<nsDocShell> nsDocShell::Create(

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::Init();

if (NS_WARN_IF(NS_FAILED(rv))) {

return nullptr;

}

// Create our ContentListener

ds->mContentListener = new nsDSURIContentListener(ds);

rv = ds->mContentListener->Init();

if (NS_WARN_IF(NS_FAILED(rv))) {

return nullptr;

}

// If parent intercept is not enabled then we must forward to

// the network controller from docshell. We also 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 (!ServiceWorkerParentInterceptEnabled() || 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);

if (NS_WARN_IF(NS_FAILED(rv))) {

return nullptr;

}

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

RefPtr<BrowsingContext> parent = aBrowsingContext->GetParent();

if (parent && parent->GetDocShell()) {

parent->GetDocShell()->AddChild(ds);

}

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

aBrowsingContext->SetDocShell(ds);

return ds.forget();

}

void nsDocShell::DestroyChildren() {

nsCOMPtr<nsIDocShellTreeItem> shell;

nsTObserverArray<nsDocLoader*>::ForwardIterator iter(mChildList);

while (iter.HasMore()) {

shell = do_QueryObject(iter.GetNext());

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

if (shell) {

shell->SetTreeOwner(nullptr);

}

}

nsDocLoader::DestroyChildren();

}

NS_IMPL_CYCLE_COLLECTION_INHERITED(nsDocShell, nsDocLoader,

mSessionStorageManager, mScriptGlobal,

mInitialClientSource, mSessionHistory,

mBrowsingContext, mChromeEventHandler)

NS_IMPL_ADDREF_INHERITED(nsDocShell, nsDocLoader)

NS_IMPL_RELEASE_INHERITED(nsDocShell, nsDocLoader)

NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsDocShell)

NS_INTERFACE_MAP_ENTRY(nsIDocShell)

NS_INTERFACE_MAP_ENTRY(nsIDocShellTreeItem)

NS_INTERFACE_MAP_ENTRY(nsIWebNavigation)

NS_INTERFACE_MAP_ENTRY(nsIBaseWindow)

NS_INTERFACE_MAP_ENTRY(nsIScrollable)

NS_INTERFACE_MAP_ENTRY(nsIRefreshURI)

NS_INTERFACE_MAP_ENTRY(nsIWebProgressListener)

NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)

NS_INTERFACE_MAP_ENTRY(nsIWebPageDescriptor)

NS_INTERFACE_MAP_ENTRY(nsIAuthPromptProvider)

NS_INTERFACE_MAP_ENTRY(nsILoadContext)

NS_INTERFACE_MAP_ENTRY(nsIDOMStorageManager)

NS_INTERFACE_MAP_ENTRY_CONDITIONAL(nsINetworkInterceptController,

mInterceptController)

NS_INTERFACE_MAP_ENTRY(nsIDeprecationWarner)

NS_INTERFACE_MAP_END_INHERITING(nsDocLoader)

NS_IMETHODIMP

nsDocShell::GetInterface(const nsIID& aIID, void** aSink) {

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(EnsureContentViewer())) {

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

doc.forget(aSink);

return *aSink ? NS_OK : NS_NOINTERFACE;

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

*aSink = nullptr;

// Return application cache associated with this docshell, if any

nsCOMPtr<nsIContentViewer> contentViewer;

GetContentViewer(getter_AddRefs(contentViewer));

if (!contentViewer) {

return NS_ERROR_NO_INTERFACE;

}

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

NS_ASSERTION(doc, "Should have a document.");

if (!doc) {

return NS_ERROR_NO_INTERFACE;

}

#if defined(DEBUG)

MOZ_LOG(

gDocShellLog, LogLevel::Debug,

("nsDocShell[%p]: returning app cache container %p", this, doc.get()));

#endif

return doc->QueryInterface(aIID, aSink);

} 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))) {

RefPtr<ChildSHistory> shistory = GetSessionHistory();

if (shistory) {

// XXX(nika): Stop exposing nsISHistory through GetInterface.

nsCOMPtr<nsISHistory> legacy = shistory->LegacySHistory();

legacy.forget(aSink);

return NS_OK;

}

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;

}

NS_IMETHODIMP

nsDocShell::SetCancelContentJSEpoch(int32_t aEpoch) {

// 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;

}

NS_IMETHODIMP

nsDocShell::LoadURI(nsDocShellLoadState* aLoadState) {

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

MOZ_ASSERT(

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

"Should not have these flags set");

if (!aLoadState->TriggeringPrincipal()) {

#ifndef ANDROID

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

#endif

if (mUseStrictSecurityChecks) {

return NS_ERROR_FAILURE;

}

}

// 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

}

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->SHEntry() &&

!LOAD_TYPE_HAS_FLAGS(aLoadState->LoadType(),

LOAD_FLAGS_REPLACE_HISTORY)) {

// 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.

MaybeHandleSubframeHistory(aLoadState);

}

if (aLoadState->SHEntry()) {

#ifdef DEBUG

MOZ_LOG(gDocShellLog, LogLevel::Debug,

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

#endif

return LoadHistoryEntry(aLoadState->SHEntry(), aLoadState->LoadType());

}

// 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;

}

// Set up the inheriting principal in LoadState.

nsresult rv =

aLoadState->SetupInheritingPrincipal(mItemType, mOriginAttributes);

NS_ENSURE_SUCCESS(rv, rv);

rv = aLoadState->SetupTriggeringPrincipal(mOriginAttributes);

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->SHEntry() == nullptr,

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

return InternalLoad(aLoadState,

nullptr, // no nsIDocShell

nullptr); // no nsIRequest

}

void nsDocShell::MaybeHandleSubframeHistory(nsDocShellLoadState* aLoadState) {

// First, verify if this is a subframe.

nsCOMPtr<nsIDocShellTreeItem> parentAsItem;

GetInProcessSameTypeParent(getter_AddRefs(parentAsItem));

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

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

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

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

// into session history.

bool inOnLoadHandler = false;

GetIsExecutingOnLoadHandler(&inOnLoadHandler);

if (inOnLoadHandler) {

aLoadState->SetLoadType(LOAD_NORMAL_REPLACE);

}

return;

}

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

* loaded through a history mechanism, then get the SH entry for the child

* from the parent. This is done to restore frameset navigation while going

* back/forward. If the parent was loaded through any other loadType, set the

* child's loadType too accordingly, so that session history does not get

* confused.

*/

// Get the parent's load type

uint32_t parentLoadType;

parentDS->GetLoadType(&parentLoadType);

// Get the ShEntry for the child from the parent

nsCOMPtr<nsISHEntry> currentSH;

bool oshe = false;

parentDS->GetCurrentSHEntry(getter_AddRefs(currentSH), &oshe);

bool dynamicallyAddedChild = mDynamicallyCreated;

if (!dynamicallyAddedChild && !oshe && currentSH) {

currentSH->HasDynamicallyAddedChild(&dynamicallyAddedChild);

}

if (!dynamicallyAddedChild) {

// Only use the old SHEntry, if we're sure enough that

// it wasn't originally for some other frame.

nsCOMPtr<nsISHEntry> shEntry;

parentDS->GetChildSHEntry(mChildOffset, getter_AddRefs(shEntry));

aLoadState->SetSHEntry(shEntry);

}

// Make some decisions on the child frame's loadType based on the

// parent's loadType, if the subframe hasn't loaded anything into it.

//

// In some cases privileged scripts may try to get the DOMWindow

// reference of this docshell before the loading starts, causing the

// initial about:blank content viewer being created and mCurrentURI being

// set. To handle this case we check if mCurrentURI is about:blank and

// currentSHEntry is null.

nsCOMPtr<nsISHEntry> currentChildEntry;

GetCurrentSHEntry(getter_AddRefs(currentChildEntry), &oshe);

if (mCurrentURI && (!NS_IsAboutBlank(mCurrentURI) || currentChildEntry)) {

// This is a pre-existing subframe. If

// 1. The load of this frame was not originally initiated by session

// history directly (i.e. (!shEntry) condition succeeded, but it can

// still be a history load on parent which causes this frame being

// loaded), which we checked with the above assert, and

// 2. mCurrentURI is not null, nor the initial about:blank,

// it is possible that a parent's onLoadHandler or even self's

// onLoadHandler is loading a new page in this child. Check parent's and

// self's busy flag and if it is set, we don't want this onLoadHandler

// load to get in to session history.

BusyFlags parentBusy = parentDS->GetBusyFlags();

BusyFlags selfBusy = GetBusyFlags();

if (parentBusy & BUSY_FLAGS_BUSY || selfBusy & BUSY_FLAGS_BUSY) {

aLoadState->SetLoadType(LOAD_NORMAL_REPLACE);

aLoadState->SetSHEntry(nullptr);

}

return;

}

// This is a newly created frame. Check for exception cases first.

// By default the subframe will inherit the parent's loadType.

if (aLoadState->SHEntry() &&

(parentLoadType == LOAD_NORMAL || parentLoadType == LOAD_LINK ||

parentLoadType == LOAD_NORMAL_EXTERNAL)) {

// The parent was loaded normally. In this case, this *brand new*

// child really shouldn't have a SHEntry. If it does, it could be

// because the parent is replacing an existing frame with a new frame,

// in the onLoadHandler. We don't want this url to get into session

// history. Clear off shEntry, and set load type to

// LOAD_BYPASS_HISTORY.

bool inOnLoadHandler = false;

parentDS->GetIsExecutingOnLoadHandler(&inOnLoadHandler);

if (inOnLoadHandler) {

aLoadState->SetLoadType(LOAD_NORMAL_REPLACE);

aLoadState->SetSHEntry(nullptr);

}

} else if (parentLoadType == LOAD_REFRESH) {

// Clear shEntry. For refresh loads, we have to load

// what comes through the pipe, not what's in history.

aLoadState->SetSHEntry(nullptr);

} else if ((parentLoadType == LOAD_BYPASS_HISTORY) ||

(aLoadState->SHEntry() &&

((parentLoadType & LOAD_CMD_HISTORY) ||

(parentLoadType == LOAD_RELOAD_NORMAL) ||

(parentLoadType == LOAD_RELOAD_CHARSET_CHANGE) ||

(parentLoadType == LOAD_RELOAD_CHARSET_CHANGE_BYPASS_CACHE) ||

(parentLoadType ==

LOAD_RELOAD_CHARSET_CHANGE_BYPASS_PROXY_AND_CACHE)))) {

// If the parent url, bypassed history or was loaded from

// history, pass on the parent's loadType to the new child

// frame too, so that the child frame will also

// avoid getting into history.

aLoadState->SetLoadType(parentLoadType);

} else if (parentLoadType == LOAD_ERROR_PAGE) {

// If the parent document is an error page, we don't

// want to update global/session history. However,

// this child frame is not an error page.

aLoadState->SetLoadType(LOAD_BYPASS_HISTORY);

} else if ((parentLoadType == LOAD_RELOAD_BYPASS_CACHE) ||

(parentLoadType == LOAD_RELOAD_BYPASS_PROXY) ||

(parentLoadType == LOAD_RELOAD_BYPASS_PROXY_AND_CACHE)) {

// the new frame should inherit the parent's load type so that it also

// bypasses the cache and/or proxy

aLoadState->SetLoadType(parentLoadType);

}

}

/*

* Reset state to a new content model within the current document and the

* document viewer. Called by the document before initiating an out of band

* document.write().

*/

NS_IMETHODIMP

nsDocShell::PrepareForNewContentModel() {

mEODForCurrentDocument = false;

return NS_OK;

}

NS_IMETHODIMP

nsDocShell::FirePageHideNotification(bool aIsUnload) {

FirePageHideNotificationInternal(aIsUnload, false);

return NS_OK;

}

void nsDocShell::FirePageHideNotificationInternal(

bool aIsUnload, bool aSkipCheckingDynEntries) {

if (mContentViewer && !mFiredUnloadEvent) {

// Keep an explicit reference since calling PageHide could release

// mContentViewer

nsCOMPtr<nsIContentViewer> contentViewer(mContentViewer);

mFiredUnloadEvent = true;

if (mTiming) {

mTiming->NotifyUnloadEventStart();

}

contentViewer->PageHide(aIsUnload);

if (mTiming) {

mTiming->NotifyUnloadEventEnd();

}

AutoTArray<nsCOMPtr<nsIDocShell>, 8> kids;

uint32_t n = mChildList.Length();

kids.SetCapacity(n);

for (uint32_t i = 0; i < n; i++) {

kids.AppendElement(do_QueryInterface(ChildAt(i)));

}

n = kids.Length();

for (uint32_t i = 0; i < n; ++i) {

RefPtr<nsDocShell> child = static_cast<nsDocShell*>(kids[i].get());

if (child) {

// Skip checking dynamic subframe entries in our children.

child->FirePageHideNotificationInternal(aIsUnload, true);

}

}

// If the document is unloading, remove all dynamic subframe entries.

if (aIsUnload && !aSkipCheckingDynEntries) {

RefPtr<ChildSHistory> rootSH = GetRootSessionHistory();

if (rootSH && mOSHE) {

int32_t index = rootSH->Index();

rootSH->LegacySHistory()->RemoveDynEntries(index, mOSHE);

}

}

// Now make sure our editor, if any, is detached before we go

// any farther.

DetachEditorFromWindow();

}

}

nsresult nsDocShell::DispatchToTabGroup(

TaskCategory aCategory, already_AddRefed<nsIRunnable>&& aRunnable) {

// Hold the ref so we won't forget to release it.

nsCOMPtr<nsIRunnable> runnable(aRunnable);

nsCOMPtr<nsPIDOMWindowOuter> win = GetWindow();

if (!win) {

// Window should only be unavailable after destroyed.

MOZ_ASSERT(mIsBeingDestroyed);

return NS_ERROR_FAILURE;

}

if (win->GetDocGroup()) {

return win->GetDocGroup()->Dispatch(aCategory, runnable.forget());

}

RefPtr<mozilla::dom::TabGroup> tabGroup = win->TabGroup();

return tabGroup->Dispatch(aCategory, runnable.forget());

}

NS_IMETHODIMP

nsDocShell::DispatchLocationChangeEvent() {

return DispatchToTabGroup(

TaskCategory::Other,

NewRunnableMethod("nsDocShell::FireDummyOnLocationChange", this,

&nsDocShell::FireDummyOnLocationChange));

}