/* -*- 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, nsIPrincipal* aTriggeringPrincipal) 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, nsIPrincipal* aTriggeringPrincipal = nullptr) 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, bool aIsFromProcessingFrameAttributes, bool aLoadFromExternal, bool aForceAllowDataURI, 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__ */