summaryrefslogtreecommitdiffstats
path: root/docshell/base/nsDocShell.h
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /docshell/base/nsDocShell.h
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'docshell/base/nsDocShell.h')
-rw-r--r--docshell/base/nsDocShell.h1083
1 files changed, 1083 insertions, 0 deletions
diff --git a/docshell/base/nsDocShell.h b/docshell/base/nsDocShell.h
new file mode 100644
index 000000000..3ca9e0b34
--- /dev/null
+++ b/docshell/base/nsDocShell.h
@@ -0,0 +1,1083 @@
+/* -*- 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/. */
+
+#ifndef nsDocShell_h__
+#define nsDocShell_h__
+
+#include "nsITimer.h"
+#include "nsContentPolicyUtils.h"
+#include "nsIDocShell.h"
+#include "nsIDocShellTreeItem.h"
+#include "nsIBaseWindow.h"
+#include "nsINetworkInterceptController.h"
+#include "nsIScrollable.h"
+#include "nsITextScroll.h"
+#include "nsIContentViewerContainer.h"
+#include "nsIDOMStorageManager.h"
+#include "nsDocLoader.h"
+#include "mozilla/BasePrincipal.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/WeakPtr.h"
+#include "mozilla/TimeStamp.h"
+#include "GeckoProfiler.h"
+#include "mozilla/dom/ProfileTimelineMarkerBinding.h"
+#include "mozilla/LinkedList.h"
+#include "jsapi.h"
+
+// Helper Classes
+#include "nsCOMPtr.h"
+#include "nsPoint.h" // mCurrent/mDefaultScrollbarPreferences
+#include "nsString.h"
+#include "nsAutoPtr.h"
+#include "nsThreadUtils.h"
+#include "nsContentUtils.h"
+#include "timeline/ObservedDocShell.h"
+#include "timeline/TimelineConsumers.h"
+#include "timeline/TimelineMarker.h"
+
+// Threshold value in ms for META refresh based redirects
+#define REFRESH_REDIRECT_TIMER 15000
+
+// Interfaces Needed
+#include "nsIDocCharset.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIRefreshURI.h"
+#include "nsIWebNavigation.h"
+#include "nsIWebPageDescriptor.h"
+#include "nsIWebProgressListener.h"
+#include "nsIDocShellLoadInfo.h"
+#include "nsIAuthPromptProvider.h"
+#include "nsILoadContext.h"
+#include "nsIWebShellServices.h"
+#include "nsILinkHandler.h"
+#include "nsIClipboardCommands.h"
+#include "nsITabParent.h"
+#include "nsCRT.h"
+#include "prtime.h"
+#include "nsRect.h"
+#include "Units.h"
+#include "nsIDeprecationWarner.h"
+
+namespace mozilla {
+namespace dom {
+class EventTarget;
+typedef uint32_t ScreenOrientationInternal;
+} // namespace dom
+} // namespace mozilla
+
+class nsDocShell;
+class nsDOMNavigationTiming;
+class nsGlobalWindow;
+class nsIController;
+class nsIScrollableFrame;
+class OnLinkClickEvent;
+class nsDSURIContentListener;
+class nsDocShellEditorData;
+class nsIClipboardDragDropHookList;
+class nsICommandManager;
+class nsIContentViewer;
+class nsIDocument;
+class nsIDOMNode;
+class nsIDocShellTreeOwner;
+class nsIGlobalHistory2;
+class nsIHttpChannel;
+class nsIMutableArray;
+class nsIPrompt;
+class nsISHistory;
+class nsISecureBrowserUI;
+class nsIStringBundle;
+class nsIURIFixup;
+class nsIURILoader;
+class nsIWebBrowserFind;
+class nsIWidget;
+
+/* internally used ViewMode types */
+enum ViewMode
+{
+ viewNormal = 0x0,
+ viewSource = 0x1
+};
+
+class nsRefreshTimer : public nsITimerCallback
+{
+public:
+ nsRefreshTimer();
+
+ NS_DECL_THREADSAFE_ISUPPORTS
+ NS_DECL_NSITIMERCALLBACK
+
+ int32_t GetDelay() { return mDelay ;}
+
+ RefPtr<nsDocShell> mDocShell;
+ nsCOMPtr<nsIURI> mURI;
+ nsCOMPtr<nsIPrincipal> mPrincipal;
+ int32_t mDelay;
+ bool mRepeat;
+ bool mMetaRefresh;
+
+protected:
+ virtual ~nsRefreshTimer();
+};
+
+enum eCharsetReloadState
+{
+ eCharsetReloadInit,
+ eCharsetReloadRequested,
+ eCharsetReloadStopOrigional
+};
+
+class nsDocShell final
+ : public nsDocLoader
+ , public nsIDocShell
+ , public nsIWebNavigation
+ , public nsIBaseWindow
+ , public nsIScrollable
+ , public nsITextScroll
+ , public nsIDocCharset
+ , public nsIContentViewerContainer
+ , public nsIRefreshURI
+ , public nsIWebProgressListener
+ , public nsIWebPageDescriptor
+ , public nsIAuthPromptProvider
+ , public nsILoadContext
+ , public nsIWebShellServices
+ , public nsILinkHandler
+ , public nsIClipboardCommands
+ , public nsIDOMStorageManager
+ , public nsINetworkInterceptController
+ , public nsIDeprecationWarner
+ , public mozilla::SupportsWeakPtr<nsDocShell>
+{
+ friend class nsDSURIContentListener;
+
+public:
+ MOZ_DECLARE_WEAKREFERENCE_TYPENAME(nsDocShell)
+
+ nsDocShell();
+
+ NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW
+
+ virtual nsresult Init() override;
+
+ NS_DECL_ISUPPORTS_INHERITED
+
+ NS_DECL_NSIDOCSHELL
+ NS_DECL_NSIDOCSHELLTREEITEM
+ NS_DECL_NSIWEBNAVIGATION
+ NS_DECL_NSIBASEWINDOW
+ NS_DECL_NSISCROLLABLE
+ NS_DECL_NSITEXTSCROLL
+ NS_DECL_NSIDOCCHARSET
+ NS_DECL_NSIINTERFACEREQUESTOR
+ NS_DECL_NSIWEBPROGRESSLISTENER
+ NS_DECL_NSIREFRESHURI
+ NS_DECL_NSICONTENTVIEWERCONTAINER
+ NS_DECL_NSIWEBPAGEDESCRIPTOR
+ NS_DECL_NSIAUTHPROMPTPROVIDER
+ NS_DECL_NSICLIPBOARDCOMMANDS
+ NS_DECL_NSIWEBSHELLSERVICES
+ NS_DECL_NSINETWORKINTERCEPTCONTROLLER
+ NS_DECL_NSIDEPRECATIONWARNER
+ NS_FORWARD_SAFE_NSIDOMSTORAGEMANAGER(TopSessionStorageManager())
+
+ NS_IMETHOD Stop() override
+ {
+ // Need this here because otherwise nsIWebNavigation::Stop
+ // overrides the docloader's Stop()
+ return nsDocLoader::Stop();
+ }
+
+ // Need to implement (and forward) nsISecurityEventSink, because
+ // nsIWebProgressListener has methods with identical names...
+ NS_FORWARD_NSISECURITYEVENTSINK(nsDocLoader::)
+
+ // nsILinkHandler
+ NS_IMETHOD OnLinkClick(nsIContent* aContent,
+ nsIURI* aURI,
+ const char16_t* aTargetSpec,
+ const nsAString& aFileName,
+ nsIInputStream* aPostDataStream,
+ nsIInputStream* aHeadersDataStream,
+ bool aIsTrusted) override;
+ NS_IMETHOD OnLinkClickSync(nsIContent* aContent,
+ nsIURI* aURI,
+ const char16_t* aTargetSpec,
+ const nsAString& aFileName,
+ nsIInputStream* aPostDataStream = 0,
+ nsIInputStream* aHeadersDataStream = 0,
+ nsIDocShell** aDocShell = 0,
+ nsIRequest** aRequest = 0) override;
+ NS_IMETHOD OnOverLink(nsIContent* aContent,
+ nsIURI* aURI,
+ const char16_t* aTargetSpec) override;
+ NS_IMETHOD OnLeaveLink() override;
+
+ nsDocShellInfoLoadType ConvertLoadTypeToDocShellLoadInfo(uint32_t aLoadType);
+ uint32_t ConvertDocShellLoadInfoToLoadType(
+ nsDocShellInfoLoadType aDocShellLoadType);
+
+ // Don't use NS_DECL_NSILOADCONTEXT because some of nsILoadContext's methods
+ // are shared with nsIDocShell (appID, etc.) and can't be declared twice.
+ NS_IMETHOD GetAssociatedWindow(mozIDOMWindowProxy**) override;
+ NS_IMETHOD GetTopWindow(mozIDOMWindowProxy**) override;
+ NS_IMETHOD GetTopFrameElement(nsIDOMElement**) override;
+ NS_IMETHOD GetNestedFrameId(uint64_t*) override;
+ NS_IMETHOD GetIsContent(bool*) override;
+ NS_IMETHOD GetUsePrivateBrowsing(bool*) override;
+ NS_IMETHOD SetUsePrivateBrowsing(bool) override;
+ NS_IMETHOD SetPrivateBrowsing(bool) override;
+ NS_IMETHOD GetUseRemoteTabs(bool*) override;
+ NS_IMETHOD SetRemoteTabs(bool) override;
+ NS_IMETHOD GetOriginAttributes(JS::MutableHandle<JS::Value>) override;
+ NS_IMETHOD IsTrackingProtectionOn(bool*) override;
+
+ // Restores a cached presentation from history (mLSHE).
+ // This method swaps out the content viewer and simulates loads for
+ // subframes. It then simulates the completion of the toplevel load.
+ nsresult RestoreFromHistory();
+
+ // Perform a URI load from a refresh timer. This is just like the
+ // ForceRefreshURI method on nsIRefreshURI, but makes sure to take
+ // the timer involved out of mRefreshURIList if it's there.
+ // aTimer must not be null.
+ nsresult ForceRefreshURIFromTimer(nsIURI* aURI, int32_t aDelay,
+ bool aMetaRefresh, nsITimer* aTimer,
+ nsIPrincipal* aPrincipal);
+
+ friend class OnLinkClickEvent;
+
+ // We need dummy OnLocationChange in some cases to update the UI without
+ // updating security info.
+ void FireDummyOnLocationChange()
+ {
+ FireOnLocationChange(this, nullptr, mCurrentURI,
+ LOCATION_CHANGE_SAME_DOCUMENT);
+ }
+
+ nsresult HistoryTransactionRemoved(int32_t aIndex);
+
+ // Notify Scroll observers when an async panning/zooming transform
+ // has started being applied
+ void NotifyAsyncPanZoomStarted();
+ // Notify Scroll observers when an async panning/zooming transform
+ // is no longer applied
+ void NotifyAsyncPanZoomStopped();
+
+ void SetInFrameSwap(bool aInSwap)
+ {
+ mInFrameSwap = aInSwap;
+ }
+ bool InFrameSwap();
+
+private:
+ bool CanSetOriginAttributes();
+
+public:
+ const mozilla::DocShellOriginAttributes&
+ GetOriginAttributes()
+ {
+ return mOriginAttributes;
+ }
+
+ nsresult SetOriginAttributes(const mozilla::DocShellOriginAttributes& aAttrs);
+
+ void GetInterceptedDocumentId(nsAString& aId)
+ {
+ aId = mInterceptedDocumentId;
+ }
+
+private:
+ // An observed docshell wrapper is created when recording markers is enabled.
+ mozilla::UniquePtr<mozilla::ObservedDocShell> mObserved;
+
+ // It is necessary to allow adding a timeline marker wherever a docshell
+ // instance is available. This operation happens frequently and needs to
+ // be very fast, so instead of using a Map or having to search for some
+ // docshell-specific markers storage, a pointer to an `ObservedDocShell` is
+ // is stored on docshells directly.
+ friend void mozilla::TimelineConsumers::AddConsumer(nsDocShell*);
+ friend void mozilla::TimelineConsumers::RemoveConsumer(nsDocShell*);
+ friend void mozilla::TimelineConsumers::AddMarkerForDocShell(
+ nsDocShell*, const char*, MarkerTracingType, MarkerStackRequest);
+ friend void mozilla::TimelineConsumers::AddMarkerForDocShell(
+ nsDocShell*, const char*, const TimeStamp&, MarkerTracingType,
+ MarkerStackRequest);
+ friend void mozilla::TimelineConsumers::AddMarkerForDocShell(
+ nsDocShell*, UniquePtr<AbstractTimelineMarker>&&);
+ friend void mozilla::TimelineConsumers::PopMarkers(nsDocShell*,
+ JSContext*, nsTArray<dom::ProfileTimelineMarker>&);
+
+public:
+ // Tell the favicon service that aNewURI has the same favicon as aOldURI.
+ static void CopyFavicon(nsIURI* aOldURI,
+ nsIURI* aNewURI,
+ nsIPrincipal* aLoadingPrincipal,
+ bool aInPrivateBrowsing);
+
+ static nsDocShell* Cast(nsIDocShell* aDocShell)
+ {
+ return static_cast<nsDocShell*>(aDocShell);
+ }
+
+protected:
+ virtual ~nsDocShell();
+ virtual void DestroyChildren() override;
+
+ // Content Viewer Management
+ nsresult EnsureContentViewer();
+ // aPrincipal can be passed in if the caller wants. If null is
+ // passed in, the about:blank principal will end up being used.
+ nsresult CreateAboutBlankContentViewer(nsIPrincipal* aPrincipal,
+ nsIURI* aBaseURI,
+ bool aTryToSaveOldPresentation = true);
+ nsresult CreateContentViewer(const nsACString& aContentType,
+ nsIRequest* aRequest,
+ nsIStreamListener** aContentHandler);
+ nsresult NewContentViewerObj(const nsACString& aContentType,
+ nsIRequest* aRequest, nsILoadGroup* aLoadGroup,
+ nsIStreamListener** aContentHandler,
+ nsIContentViewer** aViewer);
+ nsresult SetupNewViewer(nsIContentViewer* aNewViewer);
+
+ void SetupReferrerFromChannel(nsIChannel* aChannel);
+
+ nsresult GetEldestPresContext(nsPresContext** aPresContext);
+
+ // Get the principal that we'll set on the channel if we're inheriting. If
+ // aConsiderCurrentDocument is true, we try to use the current document if
+ // at all possible. If that fails, we fall back on the parent document.
+ // If that fails too, we force creation of a content viewer and use the
+ // resulting principal. If aConsiderCurrentDocument is false, we just look
+ // at the parent.
+ nsIPrincipal* GetInheritedPrincipal(bool aConsiderCurrentDocument);
+
+ // Actually open a channel and perform a URI load. Callers need to pass a
+ // non-null aTriggeringPrincipal which initiated the URI load. Please note
+ // that aTriggeringPrincipal will be used for performing security checks.
+ // If the argument aURI is provided by the web, then please do not pass a
+ // SystemPrincipal as the triggeringPrincipal. If principalToInherit is
+ // null, then no inheritance of any sort will happen and the load will
+ // get a principal based on the URI being loaded.
+ // If aSrcdoc is not void, the load will be considered as a srcdoc load,
+ // and the contents of aSrcdoc will be loaded instead of aURI.
+ // aOriginalURI will be set as the originalURI on the channel that does the
+ // load. If aOriginalURI is null, aURI will be set as the originalURI.
+ // If aLoadReplace is true, LOAD_REPLACE flag will be set to the nsIChannel.
+ nsresult DoURILoad(nsIURI* aURI,
+ nsIURI* aOriginalURI,
+ bool aLoadReplace,
+ nsIURI* aReferrer,
+ bool aSendReferrer,
+ uint32_t aReferrerPolicy,
+ nsIPrincipal* aTriggeringPrincipal,
+ nsIPrincipal* aPrincipalToInherit,
+ const char* aTypeHint,
+ const nsAString& aFileName,
+ nsIInputStream* aPostData,
+ nsIInputStream* aHeadersData,
+ bool aFirstParty,
+ nsIDocShell** aDocShell,
+ nsIRequest** aRequest,
+ bool aIsNewWindowTarget,
+ bool aBypassClassifier,
+ bool aForceAllowCookies,
+ const nsAString& aSrcdoc,
+ nsIURI* aBaseURI,
+ nsContentPolicyType aContentPolicyType);
+ nsresult AddHeadersToChannel(nsIInputStream* aHeadersData,
+ nsIChannel* aChannel);
+ nsresult DoChannelLoad(nsIChannel* aChannel,
+ nsIURILoader* aURILoader,
+ bool aBypassClassifier);
+
+ nsresult ScrollToAnchor(bool aCurHasRef,
+ bool aNewHasRef,
+ nsACString& aNewHash,
+ uint32_t aLoadType);
+
+ // Returns true if would have called FireOnLocationChange,
+ // but did not because aFireOnLocationChange was false on entry.
+ // In this case it is the caller's responsibility to ensure
+ // FireOnLocationChange is called.
+ // In all other cases false is returned.
+ bool OnLoadingSite(nsIChannel* aChannel,
+ bool aFireOnLocationChange,
+ bool aAddToGlobalHistory = true);
+
+ // Returns true if would have called FireOnLocationChange,
+ // but did not because aFireOnLocationChange was false on entry.
+ // In this case it is the caller's responsibility to ensure
+ // FireOnLocationChange is called.
+ // In all other cases false is returned.
+ // Either aChannel or aTriggeringPrincipal must be null. If aChannel is
+ // present, the owner should be gotten from it.
+ // If OnNewURI calls AddToSessionHistory, it will pass its
+ // aCloneSHChildren argument as aCloneChildren.
+ bool OnNewURI(nsIURI* aURI, nsIChannel* aChannel,
+ nsIPrincipal* aTriggeringPrincipal,
+ nsIPrincipal* aPrincipalToInherit,
+ uint32_t aLoadType,
+ bool aFireOnLocationChange,
+ bool aAddToGlobalHistory,
+ bool aCloneSHChildren);
+
+ void SetReferrerURI(nsIURI* aURI);
+ void SetReferrerPolicy(uint32_t aReferrerPolicy);
+
+ // Session History
+ bool ShouldAddToSessionHistory(nsIURI* aURI);
+ // Either aChannel or aOwner must be null. If aChannel is
+ // present, the owner should be gotten from it.
+ // If aCloneChildren is true, then our current session history's
+ // children will be cloned onto the new entry. This should be
+ // used when we aren't actually changing the document while adding
+ // the new session history entry.
+ nsresult AddToSessionHistory(nsIURI* aURI, nsIChannel* aChannel,
+ nsIPrincipal* aTriggeringPrincipal,
+ nsIPrincipal* aPrincipalToInherit,
+ bool aCloneChildren,
+ nsISHEntry** aNewEntry);
+ nsresult AddChildSHEntryToParent(nsISHEntry* aNewEntry, int32_t aChildOffset,
+ bool aCloneChildren);
+
+ nsresult AddChildSHEntryInternal(nsISHEntry* aCloneRef, nsISHEntry* aNewEntry,
+ int32_t aChildOffset, uint32_t aLoadType,
+ bool aCloneChildren);
+
+ nsresult LoadHistoryEntry(nsISHEntry* aEntry, uint32_t aLoadType);
+ nsresult PersistLayoutHistoryState();
+
+ // Clone a session history tree for subframe navigation.
+ // The tree rooted at |aSrcEntry| will be cloned into |aDestEntry|, except
+ // for the entry with id |aCloneID|, which will be replaced with
+ // |aReplaceEntry|. |aSrcShell| is a (possibly null) docshell which
+ // corresponds to |aSrcEntry| via its mLSHE or mOHE pointers, and will
+ // have that pointer updated to point to the cloned history entry.
+ // If aCloneChildren is true then the children of the entry with id
+ // |aCloneID| will be cloned into |aReplaceEntry|.
+ static nsresult CloneAndReplace(nsISHEntry* aSrcEntry,
+ nsDocShell* aSrcShell,
+ uint32_t aCloneID,
+ nsISHEntry* aReplaceEntry,
+ bool aCloneChildren,
+ nsISHEntry** aDestEntry);
+
+ // Child-walking callback for CloneAndReplace
+ static nsresult CloneAndReplaceChild(nsISHEntry* aEntry, nsDocShell* aShell,
+ int32_t aChildIndex, void* aData);
+
+ nsresult GetRootSessionHistory(nsISHistory** aReturn);
+ nsresult GetHttpChannel(nsIChannel* aChannel, nsIHttpChannel** aReturn);
+ bool ShouldDiscardLayoutState(nsIHttpChannel* aChannel);
+
+ // Determine whether this docshell corresponds to the given history entry,
+ // via having a pointer to it in mOSHE or mLSHE.
+ bool HasHistoryEntry(nsISHEntry* aEntry) const
+ {
+ return aEntry && (aEntry == mOSHE || aEntry == mLSHE);
+ }
+
+ // Update any pointers (mOSHE or mLSHE) to aOldEntry to point to aNewEntry
+ void SwapHistoryEntries(nsISHEntry* aOldEntry, nsISHEntry* aNewEntry);
+
+ // Call this method to swap in a new history entry to m[OL]SHE, rather than
+ // setting it directly. This completes the navigation in all docshells
+ // in the case of a subframe navigation.
+ void SetHistoryEntry(nsCOMPtr<nsISHEntry>* aPtr, nsISHEntry* aEntry);
+
+ // Child-walking callback for SetHistoryEntry
+ static nsresult SetChildHistoryEntry(nsISHEntry* aEntry, nsDocShell* aShell,
+ int32_t aEntryIndex, void* aData);
+
+ // Callback prototype for WalkHistoryEntries.
+ // aEntry is the child history entry, aShell is its corresponding docshell,
+ // aChildIndex is the child's index in its parent entry, and aData is
+ // the opaque pointer passed to WalkHistoryEntries.
+ typedef nsresult(*WalkHistoryEntriesFunc)(nsISHEntry* aEntry,
+ nsDocShell* aShell,
+ int32_t aChildIndex,
+ void* aData);
+
+ // For each child of aRootEntry, find the corresponding docshell which is
+ // a child of aRootShell, and call aCallback. The opaque pointer aData
+ // is passed to the callback.
+ static nsresult WalkHistoryEntries(nsISHEntry* aRootEntry,
+ nsDocShell* aRootShell,
+ WalkHistoryEntriesFunc aCallback,
+ void* aData);
+
+ // overridden from nsDocLoader, this provides more information than the
+ // normal OnStateChange with flags STATE_REDIRECTING
+ virtual void OnRedirectStateChange(nsIChannel* aOldChannel,
+ nsIChannel* aNewChannel,
+ uint32_t aRedirectFlags,
+ uint32_t aStateFlags) override;
+
+ /**
+ * Helper function that determines if channel is an HTTP POST.
+ *
+ * @param aChannel
+ * The channel to test
+ *
+ * @return True iff channel is an HTTP post.
+ */
+ bool ChannelIsPost(nsIChannel* aChannel);
+
+ /**
+ * Helper function that finds the last URI and its transition flags for a
+ * channel.
+ *
+ * This method first checks the channel's property bag to see if previous
+ * info has been saved. If not, it gives back the referrer of the channel.
+ *
+ * @param aChannel
+ * The channel we are transitioning to
+ * @param aURI
+ * Output parameter with the previous URI, not addref'd
+ * @param aChannelRedirectFlags
+ * If a redirect, output parameter with the previous redirect flags
+ * from nsIChannelEventSink
+ */
+ void ExtractLastVisit(nsIChannel* aChannel,
+ nsIURI** aURI,
+ uint32_t* aChannelRedirectFlags);
+
+ /**
+ * Helper function that caches a URI and a transition for saving later.
+ *
+ * @param aChannel
+ * Channel that will have these properties saved
+ * @param aURI
+ * The URI to save for later
+ * @param aChannelRedirectFlags
+ * The nsIChannelEventSink redirect flags to save for later
+ */
+ void SaveLastVisit(nsIChannel* aChannel,
+ nsIURI* aURI,
+ uint32_t aChannelRedirectFlags);
+
+ /**
+ * Helper function for adding a URI visit using IHistory. If IHistory is
+ * not available, the method tries nsIGlobalHistory2.
+ *
+ * The IHistory API maintains chains of visits, tracking both HTTP referrers
+ * and redirects for a user session. VisitURI requires the current URI and
+ * the previous URI in the chain.
+ *
+ * Visits can be saved either during a redirect or when the request has
+ * reached its final destination. The previous URI in the visit may be
+ * from another redirect or it may be the referrer.
+ *
+ * @pre aURI is not null.
+ *
+ * @param aURI
+ * The URI that was just visited
+ * @param aReferrerURI
+ * The referrer URI of this request
+ * @param aPreviousURI
+ * The previous URI of this visit (may be the same as aReferrerURI)
+ * @param aChannelRedirectFlags
+ * For redirects, the redirect flags from nsIChannelEventSink
+ * (0 otherwise)
+ * @param aResponseStatus
+ * For HTTP channels, the response code (0 otherwise).
+ */
+ void AddURIVisit(nsIURI* aURI,
+ nsIURI* aReferrerURI,
+ nsIURI* aPreviousURI,
+ uint32_t aChannelRedirectFlags,
+ uint32_t aResponseStatus = 0);
+
+ // Helper Routines
+ nsresult ConfirmRepost(bool* aRepost);
+ NS_IMETHOD GetPromptAndStringBundle(nsIPrompt** aPrompt,
+ nsIStringBundle** aStringBundle);
+ NS_IMETHOD GetChildOffset(nsIDOMNode* aChild, nsIDOMNode* aParent,
+ int32_t* aOffset);
+ nsIScrollableFrame* GetRootScrollFrame();
+ NS_IMETHOD EnsureScriptEnvironment();
+ NS_IMETHOD EnsureEditorData();
+ nsresult EnsureTransferableHookData();
+ NS_IMETHOD EnsureFind();
+ nsresult RefreshURIFromQueue();
+ NS_IMETHOD LoadErrorPage(nsIURI* aURI, const char16_t* aURL,
+ const char* aErrorPage,
+ const char16_t* aErrorType,
+ const char16_t* aDescription,
+ const char* aCSSClass,
+ nsIChannel* aFailedChannel);
+ bool IsPrintingOrPP(bool aDisplayErrorDialog = true);
+ bool IsNavigationAllowed(bool aDisplayPrintErrorDialog = true,
+ bool aCheckIfUnloadFired = true);
+
+ nsresult SetBaseUrlForWyciwyg(nsIContentViewer* aContentViewer);
+
+ static inline uint32_t PRTimeToSeconds(PRTime aTimeUsec)
+ {
+ PRTime usecPerSec = PR_USEC_PER_SEC;
+ return uint32_t(aTimeUsec /= usecPerSec);
+ }
+
+ inline bool UseErrorPages()
+ {
+ return (mObserveErrorPages ? sUseErrorPages : mUseErrorPages);
+ }
+
+ bool IsFrame();
+
+ //
+ // Helper method that is called when a new document (including any
+ // sub-documents - ie. frames) has been completely loaded.
+ //
+ virtual nsresult EndPageLoad(nsIWebProgress* aProgress,
+ nsIChannel* aChannel,
+ nsresult aResult);
+
+ // Sets the current document's current state object to the given SHEntry's
+ // state object. The current state object is eventually given to the page
+ // in the PopState event.
+ nsresult SetDocCurrentStateObj(nsISHEntry* aShEntry);
+
+ nsresult CheckLoadingPermissions();
+
+ // Security checks to prevent frameset spoofing. See comments at
+ // implementation sites.
+ static bool CanAccessItem(nsIDocShellTreeItem* aTargetItem,
+ nsIDocShellTreeItem* aAccessingItem,
+ bool aConsiderOpener = true);
+ static bool ValidateOrigin(nsIDocShellTreeItem* aOriginTreeItem,
+ nsIDocShellTreeItem* aTargetTreeItem);
+
+ // Returns true if would have called FireOnLocationChange,
+ // but did not because aFireOnLocationChange was false on entry.
+ // In this case it is the caller's responsibility to ensure
+ // FireOnLocationChange is called.
+ // In all other cases false is returned.
+ bool SetCurrentURI(nsIURI* aURI, nsIRequest* aRequest,
+ bool aFireOnLocationChange,
+ uint32_t aLocationFlags);
+
+ // The following methods deal with saving and restoring content viewers
+ // in session history.
+
+ // mContentViewer points to the current content viewer associated with
+ // this docshell. When loading a new document, the content viewer is
+ // either destroyed or stored into a session history entry. To make sure
+ // that destruction happens in a controlled fashion, a given content viewer
+ // is always owned in exactly one of these ways:
+ // 1) The content viewer is active and owned by a docshell's
+ // mContentViewer.
+ // 2) The content viewer is still being displayed while we begin loading
+ // a new document. The content viewer is owned by the _new_
+ // content viewer's mPreviousViewer, and has a pointer to the
+ // nsISHEntry where it will eventually be stored. The content viewer
+ // has been close()d by the docshell, which detaches the document from
+ // the window object.
+ // 3) The content viewer is cached in session history. The nsISHEntry
+ // has the only owning reference to the content viewer. The viewer
+ // has released its nsISHEntry pointer to prevent circular ownership.
+ //
+ // When restoring a content viewer from session history, open() is called
+ // to reattach the document to the window object. The content viewer is
+ // then placed into mContentViewer and removed from the history entry.
+ // (mContentViewer is put into session history as described above, if
+ // applicable).
+
+ // Determines whether we can safely cache the current mContentViewer in
+ // session history. This checks a number of factors such as cache policy,
+ // pending requests, and unload handlers.
+ // |aLoadType| should be the load type that will replace the current
+ // presentation. |aNewRequest| should be the request for the document to
+ // be loaded in place of the current document, or null if such a request
+ // has not been created yet. |aNewDocument| should be the document that will
+ // replace the current document.
+ bool CanSavePresentation(uint32_t aLoadType,
+ nsIRequest* aNewRequest,
+ nsIDocument* aNewDocument);
+
+ // Captures the state of the supporting elements of the presentation
+ // (the "window" object, docshell tree, meta-refresh loads, and security
+ // state) and stores them on |mOSHE|.
+ nsresult CaptureState();
+
+ // Begin the toplevel restore process for |aSHEntry|.
+ // This simulates a channel open, and defers the real work until
+ // RestoreFromHistory is called from a PLEvent.
+ nsresult RestorePresentation(nsISHEntry* aSHEntry, bool* aRestoring);
+
+ // Call BeginRestore(nullptr, false) for each child of this shell.
+ nsresult BeginRestoreChildren();
+
+ // Method to get our current position and size without flushing
+ void DoGetPositionAndSize(int32_t* aX, int32_t* aY, int32_t* aWidth,
+ int32_t* aHeight);
+
+ // Call this when a URI load is handed to us (via OnLinkClick or
+ // InternalLoad). This makes sure that we're not inside unload, or that if
+ // we are it's still OK to load this URI.
+ bool IsOKToLoadURI(nsIURI* aURI);
+
+ void ReattachEditorToWindow(nsISHEntry* aSHEntry);
+
+ nsCOMPtr<nsIDOMStorageManager> mSessionStorageManager;
+ nsIDOMStorageManager* TopSessionStorageManager();
+
+ // helpers for executing commands
+ nsresult GetControllerForCommand(const char* aCommand,
+ nsIController** aResult);
+ nsresult EnsureCommandHandler();
+
+ nsIChannel* GetCurrentDocChannel();
+
+ bool ShouldBlockLoadingForBackButton();
+
+ // Convenience method for getting our parent docshell. Can return null
+ already_AddRefed<nsDocShell> GetParentDocshell();
+
+ // Check if aURI is about:newtab.
+ bool IsAboutNewtab(nsIURI* aURI);
+
+protected:
+ nsresult GetCurScrollPos(int32_t aScrollOrientation, int32_t* aCurPos);
+ nsresult SetCurScrollPosEx(int32_t aCurHorizontalPos,
+ int32_t aCurVerticalPos);
+
+ // Override the parent setter from nsDocLoader
+ virtual nsresult SetDocLoaderParent(nsDocLoader* aLoader) override;
+
+ void ClearFrameHistory(nsISHEntry* aEntry);
+
+ /**
+ * Initializes mTiming if it isn't yet.
+ * After calling this, mTiming is non-null.
+ */
+ void MaybeInitTiming();
+
+ bool DisplayLoadError(nsresult aError, nsIURI* aURI, const char16_t* aURL,
+ nsIChannel* aFailedChannel)
+ {
+ bool didDisplayLoadError = false;
+ DisplayLoadError(aError, aURI, aURL, aFailedChannel, &didDisplayLoadError);
+ return didDisplayLoadError;
+ }
+
+public:
+ // Event type dispatched by RestorePresentation
+ class RestorePresentationEvent : public mozilla::Runnable
+ {
+ public:
+ NS_DECL_NSIRUNNABLE
+ explicit RestorePresentationEvent(nsDocShell* aDs) : mDocShell(aDs) {}
+ void Revoke() { mDocShell = nullptr; }
+ private:
+ RefPtr<nsDocShell> mDocShell;
+ };
+
+protected:
+ bool JustStartedNetworkLoad();
+
+ nsresult CreatePrincipalFromReferrer(nsIURI* aReferrer,
+ nsIPrincipal** aResult);
+
+ static const nsCString FrameTypeToString(uint32_t aFrameType)
+ {
+ switch (aFrameType) {
+ case FRAME_TYPE_APP:
+ return NS_LITERAL_CSTRING("app");
+ case FRAME_TYPE_BROWSER:
+ return NS_LITERAL_CSTRING("browser");
+ case FRAME_TYPE_REGULAR:
+ return NS_LITERAL_CSTRING("regular");
+ default:
+ NS_ERROR("Unknown frame type");
+ return EmptyCString();
+ }
+ }
+
+ uint32_t GetInheritedFrameType();
+
+ bool HasUnloadedParent();
+
+ // Dimensions of the docshell
+ nsIntRect mBounds;
+ nsString mName;
+ nsString mTitle;
+ nsString mCustomUserAgent;
+
+ /**
+ * Content-Type Hint of the most-recently initiated load. Used for
+ * session history entries.
+ */
+ nsCString mContentTypeHint;
+ nsIntPoint mDefaultScrollbarPref; // persistent across doc loads
+
+ nsCOMPtr<nsIMutableArray> mRefreshURIList;
+ nsCOMPtr<nsIMutableArray> mSavedRefreshURIList;
+ RefPtr<nsDSURIContentListener> mContentListener;
+ nsCOMPtr<nsIContentViewer> mContentViewer;
+ nsCOMPtr<nsIWidget> mParentWidget;
+
+ // mCurrentURI should be marked immutable on set if possible.
+ nsCOMPtr<nsIURI> mCurrentURI;
+ nsCOMPtr<nsIURI> mReferrerURI;
+ uint32_t mReferrerPolicy;
+ RefPtr<nsGlobalWindow> mScriptGlobal;
+ nsCOMPtr<nsISHistory> mSessionHistory;
+ nsCOMPtr<nsIGlobalHistory2> mGlobalHistory;
+ nsCOMPtr<nsIWebBrowserFind> mFind;
+ nsCOMPtr<nsICommandManager> mCommandManager;
+ // Reference to the SHEntry for this docshell until the page is destroyed.
+ // Somebody give me better name
+ nsCOMPtr<nsISHEntry> mOSHE;
+ // Reference to the SHEntry for this docshell until the page is loaded
+ // Somebody give me better name.
+ // If mLSHE is non-null, non-pushState subframe loads don't create separate
+ // root history entries. That is, frames loaded during the parent page
+ // load don't generate history entries the way frame navigation after the
+ // parent has loaded does. (This isn't the only purpose of mLSHE.)
+ nsCOMPtr<nsISHEntry> mLSHE;
+
+ // Holds a weak pointer to a RestorePresentationEvent object if any that
+ // holds a weak pointer back to us. We use this pointer to possibly revoke
+ // the event whenever necessary.
+ nsRevocableEventPtr<RestorePresentationEvent> mRestorePresentationEvent;
+
+ // Editor data, if this document is designMode or contentEditable.
+ nsAutoPtr<nsDocShellEditorData> mEditorData;
+
+ // Transferable hooks/callbacks
+ nsCOMPtr<nsIClipboardDragDropHookList> mTransferableHookData;
+
+ // Secure browser UI object
+ nsCOMPtr<nsISecureBrowserUI> mSecurityUI;
+
+ // The URI we're currently loading. This is only relevant during the
+ // firing of a pagehide/unload. The caller of FirePageHideNotification()
+ // is responsible for setting it and unsetting it. It may be null if the
+ // pagehide/unload is happening for some reason other than just loading a
+ // new URI.
+ nsCOMPtr<nsIURI> mLoadingURI;
+
+ // Set in LoadErrorPage from the method argument and used later
+ // in CreateContentViewer. We have to delay an shistory entry creation
+ // for which these objects are needed.
+ nsCOMPtr<nsIURI> mFailedURI;
+ nsCOMPtr<nsIChannel> mFailedChannel;
+ uint32_t mFailedLoadType;
+
+ // Set in DoURILoad when either the LOAD_RELOAD_ALLOW_MIXED_CONTENT flag or
+ // the LOAD_NORMAL_ALLOW_MIXED_CONTENT flag is set.
+ // Checked in nsMixedContentBlocker, to see if the channels match.
+ nsCOMPtr<nsIChannel> mMixedContentChannel;
+
+ // WEAK REFERENCES BELOW HERE.
+ // Note these are intentionally not addrefd. Doing so will create a cycle.
+ // For that reasons don't use nsCOMPtr.
+
+ nsIDocShellTreeOwner* mTreeOwner; // Weak Reference
+ mozilla::dom::EventTarget* mChromeEventHandler; // Weak Reference
+
+ eCharsetReloadState mCharsetReloadState;
+
+ // Offset in the parent's child list.
+ // -1 if the docshell is added dynamically to the parent shell.
+ uint32_t mChildOffset;
+ uint32_t mBusyFlags;
+ uint32_t mAppType;
+ uint32_t mLoadType;
+
+ int32_t mMarginWidth;
+ int32_t mMarginHeight;
+
+ // This can either be a content docshell or a chrome docshell. After
+ // Create() is called, the type is not expected to change.
+ int32_t mItemType;
+
+ // Index into the SHTransaction list, indicating the previous and current
+ // transaction at the time that this DocShell begins to load
+ int32_t mPreviousTransIndex;
+ int32_t mLoadedTransIndex;
+
+ uint32_t mSandboxFlags;
+ nsWeakPtr mOnePermittedSandboxedNavigator;
+
+ // The orientation lock as described by
+ // https://w3c.github.io/screen-orientation/
+ mozilla::dom::ScreenOrientationInternal mOrientationLock;
+
+ // mFullscreenAllowed stores how we determine whether fullscreen is allowed
+ // when GetFullscreenAllowed() is called. Fullscreen is allowed in a
+ // docshell when all containing iframes have the allowfullscreen
+ // attribute set to true. When mFullscreenAllowed is CHECK_ATTRIBUTES
+ // we check this docshell's containing frame for the allowfullscreen
+ // attribute, and recurse onto the parent docshell to ensure all containing
+ // frames also have the allowfullscreen attribute. If we find an ancestor
+ // docshell with mFullscreenAllowed not equal to CHECK_ATTRIBUTES, we've
+ // reached a content boundary, and mFullscreenAllowed denotes whether the
+ // parent across the content boundary has allowfullscreen=true in all its
+ // containing iframes. mFullscreenAllowed defaults to CHECK_ATTRIBUTES and
+ // is set otherwise when docshells which are content boundaries are created.
+ enum FullscreenAllowedState : uint8_t
+ {
+ CHECK_ATTRIBUTES,
+ PARENT_ALLOWS,
+ PARENT_PROHIBITS
+ };
+ FullscreenAllowedState mFullscreenAllowed;
+
+ // Cached value of the "browser.xul.error_pages.enabled" preference.
+ static bool sUseErrorPages;
+
+ bool mCreated : 1;
+ bool mAllowSubframes : 1;
+ bool mAllowPlugins : 1;
+ bool mAllowJavascript : 1;
+ bool mAllowMetaRedirects : 1;
+ bool mAllowImages : 1;
+ bool mAllowMedia : 1;
+ bool mAllowDNSPrefetch : 1;
+ bool mAllowWindowControl : 1;
+ bool mAllowContentRetargeting : 1;
+ bool mAllowContentRetargetingOnChildren : 1;
+ bool mUseErrorPages : 1;
+ bool mObserveErrorPages : 1;
+ bool mAllowAuth : 1;
+ bool mAllowKeywordFixup : 1;
+ bool mIsOffScreenBrowser : 1;
+ bool mIsActive : 1;
+ bool mDisableMetaRefreshWhenInactive : 1;
+ bool mIsPrerendered : 1;
+ bool mIsAppTab : 1;
+ bool mUseGlobalHistory : 1;
+ bool mUseRemoteTabs : 1;
+ bool mDeviceSizeIsPageSize : 1;
+ bool mWindowDraggingAllowed : 1;
+ bool mInFrameSwap : 1;
+ bool mInheritPrivateBrowsingId : 1;
+
+ // Because scriptability depends on the mAllowJavascript values of our
+ // ancestors, we cache the effective scriptability and recompute it when
+ // it might have changed;
+ bool mCanExecuteScripts : 1;
+ void RecomputeCanExecuteScripts();
+
+ // This boolean is set to true right before we fire pagehide and generally
+ // unset when we embed a new content viewer. While it's true no navigation
+ // is allowed in this docshell.
+ bool mFiredUnloadEvent : 1;
+
+ // this flag is for bug #21358. a docshell may load many urls
+ // which don't result in new documents being created (i.e. a new
+ // content viewer) we want to make sure we don't call a on load
+ // event more than once for a given content viewer.
+ bool mEODForCurrentDocument : 1;
+ bool mURIResultedInDocument : 1;
+
+ bool mIsBeingDestroyed : 1;
+
+ bool mIsExecutingOnLoadHandler : 1;
+
+ // Indicates that a DocShell in this "docshell tree" is printing
+ bool mIsPrintingOrPP : 1;
+
+ // Indicates to CreateContentViewer() that it is safe to cache the old
+ // presentation of the page, and to SetupNewViewer() that the old viewer
+ // should be passed a SHEntry to save itself into.
+ bool mSavingOldViewer : 1;
+
+ // @see nsIDocShellHistory::createdDynamically
+ bool mDynamicallyCreated : 1;
+ bool mAffectPrivateSessionLifetime : 1;
+ bool mInvisible : 1;
+ bool mHasLoadedNonBlankURI : 1;
+
+ // This flag means that mTiming has been initialized but nulled out.
+ // We will check the innerWin's timing before creating a new one
+ // in MaybeInitTiming()
+ bool mBlankTiming : 1;
+
+ // The following two fields cannot be declared as bit fields
+ // because of uses with AutoRestore.
+ bool mCreatingDocument; // (should be) debugging only
+#ifdef DEBUG
+ bool mInEnsureScriptEnv;
+#endif
+
+ uint64_t mHistoryID;
+ uint32_t mDefaultLoadFlags;
+
+ static nsIURIFixup* sURIFixup;
+
+ RefPtr<nsDOMNavigationTiming> mTiming;
+
+ // Are we a regular frame, a browser frame, or an app frame?
+ uint32_t mFrameType;
+
+ // This represents the state of private browsing in the docshell.
+ // Currently treated as a binary value: 1 - in private mode, 0 - not private mode
+ // On content docshells mPrivateBrowsingId == mOriginAttributes.mPrivateBrowsingId
+ // On chrome docshells this value will be set, but not have the corresponding
+ // origin attribute set.
+ uint32_t mPrivateBrowsingId;
+
+ nsString mInterceptedDocumentId;
+
+private:
+ nsCString mForcedCharset;
+ nsCString mParentCharset;
+ int32_t mParentCharsetSource;
+ nsCOMPtr<nsIPrincipal> mParentCharsetPrincipal;
+ nsTObserverArray<nsWeakPtr> mPrivacyObservers;
+ nsTObserverArray<nsWeakPtr> mReflowObservers;
+ nsTObserverArray<nsWeakPtr> mScrollObservers;
+ nsCString mOriginalUriString;
+ nsWeakPtr mOpener;
+ mozilla::DocShellOriginAttributes mOriginAttributes;
+
+ // A depth count of how many times NotifyRunToCompletionStart
+ // has been called without a matching NotifyRunToCompletionStop.
+ uint32_t mJSRunToCompletionDepth;
+
+ // Whether or not touch events are overridden. Possible values are defined
+ // as constants in the nsIDocShell.idl file.
+ uint32_t mTouchEventsOverride;
+
+ // Separate function to do the actual name (i.e. not _top, _self etc.)
+ // searching for FindItemWithName.
+ nsresult DoFindItemWithName(const nsAString& aName,
+ nsISupports* aRequestor,
+ nsIDocShellTreeItem* aOriginalRequestor,
+ nsIDocShellTreeItem** aResult);
+
+ // Helper assertion to enforce that mInPrivateBrowsing is in sync with
+ // OriginAttributes.mPrivateBrowsingId
+ void AssertOriginAttributesMatchPrivateBrowsing();
+
+ // Notify consumers of a search being loaded through the observer service:
+ void MaybeNotifyKeywordSearchLoading(const nsString& aProvider,
+ const nsString& aKeyword);
+
+#ifdef DEBUG
+ // We're counting the number of |nsDocShells| to help find leaks
+ static unsigned long gNumberOfDocShells;
+#endif /* DEBUG */
+
+public:
+ class InterfaceRequestorProxy : public nsIInterfaceRequestor
+ {
+ public:
+ explicit InterfaceRequestorProxy(nsIInterfaceRequestor* aRequestor);
+ NS_DECL_THREADSAFE_ISUPPORTS
+ NS_DECL_NSIINTERFACEREQUESTOR
+
+ protected:
+ virtual ~InterfaceRequestorProxy();
+ InterfaceRequestorProxy() {}
+ nsWeakPtr mWeakPtr;
+ };
+};
+
+#endif /* nsDocShell_h__ */