michael@0: /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
michael@0: /* vim: set ts=4 sw=4 tw=80 et: */
michael@0: /* This Source Code Form is subject to the terms of the Mozilla Public
michael@0:  * License, v. 2.0. If a copy of the MPL was not distributed with this
michael@0:  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
michael@0: 
michael@0: #include "nsDocShell.h"
michael@0: 
michael@0: #include <algorithm>
michael@0: 
michael@0: #include "mozilla/ArrayUtils.h"
michael@0: #include "mozilla/Attributes.h"
michael@0: #include "mozilla/AutoRestore.h"
michael@0: #include "mozilla/Casting.h"
michael@0: #include "mozilla/dom/ContentChild.h"
michael@0: #include "mozilla/dom/Element.h"
michael@0: #include "mozilla/dom/TabChild.h"
michael@0: #include "mozilla/EventStateManager.h"
michael@0: #include "mozilla/Preferences.h"
michael@0: #include "mozilla/Services.h"
michael@0: #include "mozilla/StartupTimeline.h"
michael@0: #include "mozilla/Telemetry.h"
michael@0: #include "mozilla/unused.h"
michael@0: #include "mozilla/VisualEventTracer.h"
michael@0: 
michael@0: #ifdef MOZ_LOGGING
michael@0: // so we can get logging even in release builds (but only for some things)
michael@0: #define FORCE_PR_LOG 1
michael@0: #endif
michael@0: 
michael@0: #include "nsIContent.h"
michael@0: #include "nsIDocument.h"
michael@0: #include "nsIDOMDocument.h"
michael@0: #include "nsIDOMElement.h"
michael@0: #include "nsIDOMStorage.h"
michael@0: #include "nsPIDOMStorage.h"
michael@0: #include "nsIContentViewer.h"
michael@0: #include "nsIDocumentLoaderFactory.h"
michael@0: #include "nsCURILoader.h"
michael@0: #include "nsDocShellCID.h"
michael@0: #include "nsDOMCID.h"
michael@0: #include "nsNetUtil.h"
michael@0: #include "nsRect.h"
michael@0: #include "prenv.h"
michael@0: #include "nsIMarkupDocumentViewer.h"
michael@0: #include "nsIDOMWindow.h"
michael@0: #include "nsIWebBrowserChrome.h"
michael@0: #include "nsPoint.h"
michael@0: #include "nsIObserverService.h"
michael@0: #include "nsIPrompt.h"
michael@0: #include "nsIAuthPrompt.h"
michael@0: #include "nsIAuthPrompt2.h"
michael@0: #include "nsIChannelEventSink.h"
michael@0: #include "nsIAsyncVerifyRedirectCallback.h"
michael@0: #include "nsIScriptSecurityManager.h"
michael@0: #include "nsIScriptObjectPrincipal.h"
michael@0: #include "nsIScrollableFrame.h"
michael@0: #include "nsContentPolicyUtils.h" // NS_CheckContentLoadPolicy(...)
michael@0: #include "nsISeekableStream.h"
michael@0: #include "nsAutoPtr.h"
michael@0: #include "nsIWritablePropertyBag2.h"
michael@0: #include "nsIAppShell.h"
michael@0: #include "nsWidgetsCID.h"
michael@0: #include "nsIInterfaceRequestorUtils.h"
michael@0: #include "nsView.h"
michael@0: #include "nsViewManager.h"
michael@0: #include "nsIScriptChannel.h"
michael@0: #include "nsITimedChannel.h"
michael@0: #include "nsIPrivacyTransitionObserver.h"
michael@0: #include "nsIReflowObserver.h"
michael@0: #include "nsIScrollObserver.h"
michael@0: #include "nsIDocShellTreeItem.h"
michael@0: #include "nsIChannel.h"
michael@0: #include "IHistory.h"
michael@0: #include "nsViewSourceHandler.h"
michael@0: 
michael@0: // we want to explore making the document own the load group
michael@0: // so we can associate the document URI with the load group.
michael@0: // until this point, we have an evil hack:
michael@0: #include "nsIHttpChannelInternal.h"  
michael@0: #include "nsPILoadGroupInternal.h"
michael@0: 
michael@0: // Local Includes
michael@0: #include "nsDocShellLoadInfo.h"
michael@0: #include "nsCDefaultURIFixup.h"
michael@0: #include "nsDocShellEnumerator.h"
michael@0: #include "nsSHistory.h"
michael@0: #include "nsDocShellEditorData.h"
michael@0: 
michael@0: // Helper Classes
michael@0: #include "nsError.h"
michael@0: #include "nsEscape.h"
michael@0: 
michael@0: // Interfaces Needed
michael@0: #include "nsIUploadChannel.h"
michael@0: #include "nsIUploadChannel2.h"
michael@0: #include "nsIWebProgress.h"
michael@0: #include "nsILayoutHistoryState.h"
michael@0: #include "nsITimer.h"
michael@0: #include "nsISHistoryInternal.h"
michael@0: #include "nsIPrincipal.h"
michael@0: #include "nsISHEntry.h"
michael@0: #include "nsIWindowWatcher.h"
michael@0: #include "nsIPromptFactory.h"
michael@0: #include "nsITransportSecurityInfo.h"
michael@0: #include "nsINSSErrorsService.h"
michael@0: #include "nsIApplicationCacheChannel.h"
michael@0: #include "nsIApplicationCacheContainer.h"
michael@0: #include "nsStreamUtils.h"
michael@0: #include "nsIController.h"
michael@0: #include "nsPICommandUpdater.h"
michael@0: #include "nsIDOMHTMLAnchorElement.h"
michael@0: #include "nsIWebBrowserChrome3.h"
michael@0: #include "nsITabChild.h"
michael@0: #include "nsISiteSecurityService.h"
michael@0: #include "nsStructuredCloneContainer.h"
michael@0: #include "nsIStructuredCloneContainer.h"
michael@0: #ifdef MOZ_PLACES
michael@0: #include "nsIFaviconService.h"
michael@0: #include "mozIAsyncFavicons.h"
michael@0: #endif
michael@0: #include "nsINetworkSeer.h"
michael@0: 
michael@0: // Editor-related
michael@0: #include "nsIEditingSession.h"
michael@0: 
michael@0: #include "nsPIDOMWindow.h"
michael@0: #include "nsGlobalWindow.h"
michael@0: #include "nsPIWindowRoot.h"
michael@0: #include "nsICachingChannel.h"
michael@0: #include "nsIMultiPartChannel.h"
michael@0: #include "nsIWyciwygChannel.h"
michael@0: 
michael@0: // For reporting errors with the console service.
michael@0: // These can go away if error reporting is propagated up past nsDocShell.
michael@0: #include "nsIScriptError.h"
michael@0: 
michael@0: // used to dispatch urls to default protocol handlers
michael@0: #include "nsCExternalHandlerService.h"
michael@0: #include "nsIExternalProtocolService.h"
michael@0: 
michael@0: #include "nsFocusManager.h"
michael@0: 
michael@0: #include "nsITextToSubURI.h"
michael@0: 
michael@0: #include "nsIJARChannel.h"
michael@0: 
michael@0: #include "prlog.h"
michael@0: 
michael@0: #include "nsISelectionDisplay.h"
michael@0: 
michael@0: #include "nsIGlobalHistory2.h"
michael@0: 
michael@0: #include "nsIFrame.h"
michael@0: #include "nsSubDocumentFrame.h"
michael@0: 
michael@0: // for embedding
michael@0: #include "nsIWebBrowserChromeFocus.h"
michael@0: 
michael@0: #if NS_PRINT_PREVIEW
michael@0: #include "nsIDocumentViewerPrint.h"
michael@0: #include "nsIWebBrowserPrint.h"
michael@0: #endif
michael@0: 
michael@0: #include "nsContentUtils.h"
michael@0: #include "nsCxPusher.h"
michael@0: #include "nsIChannelPolicy.h"
michael@0: #include "nsIContentSecurityPolicy.h"
michael@0: #include "nsSandboxFlags.h"
michael@0: #include "mozIThirdPartyUtil.h"
michael@0: #include "nsXULAppAPI.h"
michael@0: #include "nsDOMNavigationTiming.h"
michael@0: #include "nsISecurityUITelemetry.h"
michael@0: #include "nsIAppsService.h"
michael@0: #include "nsDSURIContentListener.h"
michael@0: #include "nsDocShellLoadTypes.h"
michael@0: #include "nsDocShellTransferableHooks.h"
michael@0: #include "nsICommandManager.h"
michael@0: #include "nsIDOMNode.h"
michael@0: #include "nsIDocShellTreeOwner.h"
michael@0: #include "nsIHttpChannel.h"
michael@0: #include "nsISHContainer.h"
michael@0: #include "nsISHistory.h"
michael@0: #include "nsISecureBrowserUI.h"
michael@0: #include "nsIStringBundle.h"
michael@0: #include "nsISupportsArray.h"
michael@0: #include "nsIURIFixup.h"
michael@0: #include "nsIURILoader.h"
michael@0: #include "nsIWebBrowserFind.h"
michael@0: #include "nsIWidget.h"
michael@0: #include "mozilla/dom/EncodingUtils.h"
michael@0: 
michael@0: static NS_DEFINE_CID(kAppShellCID, NS_APPSHELL_CID);
michael@0: 
michael@0: #if defined(DEBUG_bryner) || defined(DEBUG_chb)
michael@0: //#define DEBUG_DOCSHELL_FOCUS
michael@0: #define DEBUG_PAGE_CACHE
michael@0: #endif
michael@0: 
michael@0: #ifdef XP_WIN
michael@0: #include <process.h>
michael@0: #define getpid _getpid
michael@0: #else
michael@0: #include <unistd.h> // for getpid()
michael@0: #endif
michael@0: 
michael@0: using namespace mozilla;
michael@0: using namespace mozilla::dom;
michael@0: 
michael@0: // True means sUseErrorPages has been added to preferences var cache.
michael@0: static bool gAddedPreferencesVarCache = false;
michael@0: 
michael@0: bool nsDocShell::sUseErrorPages = false;
michael@0: 
michael@0: // Number of documents currently loading
michael@0: static int32_t gNumberOfDocumentsLoading = 0;
michael@0: 
michael@0: // Global count of existing docshells.
michael@0: static int32_t gDocShellCount = 0;
michael@0: 
michael@0: // Global count of docshells with the private attribute set
michael@0: static uint32_t gNumberOfPrivateDocShells = 0;
michael@0: 
michael@0: // Global reference to the URI fixup service.
michael@0: nsIURIFixup *nsDocShell::sURIFixup = 0;
michael@0: 
michael@0: // True means we validate window targets to prevent frameset
michael@0: // spoofing. Initialize this to a non-bolean value so we know to check
michael@0: // the pref on the creation of the first docshell.
michael@0: static uint32_t gValidateOrigin = 0xffffffff;
michael@0: 
michael@0: // Hint for native dispatch of events on how long to delay after 
michael@0: // all documents have loaded in milliseconds before favoring normal
michael@0: // native event dispatch priorites over performance
michael@0: // Can be overridden with docshell.event_starvation_delay_hint pref.
michael@0: #define NS_EVENT_STARVATION_DELAY_HINT 2000
michael@0: 
michael@0: #ifdef PR_LOGGING
michael@0: #ifdef DEBUG
michael@0: static PRLogModuleInfo* gDocShellLog;
michael@0: #endif
michael@0: static PRLogModuleInfo* gDocShellLeakLog;
michael@0: #endif
michael@0: 
michael@0: const char kBrandBundleURL[]      = "chrome://branding/locale/brand.properties";
michael@0: const char kAppstringsBundleURL[] = "chrome://global/locale/appstrings.properties";
michael@0: 
michael@0: static void
michael@0: FavorPerformanceHint(bool perfOverStarvation)
michael@0: {
michael@0:     nsCOMPtr<nsIAppShell> appShell = do_GetService(kAppShellCID);
michael@0:     if (appShell) {
michael@0:         appShell->FavorPerformanceHint(perfOverStarvation,
michael@0:                                        Preferences::GetUint("docshell.event_starvation_delay_hint",
michael@0:                                                             NS_EVENT_STARVATION_DELAY_HINT));
michael@0:     }
michael@0: }
michael@0: 
michael@0: //*****************************************************************************
michael@0: // <a ping> support
michael@0: //*****************************************************************************
michael@0: 
michael@0: #define PREF_PINGS_ENABLED           "browser.send_pings"
michael@0: #define PREF_PINGS_MAX_PER_LINK      "browser.send_pings.max_per_link"
michael@0: #define PREF_PINGS_REQUIRE_SAME_HOST "browser.send_pings.require_same_host"
michael@0: 
michael@0: // Check prefs to see if pings are enabled and if so what restrictions might
michael@0: // be applied.
michael@0: //
michael@0: // @param maxPerLink
michael@0: //   This parameter returns the number of pings that are allowed per link click
michael@0: //
michael@0: // @param requireSameHost
michael@0: //   This parameter returns true if pings are restricted to the same host as
michael@0: //   the document in which the click occurs.  If the same host restriction is
michael@0: //   imposed, then we still allow for pings to cross over to different
michael@0: //   protocols and ports for flexibility and because it is not possible to send
michael@0: //   a ping via FTP.
michael@0: //
michael@0: // @returns
michael@0: //   true if pings are enabled and false otherwise.
michael@0: //
michael@0: static bool
michael@0: PingsEnabled(int32_t *maxPerLink, bool *requireSameHost)
michael@0: {
michael@0:   bool allow = Preferences::GetBool(PREF_PINGS_ENABLED, false);
michael@0: 
michael@0:   *maxPerLink = 1;
michael@0:   *requireSameHost = true;
michael@0: 
michael@0:   if (allow) {
michael@0:     Preferences::GetInt(PREF_PINGS_MAX_PER_LINK, maxPerLink);
michael@0:     Preferences::GetBool(PREF_PINGS_REQUIRE_SAME_HOST, requireSameHost);
michael@0:   }
michael@0: 
michael@0:   return allow;
michael@0: }
michael@0: 
michael@0: static bool
michael@0: CheckPingURI(nsIURI* uri, nsIContent* content)
michael@0: {
michael@0:   if (!uri)
michael@0:     return false;
michael@0: 
michael@0:   // Check with nsIScriptSecurityManager
michael@0:   nsCOMPtr<nsIScriptSecurityManager> ssmgr =
michael@0:     do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID);
michael@0:   NS_ENSURE_TRUE(ssmgr, false);
michael@0: 
michael@0:   nsresult rv =
michael@0:     ssmgr->CheckLoadURIWithPrincipal(content->NodePrincipal(), uri,
michael@0:                                      nsIScriptSecurityManager::STANDARD);
michael@0:   if (NS_FAILED(rv)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   // Ignore non-HTTP(S)
michael@0:   bool match;
michael@0:   if ((NS_FAILED(uri->SchemeIs("http", &match)) || !match) &&
michael@0:       (NS_FAILED(uri->SchemeIs("https", &match)) || !match)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   // Check with contentpolicy
michael@0:   int16_t shouldLoad = nsIContentPolicy::ACCEPT;
michael@0:   rv = NS_CheckContentLoadPolicy(nsIContentPolicy::TYPE_PING,
michael@0:                                  uri,
michael@0:                                  content->NodePrincipal(),
michael@0:                                  content,
michael@0:                                  EmptyCString(), // mime hint
michael@0:                                  nullptr, //extra
michael@0:                                  &shouldLoad);
michael@0:   return NS_SUCCEEDED(rv) && NS_CP_ACCEPTED(shouldLoad);
michael@0: }
michael@0: 
michael@0: typedef void (* ForEachPingCallback)(void *closure, nsIContent *content,
michael@0:                                      nsIURI *uri, nsIIOService *ios);
michael@0: 
michael@0: static void
michael@0: ForEachPing(nsIContent *content, ForEachPingCallback callback, void *closure)
michael@0: {
michael@0:   // NOTE: Using nsIDOMHTMLAnchorElement::GetPing isn't really worth it here
michael@0:   //       since we'd still need to parse the resulting string.  Instead, we
michael@0:   //       just parse the raw attribute.  It might be nice if the content node
michael@0:   //       implemented an interface that exposed an enumeration of nsIURIs.
michael@0: 
michael@0:   // Make sure we are dealing with either an <A> or <AREA> element in the HTML
michael@0:   // or XHTML namespace.
michael@0:   if (!content->IsHTML())
michael@0:     return;
michael@0:   nsIAtom *nameAtom = content->Tag();
michael@0:   if (nameAtom != nsGkAtoms::a && nameAtom != nsGkAtoms::area)
michael@0:     return;
michael@0: 
michael@0:   nsCOMPtr<nsIAtom> pingAtom = do_GetAtom("ping");
michael@0:   if (!pingAtom)
michael@0:     return;
michael@0: 
michael@0:   nsAutoString value;
michael@0:   content->GetAttr(kNameSpaceID_None, pingAtom, value);
michael@0:   if (value.IsEmpty())
michael@0:     return;
michael@0: 
michael@0:   nsCOMPtr<nsIIOService> ios = do_GetIOService();
michael@0:   if (!ios)
michael@0:     return;
michael@0: 
michael@0:   nsIDocument *doc = content->OwnerDoc();
michael@0: 
michael@0:   // value contains relative URIs split on spaces (U+0020)
michael@0:   const char16_t *start = value.BeginReading();
michael@0:   const char16_t *end   = value.EndReading();
michael@0:   const char16_t *iter  = start;
michael@0:   for (;;) {
michael@0:     if (iter < end && *iter != ' ') {
michael@0:       ++iter;
michael@0:     } else {  // iter is pointing at either end or a space
michael@0:       while (*start == ' ' && start < iter)
michael@0:         ++start;
michael@0:       if (iter != start) {
michael@0:         nsCOMPtr<nsIURI> uri, baseURI = content->GetBaseURI();
michael@0:         ios->NewURI(NS_ConvertUTF16toUTF8(Substring(start, iter)),
michael@0:                     doc->GetDocumentCharacterSet().get(),
michael@0:                     baseURI, getter_AddRefs(uri));
michael@0:         if (CheckPingURI(uri, content)) {
michael@0:           callback(closure, content, uri, ios);
michael@0:         }
michael@0:       }
michael@0:       start = iter = iter + 1;
michael@0:       if (iter >= end)
michael@0:         break;
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: //----------------------------------------------------------------------
michael@0: 
michael@0: // We wait this many milliseconds before killing the ping channel...
michael@0: #define PING_TIMEOUT 10000
michael@0: 
michael@0: static void
michael@0: OnPingTimeout(nsITimer *timer, void *closure)
michael@0: {
michael@0:   nsILoadGroup *loadGroup = static_cast<nsILoadGroup *>(closure);
michael@0:   if (loadGroup)
michael@0:     loadGroup->Cancel(NS_ERROR_ABORT);
michael@0: }
michael@0: 
michael@0: // Check to see if two URIs have the same host or not
michael@0: static bool
michael@0: IsSameHost(nsIURI *uri1, nsIURI *uri2)
michael@0: {
michael@0:   nsAutoCString host1, host2;
michael@0:   uri1->GetAsciiHost(host1);
michael@0:   uri2->GetAsciiHost(host2);
michael@0:   return host1.Equals(host2);
michael@0: }
michael@0: 
michael@0: class nsPingListener MOZ_FINAL : public nsIStreamListener
michael@0:                                , public nsIInterfaceRequestor
michael@0:                                , public nsIChannelEventSink
michael@0: {
michael@0: public:
michael@0:   NS_DECL_ISUPPORTS
michael@0:   NS_DECL_NSIREQUESTOBSERVER
michael@0:   NS_DECL_NSISTREAMLISTENER
michael@0:   NS_DECL_NSIINTERFACEREQUESTOR
michael@0:   NS_DECL_NSICHANNELEVENTSINK
michael@0: 
michael@0:   nsPingListener(bool requireSameHost, nsIContent* content, nsILoadGroup* loadGroup)
michael@0:     : mRequireSameHost(requireSameHost),
michael@0:       mContent(content),
michael@0:       mLoadGroup(loadGroup)
michael@0:   {}
michael@0: 
michael@0:   ~nsPingListener();
michael@0: 
michael@0:   nsresult StartTimeout();
michael@0: 
michael@0: private:
michael@0:   bool mRequireSameHost;
michael@0:   nsCOMPtr<nsIContent> mContent;
michael@0:   nsCOMPtr<nsILoadGroup> mLoadGroup;
michael@0:   nsCOMPtr<nsITimer> mTimer;
michael@0: };
michael@0: 
michael@0: NS_IMPL_ISUPPORTS(nsPingListener, nsIStreamListener, nsIRequestObserver,
michael@0:                   nsIInterfaceRequestor, nsIChannelEventSink)
michael@0: 
michael@0: nsPingListener::~nsPingListener()
michael@0: {
michael@0:   if (mTimer) {
michael@0:     mTimer->Cancel();
michael@0:     mTimer = nullptr;
michael@0:   }
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsPingListener::StartTimeout()
michael@0: {
michael@0:   nsCOMPtr<nsITimer> timer = do_CreateInstance(NS_TIMER_CONTRACTID);
michael@0: 
michael@0:   if (timer) {
michael@0:     nsresult rv = timer->InitWithFuncCallback(OnPingTimeout, mLoadGroup,
michael@0:                                               PING_TIMEOUT,
michael@0:                                               nsITimer::TYPE_ONE_SHOT);
michael@0:     if (NS_SUCCEEDED(rv)) {
michael@0:       mTimer = timer;
michael@0:       return NS_OK;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return NS_ERROR_OUT_OF_MEMORY;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsPingListener::OnStartRequest(nsIRequest *request, nsISupports *context)
michael@0: {
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsPingListener::OnDataAvailable(nsIRequest *request, nsISupports *context,
michael@0:                                 nsIInputStream *stream, uint64_t offset,
michael@0:                                 uint32_t count)
michael@0: {
michael@0:   uint32_t result;
michael@0:   return stream->ReadSegments(NS_DiscardSegment, nullptr, count, &result);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsPingListener::OnStopRequest(nsIRequest *request, nsISupports *context,
michael@0:                               nsresult status)
michael@0: {
michael@0:   mLoadGroup = nullptr;
michael@0: 
michael@0:   if (mTimer) {
michael@0:     mTimer->Cancel();
michael@0:     mTimer = nullptr;
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsPingListener::GetInterface(const nsIID &iid, void **result)
michael@0: {
michael@0:   if (iid.Equals(NS_GET_IID(nsIChannelEventSink))) {
michael@0:     NS_ADDREF_THIS();
michael@0:     *result = (nsIChannelEventSink *) this;
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   return NS_ERROR_NO_INTERFACE;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsPingListener::AsyncOnChannelRedirect(nsIChannel *oldChan, nsIChannel *newChan,
michael@0:                                        uint32_t flags,
michael@0:                                        nsIAsyncVerifyRedirectCallback *callback)
michael@0: {
michael@0:   nsCOMPtr<nsIURI> newURI;
michael@0:   newChan->GetURI(getter_AddRefs(newURI));
michael@0: 
michael@0:   if (!CheckPingURI(newURI, mContent))
michael@0:     return NS_ERROR_ABORT;
michael@0: 
michael@0:   if (!mRequireSameHost) {
michael@0:     callback->OnRedirectVerifyCallback(NS_OK);
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   // XXXbz should this be using something more like the nsContentUtils
michael@0:   // same-origin checker?
michael@0:   nsCOMPtr<nsIURI> oldURI;
michael@0:   oldChan->GetURI(getter_AddRefs(oldURI));
michael@0:   NS_ENSURE_STATE(oldURI && newURI);
michael@0: 
michael@0:   if (!IsSameHost(oldURI, newURI))
michael@0:     return NS_ERROR_ABORT;
michael@0: 
michael@0:   callback->OnRedirectVerifyCallback(NS_OK);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: struct SendPingInfo {
michael@0:   int32_t numPings;
michael@0:   int32_t maxPings;
michael@0:   bool    requireSameHost;
michael@0:   nsIURI *target;
michael@0:   nsIURI *referrer;
michael@0: };
michael@0: 
michael@0: static void
michael@0: SendPing(void *closure, nsIContent *content, nsIURI *uri, nsIIOService *ios)
michael@0: {
michael@0:   SendPingInfo *info = static_cast<SendPingInfo *>(closure);
michael@0:   if (info->numPings >= info->maxPings)
michael@0:     return;
michael@0: 
michael@0:   if (info->requireSameHost) {
michael@0:     // Make sure the referrer and the given uri share the same origin.  We
michael@0:     // only require the same hostname.  The scheme and port may differ.
michael@0:     if (!IsSameHost(uri, info->referrer))
michael@0:       return;
michael@0:   }
michael@0: 
michael@0:   nsIDocument *doc = content->OwnerDoc();
michael@0: 
michael@0:   nsCOMPtr<nsIChannel> chan;
michael@0:   ios->NewChannelFromURI(uri, getter_AddRefs(chan));
michael@0:   if (!chan)
michael@0:     return;
michael@0: 
michael@0:   // Don't bother caching the result of this URI load.
michael@0:   chan->SetLoadFlags(nsIRequest::INHIBIT_CACHING);
michael@0: 
michael@0:   nsCOMPtr<nsIHttpChannel> httpChan = do_QueryInterface(chan);
michael@0:   if (!httpChan)
michael@0:     return;
michael@0: 
michael@0:   // This is needed in order for 3rd-party cookie blocking to work.
michael@0:   nsCOMPtr<nsIHttpChannelInternal> httpInternal = do_QueryInterface(httpChan);
michael@0:   if (httpInternal)
michael@0:     httpInternal->SetDocumentURI(doc->GetDocumentURI());
michael@0: 
michael@0: 
michael@0:   httpChan->SetRequestMethod(NS_LITERAL_CSTRING("POST"));
michael@0: 
michael@0:   // Remove extraneous request headers (to reduce request size)
michael@0:   httpChan->SetRequestHeader(NS_LITERAL_CSTRING("accept"),
michael@0:                              EmptyCString(), false);
michael@0:   httpChan->SetRequestHeader(NS_LITERAL_CSTRING("accept-language"),
michael@0:                              EmptyCString(), false);
michael@0:   httpChan->SetRequestHeader(NS_LITERAL_CSTRING("accept-encoding"),
michael@0:                              EmptyCString(), false);
michael@0: 
michael@0:   // Always send a Ping-To header.
michael@0:   nsAutoCString pingTo;
michael@0:   if (NS_SUCCEEDED(info->target->GetSpec(pingTo)))
michael@0:     httpChan->SetRequestHeader(NS_LITERAL_CSTRING("Ping-To"), pingTo, false);
michael@0: 
michael@0:   nsCOMPtr<nsIScriptSecurityManager> sm =
michael@0:     do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID);
michael@0: 
michael@0:   if (sm && info->referrer) {
michael@0:     bool referrerIsSecure;
michael@0:     uint32_t flags = nsIProtocolHandler::URI_SAFE_TO_LOAD_IN_SECURE_CONTEXT;
michael@0:     nsresult rv = NS_URIChainHasFlags(info->referrer, flags, &referrerIsSecure);
michael@0: 
michael@0:     // Default to sending less data if NS_URIChainHasFlags() fails.
michael@0:     referrerIsSecure = NS_FAILED(rv) || referrerIsSecure;
michael@0: 
michael@0:     bool sameOrigin =
michael@0:       NS_SUCCEEDED(sm->CheckSameOriginURI(info->referrer, uri, false));
michael@0: 
michael@0:     // If both the address of the document containing the hyperlink being
michael@0:     // audited and "ping URL" have the same origin or the document containing
michael@0:     // the hyperlink being audited was not retrieved over an encrypted
michael@0:     // connection, send a Ping-From header.
michael@0:     if (sameOrigin || !referrerIsSecure) {
michael@0:       nsAutoCString pingFrom;
michael@0:       if (NS_SUCCEEDED(info->referrer->GetSpec(pingFrom)))
michael@0:         httpChan->SetRequestHeader(NS_LITERAL_CSTRING("Ping-From"), pingFrom, false);
michael@0:     }
michael@0: 
michael@0:     // If the document containing the hyperlink being audited was not retrieved
michael@0:     // over an encrypted connection and its address does not have the same
michael@0:     // origin as "ping URL", send a referrer.
michael@0:     if (!sameOrigin && !referrerIsSecure)
michael@0:       httpChan->SetReferrer(info->referrer);
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIUploadChannel2> uploadChan = do_QueryInterface(httpChan);
michael@0:   if (!uploadChan)
michael@0:     return;
michael@0: 
michael@0:   NS_NAMED_LITERAL_CSTRING(uploadData, "PING");
michael@0: 
michael@0:   nsCOMPtr<nsIInputStream> uploadStream;
michael@0:   NS_NewPostDataStream(getter_AddRefs(uploadStream), false, uploadData);
michael@0:   if (!uploadStream)
michael@0:     return;
michael@0: 
michael@0:   uploadChan->ExplicitSetUploadStream(uploadStream,
michael@0:     NS_LITERAL_CSTRING("text/ping"), uploadData.Length(),
michael@0:     NS_LITERAL_CSTRING("POST"), false);
michael@0: 
michael@0:   // The channel needs to have a loadgroup associated with it, so that we can
michael@0:   // cancel the channel and any redirected channels it may create.
michael@0:   nsCOMPtr<nsILoadGroup> loadGroup =
michael@0:       do_CreateInstance(NS_LOADGROUP_CONTRACTID);
michael@0:   if (!loadGroup)
michael@0:     return;
michael@0:   chan->SetLoadGroup(loadGroup);
michael@0: 
michael@0:   // Construct a listener that merely discards any response.  If successful at
michael@0:   // opening the channel, then it is not necessary to hold a reference to the
michael@0:   // channel.  The networking subsystem will take care of that for us.
michael@0:   nsPingListener *pingListener =
michael@0:       new nsPingListener(info->requireSameHost, content, loadGroup);
michael@0:   if (!pingListener)
michael@0:     return;
michael@0: 
michael@0:   nsCOMPtr<nsIStreamListener> listener(pingListener);
michael@0: 
michael@0:   // Observe redirects as well:
michael@0:   nsCOMPtr<nsIInterfaceRequestor> callbacks = do_QueryInterface(listener);
michael@0:   NS_ASSERTION(callbacks, "oops");
michael@0:   loadGroup->SetNotificationCallbacks(callbacks);
michael@0: 
michael@0:   chan->AsyncOpen(listener, nullptr);
michael@0: 
michael@0:   // Even if AsyncOpen failed, we still count this as a successful ping.  It's
michael@0:   // possible that AsyncOpen may have failed after triggering some background
michael@0:   // process that may have written something to the network.
michael@0:   info->numPings++;
michael@0: 
michael@0:   // Prevent ping requests from stalling and never being garbage collected...
michael@0:   if (NS_FAILED(pingListener->StartTimeout())) {
michael@0:     // If we failed to setup the timer, then we should just cancel the channel
michael@0:     // because we won't be able to ensure that it goes away in a timely manner.
michael@0:     chan->Cancel(NS_ERROR_ABORT);
michael@0:   }
michael@0: }
michael@0: 
michael@0: // Spec: http://whatwg.org/specs/web-apps/current-work/#ping
michael@0: static void
michael@0: DispatchPings(nsIContent *content, nsIURI *target, nsIURI *referrer)
michael@0: {
michael@0:   SendPingInfo info;
michael@0: 
michael@0:   if (!PingsEnabled(&info.maxPings, &info.requireSameHost))
michael@0:     return;
michael@0:   if (info.maxPings == 0)
michael@0:     return;
michael@0: 
michael@0:   info.numPings = 0;
michael@0:   info.target = target;
michael@0:   info.referrer = referrer;
michael@0: 
michael@0:   ForEachPing(content, SendPing, &info);
michael@0: }
michael@0: 
michael@0: static nsDOMPerformanceNavigationType
michael@0: ConvertLoadTypeToNavigationType(uint32_t aLoadType)
michael@0: {
michael@0:   // Not initialized, assume it's normal load.
michael@0:   if (aLoadType == 0) {
michael@0:     aLoadType = LOAD_NORMAL;
michael@0:   }
michael@0: 
michael@0:   nsDOMPerformanceNavigationType result = dom::PerformanceNavigation::TYPE_RESERVED;
michael@0:   switch (aLoadType) {
michael@0:     case LOAD_NORMAL:
michael@0:     case LOAD_NORMAL_EXTERNAL:
michael@0:     case LOAD_NORMAL_BYPASS_CACHE:
michael@0:     case LOAD_NORMAL_BYPASS_PROXY:
michael@0:     case LOAD_NORMAL_BYPASS_PROXY_AND_CACHE:
michael@0:     case LOAD_NORMAL_REPLACE:
michael@0:     case LOAD_NORMAL_ALLOW_MIXED_CONTENT:
michael@0:     case LOAD_LINK:
michael@0:     case LOAD_STOP_CONTENT:
michael@0:     case LOAD_REPLACE_BYPASS_CACHE:
michael@0:         result = dom::PerformanceNavigation::TYPE_NAVIGATE;
michael@0:         break;
michael@0:     case LOAD_HISTORY:
michael@0:         result = dom::PerformanceNavigation::TYPE_BACK_FORWARD;
michael@0:         break;
michael@0:     case LOAD_RELOAD_NORMAL:
michael@0:     case LOAD_RELOAD_CHARSET_CHANGE:
michael@0:     case LOAD_RELOAD_BYPASS_CACHE:
michael@0:     case LOAD_RELOAD_BYPASS_PROXY:
michael@0:     case LOAD_RELOAD_BYPASS_PROXY_AND_CACHE:
michael@0:     case LOAD_RELOAD_ALLOW_MIXED_CONTENT:
michael@0:         result = dom::PerformanceNavigation::TYPE_RELOAD;
michael@0:         break;
michael@0:     case LOAD_STOP_CONTENT_AND_REPLACE:
michael@0:     case LOAD_REFRESH:
michael@0:     case LOAD_BYPASS_HISTORY:
michael@0:     case LOAD_ERROR_PAGE:
michael@0:     case LOAD_PUSHSTATE:
michael@0:         result = dom::PerformanceNavigation::TYPE_RESERVED;
michael@0:         break;
michael@0:     default:
michael@0:         // NS_NOTREACHED("Unexpected load type value");
michael@0:         result = dom::PerformanceNavigation::TYPE_RESERVED;
michael@0:         break;
michael@0:   }
michael@0: 
michael@0:   return result;
michael@0: }
michael@0: 
michael@0: static nsISHEntry* GetRootSHEntry(nsISHEntry *entry);
michael@0: 
michael@0: static void
michael@0: IncreasePrivateDocShellCount()
michael@0: {
michael@0:     gNumberOfPrivateDocShells++;
michael@0:     if (gNumberOfPrivateDocShells > 1 ||
michael@0:         XRE_GetProcessType() != GeckoProcessType_Content) {
michael@0:         return;
michael@0:     }
michael@0: 
michael@0:     mozilla::dom::ContentChild* cc = mozilla::dom::ContentChild::GetSingleton();
michael@0:     cc->SendPrivateDocShellsExist(true);
michael@0: }
michael@0: 
michael@0: static void
michael@0: DecreasePrivateDocShellCount()
michael@0: {
michael@0:     MOZ_ASSERT(gNumberOfPrivateDocShells > 0);
michael@0:     gNumberOfPrivateDocShells--;
michael@0:     if (!gNumberOfPrivateDocShells)
michael@0:     {
michael@0:         if (XRE_GetProcessType() == GeckoProcessType_Content) {
michael@0:             mozilla::dom::ContentChild* cc = mozilla::dom::ContentChild::GetSingleton();
michael@0:             cc->SendPrivateDocShellsExist(false);
michael@0:             return;
michael@0:         }
michael@0: 
michael@0:         nsCOMPtr<nsIObserverService> obsvc = mozilla::services::GetObserverService();
michael@0:         if (obsvc) {
michael@0:             obsvc->NotifyObservers(nullptr, "last-pb-context-exited", nullptr);
michael@0:         }
michael@0:     }
michael@0: }
michael@0: 
michael@0: //*****************************************************************************
michael@0: //***    nsDocShell: Object Management
michael@0: //*****************************************************************************
michael@0: 
michael@0: static uint64_t gDocshellIDCounter = 0;
michael@0: 
michael@0: // Note: operator new zeros our memory
michael@0: nsDocShell::nsDocShell():
michael@0:     nsDocLoader(),
michael@0:     mDefaultScrollbarPref(Scrollbar_Auto, Scrollbar_Auto),
michael@0:     mTreeOwner(nullptr),
michael@0:     mChromeEventHandler(nullptr),
michael@0:     mCharsetReloadState(eCharsetReloadInit),
michael@0:     mChildOffset(0),
michael@0:     mBusyFlags(BUSY_FLAGS_NONE),
michael@0:     mAppType(nsIDocShell::APP_TYPE_UNKNOWN),
michael@0:     mLoadType(0),
michael@0:     mMarginWidth(-1),
michael@0:     mMarginHeight(-1),
michael@0:     mItemType(typeContent),
michael@0:     mPreviousTransIndex(-1),
michael@0:     mLoadedTransIndex(-1),
michael@0:     mSandboxFlags(0),
michael@0:     mFullscreenAllowed(CHECK_ATTRIBUTES),
michael@0:     mCreated(false),
michael@0:     mAllowSubframes(true),
michael@0:     mAllowPlugins(true),
michael@0:     mAllowJavascript(true),
michael@0:     mAllowMetaRedirects(true),
michael@0:     mAllowImages(true),
michael@0:     mAllowMedia(true),
michael@0:     mAllowDNSPrefetch(true),
michael@0:     mAllowWindowControl(true),
michael@0:     mAllowContentRetargeting(true),
michael@0:     mCreatingDocument(false),
michael@0:     mUseErrorPages(false),
michael@0:     mObserveErrorPages(true),
michael@0:     mAllowAuth(true),
michael@0:     mAllowKeywordFixup(false),
michael@0:     mIsOffScreenBrowser(false),
michael@0:     mIsActive(true),
michael@0:     mIsAppTab(false),
michael@0:     mUseGlobalHistory(false),
michael@0:     mInPrivateBrowsing(false),
michael@0:     mUseRemoteTabs(false),
michael@0:     mDeviceSizeIsPageSize(false),
michael@0:     mCanExecuteScripts(false),
michael@0:     mFiredUnloadEvent(false),
michael@0:     mEODForCurrentDocument(false),
michael@0:     mURIResultedInDocument(false),
michael@0:     mIsBeingDestroyed(false),
michael@0:     mIsExecutingOnLoadHandler(false),
michael@0:     mIsPrintingOrPP(false),
michael@0:     mSavingOldViewer(false),
michael@0: #ifdef DEBUG
michael@0:     mInEnsureScriptEnv(false),
michael@0: #endif
michael@0:     mAffectPrivateSessionLifetime(true),
michael@0:     mInvisible(false),
michael@0:     mDefaultLoadFlags(nsIRequest::LOAD_NORMAL),
michael@0:     mFrameType(eFrameTypeRegular),
michael@0:     mOwnOrContainingAppId(nsIScriptSecurityManager::UNKNOWN_APP_ID),
michael@0:     mParentCharsetSource(0)
michael@0: {
michael@0:     mHistoryID = ++gDocshellIDCounter;
michael@0:     if (gDocShellCount++ == 0) {
michael@0:         NS_ASSERTION(sURIFixup == nullptr,
michael@0:                      "Huh, sURIFixup not null in first nsDocShell ctor!");
michael@0: 
michael@0:         CallGetService(NS_URIFIXUP_CONTRACTID, &sURIFixup);
michael@0:     }
michael@0: 
michael@0: #ifdef PR_LOGGING
michael@0: #ifdef DEBUG
michael@0:     if (! gDocShellLog)
michael@0:         gDocShellLog = PR_NewLogModule("nsDocShell");
michael@0: #endif
michael@0:     if (nullptr == gDocShellLeakLog)
michael@0:         gDocShellLeakLog = PR_NewLogModule("nsDocShellLeak");
michael@0:     if (gDocShellLeakLog)
michael@0:         PR_LOG(gDocShellLeakLog, PR_LOG_DEBUG, ("DOCSHELL %p created\n", this));
michael@0: #endif
michael@0: 
michael@0: #ifdef DEBUG
michael@0:   // We're counting the number of |nsDocShells| to help find leaks
michael@0:   ++gNumberOfDocShells;
michael@0:   if (!PR_GetEnv("MOZ_QUIET")) {
michael@0:       printf_stderr("++DOCSHELL %p == %ld [pid = %d] [id = %llu]\n",
michael@0:                     (void*) this,
michael@0:                     gNumberOfDocShells,
michael@0:                     getpid(),
michael@0:                     SafeCast<unsigned long long>(mHistoryID));
michael@0:   }
michael@0: #endif
michael@0: }
michael@0: 
michael@0: nsDocShell::~nsDocShell()
michael@0: {
michael@0:     Destroy();
michael@0: 
michael@0:     nsCOMPtr<nsISHistoryInternal>
michael@0:         shPrivate(do_QueryInterface(mSessionHistory));
michael@0:     if (shPrivate) {
michael@0:         shPrivate->SetRootDocShell(nullptr);
michael@0:     }
michael@0: 
michael@0:     if (--gDocShellCount == 0) {
michael@0:         NS_IF_RELEASE(sURIFixup);
michael@0:     }
michael@0: 
michael@0: #ifdef PR_LOGGING
michael@0:     if (gDocShellLeakLog)
michael@0:         PR_LOG(gDocShellLeakLog, PR_LOG_DEBUG, ("DOCSHELL %p destroyed\n", this));
michael@0: #endif
michael@0: 
michael@0: #ifdef DEBUG
michael@0:     // We're counting the number of |nsDocShells| to help find leaks
michael@0:     --gNumberOfDocShells;
michael@0:     if (!PR_GetEnv("MOZ_QUIET")) {
michael@0:         printf_stderr("--DOCSHELL %p == %ld [pid = %d] [id = %llu]\n",
michael@0:                       (void*) this,
michael@0:                       gNumberOfDocShells,
michael@0:                       getpid(),
michael@0:                       SafeCast<unsigned long long>(mHistoryID));
michael@0:     }
michael@0: #endif
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::Init()
michael@0: {
michael@0:     nsresult rv = nsDocLoader::Init();
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     NS_ASSERTION(mLoadGroup, "Something went wrong!");
michael@0: 
michael@0:     mContentListener = new nsDSURIContentListener(this);
michael@0:     NS_ENSURE_TRUE(mContentListener, NS_ERROR_OUT_OF_MEMORY);
michael@0: 
michael@0:     rv = mContentListener->Init();
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     // We want to hold a strong ref to the loadgroup, so it better hold a weak
michael@0:     // ref to us...  use an InterfaceRequestorProxy to do this.
michael@0:     nsCOMPtr<nsIInterfaceRequestor> proxy =
michael@0:         new InterfaceRequestorProxy(static_cast<nsIInterfaceRequestor*>
michael@0:                                                (this));
michael@0:     NS_ENSURE_TRUE(proxy, NS_ERROR_OUT_OF_MEMORY);
michael@0:     mLoadGroup->SetNotificationCallbacks(proxy);
michael@0: 
michael@0:     rv = nsDocLoader::AddDocLoaderAsChildOfRoot(this);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0:     
michael@0:     // Add as |this| a progress listener to itself.  A little weird, but
michael@0:     // simpler than reproducing all the listener-notification logic in
michael@0:     // overrides of the various methods via which nsDocLoader can be
michael@0:     // notified.   Note that this holds an nsWeakPtr to ourselves, so it's ok.
michael@0:     return AddProgressListener(this, nsIWebProgress::NOTIFY_STATE_DOCUMENT |
michael@0:                                      nsIWebProgress::NOTIFY_STATE_NETWORK);
michael@0:     
michael@0: }
michael@0: 
michael@0: void
michael@0: nsDocShell::DestroyChildren()
michael@0: {
michael@0:     nsCOMPtr<nsIDocShellTreeItem> shell;
michael@0:     nsTObserverArray<nsDocLoader*>::ForwardIterator iter(mChildList);
michael@0:     while (iter.HasMore()) {
michael@0:         shell = do_QueryObject(iter.GetNext());
michael@0:         NS_ASSERTION(shell, "docshell has null child");
michael@0: 
michael@0:         if (shell) {
michael@0:             shell->SetTreeOwner(nullptr);
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     nsDocLoader::DestroyChildren();
michael@0: }
michael@0: 
michael@0: //*****************************************************************************
michael@0: // nsDocShell::nsISupports
michael@0: //*****************************************************************************   
michael@0: 
michael@0: NS_IMPL_ADDREF_INHERITED(nsDocShell, nsDocLoader)
michael@0: NS_IMPL_RELEASE_INHERITED(nsDocShell, nsDocLoader)
michael@0: 
michael@0: NS_INTERFACE_MAP_BEGIN(nsDocShell)
michael@0:     NS_INTERFACE_MAP_ENTRY(nsIDocShell)
michael@0:     NS_INTERFACE_MAP_ENTRY(nsIDocShellTreeItem)
michael@0:     NS_INTERFACE_MAP_ENTRY(nsIWebNavigation)
michael@0:     NS_INTERFACE_MAP_ENTRY(nsIBaseWindow)
michael@0:     NS_INTERFACE_MAP_ENTRY(nsIScrollable)
michael@0:     NS_INTERFACE_MAP_ENTRY(nsITextScroll)
michael@0:     NS_INTERFACE_MAP_ENTRY(nsIDocCharset)
michael@0:     NS_INTERFACE_MAP_ENTRY(nsIRefreshURI)
michael@0:     NS_INTERFACE_MAP_ENTRY(nsIWebProgressListener)
michael@0:     NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
michael@0:     NS_INTERFACE_MAP_ENTRY(nsIContentViewerContainer)
michael@0:     NS_INTERFACE_MAP_ENTRY(nsIWebPageDescriptor)
michael@0:     NS_INTERFACE_MAP_ENTRY(nsIAuthPromptProvider)
michael@0:     NS_INTERFACE_MAP_ENTRY(nsILoadContext)
michael@0:     NS_INTERFACE_MAP_ENTRY(nsIWebShellServices)
michael@0:     NS_INTERFACE_MAP_ENTRY(nsILinkHandler)
michael@0:     NS_INTERFACE_MAP_ENTRY(nsIClipboardCommands)
michael@0:     NS_INTERFACE_MAP_ENTRY(nsIDOMStorageManager)
michael@0: NS_INTERFACE_MAP_END_INHERITING(nsDocLoader)
michael@0: 
michael@0: ///*****************************************************************************
michael@0: // nsDocShell::nsIInterfaceRequestor
michael@0: //*****************************************************************************   
michael@0: NS_IMETHODIMP nsDocShell::GetInterface(const nsIID & aIID, void **aSink)
michael@0: {
michael@0:     NS_PRECONDITION(aSink, "null out param");
michael@0: 
michael@0:     *aSink = nullptr;
michael@0: 
michael@0:     if (aIID.Equals(NS_GET_IID(nsICommandManager))) {
michael@0:         NS_ENSURE_SUCCESS(EnsureCommandHandler(), NS_ERROR_FAILURE);
michael@0:         *aSink = mCommandManager;
michael@0:     }
michael@0:     else if (aIID.Equals(NS_GET_IID(nsIURIContentListener))) {
michael@0:         *aSink = mContentListener;
michael@0:     }
michael@0:     else if ((aIID.Equals(NS_GET_IID(nsIScriptGlobalObject)) ||
michael@0:               aIID.Equals(NS_GET_IID(nsPIDOMWindow)) ||
michael@0:               aIID.Equals(NS_GET_IID(nsIDOMWindow)) ||
michael@0:               aIID.Equals(NS_GET_IID(nsIDOMWindowInternal))) &&
michael@0:              NS_SUCCEEDED(EnsureScriptEnvironment())) {
michael@0:         return mScriptGlobal->QueryInterface(aIID, aSink);
michael@0:     }
michael@0:     else if (aIID.Equals(NS_GET_IID(nsIDOMDocument)) &&
michael@0:              NS_SUCCEEDED(EnsureContentViewer())) {
michael@0:         mContentViewer->GetDOMDocument((nsIDOMDocument **) aSink);
michael@0:         return *aSink ? NS_OK : NS_NOINTERFACE;
michael@0:     }
michael@0:     else if (aIID.Equals(NS_GET_IID(nsIDocument)) &&
michael@0:              NS_SUCCEEDED(EnsureContentViewer())) {
michael@0:         nsCOMPtr<nsIDocument> doc = mContentViewer->GetDocument();
michael@0:         doc.forget(aSink);
michael@0:         return *aSink ? NS_OK : NS_NOINTERFACE;
michael@0:     }
michael@0:     else if (aIID.Equals(NS_GET_IID(nsIApplicationCacheContainer))) {
michael@0:         *aSink = nullptr;
michael@0: 
michael@0:         // Return application cache associated with this docshell, if any
michael@0: 
michael@0:         nsCOMPtr<nsIContentViewer> contentViewer;
michael@0:         GetContentViewer(getter_AddRefs(contentViewer));
michael@0:         if (!contentViewer)
michael@0:             return NS_ERROR_NO_INTERFACE;
michael@0: 
michael@0:         nsCOMPtr<nsIDOMDocument> domDoc;
michael@0:         contentViewer->GetDOMDocument(getter_AddRefs(domDoc));
michael@0:         NS_ASSERTION(domDoc, "Should have a document.");
michael@0:         if (!domDoc)
michael@0:             return NS_ERROR_NO_INTERFACE;
michael@0: 
michael@0: #if defined(PR_LOGGING) && defined(DEBUG)
michael@0:         PR_LOG(gDocShellLog, PR_LOG_DEBUG,
michael@0:                ("nsDocShell[%p]: returning app cache container %p",
michael@0:                 this, domDoc.get()));
michael@0: #endif
michael@0:         return domDoc->QueryInterface(aIID, aSink);
michael@0:     }
michael@0:     else if (aIID.Equals(NS_GET_IID(nsIPrompt)) &&
michael@0:              NS_SUCCEEDED(EnsureScriptEnvironment())) {
michael@0:         nsresult rv;
michael@0:         nsCOMPtr<nsIWindowWatcher> wwatch =
michael@0:             do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv);
michael@0:         NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:         // Get the an auth prompter for our window so that the parenting
michael@0:         // of the dialogs works as it should when using tabs.
michael@0:         nsIPrompt *prompt;
michael@0:         rv = wwatch->GetNewPrompter(mScriptGlobal, &prompt);
michael@0:         NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:         *aSink = prompt;
michael@0:         return NS_OK;
michael@0:     }
michael@0:     else if (aIID.Equals(NS_GET_IID(nsIAuthPrompt)) ||
michael@0:              aIID.Equals(NS_GET_IID(nsIAuthPrompt2))) {
michael@0:         return NS_SUCCEEDED(
michael@0:                 GetAuthPrompt(PROMPT_NORMAL, aIID, aSink)) ?
michael@0:                 NS_OK : NS_NOINTERFACE;
michael@0:     }
michael@0:     else if (aIID.Equals(NS_GET_IID(nsISHistory))) {
michael@0:         nsCOMPtr<nsISHistory> shistory;
michael@0:         nsresult
michael@0:             rv =
michael@0:             GetSessionHistory(getter_AddRefs(shistory));
michael@0:         if (NS_SUCCEEDED(rv) && shistory) {
michael@0:             *aSink = shistory;
michael@0:             NS_ADDREF((nsISupports *) * aSink);
michael@0:             return NS_OK;
michael@0:         }
michael@0:         return NS_NOINTERFACE;
michael@0:     }
michael@0:     else if (aIID.Equals(NS_GET_IID(nsIWebBrowserFind))) {
michael@0:         nsresult rv = EnsureFind();
michael@0:         if (NS_FAILED(rv)) return rv;
michael@0: 
michael@0:         *aSink = mFind;
michael@0:         NS_ADDREF((nsISupports*)*aSink);
michael@0:         return NS_OK;
michael@0:     }
michael@0:     else if (aIID.Equals(NS_GET_IID(nsIEditingSession)) && NS_SUCCEEDED(EnsureEditorData())) {
michael@0:       nsCOMPtr<nsIEditingSession> editingSession;
michael@0:       mEditorData->GetEditingSession(getter_AddRefs(editingSession));
michael@0:       if (editingSession)
michael@0:       {
michael@0:         *aSink = editingSession;
michael@0:         NS_ADDREF((nsISupports *)*aSink);
michael@0:         return NS_OK;
michael@0:       }  
michael@0: 
michael@0:       return NS_NOINTERFACE;   
michael@0:     }
michael@0:     else if (aIID.Equals(NS_GET_IID(nsIClipboardDragDropHookList)) 
michael@0:             && NS_SUCCEEDED(EnsureTransferableHookData())) {
michael@0:         *aSink = mTransferableHookData;
michael@0:         NS_ADDREF((nsISupports *)*aSink);
michael@0:         return NS_OK;
michael@0:     }
michael@0:     else if (aIID.Equals(NS_GET_IID(nsISelectionDisplay))) {
michael@0:       nsIPresShell* shell = GetPresShell();
michael@0:       if (shell)
michael@0:         return shell->QueryInterface(aIID,aSink);    
michael@0:     }
michael@0:     else if (aIID.Equals(NS_GET_IID(nsIDocShellTreeOwner))) {
michael@0:       nsCOMPtr<nsIDocShellTreeOwner> treeOwner;
michael@0:       nsresult rv = GetTreeOwner(getter_AddRefs(treeOwner));
michael@0:       if (NS_SUCCEEDED(rv) && treeOwner)
michael@0:         return treeOwner->QueryInterface(aIID, aSink);
michael@0:     }
michael@0:     else if (aIID.Equals(NS_GET_IID(nsITabChild))) {
michael@0:       nsCOMPtr<nsIDocShellTreeOwner> treeOwner;
michael@0:       nsresult rv = GetTreeOwner(getter_AddRefs(treeOwner));
michael@0:       if (NS_SUCCEEDED(rv) && treeOwner) {
michael@0:         nsCOMPtr<nsIInterfaceRequestor> ir = do_QueryInterface(treeOwner);
michael@0:         if (ir)
michael@0:           return ir->GetInterface(aIID, aSink);
michael@0:       }
michael@0:     }
michael@0:     else if (aIID.Equals(NS_GET_IID(nsIContentFrameMessageManager))) {
michael@0:       nsCOMPtr<nsITabChild> tabChild =
michael@0:         do_GetInterface(static_cast<nsIDocShell*>(this));
michael@0:       nsCOMPtr<nsIContentFrameMessageManager> mm;
michael@0:       if (tabChild) {
michael@0:         tabChild->
michael@0:           GetMessageManager(getter_AddRefs(mm));
michael@0:       } else {
michael@0:         nsCOMPtr<nsPIDOMWindow> win =
michael@0:           do_GetInterface(static_cast<nsIDocShell*>(this));
michael@0:         if (win) {
michael@0:           mm = do_QueryInterface(win->GetParentTarget());
michael@0:         }
michael@0:       }
michael@0:       *aSink = mm.get();
michael@0:     }
michael@0:     else {
michael@0:       return nsDocLoader::GetInterface(aIID, aSink);
michael@0:     }
michael@0: 
michael@0:     NS_IF_ADDREF(((nsISupports *) * aSink));
michael@0:     return *aSink ? NS_OK : NS_NOINTERFACE;
michael@0: }
michael@0: 
michael@0: uint32_t
michael@0: nsDocShell::
michael@0: ConvertDocShellLoadInfoToLoadType(nsDocShellInfoLoadType aDocShellLoadType)
michael@0: {
michael@0:     uint32_t loadType = LOAD_NORMAL;
michael@0: 
michael@0:     switch (aDocShellLoadType) {
michael@0:     case nsIDocShellLoadInfo::loadNormal:
michael@0:         loadType = LOAD_NORMAL;
michael@0:         break;
michael@0:     case nsIDocShellLoadInfo::loadNormalReplace:
michael@0:         loadType = LOAD_NORMAL_REPLACE;
michael@0:         break;
michael@0:     case nsIDocShellLoadInfo::loadNormalExternal:
michael@0:         loadType = LOAD_NORMAL_EXTERNAL;
michael@0:         break;
michael@0:     case nsIDocShellLoadInfo::loadHistory:
michael@0:         loadType = LOAD_HISTORY;
michael@0:         break;
michael@0:     case nsIDocShellLoadInfo::loadNormalBypassCache:
michael@0:         loadType = LOAD_NORMAL_BYPASS_CACHE;
michael@0:         break;
michael@0:     case nsIDocShellLoadInfo::loadNormalBypassProxy:
michael@0:         loadType = LOAD_NORMAL_BYPASS_PROXY;
michael@0:         break;
michael@0:     case nsIDocShellLoadInfo::loadNormalBypassProxyAndCache:
michael@0:         loadType = LOAD_NORMAL_BYPASS_PROXY_AND_CACHE;
michael@0:         break;
michael@0:     case nsIDocShellLoadInfo::loadNormalAllowMixedContent:
michael@0:         loadType = LOAD_NORMAL_ALLOW_MIXED_CONTENT;
michael@0:         break;
michael@0:     case nsIDocShellLoadInfo::loadReloadNormal:
michael@0:         loadType = LOAD_RELOAD_NORMAL;
michael@0:         break;
michael@0:     case nsIDocShellLoadInfo::loadReloadCharsetChange:
michael@0:         loadType = LOAD_RELOAD_CHARSET_CHANGE;
michael@0:         break;
michael@0:     case nsIDocShellLoadInfo::loadReloadBypassCache:
michael@0:         loadType = LOAD_RELOAD_BYPASS_CACHE;
michael@0:         break;
michael@0:     case nsIDocShellLoadInfo::loadReloadBypassProxy:
michael@0:         loadType = LOAD_RELOAD_BYPASS_PROXY;
michael@0:         break;
michael@0:     case nsIDocShellLoadInfo::loadReloadBypassProxyAndCache:
michael@0:         loadType = LOAD_RELOAD_BYPASS_PROXY_AND_CACHE;
michael@0:         break;
michael@0:     case nsIDocShellLoadInfo::loadLink:
michael@0:         loadType = LOAD_LINK;
michael@0:         break;
michael@0:     case nsIDocShellLoadInfo::loadRefresh:
michael@0:         loadType = LOAD_REFRESH;
michael@0:         break;
michael@0:     case nsIDocShellLoadInfo::loadBypassHistory:
michael@0:         loadType = LOAD_BYPASS_HISTORY;
michael@0:         break;
michael@0:     case nsIDocShellLoadInfo::loadStopContent:
michael@0:         loadType = LOAD_STOP_CONTENT;
michael@0:         break;
michael@0:     case nsIDocShellLoadInfo::loadStopContentAndReplace:
michael@0:         loadType = LOAD_STOP_CONTENT_AND_REPLACE;
michael@0:         break;
michael@0:     case nsIDocShellLoadInfo::loadPushState:
michael@0:         loadType = LOAD_PUSHSTATE;
michael@0:         break;
michael@0:     case nsIDocShellLoadInfo::loadReplaceBypassCache:
michael@0:         loadType = LOAD_REPLACE_BYPASS_CACHE;
michael@0:         break;
michael@0:     case nsIDocShellLoadInfo::loadReloadMixedContent:
michael@0:         loadType = LOAD_RELOAD_ALLOW_MIXED_CONTENT;
michael@0:         break;
michael@0:     default:
michael@0:         NS_NOTREACHED("Unexpected nsDocShellInfoLoadType value");
michael@0:     }
michael@0: 
michael@0:     return loadType;
michael@0: }
michael@0: 
michael@0: 
michael@0: nsDocShellInfoLoadType
michael@0: nsDocShell::ConvertLoadTypeToDocShellLoadInfo(uint32_t aLoadType)
michael@0: {
michael@0:     nsDocShellInfoLoadType docShellLoadType = nsIDocShellLoadInfo::loadNormal;
michael@0:     switch (aLoadType) {
michael@0:     case LOAD_NORMAL:
michael@0:         docShellLoadType = nsIDocShellLoadInfo::loadNormal;
michael@0:         break;
michael@0:     case LOAD_NORMAL_REPLACE:
michael@0:         docShellLoadType = nsIDocShellLoadInfo::loadNormalReplace;
michael@0:         break;
michael@0:     case LOAD_NORMAL_EXTERNAL:
michael@0:         docShellLoadType = nsIDocShellLoadInfo::loadNormalExternal;
michael@0:         break;
michael@0:     case LOAD_NORMAL_BYPASS_CACHE:
michael@0:         docShellLoadType = nsIDocShellLoadInfo::loadNormalBypassCache;
michael@0:         break;
michael@0:     case LOAD_NORMAL_BYPASS_PROXY:
michael@0:         docShellLoadType = nsIDocShellLoadInfo::loadNormalBypassProxy;
michael@0:         break;
michael@0:     case LOAD_NORMAL_BYPASS_PROXY_AND_CACHE:
michael@0:         docShellLoadType = nsIDocShellLoadInfo::loadNormalBypassProxyAndCache;
michael@0:         break;
michael@0:     case LOAD_NORMAL_ALLOW_MIXED_CONTENT:
michael@0:         docShellLoadType = nsIDocShellLoadInfo::loadNormalAllowMixedContent;
michael@0:         break;
michael@0:     case LOAD_HISTORY:
michael@0:         docShellLoadType = nsIDocShellLoadInfo::loadHistory;
michael@0:         break;
michael@0:     case LOAD_RELOAD_NORMAL:
michael@0:         docShellLoadType = nsIDocShellLoadInfo::loadReloadNormal;
michael@0:         break;
michael@0:     case LOAD_RELOAD_CHARSET_CHANGE:
michael@0:         docShellLoadType = nsIDocShellLoadInfo::loadReloadCharsetChange;
michael@0:         break;
michael@0:     case LOAD_RELOAD_BYPASS_CACHE:
michael@0:         docShellLoadType = nsIDocShellLoadInfo::loadReloadBypassCache;
michael@0:         break;
michael@0:     case LOAD_RELOAD_BYPASS_PROXY:
michael@0:         docShellLoadType = nsIDocShellLoadInfo::loadReloadBypassProxy;
michael@0:         break;
michael@0:     case LOAD_RELOAD_BYPASS_PROXY_AND_CACHE:
michael@0:         docShellLoadType = nsIDocShellLoadInfo::loadReloadBypassProxyAndCache;
michael@0:         break;
michael@0:     case LOAD_LINK:
michael@0:         docShellLoadType = nsIDocShellLoadInfo::loadLink;
michael@0:         break;
michael@0:     case LOAD_REFRESH:
michael@0:         docShellLoadType = nsIDocShellLoadInfo::loadRefresh;
michael@0:         break;
michael@0:     case LOAD_BYPASS_HISTORY:
michael@0:     case LOAD_ERROR_PAGE:
michael@0:         docShellLoadType = nsIDocShellLoadInfo::loadBypassHistory;
michael@0:         break;
michael@0:     case LOAD_STOP_CONTENT:
michael@0:         docShellLoadType = nsIDocShellLoadInfo::loadStopContent;
michael@0:         break;
michael@0:     case LOAD_STOP_CONTENT_AND_REPLACE:
michael@0:         docShellLoadType = nsIDocShellLoadInfo::loadStopContentAndReplace;
michael@0:         break;
michael@0:     case LOAD_PUSHSTATE:
michael@0:         docShellLoadType = nsIDocShellLoadInfo::loadPushState;
michael@0:         break;
michael@0:     case LOAD_REPLACE_BYPASS_CACHE:
michael@0:         docShellLoadType = nsIDocShellLoadInfo::loadReplaceBypassCache;
michael@0:         break;
michael@0:     case LOAD_RELOAD_ALLOW_MIXED_CONTENT:
michael@0:         docShellLoadType = nsIDocShellLoadInfo::loadReloadMixedContent;
michael@0:         break;
michael@0:     default:
michael@0:         NS_NOTREACHED("Unexpected load type value");
michael@0:     }
michael@0: 
michael@0:     return docShellLoadType;
michael@0: }                                                                               
michael@0: 
michael@0: //*****************************************************************************
michael@0: // nsDocShell::nsIDocShell
michael@0: //*****************************************************************************   
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::LoadURI(nsIURI * aURI,
michael@0:                     nsIDocShellLoadInfo * aLoadInfo,
michael@0:                     uint32_t aLoadFlags,
michael@0:                     bool aFirstParty)
michael@0: {
michael@0:     NS_PRECONDITION(aLoadInfo || (aLoadFlags & EXTRA_LOAD_FLAGS) == 0,
michael@0:                     "Unexpected flags");
michael@0:     NS_PRECONDITION((aLoadFlags & 0xf) == 0, "Should not have these flags set");
michael@0:     
michael@0:     // Note: we allow loads to get through here even if mFiredUnloadEvent is
michael@0:     // true; that case will get handled in LoadInternal or LoadHistoryEntry.
michael@0:     if (IsPrintingOrPP()) {
michael@0:       return NS_OK; // JS may not handle returning of an error code
michael@0:     }
michael@0:     nsCOMPtr<nsIURI> referrer;
michael@0:     nsCOMPtr<nsIInputStream> postStream;
michael@0:     nsCOMPtr<nsIInputStream> headersStream;
michael@0:     nsCOMPtr<nsISupports> owner;
michael@0:     bool inheritOwner = false;
michael@0:     bool ownerIsExplicit = false;
michael@0:     bool sendReferrer = true;
michael@0:     bool isSrcdoc = false;
michael@0:     nsCOMPtr<nsISHEntry> shEntry;
michael@0:     nsXPIDLString target;
michael@0:     nsAutoString srcdoc;
michael@0:     nsCOMPtr<nsIDocShell> sourceDocShell;
michael@0:     nsCOMPtr<nsIURI> baseURI;
michael@0: 
michael@0:     uint32_t loadType = MAKE_LOAD_TYPE(LOAD_NORMAL, aLoadFlags);    
michael@0: 
michael@0:     NS_ENSURE_ARG(aURI);
michael@0: 
michael@0:     if (!StartupTimeline::HasRecord(StartupTimeline::FIRST_LOAD_URI) &&
michael@0:         mItemType == typeContent && !NS_IsAboutBlank(aURI)) {
michael@0:         StartupTimeline::RecordOnce(StartupTimeline::FIRST_LOAD_URI);
michael@0:     }
michael@0: 
michael@0:     // Extract the info from the DocShellLoadInfo struct...
michael@0:     if (aLoadInfo) {
michael@0:         aLoadInfo->GetReferrer(getter_AddRefs(referrer));
michael@0: 
michael@0:         nsDocShellInfoLoadType lt = nsIDocShellLoadInfo::loadNormal;
michael@0:         aLoadInfo->GetLoadType(&lt);
michael@0:         // Get the appropriate loadType from nsIDocShellLoadInfo type
michael@0:         loadType = ConvertDocShellLoadInfoToLoadType(lt);
michael@0: 
michael@0:         aLoadInfo->GetOwner(getter_AddRefs(owner));
michael@0:         aLoadInfo->GetInheritOwner(&inheritOwner);
michael@0:         aLoadInfo->GetOwnerIsExplicit(&ownerIsExplicit);
michael@0:         aLoadInfo->GetSHEntry(getter_AddRefs(shEntry));
michael@0:         aLoadInfo->GetTarget(getter_Copies(target));
michael@0:         aLoadInfo->GetPostDataStream(getter_AddRefs(postStream));
michael@0:         aLoadInfo->GetHeadersStream(getter_AddRefs(headersStream));
michael@0:         aLoadInfo->GetSendReferrer(&sendReferrer);
michael@0:         aLoadInfo->GetIsSrcdocLoad(&isSrcdoc);
michael@0:         aLoadInfo->GetSrcdocData(srcdoc);
michael@0:         aLoadInfo->GetSourceDocShell(getter_AddRefs(sourceDocShell));
michael@0:         aLoadInfo->GetBaseURI(getter_AddRefs(baseURI));
michael@0:     }
michael@0: 
michael@0: #if defined(PR_LOGGING) && defined(DEBUG)
michael@0:     if (PR_LOG_TEST(gDocShellLog, PR_LOG_DEBUG)) {
michael@0:         nsAutoCString uristr;
michael@0:         aURI->GetAsciiSpec(uristr);
michael@0:         PR_LOG(gDocShellLog, PR_LOG_DEBUG,
michael@0:                ("nsDocShell[%p]: loading %s with flags 0x%08x",
michael@0:                 this, uristr.get(), aLoadFlags));
michael@0:     }
michael@0: #endif
michael@0: 
michael@0:     if (!shEntry &&
michael@0:         !LOAD_TYPE_HAS_FLAGS(loadType, LOAD_FLAGS_REPLACE_HISTORY)) {
michael@0:         // First verify if this is a subframe.
michael@0:         nsCOMPtr<nsIDocShellTreeItem> parentAsItem;
michael@0:         GetSameTypeParent(getter_AddRefs(parentAsItem));
michael@0:         nsCOMPtr<nsIDocShell> parentDS(do_QueryInterface(parentAsItem));
michael@0:         uint32_t parentLoadType;
michael@0: 
michael@0:         if (parentDS && parentDS != static_cast<nsIDocShell *>(this)) {
michael@0:             /* OK. It is a subframe. Checkout the 
michael@0:              * parent's loadtype. If the parent was loaded thro' a history
michael@0:              * mechanism, then get the SH entry for the child from the parent.
michael@0:              * This is done to restore frameset navigation while going back/forward.
michael@0:              * If the parent was loaded through any other loadType, set the
michael@0:              * child's loadType too accordingly, so that session history does not
michael@0:              * get confused. 
michael@0:              */
michael@0:             
michael@0:             // Get the parent's load type
michael@0:             parentDS->GetLoadType(&parentLoadType);            
michael@0: 
michael@0:             // Get the ShEntry for the child from the parent
michael@0:             nsCOMPtr<nsISHEntry> currentSH;
michael@0:             bool oshe = false;
michael@0:             parentDS->GetCurrentSHEntry(getter_AddRefs(currentSH), &oshe);
michael@0:             bool dynamicallyAddedChild = mDynamicallyCreated;
michael@0:             if (!dynamicallyAddedChild && !oshe && currentSH) {
michael@0:                 currentSH->HasDynamicallyAddedChild(&dynamicallyAddedChild);
michael@0:             }
michael@0:             if (!dynamicallyAddedChild) {
michael@0:                 // Only use the old SHEntry, if we're sure enough that
michael@0:                 // it wasn't originally for some other frame.
michael@0:                 parentDS->GetChildSHEntry(mChildOffset, getter_AddRefs(shEntry));
michael@0:             }
michael@0: 
michael@0:             // Make some decisions on the child frame's loadType based on the 
michael@0:             // parent's loadType. 
michael@0:             if (mCurrentURI == nullptr) {
michael@0:                 // This is a newly created frame. Check for exception cases first. 
michael@0:                 // By default the subframe will inherit the parent's loadType.
michael@0:                 if (shEntry && (parentLoadType == LOAD_NORMAL ||
michael@0:                             parentLoadType == LOAD_LINK   ||
michael@0:                             parentLoadType == LOAD_NORMAL_EXTERNAL)) {
michael@0:                     // The parent was loaded normally. In this case, this *brand new* child really shouldn't
michael@0:                     // have a SHEntry. If it does, it could be because the parent is replacing an
michael@0:                     // existing frame with a new frame, in the onLoadHandler. We don't want this
michael@0:                     // url to get into session history. Clear off shEntry, and set load type to
michael@0:                     // LOAD_BYPASS_HISTORY. 
michael@0:                     bool inOnLoadHandler=false;
michael@0:                     parentDS->GetIsExecutingOnLoadHandler(&inOnLoadHandler);
michael@0:                     if (inOnLoadHandler) {
michael@0:                         loadType = LOAD_NORMAL_REPLACE;
michael@0:                         shEntry = nullptr;
michael@0:                     }
michael@0:                 }   else if (parentLoadType == LOAD_REFRESH) {
michael@0:                     // Clear shEntry. For refresh loads, we have to load
michael@0:                     // what comes thro' the pipe, not what's in history.
michael@0:                     shEntry = nullptr;
michael@0:                 } else if ((parentLoadType == LOAD_BYPASS_HISTORY) ||
michael@0:                         (shEntry && 
michael@0:                          ((parentLoadType & LOAD_CMD_HISTORY) || 
michael@0:                           (parentLoadType == LOAD_RELOAD_NORMAL) || 
michael@0:                           (parentLoadType == LOAD_RELOAD_CHARSET_CHANGE)))) {
michael@0:                     // If the parent url, bypassed history or was loaded from
michael@0:                     // history, pass on the parent's loadType to the new child 
michael@0:                     // frame too, so that the child frame will also
michael@0:                     // avoid getting into history. 
michael@0:                     loadType = parentLoadType;
michael@0:                 } else if (parentLoadType == LOAD_ERROR_PAGE) {
michael@0:                     // If the parent document is an error page, we don't
michael@0:                     // want to update global/session history. However,
michael@0:                     // this child frame is not an error page.
michael@0:                     loadType = LOAD_BYPASS_HISTORY;
michael@0:                 } else if ((parentLoadType == LOAD_RELOAD_BYPASS_CACHE) ||
michael@0:                            (parentLoadType == LOAD_RELOAD_BYPASS_PROXY) ||
michael@0:                            (parentLoadType == LOAD_RELOAD_BYPASS_PROXY_AND_CACHE)) {
michael@0:                     // the new frame should inherit the parent's load type so that it also
michael@0:                     // bypasses the cache and/or proxy
michael@0:                     loadType = parentLoadType;
michael@0:                 }
michael@0:             } else {
michael@0:                 // This is a pre-existing subframe. If the load was not originally initiated
michael@0:                 // by session history, (if (!shEntry) condition succeeded) and mCurrentURI is not null,
michael@0:                 // it is possible that a parent's onLoadHandler or even self's onLoadHandler is loading 
michael@0:                 // a new page in this child. Check parent's and self's busy flag  and if it is set,
michael@0:                 // we don't want this onLoadHandler load to get in to session history.
michael@0:                 uint32_t parentBusy = BUSY_FLAGS_NONE;
michael@0:                 uint32_t selfBusy = BUSY_FLAGS_NONE;
michael@0:                 parentDS->GetBusyFlags(&parentBusy);                    
michael@0:                 GetBusyFlags(&selfBusy);
michael@0:                 if (parentBusy & BUSY_FLAGS_BUSY ||
michael@0:                         selfBusy & BUSY_FLAGS_BUSY) {
michael@0:                     loadType = LOAD_NORMAL_REPLACE;
michael@0:                     shEntry = nullptr; 
michael@0:                 }
michael@0:             }
michael@0:         } //parentDS
michael@0:         else {  
michael@0:             // This is the root docshell. If we got here while  
michael@0:             // executing an onLoad Handler,this load will not go 
michael@0:             // into session history.
michael@0:             bool inOnLoadHandler=false;
michael@0:             GetIsExecutingOnLoadHandler(&inOnLoadHandler);
michael@0:             if (inOnLoadHandler) {
michael@0:                 loadType = LOAD_NORMAL_REPLACE;
michael@0:             }
michael@0:         } 
michael@0:     } // !shEntry
michael@0: 
michael@0:     if (shEntry) {
michael@0: #ifdef DEBUG
michael@0:         PR_LOG(gDocShellLog, PR_LOG_DEBUG,
michael@0:               ("nsDocShell[%p]: loading from session history", this));
michael@0: #endif
michael@0: 
michael@0:         return LoadHistoryEntry(shEntry, loadType);
michael@0:     }
michael@0: 
michael@0:     // On history navigation via Back/Forward buttons, don't execute
michael@0:     // automatic JavaScript redirection such as |location.href = ...| or
michael@0:     // |window.open()|
michael@0:     //
michael@0:     // LOAD_NORMAL:        window.open(...) etc.
michael@0:     // LOAD_STOP_CONTENT:  location.href = ..., location.assign(...)
michael@0:     if ((loadType == LOAD_NORMAL || loadType == LOAD_STOP_CONTENT) &&
michael@0:         ShouldBlockLoadingForBackButton()) {
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     // Perform the load...
michael@0: 
michael@0:     // We need an owner (a referring principal).
michael@0:     //
michael@0:     // If ownerIsExplicit is not set there are 4 possibilities:
michael@0:     // (1) If the system principal or an expanded principal was passed
michael@0:     //     in and we're a typeContent docshell, inherit the principal
michael@0:     //     from the current document instead.
michael@0:     // (2) In all other cases when the principal passed in is not null,
michael@0:     //     use that principal.
michael@0:     // (3) If the caller has allowed inheriting from the current document,
michael@0:     //     or if we're being called from system code (eg chrome JS or pure
michael@0:     //     C++) then inheritOwner should be true and InternalLoad will get
michael@0:     //     an owner from the current document. If none of these things are
michael@0:     //     true, then
michael@0:     // (4) we pass a null owner into the channel, and an owner will be
michael@0:     //     created later from the channel's internal data.
michael@0:     //
michael@0:     // If ownerIsExplicit *is* set, there are 4 possibilities
michael@0:     // (1) If the system principal or an expanded principal was passed in
michael@0:     //     and we're a typeContent docshell, return an error.
michael@0:     // (2) In all other cases when the principal passed in is not null,
michael@0:     //     use that principal.
michael@0:     // (3) If the caller has allowed inheriting from the current document,
michael@0:     //     then inheritOwner should be true and InternalLoad will get an owner
michael@0:     //     from the current document. If none of these things are true, then
michael@0:     // (4) we pass a null owner into the channel, and an owner will be
michael@0:     //     created later from the channel's internal data.
michael@0:     //
michael@0:     // NOTE: This all only works because the only thing the owner is used  
michael@0:     //       for in InternalLoad is data:, javascript:, and about:blank
michael@0:     //       URIs.  For other URIs this would all be dead wrong!
michael@0: 
michael@0:     if (owner && mItemType != typeChrome) {
michael@0:         nsCOMPtr<nsIPrincipal> ownerPrincipal = do_QueryInterface(owner);
michael@0:         if (nsContentUtils::IsSystemOrExpandedPrincipal(ownerPrincipal)) {
michael@0:             if (ownerIsExplicit) {
michael@0:                 return NS_ERROR_DOM_SECURITY_ERR;
michael@0:             }
michael@0:             owner = nullptr;
michael@0:             inheritOwner = true;
michael@0:         }
michael@0:     }
michael@0:     if (!owner && !inheritOwner && !ownerIsExplicit) {
michael@0:         // See if there's system or chrome JS code running
michael@0:         inheritOwner = nsContentUtils::IsSystemPrincipal(
michael@0:           nsContentUtils::GetSubjectPrincipal());
michael@0:     }
michael@0: 
michael@0:     if (aLoadFlags & LOAD_FLAGS_DISALLOW_INHERIT_OWNER) {
michael@0:         inheritOwner = false;
michael@0:         owner = do_CreateInstance("@mozilla.org/nullprincipal;1");
michael@0:     }
michael@0: 
michael@0:     uint32_t flags = 0;
michael@0: 
michael@0:     if (inheritOwner)
michael@0:         flags |= INTERNAL_LOAD_FLAGS_INHERIT_OWNER;
michael@0: 
michael@0:     if (!sendReferrer)
michael@0:         flags |= INTERNAL_LOAD_FLAGS_DONT_SEND_REFERRER;
michael@0:             
michael@0:     if (aLoadFlags & LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP)
michael@0:         flags |= INTERNAL_LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP;
michael@0: 
michael@0:     if (aLoadFlags & LOAD_FLAGS_FIXUP_SCHEME_TYPOS)
michael@0:         flags |= INTERNAL_LOAD_FLAGS_FIXUP_SCHEME_TYPOS;
michael@0: 
michael@0:     if (aLoadFlags & LOAD_FLAGS_FIRST_LOAD)
michael@0:         flags |= INTERNAL_LOAD_FLAGS_FIRST_LOAD;
michael@0: 
michael@0:     if (aLoadFlags & LOAD_FLAGS_BYPASS_CLASSIFIER)
michael@0:         flags |= INTERNAL_LOAD_FLAGS_BYPASS_CLASSIFIER;
michael@0: 
michael@0:     if (aLoadFlags & LOAD_FLAGS_FORCE_ALLOW_COOKIES)
michael@0:         flags |= INTERNAL_LOAD_FLAGS_FORCE_ALLOW_COOKIES;
michael@0: 
michael@0:     if (isSrcdoc)
michael@0:         flags |= INTERNAL_LOAD_FLAGS_IS_SRCDOC;
michael@0: 
michael@0:     return InternalLoad(aURI,
michael@0:                         referrer,
michael@0:                         owner,
michael@0:                         flags,
michael@0:                         target.get(),
michael@0:                         nullptr,         // No type hint
michael@0:                         NullString(),    // No forced download
michael@0:                         postStream,
michael@0:                         headersStream,
michael@0:                         loadType,
michael@0:                         nullptr,         // No SHEntry
michael@0:                         aFirstParty,
michael@0:                         srcdoc,
michael@0:                         sourceDocShell,
michael@0:                         baseURI,
michael@0:                         nullptr,         // No nsIDocShell
michael@0:                         nullptr);        // No nsIRequest
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::LoadStream(nsIInputStream *aStream, nsIURI * aURI,
michael@0:                        const nsACString &aContentType,
michael@0:                        const nsACString &aContentCharset,
michael@0:                        nsIDocShellLoadInfo * aLoadInfo)
michael@0: {
michael@0:     NS_ENSURE_ARG(aStream);
michael@0: 
michael@0:     mAllowKeywordFixup = false;
michael@0: 
michael@0:     // if the caller doesn't pass in a URI we need to create a dummy URI. necko
michael@0:     // currently requires a URI in various places during the load. Some consumers
michael@0:     // do as well.
michael@0:     nsCOMPtr<nsIURI> uri = aURI;
michael@0:     if (!uri) {
michael@0:         // HACK ALERT
michael@0:         nsresult rv = NS_OK;
michael@0:         uri = do_CreateInstance(NS_SIMPLEURI_CONTRACTID, &rv);
michael@0:         if (NS_FAILED(rv))
michael@0:             return rv;
michael@0:         // Make sure that the URI spec "looks" like a protocol and path...
michael@0:         // For now, just use a bogus protocol called "internal"
michael@0:         rv = uri->SetSpec(NS_LITERAL_CSTRING("internal:load-stream"));
michael@0:         if (NS_FAILED(rv))
michael@0:             return rv;
michael@0:     }
michael@0: 
michael@0:     uint32_t loadType = LOAD_NORMAL;
michael@0:     if (aLoadInfo) {
michael@0:         nsDocShellInfoLoadType lt = nsIDocShellLoadInfo::loadNormal;
michael@0:         (void) aLoadInfo->GetLoadType(&lt);
michael@0:         // Get the appropriate LoadType from nsIDocShellLoadInfo type
michael@0:         loadType = ConvertDocShellLoadInfoToLoadType(lt);
michael@0:     }
michael@0: 
michael@0:     NS_ENSURE_SUCCESS(Stop(nsIWebNavigation::STOP_NETWORK), NS_ERROR_FAILURE);
michael@0: 
michael@0:     mLoadType = loadType;
michael@0: 
michael@0:     // build up a channel for this stream.
michael@0:     nsCOMPtr<nsIChannel> channel;
michael@0:     NS_ENSURE_SUCCESS(NS_NewInputStreamChannel
michael@0:                       (getter_AddRefs(channel), uri, aStream,
michael@0:                        aContentType, aContentCharset),
michael@0:                       NS_ERROR_FAILURE);
michael@0: 
michael@0:     nsCOMPtr<nsIURILoader>
michael@0:         uriLoader(do_GetService(NS_URI_LOADER_CONTRACTID));
michael@0:     NS_ENSURE_TRUE(uriLoader, NS_ERROR_FAILURE);
michael@0: 
michael@0:     NS_ENSURE_SUCCESS(DoChannelLoad(channel, uriLoader, false),
michael@0:                       NS_ERROR_FAILURE);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::CreateLoadInfo(nsIDocShellLoadInfo ** aLoadInfo)
michael@0: {
michael@0:     nsDocShellLoadInfo *loadInfo = new nsDocShellLoadInfo();
michael@0:     NS_ENSURE_TRUE(loadInfo, NS_ERROR_OUT_OF_MEMORY);
michael@0:     nsCOMPtr<nsIDocShellLoadInfo> localRef(loadInfo);
michael@0: 
michael@0:     *aLoadInfo = localRef;
michael@0:     NS_ADDREF(*aLoadInfo);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: 
michael@0: /*
michael@0:  * Reset state to a new content model within the current document and the document
michael@0:  * viewer.  Called by the document before initiating an out of band document.write().
michael@0:  */
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::PrepareForNewContentModel()
michael@0: {
michael@0:   mEODForCurrentDocument = false;
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::FirePageHideNotification(bool aIsUnload)
michael@0: {
michael@0:     if (mContentViewer && !mFiredUnloadEvent) {
michael@0:         // Keep an explicit reference since calling PageHide could release
michael@0:         // mContentViewer
michael@0:         nsCOMPtr<nsIContentViewer> kungFuDeathGrip(mContentViewer);
michael@0:         mFiredUnloadEvent = true;
michael@0: 
michael@0:         if (mTiming) {
michael@0:             mTiming->NotifyUnloadEventStart();
michael@0:         }
michael@0: 
michael@0:         mContentViewer->PageHide(aIsUnload);
michael@0: 
michael@0:         if (mTiming) {
michael@0:             mTiming->NotifyUnloadEventEnd();
michael@0:         }
michael@0: 
michael@0:         nsAutoTArray<nsCOMPtr<nsIDocShell>, 8> kids;
michael@0:         uint32_t n = mChildList.Length();
michael@0:         kids.SetCapacity(n);
michael@0:         for (uint32_t i = 0; i < n; i++) {
michael@0:             kids.AppendElement(do_QueryInterface(ChildAt(i)));
michael@0:         }
michael@0: 
michael@0:         n = kids.Length();
michael@0:         for (uint32_t i = 0; i < n; ++i) {
michael@0:             if (kids[i]) {
michael@0:                 kids[i]->FirePageHideNotification(aIsUnload);
michael@0:             }
michael@0:         }
michael@0:         // Now make sure our editor, if any, is detached before we go
michael@0:         // any farther.
michael@0:         DetachEditorFromWindow();
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsDocShell::MaybeInitTiming()
michael@0: {
michael@0:     if (mTiming) {
michael@0:         return;
michael@0:     }
michael@0: 
michael@0:     mTiming = new nsDOMNavigationTiming();
michael@0:     mTiming->NotifyNavigationStart();
michael@0: }
michael@0: 
michael@0: 
michael@0: //
michael@0: // Bug 13871: Prevent frameset spoofing
michael@0: //
michael@0: // This routine answers: 'Is origin's document from same domain as
michael@0: // target's document?'
michael@0: //
michael@0: // file: uris are considered the same domain for the purpose of
michael@0: // frame navigation regardless of script accessibility (bug 420425)
michael@0: //
michael@0: /* static */
michael@0: bool
michael@0: nsDocShell::ValidateOrigin(nsIDocShellTreeItem* aOriginTreeItem,
michael@0:                            nsIDocShellTreeItem* aTargetTreeItem)
michael@0: {
michael@0:     // We want to bypass this check for chrome callers, but only if there's
michael@0:     // JS on the stack. System callers still need to do it.
michael@0:     if (nsContentUtils::GetCurrentJSContext() && nsContentUtils::IsCallerChrome()) {
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     // Get origin document principal
michael@0:     nsCOMPtr<nsIDocument> originDocument(do_GetInterface(aOriginTreeItem));
michael@0:     NS_ENSURE_TRUE(originDocument, false);
michael@0: 
michael@0:     // Get target principal
michael@0:     nsCOMPtr<nsIDocument> targetDocument(do_GetInterface(aTargetTreeItem));
michael@0:     NS_ENSURE_TRUE(targetDocument, false);
michael@0: 
michael@0:     bool equal;
michael@0:     nsresult rv = originDocument->NodePrincipal()->Equals(targetDocument->NodePrincipal(),
michael@0:                                                           &equal);
michael@0:     if (NS_SUCCEEDED(rv) && equal) {
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     // Not strictly equal, special case if both are file: uris
michael@0:     bool originIsFile = false;
michael@0:     bool targetIsFile = false;
michael@0:     nsCOMPtr<nsIURI> originURI;
michael@0:     nsCOMPtr<nsIURI> targetURI;
michael@0:     nsCOMPtr<nsIURI> innerOriginURI;
michael@0:     nsCOMPtr<nsIURI> innerTargetURI;
michael@0: 
michael@0:     rv = originDocument->NodePrincipal()->GetURI(getter_AddRefs(originURI));
michael@0:     if (NS_SUCCEEDED(rv) && originURI)
michael@0:         innerOriginURI = NS_GetInnermostURI(originURI);
michael@0: 
michael@0:     rv = targetDocument->NodePrincipal()->GetURI(getter_AddRefs(targetURI));
michael@0:     if (NS_SUCCEEDED(rv) && targetURI)
michael@0:         innerTargetURI = NS_GetInnermostURI(targetURI);
michael@0: 
michael@0:     return innerOriginURI && innerTargetURI &&
michael@0:         NS_SUCCEEDED(innerOriginURI->SchemeIs("file", &originIsFile)) &&
michael@0:         NS_SUCCEEDED(innerTargetURI->SchemeIs("file", &targetIsFile)) &&
michael@0:         originIsFile && targetIsFile;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetEldestPresContext(nsPresContext** aPresContext)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aPresContext);
michael@0:     *aPresContext = nullptr;
michael@0: 
michael@0:     nsCOMPtr<nsIContentViewer> viewer = mContentViewer;
michael@0:     while (viewer) {
michael@0:         nsCOMPtr<nsIContentViewer> prevViewer;
michael@0:         viewer->GetPreviousViewer(getter_AddRefs(prevViewer));
michael@0:         if (!prevViewer) {
michael@0:             return viewer->GetPresContext(aPresContext);
michael@0:         }
michael@0:         viewer = prevViewer;
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetPresContext(nsPresContext ** aPresContext)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aPresContext);
michael@0:     *aPresContext = nullptr;
michael@0: 
michael@0:     if (!mContentViewer)
michael@0:       return NS_OK;
michael@0: 
michael@0:     return mContentViewer->GetPresContext(aPresContext);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP_(nsIPresShell*)
michael@0: nsDocShell::GetPresShell()
michael@0: {
michael@0:     nsRefPtr<nsPresContext> presContext;
michael@0:     (void) GetPresContext(getter_AddRefs(presContext));
michael@0:     return presContext ? presContext->GetPresShell() : nullptr;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetEldestPresShell(nsIPresShell** aPresShell)
michael@0: {
michael@0:     nsresult rv = NS_OK;
michael@0: 
michael@0:     NS_ENSURE_ARG_POINTER(aPresShell);
michael@0:     *aPresShell = nullptr;
michael@0: 
michael@0:     nsRefPtr<nsPresContext> presContext;
michael@0:     (void) GetEldestPresContext(getter_AddRefs(presContext));
michael@0: 
michael@0:     if (presContext) {
michael@0:         NS_IF_ADDREF(*aPresShell = presContext->GetPresShell());
michael@0:     }
michael@0: 
michael@0:     return rv;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetContentViewer(nsIContentViewer ** aContentViewer)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aContentViewer);
michael@0: 
michael@0:     *aContentViewer = mContentViewer;
michael@0:     NS_IF_ADDREF(*aContentViewer);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetChromeEventHandler(nsIDOMEventTarget* aChromeEventHandler)
michael@0: {
michael@0:     // Weak reference. Don't addref.
michael@0:     nsCOMPtr<EventTarget> handler = do_QueryInterface(aChromeEventHandler);
michael@0:     mChromeEventHandler = handler.get();
michael@0: 
michael@0:     if (mScriptGlobal) {
michael@0:         mScriptGlobal->SetChromeEventHandler(mChromeEventHandler);
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetChromeEventHandler(nsIDOMEventTarget** aChromeEventHandler)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aChromeEventHandler);
michael@0:     nsCOMPtr<EventTarget> handler = mChromeEventHandler;
michael@0:     handler.forget(aChromeEventHandler);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: /* void setCurrentURI (in nsIURI uri); */
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetCurrentURI(nsIURI *aURI)
michael@0: {
michael@0:     // Note that securityUI will set STATE_IS_INSECURE, even if
michael@0:     // the scheme of |aURI| is "https".
michael@0:     SetCurrentURI(aURI, nullptr, true, 0);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsDocShell::SetCurrentURI(nsIURI *aURI, nsIRequest *aRequest,
michael@0:                           bool aFireOnLocationChange, uint32_t aLocationFlags)
michael@0: {
michael@0: #ifdef PR_LOGGING
michael@0:     if (gDocShellLeakLog && PR_LOG_TEST(gDocShellLeakLog, PR_LOG_DEBUG)) {
michael@0:         nsAutoCString spec;
michael@0:         if (aURI)
michael@0:             aURI->GetSpec(spec);
michael@0:         PR_LogPrint("DOCSHELL %p SetCurrentURI %s\n", this, spec.get());
michael@0:     }
michael@0: #endif
michael@0: 
michael@0:     // We don't want to send a location change when we're displaying an error
michael@0:     // page, and we don't want to change our idea of "current URI" either
michael@0:     if (mLoadType == LOAD_ERROR_PAGE) {
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     mCurrentURI = NS_TryToMakeImmutable(aURI);
michael@0:     
michael@0:     bool isRoot = false;   // Is this the root docshell
michael@0:     bool isSubFrame = false;  // Is this a subframe navigation?
michael@0: 
michael@0:     nsCOMPtr<nsIDocShellTreeItem> root;
michael@0: 
michael@0:     GetSameTypeRootTreeItem(getter_AddRefs(root));
michael@0:     if (root.get() == static_cast<nsIDocShellTreeItem *>(this)) 
michael@0:     {
michael@0:         // This is the root docshell
michael@0:         isRoot = true;
michael@0:     }
michael@0:     if (mLSHE) {
michael@0:         mLSHE->GetIsSubFrame(&isSubFrame);
michael@0:     }
michael@0: 
michael@0:     if (!isSubFrame && !isRoot) {
michael@0:       /* 
michael@0:        * We don't want to send OnLocationChange notifications when
michael@0:        * a subframe is being loaded for the first time, while
michael@0:        * visiting a frameset page
michael@0:        */
michael@0:       return false; 
michael@0:     }
michael@0: 
michael@0:     if (aFireOnLocationChange) {
michael@0:         FireOnLocationChange(this, aRequest, aURI, aLocationFlags);
michael@0:     }
michael@0:     return !aFireOnLocationChange;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetCharset(nsACString& aCharset)
michael@0: {
michael@0:     aCharset.Truncate();
michael@0: 
michael@0:     nsIPresShell* presShell = GetPresShell();
michael@0:     NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
michael@0:     nsIDocument *doc = presShell->GetDocument();
michael@0:     NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
michael@0:     aCharset = doc->GetDocumentCharacterSet();
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GatherCharsetMenuTelemetry()
michael@0: {
michael@0:   nsCOMPtr<nsIContentViewer> viewer;
michael@0:   GetContentViewer(getter_AddRefs(viewer));
michael@0:   if (!viewer) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   nsIDocument* doc = viewer->GetDocument();
michael@0:   if (!doc || doc->WillIgnoreCharsetOverride()) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   Telemetry::Accumulate(Telemetry::CHARSET_OVERRIDE_USED, true);
michael@0: 
michael@0:   bool isFileURL = false;
michael@0:   nsIURI* url = doc->GetOriginalURI();
michael@0:   if (url) {
michael@0:     url->SchemeIs("file", &isFileURL);
michael@0:   }
michael@0: 
michael@0:   int32_t charsetSource = doc->GetDocumentCharacterSetSource();
michael@0:   switch (charsetSource) {
michael@0:     case kCharsetFromTopLevelDomain:
michael@0:       // Unlabeled doc on a domain that we map to a fallback encoding
michael@0:       Telemetry::Accumulate(Telemetry::CHARSET_OVERRIDE_SITUATION, 7);
michael@0:       break;
michael@0:     case kCharsetFromFallback:
michael@0:     case kCharsetFromDocTypeDefault:
michael@0:     case kCharsetFromCache:
michael@0:     case kCharsetFromParentFrame:
michael@0:     case kCharsetFromHintPrevDoc:
michael@0:       // Changing charset on an unlabeled doc.
michael@0:       if (isFileURL) {
michael@0:         Telemetry::Accumulate(Telemetry::CHARSET_OVERRIDE_SITUATION, 0);
michael@0:       } else {
michael@0:         Telemetry::Accumulate(Telemetry::CHARSET_OVERRIDE_SITUATION, 1);
michael@0:       }
michael@0:       break;
michael@0:     case kCharsetFromAutoDetection:
michael@0:       // Changing charset on unlabeled doc where chardet fired
michael@0:       if (isFileURL) {
michael@0:         Telemetry::Accumulate(Telemetry::CHARSET_OVERRIDE_SITUATION, 2);
michael@0:       } else {
michael@0:         Telemetry::Accumulate(Telemetry::CHARSET_OVERRIDE_SITUATION, 3);
michael@0:       }
michael@0:       break;
michael@0:     case kCharsetFromMetaPrescan:
michael@0:     case kCharsetFromMetaTag:
michael@0:     case kCharsetFromChannel:
michael@0:       // Changing charset on a doc that had a charset label.
michael@0:       Telemetry::Accumulate(Telemetry::CHARSET_OVERRIDE_SITUATION, 4);
michael@0:       break;
michael@0:     case kCharsetFromParentForced:
michael@0:     case kCharsetFromUserForced:
michael@0:       // Changing charset on a document that already had an override.
michael@0:       Telemetry::Accumulate(Telemetry::CHARSET_OVERRIDE_SITUATION, 5);
michael@0:       break;
michael@0:     case kCharsetFromIrreversibleAutoDetection:
michael@0:     case kCharsetFromOtherComponent:
michael@0:     case kCharsetFromByteOrderMark:
michael@0:     case kCharsetUninitialized:
michael@0:     default:
michael@0:       // Bug. This isn't supposed to happen.
michael@0:       Telemetry::Accumulate(Telemetry::CHARSET_OVERRIDE_SITUATION, 6);
michael@0:       break;
michael@0:   }
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetCharset(const nsACString& aCharset)
michael@0: {
michael@0:     // set the charset override
michael@0:     return SetForcedCharset(aCharset);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP nsDocShell::SetForcedCharset(const nsACString& aCharset)
michael@0: {
michael@0:   if (aCharset.IsEmpty()) {
michael@0:     mForcedCharset.Truncate();
michael@0:     return NS_OK;
michael@0:   }
michael@0:   nsAutoCString encoding;
michael@0:   if (!EncodingUtils::FindEncodingForLabel(aCharset, encoding)) {
michael@0:     // Reject unknown labels
michael@0:     return NS_ERROR_INVALID_ARG;
michael@0:   }
michael@0:   if (!EncodingUtils::IsAsciiCompatible(encoding)) {
michael@0:     // Reject XSS hazards
michael@0:     return NS_ERROR_INVALID_ARG;
michael@0:   }
michael@0:   mForcedCharset = encoding;
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP nsDocShell::GetForcedCharset(nsACString& aResult)
michael@0: {
michael@0:   aResult = mForcedCharset;
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsDocShell::SetParentCharset(const nsACString& aCharset,
michael@0:                              int32_t aCharsetSource,
michael@0:                              nsIPrincipal* aPrincipal)
michael@0: {
michael@0:   mParentCharset = aCharset;
michael@0:   mParentCharsetSource = aCharsetSource;
michael@0:   mParentCharsetPrincipal = aPrincipal;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsDocShell::GetParentCharset(nsACString& aCharset,
michael@0:                              int32_t* aCharsetSource,
michael@0:                              nsIPrincipal** aPrincipal)
michael@0: {
michael@0:   aCharset = mParentCharset;
michael@0:   *aCharsetSource = mParentCharsetSource;
michael@0:   NS_IF_ADDREF(*aPrincipal = mParentCharsetPrincipal);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetChannelIsUnsafe(bool *aUnsafe)
michael@0: {
michael@0:     *aUnsafe = false;
michael@0: 
michael@0:     nsIChannel* channel = GetCurrentDocChannel();
michael@0:     if (!channel) {
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIJARChannel> jarChannel = do_QueryInterface(channel);
michael@0:     if (!jarChannel) {
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     return jarChannel->GetIsUnsafe(aUnsafe);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetHasMixedActiveContentLoaded(bool* aHasMixedActiveContentLoaded)
michael@0: {
michael@0:     nsCOMPtr<nsIDocument> doc(do_GetInterface(GetAsSupports(this)));
michael@0:     *aHasMixedActiveContentLoaded = doc && doc->GetHasMixedActiveContentLoaded();
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetHasMixedActiveContentBlocked(bool* aHasMixedActiveContentBlocked)
michael@0: {
michael@0:     nsCOMPtr<nsIDocument> doc(do_GetInterface(GetAsSupports(this)));
michael@0:     *aHasMixedActiveContentBlocked = doc && doc->GetHasMixedActiveContentBlocked();
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetHasMixedDisplayContentLoaded(bool* aHasMixedDisplayContentLoaded)
michael@0: {
michael@0:     nsCOMPtr<nsIDocument> doc(do_GetInterface(GetAsSupports(this)));
michael@0:     *aHasMixedDisplayContentLoaded = doc && doc->GetHasMixedDisplayContentLoaded();
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetHasMixedDisplayContentBlocked(bool* aHasMixedDisplayContentBlocked)
michael@0: {
michael@0:     nsCOMPtr<nsIDocument> doc(do_GetInterface(GetAsSupports(this)));
michael@0:     *aHasMixedDisplayContentBlocked = doc && doc->GetHasMixedDisplayContentBlocked();
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetAllowPlugins(bool * aAllowPlugins)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aAllowPlugins);
michael@0: 
michael@0:     *aAllowPlugins = mAllowPlugins;
michael@0:     if (!mAllowPlugins) {
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     bool unsafe;
michael@0:     *aAllowPlugins = NS_SUCCEEDED(GetChannelIsUnsafe(&unsafe)) && !unsafe;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetAllowPlugins(bool aAllowPlugins)
michael@0: {
michael@0:     mAllowPlugins = aAllowPlugins;
michael@0:     //XXX should enable or disable a plugin host
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetAllowJavascript(bool * aAllowJavascript)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aAllowJavascript);
michael@0: 
michael@0:     *aAllowJavascript = mAllowJavascript;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetAllowJavascript(bool aAllowJavascript)
michael@0: {
michael@0:     mAllowJavascript = aAllowJavascript;
michael@0:     RecomputeCanExecuteScripts();
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetUsePrivateBrowsing(bool* aUsePrivateBrowsing)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aUsePrivateBrowsing);
michael@0:     
michael@0:     *aUsePrivateBrowsing = mInPrivateBrowsing;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetUsePrivateBrowsing(bool aUsePrivateBrowsing)
michael@0: {
michael@0:     nsContentUtils::ReportToConsoleNonLocalized(
michael@0:         NS_LITERAL_STRING("Only internal code is allowed to set the usePrivateBrowsing attribute"),
michael@0:         nsIScriptError::warningFlag,
michael@0:         NS_LITERAL_CSTRING("Internal API Used"),
michael@0:         mContentViewer ? mContentViewer->GetDocument() : nullptr);
michael@0: 
michael@0:     return SetPrivateBrowsing(aUsePrivateBrowsing);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetPrivateBrowsing(bool aUsePrivateBrowsing)
michael@0: {
michael@0:     bool changed = aUsePrivateBrowsing != mInPrivateBrowsing;
michael@0:     if (changed) {
michael@0:         mInPrivateBrowsing = aUsePrivateBrowsing;
michael@0:         if (mAffectPrivateSessionLifetime) {
michael@0:             if (aUsePrivateBrowsing) {
michael@0:                 IncreasePrivateDocShellCount();
michael@0:             } else {
michael@0:                 DecreasePrivateDocShellCount();
michael@0:             }
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     nsTObserverArray<nsDocLoader*>::ForwardIterator iter(mChildList);
michael@0:     while (iter.HasMore()) {
michael@0:         nsCOMPtr<nsILoadContext> shell = do_QueryObject(iter.GetNext());
michael@0:         if (shell) {
michael@0:             shell->SetPrivateBrowsing(aUsePrivateBrowsing);
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     if (changed) {
michael@0:         nsTObserverArray<nsWeakPtr>::ForwardIterator iter(mPrivacyObservers);
michael@0:         while (iter.HasMore()) {
michael@0:             nsWeakPtr ref = iter.GetNext();
michael@0:             nsCOMPtr<nsIPrivacyTransitionObserver> obs = do_QueryReferent(ref);
michael@0:             if (!obs) {
michael@0:                 mPrivacyObservers.RemoveElement(ref);
michael@0:             } else {
michael@0:                 obs->PrivateModeChanged(aUsePrivateBrowsing);
michael@0:             }
michael@0:         }
michael@0:     }
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetUseRemoteTabs(bool* aUseRemoteTabs)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aUseRemoteTabs);
michael@0: 
michael@0:     *aUseRemoteTabs = mUseRemoteTabs;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetRemoteTabs(bool aUseRemoteTabs)
michael@0: {
michael@0: #ifdef MOZ_CRASHREPORTER
michael@0:     if (aUseRemoteTabs) {
michael@0:         CrashReporter::AnnotateCrashReport(NS_LITERAL_CSTRING("DOMIPCEnabled"),
michael@0:                                            NS_LITERAL_CSTRING("1"));
michael@0:     }
michael@0: #endif
michael@0: 
michael@0:     mUseRemoteTabs = aUseRemoteTabs;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetAffectPrivateSessionLifetime(bool aAffectLifetime)
michael@0: {
michael@0:     bool change = aAffectLifetime != mAffectPrivateSessionLifetime;
michael@0:     if (change && mInPrivateBrowsing) {
michael@0:         if (aAffectLifetime) {
michael@0:             IncreasePrivateDocShellCount();
michael@0:         } else {
michael@0:             DecreasePrivateDocShellCount();
michael@0:         }
michael@0:     }
michael@0:     mAffectPrivateSessionLifetime = aAffectLifetime;
michael@0: 
michael@0:     nsTObserverArray<nsDocLoader*>::ForwardIterator iter(mChildList);
michael@0:     while (iter.HasMore()) {
michael@0:         nsCOMPtr<nsIDocShell> shell = do_QueryObject(iter.GetNext());
michael@0:         if (shell) {
michael@0:             shell->SetAffectPrivateSessionLifetime(aAffectLifetime);
michael@0:         }
michael@0:     }
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetAffectPrivateSessionLifetime(bool* aAffectLifetime)
michael@0: {
michael@0:     *aAffectLifetime = mAffectPrivateSessionLifetime;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::AddWeakPrivacyTransitionObserver(nsIPrivacyTransitionObserver* aObserver)
michael@0: {
michael@0:     nsWeakPtr weakObs = do_GetWeakReference(aObserver);
michael@0:     if (!weakObs) {
michael@0:         return NS_ERROR_NOT_AVAILABLE;
michael@0:     }
michael@0:     return mPrivacyObservers.AppendElement(weakObs) ? NS_OK : NS_ERROR_FAILURE;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::AddWeakReflowObserver(nsIReflowObserver* aObserver)
michael@0: {
michael@0:     nsWeakPtr weakObs = do_GetWeakReference(aObserver);
michael@0:     if (!weakObs) {
michael@0:         return NS_ERROR_FAILURE;
michael@0:     }
michael@0:     return mReflowObservers.AppendElement(weakObs) ? NS_OK : NS_ERROR_FAILURE;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::RemoveWeakReflowObserver(nsIReflowObserver* aObserver)
michael@0: {
michael@0:     nsWeakPtr obs = do_GetWeakReference(aObserver);
michael@0:     return mReflowObservers.RemoveElement(obs) ? NS_OK : NS_ERROR_FAILURE;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::NotifyReflowObservers(bool aInterruptible,
michael@0:                                   DOMHighResTimeStamp aStart,
michael@0:                                   DOMHighResTimeStamp aEnd)
michael@0: {
michael@0:     nsTObserverArray<nsWeakPtr>::ForwardIterator iter(mReflowObservers);
michael@0:     while (iter.HasMore()) {
michael@0:         nsWeakPtr ref = iter.GetNext();
michael@0:         nsCOMPtr<nsIReflowObserver> obs = do_QueryReferent(ref);
michael@0:         if (!obs) {
michael@0:             mReflowObservers.RemoveElement(ref);
michael@0:         } else if (aInterruptible) {
michael@0:             obs->ReflowInterruptible(aStart, aEnd);
michael@0:         } else {
michael@0:             obs->Reflow(aStart, aEnd);
michael@0:         }
michael@0:     }
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP nsDocShell::GetAllowMetaRedirects(bool * aReturn)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aReturn);
michael@0: 
michael@0:     *aReturn = mAllowMetaRedirects;
michael@0:     if (!mAllowMetaRedirects) {
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     bool unsafe;
michael@0:     *aReturn = NS_SUCCEEDED(GetChannelIsUnsafe(&unsafe)) && !unsafe;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP nsDocShell::SetAllowMetaRedirects(bool aValue)
michael@0: {
michael@0:     mAllowMetaRedirects = aValue;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP nsDocShell::GetAllowSubframes(bool * aAllowSubframes)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aAllowSubframes);
michael@0: 
michael@0:     *aAllowSubframes = mAllowSubframes;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP nsDocShell::SetAllowSubframes(bool aAllowSubframes)
michael@0: {
michael@0:     mAllowSubframes = aAllowSubframes;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP nsDocShell::GetAllowImages(bool * aAllowImages)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aAllowImages);
michael@0: 
michael@0:     *aAllowImages = mAllowImages;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP nsDocShell::SetAllowImages(bool aAllowImages)
michael@0: {
michael@0:     mAllowImages = aAllowImages;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP nsDocShell::GetAllowMedia(bool * aAllowMedia)
michael@0: {
michael@0:     *aAllowMedia = mAllowMedia;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP nsDocShell::SetAllowMedia(bool aAllowMedia)
michael@0: {
michael@0:     mAllowMedia = aAllowMedia;
michael@0: 
michael@0:     // Mute or unmute audio contexts attached to the inner window.
michael@0:     if (mScriptGlobal) {
michael@0:         nsPIDOMWindow* innerWin = mScriptGlobal->GetCurrentInnerWindow();
michael@0:         if (innerWin) {
michael@0:             if (aAllowMedia) {
michael@0:                 innerWin->UnmuteAudioContexts();
michael@0:             } else {
michael@0:                 innerWin->MuteAudioContexts();
michael@0:             }
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP nsDocShell::GetAllowDNSPrefetch(bool * aAllowDNSPrefetch)
michael@0: {
michael@0:     *aAllowDNSPrefetch = mAllowDNSPrefetch;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP nsDocShell::SetAllowDNSPrefetch(bool aAllowDNSPrefetch)
michael@0: {
michael@0:     mAllowDNSPrefetch = aAllowDNSPrefetch;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP nsDocShell::GetAllowWindowControl(bool * aAllowWindowControl)
michael@0: {
michael@0:     *aAllowWindowControl = mAllowWindowControl;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP nsDocShell::SetAllowWindowControl(bool aAllowWindowControl)
michael@0: {
michael@0:     mAllowWindowControl = aAllowWindowControl;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetAllowContentRetargeting(bool* aAllowContentRetargeting)
michael@0: {
michael@0:     *aAllowContentRetargeting = mAllowContentRetargeting;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetAllowContentRetargeting(bool aAllowContentRetargeting)
michael@0: {
michael@0:     mAllowContentRetargeting = aAllowContentRetargeting;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetFullscreenAllowed(bool* aFullscreenAllowed)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aFullscreenAllowed);
michael@0: 
michael@0:     // Browsers and apps have their mFullscreenAllowed retrieved from their
michael@0:     // corresponding iframe in their parent upon creation.
michael@0:     if (mFullscreenAllowed != CHECK_ATTRIBUTES) {
michael@0:         *aFullscreenAllowed = (mFullscreenAllowed == PARENT_ALLOWS);
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     // Assume false until we determine otherwise...
michael@0:     *aFullscreenAllowed = false;
michael@0: 
michael@0:     // For non-browsers/apps, check that the enclosing iframe element
michael@0:     // has the allowfullscreen attribute set to true. If any ancestor
michael@0:     // iframe does not have mozallowfullscreen=true, then fullscreen is
michael@0:     // prohibited.
michael@0:     nsCOMPtr<nsPIDOMWindow> win = do_GetInterface(GetAsSupports(this));
michael@0:     if (!win) {
michael@0:         return NS_OK;
michael@0:     }
michael@0:     nsCOMPtr<nsIContent> frameElement = do_QueryInterface(win->GetFrameElementInternal());
michael@0:     if (frameElement &&
michael@0:         frameElement->IsHTML(nsGkAtoms::iframe) &&
michael@0:         !frameElement->HasAttr(kNameSpaceID_None, nsGkAtoms::allowfullscreen) &&
michael@0:         !frameElement->HasAttr(kNameSpaceID_None, nsGkAtoms::mozallowfullscreen)) {
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     // If we have no parent then we're the root docshell; no ancestor of the
michael@0:     // original docshell doesn't have a allowfullscreen attribute, so
michael@0:     // report fullscreen as allowed.
michael@0:     nsCOMPtr<nsIDocShellTreeItem> dsti = do_GetInterface(GetAsSupports(this));
michael@0:     NS_ENSURE_TRUE(dsti, NS_OK);
michael@0: 
michael@0:     nsCOMPtr<nsIDocShellTreeItem> parentTreeItem;
michael@0:     dsti->GetParent(getter_AddRefs(parentTreeItem));
michael@0:     if (!parentTreeItem) {
michael@0:         *aFullscreenAllowed = true;
michael@0:         return NS_OK;
michael@0:     }
michael@0:     // Otherwise, we have a parent, continue the checking for
michael@0:     // mozFullscreenAllowed in the parent docshell's ancestors.
michael@0:     nsCOMPtr<nsIDocShell> parent = do_QueryInterface(parentTreeItem);
michael@0:     NS_ENSURE_TRUE(parent, NS_OK);
michael@0:     
michael@0:     return parent->GetFullscreenAllowed(aFullscreenAllowed);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetFullscreenAllowed(bool aFullscreenAllowed)
michael@0: {
michael@0:     if (!nsIDocShell::GetIsBrowserOrApp()) {
michael@0:         // Only allow setting of fullscreenAllowed on content/process boundaries.
michael@0:         // At non-boundaries the fullscreenAllowed attribute is calculated based on
michael@0:         // whether all enclosing frames have the "mozFullscreenAllowed" attribute
michael@0:         // set to "true". fullscreenAllowed is set at the process boundaries to
michael@0:         // propagate the value of the parent's "mozFullscreenAllowed" attribute
michael@0:         // across process boundaries.
michael@0:         return NS_ERROR_UNEXPECTED;
michael@0:     }
michael@0:     mFullscreenAllowed = (aFullscreenAllowed ? PARENT_ALLOWS : PARENT_PROHIBITS);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetMayEnableCharacterEncodingMenu(bool* aMayEnableCharacterEncodingMenu)
michael@0: {
michael@0:   *aMayEnableCharacterEncodingMenu = false;
michael@0:   if (!mContentViewer) {
michael@0:     return NS_OK;
michael@0:   }
michael@0:   nsIDocument* doc = mContentViewer->GetDocument();
michael@0:   if (!doc) {
michael@0:     return NS_OK;
michael@0:   }
michael@0:   if (doc->WillIgnoreCharsetOverride()) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   *aMayEnableCharacterEncodingMenu = true;
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetDocShellEnumerator(int32_t aItemType, int32_t aDirection, nsISimpleEnumerator **outEnum)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(outEnum);
michael@0:     *outEnum = nullptr;
michael@0:     
michael@0:     nsRefPtr<nsDocShellEnumerator> docShellEnum;
michael@0:     if (aDirection == ENUMERATE_FORWARDS)
michael@0:         docShellEnum = new nsDocShellForwardsEnumerator;
michael@0:     else
michael@0:         docShellEnum = new nsDocShellBackwardsEnumerator;
michael@0:     
michael@0:     if (!docShellEnum) return NS_ERROR_OUT_OF_MEMORY;
michael@0:     
michael@0:     nsresult rv = docShellEnum->SetEnumDocShellType(aItemType);
michael@0:     if (NS_FAILED(rv)) return rv;
michael@0: 
michael@0:     rv = docShellEnum->SetEnumerationRootItem((nsIDocShellTreeItem *)this);
michael@0:     if (NS_FAILED(rv)) return rv;
michael@0: 
michael@0:     rv = docShellEnum->First();
michael@0:     if (NS_FAILED(rv)) return rv;
michael@0: 
michael@0:     rv = docShellEnum->QueryInterface(NS_GET_IID(nsISimpleEnumerator), (void **)outEnum);
michael@0: 
michael@0:     return rv;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetAppType(uint32_t * aAppType)
michael@0: {
michael@0:     *aAppType = mAppType;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetAppType(uint32_t aAppType)
michael@0: {
michael@0:     mAppType = aAppType;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetAllowAuth(bool * aAllowAuth)
michael@0: {
michael@0:     *aAllowAuth = mAllowAuth;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetAllowAuth(bool aAllowAuth)
michael@0: {
michael@0:     mAllowAuth = aAllowAuth;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetZoom(float *zoom)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(zoom);
michael@0:     *zoom = 1.0f;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetZoom(float zoom)
michael@0: {
michael@0:     return NS_ERROR_NOT_IMPLEMENTED;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetMarginWidth(int32_t * aWidth)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aWidth);
michael@0: 
michael@0:     *aWidth = mMarginWidth;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetMarginWidth(int32_t aWidth)
michael@0: {
michael@0:     mMarginWidth = aWidth;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetMarginHeight(int32_t * aHeight)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aHeight);
michael@0: 
michael@0:     *aHeight = mMarginHeight;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetMarginHeight(int32_t aHeight)
michael@0: {
michael@0:     mMarginHeight = aHeight;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetBusyFlags(uint32_t * aBusyFlags)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aBusyFlags);
michael@0: 
michael@0:     *aBusyFlags = mBusyFlags;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::TabToTreeOwner(bool aForward, bool* aTookFocus)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aTookFocus);
michael@0:     
michael@0:     nsCOMPtr<nsIWebBrowserChromeFocus> chromeFocus = do_GetInterface(mTreeOwner);
michael@0:     if (chromeFocus) {
michael@0:         if (aForward)
michael@0:             *aTookFocus = NS_SUCCEEDED(chromeFocus->FocusNextElement());
michael@0:         else
michael@0:             *aTookFocus = NS_SUCCEEDED(chromeFocus->FocusPrevElement());
michael@0:     } else
michael@0:         *aTookFocus = false;
michael@0:     
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetSecurityUI(nsISecureBrowserUI **aSecurityUI)
michael@0: {
michael@0:     NS_IF_ADDREF(*aSecurityUI = mSecurityUI);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetSecurityUI(nsISecureBrowserUI *aSecurityUI)
michael@0: {
michael@0:     mSecurityUI = aSecurityUI;
michael@0:     mSecurityUI->SetDocShell(this);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetUseErrorPages(bool *aUseErrorPages)
michael@0: {
michael@0:     *aUseErrorPages = UseErrorPages();
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetUseErrorPages(bool aUseErrorPages)
michael@0: {
michael@0:     // If mUseErrorPages is set explicitly, stop using sUseErrorPages.
michael@0:     if (mObserveErrorPages) {
michael@0:         mObserveErrorPages = false;
michael@0:     }
michael@0:     mUseErrorPages = aUseErrorPages;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetPreviousTransIndex(int32_t *aPreviousTransIndex)
michael@0: {
michael@0:     *aPreviousTransIndex = mPreviousTransIndex;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetLoadedTransIndex(int32_t *aLoadedTransIndex)
michael@0: {
michael@0:     *aLoadedTransIndex = mLoadedTransIndex;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::HistoryPurged(int32_t aNumEntries)
michael@0: {
michael@0:     // These indices are used for fastback cache eviction, to determine
michael@0:     // which session history entries are candidates for content viewer
michael@0:     // eviction.  We need to adjust by the number of entries that we
michael@0:     // just purged from history, so that we look at the right session history
michael@0:     // entries during eviction.
michael@0:     mPreviousTransIndex = std::max(-1, mPreviousTransIndex - aNumEntries);
michael@0:     mLoadedTransIndex = std::max(0, mLoadedTransIndex - aNumEntries);
michael@0: 
michael@0:     nsTObserverArray<nsDocLoader*>::ForwardIterator iter(mChildList);
michael@0:     while (iter.HasMore()) {
michael@0:         nsCOMPtr<nsIDocShell> shell = do_QueryObject(iter.GetNext());
michael@0:         if (shell) {
michael@0:             shell->HistoryPurged(aNumEntries);
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::HistoryTransactionRemoved(int32_t aIndex)
michael@0: {
michael@0:     // These indices are used for fastback cache eviction, to determine
michael@0:     // which session history entries are candidates for content viewer
michael@0:     // eviction.  We need to adjust by the number of entries that we
michael@0:     // just purged from history, so that we look at the right session history
michael@0:     // entries during eviction.
michael@0:     if (aIndex == mPreviousTransIndex) {
michael@0:         mPreviousTransIndex = -1;
michael@0:     } else if (aIndex < mPreviousTransIndex) {
michael@0:         --mPreviousTransIndex;
michael@0:     }
michael@0:     if (mLoadedTransIndex == aIndex) {
michael@0:         mLoadedTransIndex = 0;
michael@0:     } else if (aIndex < mLoadedTransIndex) {
michael@0:         --mLoadedTransIndex;
michael@0:     }
michael@0:                             
michael@0:     nsTObserverArray<nsDocLoader*>::ForwardIterator iter(mChildList);
michael@0:     while (iter.HasMore()) {
michael@0:         nsCOMPtr<nsIDocShell> shell = do_QueryObject(iter.GetNext());
michael@0:         if (shell) {
michael@0:             static_cast<nsDocShell*>(shell.get())->
michael@0:                 HistoryTransactionRemoved(aIndex);
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: nsIDOMStorageManager*
michael@0: nsDocShell::TopSessionStorageManager()
michael@0: {
michael@0:     nsresult rv;
michael@0: 
michael@0:     nsCOMPtr<nsIDocShellTreeItem> topItem;
michael@0:     rv = GetSameTypeRootTreeItem(getter_AddRefs(topItem));
michael@0:     if (NS_FAILED(rv)) {
michael@0:         return nullptr;
michael@0:     }
michael@0: 
michael@0:     if (!topItem) {
michael@0:         return nullptr;
michael@0:     }
michael@0: 
michael@0:     nsDocShell* topDocShell = static_cast<nsDocShell*>(topItem.get());
michael@0:     if (topDocShell != this) {
michael@0:         return topDocShell->TopSessionStorageManager();
michael@0:     }
michael@0: 
michael@0:     if (!mSessionStorageManager) {
michael@0:         mSessionStorageManager =
michael@0:             do_CreateInstance("@mozilla.org/dom/sessionStorage-manager;1");
michael@0:     }
michael@0: 
michael@0:     return mSessionStorageManager;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetSessionStorageForPrincipal(nsIPrincipal* aPrincipal,
michael@0:                                           const nsAString& aDocumentURI,
michael@0:                                           bool aCreate,
michael@0:                                           nsIDOMStorage** aStorage)
michael@0: {
michael@0:     nsCOMPtr<nsIDOMStorageManager> manager = TopSessionStorageManager();
michael@0:     if (!manager) {
michael@0:         return NS_ERROR_UNEXPECTED;
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<mozIThirdPartyUtil> thirdPartyUtil =
michael@0:                             do_GetService(THIRDPARTYUTIL_CONTRACTID);
michael@0:     if (!thirdPartyUtil)
michael@0:       return NS_ERROR_FAILURE;
michael@0: 
michael@0:     nsCOMPtr<nsIDocument> doc(do_GetInterface(GetAsSupports(this)));
michael@0:     nsCOMPtr<nsIURI> firstPartyIsolationURI;
michael@0:     nsresult rv = thirdPartyUtil->GetFirstPartyIsolationURI(nullptr, doc,
michael@0:                                            getter_AddRefs(firstPartyIsolationURI));
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     if (aCreate) {
michael@0:         return manager->CreateStorageForFirstParty(firstPartyIsolationURI,
michael@0:                                       aPrincipal, aDocumentURI,
michael@0:                                       mInPrivateBrowsing, aStorage);
michael@0:     }
michael@0: 
michael@0:     return manager->GetStorageForFirstParty(firstPartyIsolationURI, aPrincipal,
michael@0:                                             mInPrivateBrowsing, aStorage);
michael@0: }
michael@0: 
michael@0: // Bacause it is not called from anywhere, nsDocShell::AddSessionStorage()
michael@0: // does not need to be modified to isolate DOM Storage to the first party URI.
michael@0: nsresult
michael@0: nsDocShell::AddSessionStorage(nsIPrincipal* aPrincipal,
michael@0:                               nsIDOMStorage* aStorage)
michael@0: {
michael@0:     nsCOMPtr<nsPIDOMStorage> pistorage = do_QueryInterface(aStorage);
michael@0:     nsIPrincipal* storagePrincipal = pistorage->GetPrincipal();
michael@0:     if (storagePrincipal != aPrincipal) {
michael@0:         NS_ERROR("Wanting to add a sessionStorage for different principal");
michael@0:         return NS_ERROR_DOM_SECURITY_ERR;
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIDOMStorageManager> manager = TopSessionStorageManager();
michael@0:     if (!manager) {
michael@0:         return NS_ERROR_UNEXPECTED;
michael@0:     }
michael@0: 
michael@0:     return manager->CloneStorage(aStorage);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetCurrentDocumentChannel(nsIChannel** aResult)
michael@0: {
michael@0:     NS_IF_ADDREF(*aResult = GetCurrentDocChannel()); 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: nsIChannel*
michael@0: nsDocShell::GetCurrentDocChannel()
michael@0: {
michael@0:     if (mContentViewer) {
michael@0:         nsIDocument* doc = mContentViewer->GetDocument();
michael@0:         if (doc) {
michael@0:             return doc->GetChannel();
michael@0:         }
michael@0:     }
michael@0:     return nullptr;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::AddWeakScrollObserver(nsIScrollObserver* aObserver)
michael@0: {
michael@0:     nsWeakPtr weakObs = do_GetWeakReference(aObserver);
michael@0:     if (!weakObs) {
michael@0:         return NS_ERROR_FAILURE;
michael@0:     }
michael@0:     return mScrollObservers.AppendElement(weakObs) ? NS_OK : NS_ERROR_FAILURE;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::RemoveWeakScrollObserver(nsIScrollObserver* aObserver)
michael@0: {
michael@0:     nsWeakPtr obs = do_GetWeakReference(aObserver);
michael@0:     return mScrollObservers.RemoveElement(obs) ? NS_OK : NS_ERROR_FAILURE;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::NotifyScrollObservers()
michael@0: {
michael@0:     nsTObserverArray<nsWeakPtr>::ForwardIterator iter(mScrollObservers);
michael@0:     while (iter.HasMore()) {
michael@0:         nsWeakPtr ref = iter.GetNext();
michael@0:         nsCOMPtr<nsIScrollObserver> obs = do_QueryReferent(ref);
michael@0:         if (obs) {
michael@0:             obs->ScrollPositionChanged();
michael@0:         } else {
michael@0:             mScrollObservers.RemoveElement(ref);
michael@0:         }
michael@0:     }
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: //*****************************************************************************
michael@0: // nsDocShell::nsIDocShellTreeItem
michael@0: //*****************************************************************************   
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetName(nsAString& aName)
michael@0: {
michael@0:     aName = mName;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetName(const nsAString& aName)
michael@0: {
michael@0:     mName = aName;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::NameEquals(const char16_t *aName, bool *_retval)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aName);
michael@0:     NS_ENSURE_ARG_POINTER(_retval);
michael@0:     *_retval = mName.Equals(aName);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: /* virtual */ int32_t
michael@0: nsDocShell::ItemType()
michael@0: {
michael@0:    return mItemType;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetItemType(int32_t * aItemType)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aItemType);
michael@0: 
michael@0:     *aItemType = ItemType();
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetItemType(int32_t aItemType)
michael@0: {
michael@0:     NS_ENSURE_ARG((aItemType == typeChrome) || (typeContent == aItemType));
michael@0: 
michael@0:     // Only allow setting the type on root docshells.  Those would be the ones
michael@0:     // that have the docloader service as mParent or have no mParent at all.
michael@0:     nsCOMPtr<nsIDocumentLoader> docLoaderService =
michael@0:         do_GetService(NS_DOCUMENTLOADER_SERVICE_CONTRACTID);
michael@0:     NS_ENSURE_TRUE(docLoaderService, NS_ERROR_UNEXPECTED);
michael@0:     
michael@0:     NS_ENSURE_STATE(!mParent || mParent == docLoaderService);
michael@0: 
michael@0:     mItemType = aItemType;
michael@0: 
michael@0:     // disable auth prompting for anything but content
michael@0:     mAllowAuth = mItemType == typeContent; 
michael@0: 
michael@0:     nsRefPtr<nsPresContext> presContext = nullptr;
michael@0:     GetPresContext(getter_AddRefs(presContext));
michael@0:     if (presContext) {
michael@0:         presContext->UpdateIsChrome();
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetParent(nsIDocShellTreeItem ** aParent)
michael@0: {
michael@0:     if (!mParent) {
michael@0:         *aParent = nullptr;
michael@0:     } else {
michael@0:         CallQueryInterface(mParent, aParent);
michael@0:     }
michael@0:     // Note that in the case when the parent is not an nsIDocShellTreeItem we
michael@0:     // don't want to throw; we just want to return null.
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: already_AddRefed<nsDocShell>
michael@0: nsDocShell::GetParentDocshell()
michael@0: {
michael@0:     nsCOMPtr<nsIDocShell> docshell = do_QueryInterface(GetAsSupports(mParent));
michael@0:     return docshell.forget().downcast<nsDocShell>();
michael@0: }
michael@0: 
michael@0: void
michael@0: nsDocShell::RecomputeCanExecuteScripts()
michael@0: {
michael@0:     bool old = mCanExecuteScripts;
michael@0:     nsRefPtr<nsDocShell> parent = GetParentDocshell();
michael@0: 
michael@0:     // If we have no tree owner, that means that we've been detached from the
michael@0:     // docshell tree (this is distinct from having no parent dochshell, which
michael@0:     // is the case for root docshells). It would be nice to simply disallow
michael@0:     // script in detached docshells, but bug 986542 demonstrates that this
michael@0:     // behavior breaks at least one website.
michael@0:     //
michael@0:     // So instead, we use our previous value, unless mAllowJavascript has been
michael@0:     // explicitly set to false.
michael@0:     if (!mTreeOwner) {
michael@0:         mCanExecuteScripts = mCanExecuteScripts && mAllowJavascript;
michael@0:     // If scripting has been explicitly disabled on our docshell, we're done.
michael@0:     } else if (!mAllowJavascript) {
michael@0:         mCanExecuteScripts = false;
michael@0:     // If we have a parent, inherit.
michael@0:     } else if (parent) {
michael@0:         mCanExecuteScripts = parent->mCanExecuteScripts;
michael@0:     // Otherwise, we're the root of the tree, and we haven't explicitly disabled
michael@0:     // script. Allow.
michael@0:     } else {
michael@0:         mCanExecuteScripts = true;
michael@0:     }
michael@0: 
michael@0:     // Inform our active DOM window.
michael@0:     //
michael@0:     // This will pass the outer, which will be in the scope of the active inner.
michael@0:     if (mScriptGlobal && mScriptGlobal->GetGlobalJSObject()) {
michael@0:         xpc::Scriptability& scriptability =
michael@0:           xpc::Scriptability::Get(mScriptGlobal->GetGlobalJSObject());
michael@0:         scriptability.SetDocShellAllowsScript(mCanExecuteScripts);
michael@0:     }
michael@0: 
michael@0:     // If our value has changed, our children might be affected. Recompute their
michael@0:     // value as well.
michael@0:     if (old != mCanExecuteScripts) {
michael@0:         nsTObserverArray<nsDocLoader*>::ForwardIterator iter(mChildList);
michael@0:         while (iter.HasMore()) {
michael@0:             static_cast<nsDocShell*>(iter.GetNext())->RecomputeCanExecuteScripts();
michael@0:         }
michael@0:     }
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::SetDocLoaderParent(nsDocLoader * aParent)
michael@0: {
michael@0:     bool wasFrame = IsFrame();
michael@0: 
michael@0:     nsDocLoader::SetDocLoaderParent(aParent);
michael@0: 
michael@0:     nsCOMPtr<nsISupportsPriority> priorityGroup = do_QueryInterface(mLoadGroup);
michael@0:     if (wasFrame != IsFrame() && priorityGroup) {
michael@0:         priorityGroup->AdjustPriority(wasFrame ? -1 : 1);
michael@0:     }
michael@0: 
michael@0:     // Curse ambiguous nsISupports inheritance!
michael@0:     nsISupports* parent = GetAsSupports(aParent);
michael@0: 
michael@0:     // If parent is another docshell, we inherit all their flags for
michael@0:     // allowing plugins, scripting etc.
michael@0:     bool value;
michael@0:     nsCOMPtr<nsIDocShell> parentAsDocShell(do_QueryInterface(parent));
michael@0:     if (parentAsDocShell)
michael@0:     {
michael@0:         if (NS_SUCCEEDED(parentAsDocShell->GetAllowPlugins(&value)))
michael@0:         {
michael@0:             SetAllowPlugins(value);
michael@0:         }
michael@0:         if (NS_SUCCEEDED(parentAsDocShell->GetAllowJavascript(&value)))
michael@0:         {
michael@0:             SetAllowJavascript(value);
michael@0:         }
michael@0:         if (NS_SUCCEEDED(parentAsDocShell->GetAllowMetaRedirects(&value)))
michael@0:         {
michael@0:             SetAllowMetaRedirects(value);
michael@0:         }
michael@0:         if (NS_SUCCEEDED(parentAsDocShell->GetAllowSubframes(&value)))
michael@0:         {
michael@0:             SetAllowSubframes(value);
michael@0:         }
michael@0:         if (NS_SUCCEEDED(parentAsDocShell->GetAllowImages(&value)))
michael@0:         {
michael@0:             SetAllowImages(value);
michael@0:         }
michael@0:         SetAllowMedia(parentAsDocShell->GetAllowMedia());
michael@0:         if (NS_SUCCEEDED(parentAsDocShell->GetAllowWindowControl(&value)))
michael@0:         {
michael@0:             SetAllowWindowControl(value);
michael@0:         }
michael@0:         SetAllowContentRetargeting(
michael@0:             parentAsDocShell->GetAllowContentRetargeting());
michael@0:         if (NS_SUCCEEDED(parentAsDocShell->GetIsActive(&value)))
michael@0:         {
michael@0:             SetIsActive(value);
michael@0:         }
michael@0:         if (NS_FAILED(parentAsDocShell->GetAllowDNSPrefetch(&value))) {
michael@0:             value = false;
michael@0:         }
michael@0:         SetAllowDNSPrefetch(value);
michael@0:         value = parentAsDocShell->GetAffectPrivateSessionLifetime();
michael@0:         SetAffectPrivateSessionLifetime(value);
michael@0:         uint32_t flags;
michael@0:         if (NS_SUCCEEDED(parentAsDocShell->GetDefaultLoadFlags(&flags)))
michael@0:         {
michael@0:             SetDefaultLoadFlags(flags);
michael@0:         }
michael@0: 
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsILoadContext> parentAsLoadContext(do_QueryInterface(parent));
michael@0:     if (parentAsLoadContext &&
michael@0:         NS_SUCCEEDED(parentAsLoadContext->GetUsePrivateBrowsing(&value)))
michael@0:     {
michael@0:         SetPrivateBrowsing(value);
michael@0:     }
michael@0:     
michael@0:     nsCOMPtr<nsIURIContentListener> parentURIListener(do_GetInterface(parent));
michael@0:     if (parentURIListener)
michael@0:         mContentListener->SetParentContentListener(parentURIListener);
michael@0: 
michael@0:     // Our parent has changed. Recompute scriptability.
michael@0:     RecomputeCanExecuteScripts();
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetSameTypeParent(nsIDocShellTreeItem ** aParent)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aParent);
michael@0:     *aParent = nullptr;
michael@0: 
michael@0:     if (nsIDocShell::GetIsBrowserOrApp()) {
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIDocShellTreeItem> parent =
michael@0:         do_QueryInterface(GetAsSupports(mParent));
michael@0:     if (!parent)
michael@0:         return NS_OK;
michael@0: 
michael@0:     if (parent->ItemType() == mItemType) {
michael@0:         parent.swap(*aParent);
michael@0:     }
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetSameTypeParentIgnoreBrowserAndAppBoundaries(nsIDocShell** aParent)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aParent);
michael@0:     *aParent = nullptr;
michael@0: 
michael@0:     nsCOMPtr<nsIDocShellTreeItem> parent =
michael@0:         do_QueryInterface(GetAsSupports(mParent));
michael@0:     if (!parent)
michael@0:         return NS_OK;
michael@0: 
michael@0:     if (parent->ItemType() == mItemType) {
michael@0:         nsCOMPtr<nsIDocShell> parentDS = do_QueryInterface(parent);
michael@0:         parentDS.forget(aParent);
michael@0:     }
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetRootTreeItem(nsIDocShellTreeItem ** aRootTreeItem)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aRootTreeItem);
michael@0:     *aRootTreeItem = static_cast<nsIDocShellTreeItem *>(this);
michael@0: 
michael@0:     nsCOMPtr<nsIDocShellTreeItem> parent;
michael@0:     NS_ENSURE_SUCCESS(GetParent(getter_AddRefs(parent)), NS_ERROR_FAILURE);
michael@0:     while (parent) {
michael@0:         *aRootTreeItem = parent;
michael@0:         NS_ENSURE_SUCCESS((*aRootTreeItem)->GetParent(getter_AddRefs(parent)),
michael@0:                           NS_ERROR_FAILURE);
michael@0:     }
michael@0:     NS_ADDREF(*aRootTreeItem);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetSameTypeRootTreeItem(nsIDocShellTreeItem ** aRootTreeItem)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aRootTreeItem);
michael@0:     *aRootTreeItem = static_cast<nsIDocShellTreeItem *>(this);
michael@0: 
michael@0:     nsCOMPtr<nsIDocShellTreeItem> parent;
michael@0:     NS_ENSURE_SUCCESS(GetSameTypeParent(getter_AddRefs(parent)),
michael@0:                       NS_ERROR_FAILURE);
michael@0:     while (parent) {
michael@0:         *aRootTreeItem = parent;
michael@0:         NS_ENSURE_SUCCESS((*aRootTreeItem)->
michael@0:                           GetSameTypeParent(getter_AddRefs(parent)),
michael@0:                           NS_ERROR_FAILURE);
michael@0:     }
michael@0:     NS_ADDREF(*aRootTreeItem);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: /* static */
michael@0: bool
michael@0: nsDocShell::CanAccessItem(nsIDocShellTreeItem* aTargetItem,
michael@0:                           nsIDocShellTreeItem* aAccessingItem,
michael@0:                           bool aConsiderOpener)
michael@0: {
michael@0:     NS_PRECONDITION(aTargetItem, "Must have target item!");
michael@0: 
michael@0:     if (!gValidateOrigin || !aAccessingItem) {
michael@0:         // Good to go
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     // XXXbz should we care if aAccessingItem or the document therein is
michael@0:     // chrome?  Should those get extra privileges?
michael@0: 
michael@0:     // For historical context, see:
michael@0:     // 
michael@0:     // Bug 13871:  Prevent frameset spoofing
michael@0:     // Bug 103638: Targets with same name in different windows open in wrong
michael@0:     //             window with javascript
michael@0:     // Bug 408052: Adopt "ancestor" frame navigation policy
michael@0: 
michael@0:     // Now do a security check.
michael@0:     //
michael@0:     // Disallow navigation if the two frames are not part of the same app, or if
michael@0:     // they have different is-in-browser-element states.
michael@0:     //
michael@0:     // Allow navigation if
michael@0:     //  1) aAccessingItem can script aTargetItem or one of its ancestors in
michael@0:     //     the frame hierarchy or
michael@0:     //  2) aTargetItem is a top-level frame and aAccessingItem is its descendant
michael@0:     //  3) aTargetItem is a top-level frame and aAccessingItem can target
michael@0:     //     its opener per rule (1) or (2).
michael@0: 
michael@0:     if (aTargetItem == aAccessingItem) {
michael@0:         // A frame is allowed to navigate itself.
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIDocShell> targetDS = do_QueryInterface(aTargetItem);
michael@0:     nsCOMPtr<nsIDocShell> accessingDS = do_QueryInterface(aAccessingItem);
michael@0:     if (!!targetDS != !!accessingDS) {
michael@0:         // We must be able to convert both or neither to nsIDocShell.
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     if (targetDS && accessingDS &&
michael@0:         (targetDS->GetIsInBrowserElement() !=
michael@0:            accessingDS->GetIsInBrowserElement() ||
michael@0:          targetDS->GetAppId() != accessingDS->GetAppId())) {
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIDocShellTreeItem> accessingRoot;
michael@0:     aAccessingItem->GetSameTypeRootTreeItem(getter_AddRefs(accessingRoot));
michael@0: 
michael@0:     if (aTargetItem == accessingRoot) {
michael@0:         // A frame can navigate its root.
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     // Check if aAccessingItem can navigate one of aTargetItem's ancestors.
michael@0:     nsCOMPtr<nsIDocShellTreeItem> target = aTargetItem;
michael@0:     do {
michael@0:         if (ValidateOrigin(aAccessingItem, target)) {
michael@0:             return true;
michael@0:         }
michael@0:             
michael@0:         nsCOMPtr<nsIDocShellTreeItem> parent;
michael@0:         target->GetSameTypeParent(getter_AddRefs(parent));
michael@0:         parent.swap(target);
michael@0:     } while (target);
michael@0: 
michael@0:     nsCOMPtr<nsIDocShellTreeItem> targetRoot;
michael@0:     aTargetItem->GetSameTypeRootTreeItem(getter_AddRefs(targetRoot));
michael@0: 
michael@0:     if (aTargetItem != targetRoot) {
michael@0:         // target is a subframe, not in accessor's frame hierarchy, and all its
michael@0:         // ancestors have origins different from that of the accessor. Don't
michael@0:         // allow access.
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     if (!aConsiderOpener) {
michael@0:         // All done here
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIDOMWindow> targetWindow = do_GetInterface(aTargetItem);
michael@0:     if (!targetWindow) {
michael@0:         NS_ERROR("This should not happen, really");
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIDOMWindow> targetOpener;
michael@0:     targetWindow->GetOpener(getter_AddRefs(targetOpener));
michael@0:     nsCOMPtr<nsIWebNavigation> openerWebNav(do_GetInterface(targetOpener));
michael@0:     nsCOMPtr<nsIDocShellTreeItem> openerItem(do_QueryInterface(openerWebNav));
michael@0: 
michael@0:     if (!openerItem) {
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     return CanAccessItem(openerItem, aAccessingItem, false);    
michael@0: }
michael@0: 
michael@0: static bool
michael@0: ItemIsActive(nsIDocShellTreeItem *aItem)
michael@0: {
michael@0:     nsCOMPtr<nsIDOMWindow> window(do_GetInterface(aItem));
michael@0: 
michael@0:     if (window) {
michael@0:         bool isClosed;
michael@0: 
michael@0:         if (NS_SUCCEEDED(window->GetClosed(&isClosed)) && !isClosed) {
michael@0:             return true;
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     return false;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::FindItemWithName(const char16_t * aName,
michael@0:                              nsISupports * aRequestor,
michael@0:                              nsIDocShellTreeItem * aOriginalRequestor,
michael@0:                              nsIDocShellTreeItem ** _retval)
michael@0: {
michael@0:     NS_ENSURE_ARG(aName);
michael@0:     NS_ENSURE_ARG_POINTER(_retval);
michael@0: 
michael@0:     // If we don't find one, we return NS_OK and a null result
michael@0:     *_retval = nullptr;
michael@0: 
michael@0:     if (!*aName)
michael@0:         return NS_OK;
michael@0: 
michael@0:     if (aRequestor) {
michael@0:         // If aRequestor is not null we don't need to check special names, so
michael@0:         // just hand straight off to the search by actual name function.
michael@0:         return DoFindItemWithName(aName, aRequestor, aOriginalRequestor,
michael@0:                                   _retval);
michael@0:     } else {
michael@0: 
michael@0:         // This is the entry point into the target-finding algorithm.  Check
michael@0:         // for special names.  This should only be done once, hence the check
michael@0:         // for a null aRequestor.
michael@0: 
michael@0:         nsCOMPtr<nsIDocShellTreeItem> foundItem;
michael@0:         nsDependentString name(aName);
michael@0:         if (name.LowerCaseEqualsLiteral("_self")) {
michael@0:             foundItem = this;
michael@0:         }
michael@0:         else if (name.LowerCaseEqualsLiteral("_blank"))
michael@0:         {
michael@0:             // Just return null.  Caller must handle creating a new window with
michael@0:             // a blank name himself.
michael@0:             return NS_OK;
michael@0:         }
michael@0:         else if (name.LowerCaseEqualsLiteral("_parent"))
michael@0:         {
michael@0:             GetSameTypeParent(getter_AddRefs(foundItem));
michael@0:             if(!foundItem)
michael@0:                 foundItem = this;
michael@0:         }
michael@0:         else if (name.LowerCaseEqualsLiteral("_top"))
michael@0:         {
michael@0:             GetSameTypeRootTreeItem(getter_AddRefs(foundItem));
michael@0:             NS_ASSERTION(foundItem, "Must have this; worst case it's us!");
michael@0:         }
michael@0:         // _main is an IE target which should be case-insensitive but isn't
michael@0:         // see bug 217886 for details
michael@0:         else if (name.LowerCaseEqualsLiteral("_content") ||
michael@0:                  name.EqualsLiteral("_main"))
michael@0:         {
michael@0:             // Must pass our same type root as requestor to the
michael@0:             // treeowner to make sure things work right.
michael@0:             nsCOMPtr<nsIDocShellTreeItem> root;
michael@0:             GetSameTypeRootTreeItem(getter_AddRefs(root));
michael@0:             if (mTreeOwner) {
michael@0:                 NS_ASSERTION(root, "Must have this; worst case it's us!");
michael@0:                 mTreeOwner->FindItemWithName(aName, root, aOriginalRequestor,
michael@0:                                              getter_AddRefs(foundItem));
michael@0:             }
michael@0: #ifdef DEBUG
michael@0:             else {
michael@0:                 NS_ERROR("Someone isn't setting up the tree owner.  "
michael@0:                          "You might like to try that.  "
michael@0:                          "Things will.....you know, work.");
michael@0:                 // Note: _content should always exist.  If we don't have one
michael@0:                 // hanging off the treeowner, just create a named window....
michael@0:                 // so don't return here, in case we did that and can now find
michael@0:                 // it.                
michael@0:                 // XXXbz should we be using |root| instead of creating
michael@0:                 // a new window?
michael@0:             }
michael@0: #endif
michael@0:         } else {
michael@0:             // Do the search for item by an actual name.
michael@0:             DoFindItemWithName(aName, aRequestor, aOriginalRequestor,
michael@0:                                getter_AddRefs(foundItem));
michael@0:         }
michael@0: 
michael@0:         if (foundItem && !CanAccessItem(foundItem, aOriginalRequestor)) {
michael@0:             foundItem = nullptr;
michael@0:         }
michael@0: 
michael@0:         // DoFindItemWithName only returns active items and we don't check if
michael@0:         // the item is active for the special cases.
michael@0:         if (foundItem) {
michael@0:             foundItem.swap(*_retval);
michael@0:         }
michael@0:         return NS_OK;
michael@0:     }
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::DoFindItemWithName(const char16_t* aName,
michael@0:                                nsISupports* aRequestor,
michael@0:                                nsIDocShellTreeItem* aOriginalRequestor,
michael@0:                                nsIDocShellTreeItem** _retval)
michael@0: {
michael@0:     // First we check our name.
michael@0:     if (mName.Equals(aName) && ItemIsActive(this) &&
michael@0:         CanAccessItem(this, aOriginalRequestor)) {
michael@0:         NS_ADDREF(*_retval = this);
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     // This QI may fail, but the places where we want to compare, comparing
michael@0:     // against nullptr serves the same purpose.
michael@0:     nsCOMPtr<nsIDocShellTreeItem> reqAsTreeItem(do_QueryInterface(aRequestor));
michael@0: 
michael@0:     // Second we check our children making sure not to ask a child if
michael@0:     // it is the aRequestor.
michael@0: #ifdef DEBUG
michael@0:     nsresult rv =
michael@0: #endif
michael@0:     FindChildWithName(aName, true, true, reqAsTreeItem,
michael@0:                       aOriginalRequestor, _retval);
michael@0:     NS_ASSERTION(NS_SUCCEEDED(rv),
michael@0:                  "FindChildWithName should not be failing here.");
michael@0:     if (*_retval)
michael@0:         return NS_OK;
michael@0:         
michael@0:     // Third if we have a parent and it isn't the requestor then we
michael@0:     // should ask it to do the search.  If it is the requestor we
michael@0:     // should just stop here and let the parent do the rest.  If we
michael@0:     // don't have a parent, then we should ask the
michael@0:     // docShellTreeOwner to do the search.
michael@0:     nsCOMPtr<nsIDocShellTreeItem> parentAsTreeItem =
michael@0:         do_QueryInterface(GetAsSupports(mParent));
michael@0:     if (parentAsTreeItem) {
michael@0:         if (parentAsTreeItem == reqAsTreeItem)
michael@0:             return NS_OK;
michael@0: 
michael@0:         if (parentAsTreeItem->ItemType() == mItemType) {
michael@0:             return parentAsTreeItem->
michael@0:                 FindItemWithName(aName,
michael@0:                                  static_cast<nsIDocShellTreeItem*>
michael@0:                                             (this),
michael@0:                                  aOriginalRequestor,
michael@0:                                  _retval);
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // If the parent is null or not of the same type fall through and ask tree
michael@0:     // owner.
michael@0: 
michael@0:     // This may fail, but comparing against null serves the same purpose
michael@0:     nsCOMPtr<nsIDocShellTreeOwner>
michael@0:         reqAsTreeOwner(do_QueryInterface(aRequestor));
michael@0: 
michael@0:     if (mTreeOwner && mTreeOwner != reqAsTreeOwner) {
michael@0:         return mTreeOwner->
michael@0:             FindItemWithName(aName, this, aOriginalRequestor, _retval);
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsDocShell::IsSandboxedFrom(nsIDocShell* aTargetDocShell)
michael@0: {
michael@0:     // If no target then not sandboxed.
michael@0:     if (!aTargetDocShell) {
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     // We cannot be sandboxed from ourselves.
michael@0:     if (aTargetDocShell == this) {
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     // Default the sandbox flags to our flags, so that if we can't retrieve the
michael@0:     // active document, we will still enforce our own.
michael@0:     uint32_t sandboxFlags = mSandboxFlags;
michael@0:     if (mContentViewer) {
michael@0:         nsCOMPtr<nsIDocument> doc = mContentViewer->GetDocument();
michael@0:         if (doc) {
michael@0:             sandboxFlags = doc->GetSandboxFlags();
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // If no flags, we are not sandboxed at all.
michael@0:     if (!sandboxFlags) {
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     // If aTargetDocShell has an ancestor, it is not top level.
michael@0:     nsCOMPtr<nsIDocShellTreeItem> ancestorOfTarget;
michael@0:     aTargetDocShell->GetSameTypeParent(getter_AddRefs(ancestorOfTarget));
michael@0:     if (ancestorOfTarget) {
michael@0:         do {
michael@0:             // We are not sandboxed if we are an ancestor of target.
michael@0:             if (ancestorOfTarget == this) {
michael@0:                 return false;
michael@0:             }
michael@0:             nsCOMPtr<nsIDocShellTreeItem> tempTreeItem;
michael@0:             ancestorOfTarget->GetSameTypeParent(getter_AddRefs(tempTreeItem));
michael@0:             tempTreeItem.swap(ancestorOfTarget);
michael@0:         } while (ancestorOfTarget);
michael@0: 
michael@0:         // Otherwise, we are sandboxed from aTargetDocShell.
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     // aTargetDocShell is top level, are we the "one permitted sandboxed
michael@0:     // navigator", i.e. did we open aTargetDocShell?
michael@0:     nsCOMPtr<nsIDocShell> permittedNavigator;
michael@0:     aTargetDocShell->
michael@0:         GetOnePermittedSandboxedNavigator(getter_AddRefs(permittedNavigator));
michael@0:     if (permittedNavigator == this) {
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     // If SANDBOXED_TOPLEVEL_NAVIGATION flag is not on, we are not sandboxed
michael@0:     // from our top.
michael@0:     if (!(sandboxFlags & SANDBOXED_TOPLEVEL_NAVIGATION)) {
michael@0:         nsCOMPtr<nsIDocShellTreeItem> rootTreeItem;
michael@0:         GetSameTypeRootTreeItem(getter_AddRefs(rootTreeItem));
michael@0:         if (SameCOMIdentity(aTargetDocShell, rootTreeItem)) {
michael@0:             return false;
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // Otherwise, we are sandboxed from aTargetDocShell.
michael@0:     return true;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetTreeOwner(nsIDocShellTreeOwner ** aTreeOwner)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aTreeOwner);
michael@0: 
michael@0:     *aTreeOwner = mTreeOwner;
michael@0:     NS_IF_ADDREF(*aTreeOwner);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: #ifdef DEBUG_DOCSHELL_FOCUS
michael@0: static void 
michael@0: PrintDocTree(nsIDocShellTreeItem * aParentNode, int aLevel)
michael@0: {
michael@0:   for (int32_t i=0;i<aLevel;i++) printf("  ");
michael@0: 
michael@0:   int32_t childWebshellCount;
michael@0:   aParentNode->GetChildCount(&childWebshellCount);
michael@0:   nsCOMPtr<nsIDocShell> parentAsDocShell(do_QueryInterface(aParentNode));
michael@0:   int32_t type = aParentNode->ItemType();
michael@0:   nsCOMPtr<nsIPresShell> presShell = parentAsDocShell->GetPresShell();
michael@0:   nsRefPtr<nsPresContext> presContext;
michael@0:   parentAsDocShell->GetPresContext(getter_AddRefs(presContext));
michael@0:   nsIDocument *doc = presShell->GetDocument();
michael@0: 
michael@0:   nsCOMPtr<nsIDOMWindow> domwin(doc->GetWindow());
michael@0: 
michael@0:   nsCOMPtr<nsIWidget> widget;
michael@0:   nsViewManager* vm = presShell->GetViewManager();
michael@0:   if (vm) {
michael@0:     vm->GetWidget(getter_AddRefs(widget));
michael@0:   }
michael@0:   dom::Element* rootElement = doc->GetRootElement();
michael@0: 
michael@0:   printf("DS %p  Ty %s  Doc %p DW %p EM %p CN %p\n",  
michael@0:     (void*)parentAsDocShell.get(), 
michael@0:     type==nsIDocShellTreeItem::typeChrome?"Chr":"Con", 
michael@0:      (void*)doc, (void*)domwin.get(),
michael@0:      (void*)presContext->EventStateManager(), (void*)rootElement);
michael@0: 
michael@0:   if (childWebshellCount > 0) {
michael@0:     for (int32_t i=0;i<childWebshellCount;i++) {
michael@0:       nsCOMPtr<nsIDocShellTreeItem> child;
michael@0:       aParentNode->GetChildAt(i, getter_AddRefs(child));
michael@0:       PrintDocTree(child, aLevel+1);
michael@0:     }
michael@0:   }
michael@0: }
michael@0: 
michael@0: static void 
michael@0: PrintDocTree(nsIDocShellTreeItem * aParentNode)
michael@0: {
michael@0:   NS_ASSERTION(aParentNode, "Pointer is null!");
michael@0: 
michael@0:   nsCOMPtr<nsIDocShellTreeItem> parentItem;
michael@0:   aParentNode->GetParent(getter_AddRefs(parentItem));
michael@0:   while (parentItem) {
michael@0:     nsCOMPtr<nsIDocShellTreeItem>tmp;
michael@0:     parentItem->GetParent(getter_AddRefs(tmp));
michael@0:     if (!tmp) {
michael@0:       break;
michael@0:     }
michael@0:     parentItem = tmp;
michael@0:   }
michael@0: 
michael@0:   if (!parentItem) {
michael@0:     parentItem = aParentNode;
michael@0:   }
michael@0: 
michael@0:   PrintDocTree(parentItem, 0);
michael@0: }
michael@0: #endif
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetTreeOwner(nsIDocShellTreeOwner * aTreeOwner)
michael@0: {
michael@0: #ifdef DEBUG_DOCSHELL_FOCUS
michael@0:     nsCOMPtr<nsIDocShellTreeItem> item(do_QueryInterface(aTreeOwner));
michael@0:     if (item) {
michael@0:       PrintDocTree(item);
michael@0:     }
michael@0: #endif
michael@0: 
michael@0:     // Don't automatically set the progress based on the tree owner for frames
michael@0:     if (!IsFrame()) {
michael@0:         nsCOMPtr<nsIWebProgress> webProgress =
michael@0:             do_QueryInterface(GetAsSupports(this));
michael@0: 
michael@0:         if (webProgress) {
michael@0:             nsCOMPtr<nsIWebProgressListener>
michael@0:                 oldListener(do_QueryInterface(mTreeOwner));
michael@0:             nsCOMPtr<nsIWebProgressListener>
michael@0:                 newListener(do_QueryInterface(aTreeOwner));
michael@0: 
michael@0:             if (oldListener) {
michael@0:                 webProgress->RemoveProgressListener(oldListener);
michael@0:             }
michael@0: 
michael@0:             if (newListener) {
michael@0:                 webProgress->AddProgressListener(newListener,
michael@0:                                                  nsIWebProgress::NOTIFY_ALL);
michael@0:             }
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     mTreeOwner = aTreeOwner;    // Weak reference per API
michael@0: 
michael@0:     nsTObserverArray<nsDocLoader*>::ForwardIterator iter(mChildList);
michael@0:     while (iter.HasMore()) {
michael@0:         nsCOMPtr<nsIDocShellTreeItem> child = do_QueryObject(iter.GetNext());
michael@0:         NS_ENSURE_TRUE(child, NS_ERROR_FAILURE);
michael@0:         
michael@0:         if (child->ItemType() == mItemType)
michael@0:             child->SetTreeOwner(aTreeOwner);
michael@0:     }
michael@0: 
michael@0:     // Our tree owner has changed. Recompute scriptability.
michael@0:     //
michael@0:     // Note that this is near-redundant with the recomputation in
michael@0:     // SetDocLoaderParent(), but not so for the root DocShell, where the call to
michael@0:     // SetTreeOwner() happens after the initial AddDocLoaderAsChildOfRoot(),
michael@0:     // and we never set another parent. Given that this is neither expensive nor
michael@0:     // performance-critical, let's be safe and unconditionally recompute this
michael@0:     // state whenever dependent state changes.
michael@0:     RecomputeCanExecuteScripts();
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetChildOffset(uint32_t aChildOffset)
michael@0: {
michael@0:     mChildOffset = aChildOffset;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetHistoryID(uint64_t* aID)
michael@0: {
michael@0:   *aID = mHistoryID;
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetIsInUnload(bool* aIsInUnload)
michael@0: {
michael@0:     *aIsInUnload = mFiredUnloadEvent;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetChildCount(int32_t * aChildCount)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aChildCount);
michael@0:     *aChildCount = mChildList.Length();
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: 
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::AddChild(nsIDocShellTreeItem * aChild)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aChild);
michael@0: 
michael@0:     nsRefPtr<nsDocLoader> childAsDocLoader = GetAsDocLoader(aChild);
michael@0:     NS_ENSURE_TRUE(childAsDocLoader, NS_ERROR_UNEXPECTED);
michael@0: 
michael@0:     // Make sure we're not creating a loop in the docshell tree
michael@0:     nsDocLoader* ancestor = this;
michael@0:     do {
michael@0:         if (childAsDocLoader == ancestor) {
michael@0:             return NS_ERROR_ILLEGAL_VALUE;
michael@0:         }
michael@0:         ancestor = ancestor->GetParent();
michael@0:     } while (ancestor);
michael@0:     
michael@0:     // Make sure to remove the child from its current parent.
michael@0:     nsDocLoader* childsParent = childAsDocLoader->GetParent();
michael@0:     if (childsParent) {
michael@0:         childsParent->RemoveChildLoader(childAsDocLoader);
michael@0:     }
michael@0: 
michael@0:     // Make sure to clear the treeowner in case this child is a different type
michael@0:     // from us.
michael@0:     aChild->SetTreeOwner(nullptr);
michael@0:     
michael@0:     nsresult res = AddChildLoader(childAsDocLoader);
michael@0:     NS_ENSURE_SUCCESS(res, res);
michael@0:     NS_ASSERTION(!mChildList.IsEmpty(),
michael@0:                  "child list must not be empty after a successful add");
michael@0: 
michael@0:     nsCOMPtr<nsIDocShell> childDocShell = do_QueryInterface(aChild);
michael@0:     bool dynamic = false;
michael@0:     childDocShell->GetCreatedDynamically(&dynamic);
michael@0:     if (!dynamic) {
michael@0:         nsCOMPtr<nsISHEntry> currentSH;
michael@0:         bool oshe = false;
michael@0:         GetCurrentSHEntry(getter_AddRefs(currentSH), &oshe);
michael@0:         if (currentSH) {
michael@0:             currentSH->HasDynamicallyAddedChild(&dynamic);
michael@0:         }
michael@0:     }
michael@0:     childDocShell->SetChildOffset(dynamic ? -1 : mChildList.Length() - 1);
michael@0: 
michael@0:     /* Set the child's global history if the parent has one */
michael@0:     if (mUseGlobalHistory) {
michael@0:             childDocShell->SetUseGlobalHistory(true);
michael@0:     }
michael@0: 
michael@0:     if (aChild->ItemType() != mItemType) {
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     aChild->SetTreeOwner(mTreeOwner);
michael@0: 
michael@0:     nsCOMPtr<nsIDocShell> childAsDocShell(do_QueryInterface(aChild));
michael@0:     if (!childAsDocShell)
michael@0:         return NS_OK;
michael@0: 
michael@0:     // charset, style-disabling, and zoom will be inherited in SetupNewViewer()
michael@0: 
michael@0:     // Now take this document's charset and set the child's parentCharset field
michael@0:     // to it. We'll later use that field, in the loading process, for the
michael@0:     // charset choosing algorithm.
michael@0:     // If we fail, at any point, we just return NS_OK.
michael@0:     // This code has some performance impact. But this will be reduced when 
michael@0:     // the current charset will finally be stored as an Atom, avoiding the
michael@0:     // alias resolution extra look-up.
michael@0: 
michael@0:     // we are NOT going to propagate the charset is this Chrome's docshell
michael@0:     if (mItemType == nsIDocShellTreeItem::typeChrome)
michael@0:         return NS_OK;
michael@0: 
michael@0:     // get the parent's current charset
michael@0:     if (!mContentViewer)
michael@0:         return NS_OK;
michael@0:     nsIDocument* doc = mContentViewer->GetDocument();
michael@0:     if (!doc)
michael@0:         return NS_OK;
michael@0: 
michael@0:     bool isWyciwyg = false;
michael@0: 
michael@0:     if (mCurrentURI) {
michael@0:         // Check if the url is wyciwyg
michael@0:         mCurrentURI->SchemeIs("wyciwyg", &isWyciwyg);      
michael@0:     }
michael@0: 
michael@0:     if (!isWyciwyg) {
michael@0:         // If this docshell is loaded from a wyciwyg: URI, don't
michael@0:         // advertise our charset since it does not in any way reflect
michael@0:         // the actual source charset, which is what we're trying to
michael@0:         // expose here.
michael@0: 
michael@0:         const nsACString &parentCS = doc->GetDocumentCharacterSet();
michael@0:         int32_t charsetSource = doc->GetDocumentCharacterSetSource();
michael@0:         // set the child's parentCharset
michael@0:         childAsDocShell->SetParentCharset(parentCS,
michael@0:                                           charsetSource,
michael@0:                                           doc->NodePrincipal());
michael@0:     }
michael@0: 
michael@0:     // printf("### 1 >>> Adding child. Parent CS = %s. ItemType = %d.\n", NS_LossyConvertUTF16toASCII(parentCS).get(), mItemType);
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::RemoveChild(nsIDocShellTreeItem * aChild)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aChild);
michael@0: 
michael@0:     nsRefPtr<nsDocLoader> childAsDocLoader = GetAsDocLoader(aChild);
michael@0:     NS_ENSURE_TRUE(childAsDocLoader, NS_ERROR_UNEXPECTED);
michael@0:     
michael@0:     nsresult rv = RemoveChildLoader(childAsDocLoader);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0:     
michael@0:     aChild->SetTreeOwner(nullptr);
michael@0: 
michael@0:     return nsDocLoader::AddDocLoaderAsChildOfRoot(childAsDocLoader);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetChildAt(int32_t aIndex, nsIDocShellTreeItem ** aChild)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aChild);
michael@0: 
michael@0: #ifdef DEBUG
michael@0:     if (aIndex < 0) {
michael@0:       NS_WARNING("Negative index passed to GetChildAt");
michael@0:     } else if (static_cast<uint32_t>(aIndex) >= mChildList.Length()) {
michael@0:       NS_WARNING("Too large an index passed to GetChildAt");
michael@0:     }
michael@0: #endif
michael@0: 
michael@0:     nsIDocumentLoader* child = ChildAt(aIndex);
michael@0:     NS_ENSURE_TRUE(child, NS_ERROR_UNEXPECTED);
michael@0:     
michael@0:     return CallQueryInterface(child, aChild);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::FindChildWithName(const char16_t * aName,
michael@0:                               bool aRecurse, bool aSameType,
michael@0:                               nsIDocShellTreeItem * aRequestor,
michael@0:                               nsIDocShellTreeItem * aOriginalRequestor,
michael@0:                               nsIDocShellTreeItem ** _retval)
michael@0: {
michael@0:     NS_ENSURE_ARG(aName);
michael@0:     NS_ENSURE_ARG_POINTER(_retval);
michael@0: 
michael@0:     *_retval = nullptr;          // if we don't find one, we return NS_OK and a null result 
michael@0: 
michael@0:     if (!*aName)
michael@0:         return NS_OK;
michael@0: 
michael@0:     nsXPIDLString childName;
michael@0:     nsTObserverArray<nsDocLoader*>::ForwardIterator iter(mChildList);
michael@0:     while (iter.HasMore()) {
michael@0:         nsCOMPtr<nsIDocShellTreeItem> child = do_QueryObject(iter.GetNext());
michael@0:         NS_ENSURE_TRUE(child, NS_ERROR_FAILURE);
michael@0:         int32_t childType = child->ItemType();
michael@0: 
michael@0:         if (aSameType && (childType != mItemType))
michael@0:             continue;
michael@0: 
michael@0:         bool childNameEquals = false;
michael@0:         child->NameEquals(aName, &childNameEquals);
michael@0:         if (childNameEquals && ItemIsActive(child) &&
michael@0:             CanAccessItem(child, aOriginalRequestor)) {
michael@0:             child.swap(*_retval);
michael@0:             break;
michael@0:         }
michael@0: 
michael@0:         if (childType != mItemType)     //Only ask it to check children if it is same type
michael@0:             continue;
michael@0: 
michael@0:         if (aRecurse && (aRequestor != child))  // Only ask the child if it isn't the requestor
michael@0:         {
michael@0:             // See if child contains the shell with the given name
michael@0: #ifdef DEBUG
michael@0:             nsresult rv =
michael@0: #endif
michael@0:             child->FindChildWithName(aName, true,
michael@0:                                      aSameType,
michael@0:                                      static_cast<nsIDocShellTreeItem*>
michael@0:                                                 (this),
michael@0:                                      aOriginalRequestor,
michael@0:                                      _retval);
michael@0:             NS_ASSERTION(NS_SUCCEEDED(rv),
michael@0:                          "FindChildWithName should not fail here");
michael@0:             if (*_retval)           // found it
michael@0:                 return NS_OK;
michael@0:         }
michael@0:     }
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetChildSHEntry(int32_t aChildOffset, nsISHEntry ** aResult)
michael@0: {
michael@0:     nsresult rv = NS_OK;
michael@0: 
michael@0:     NS_ENSURE_ARG_POINTER(aResult);
michael@0:     *aResult = nullptr;
michael@0: 
michael@0:     
michael@0:     // A nsISHEntry for a child is *only* available when the parent is in
michael@0:     // the progress of loading a document too...
michael@0:     
michael@0:     if (mLSHE) {
michael@0:         /* Before looking for the subframe's url, check
michael@0:          * the expiration status of the parent. If the parent
michael@0:          * has expired from cache, then subframes will not be 
michael@0:          * loaded from history in certain situations.  
michael@0:          */
michael@0:         bool parentExpired=false;
michael@0:         mLSHE->GetExpirationStatus(&parentExpired);
michael@0:         
michael@0:         /* Get the parent's Load Type so that it can be set on the child too.
michael@0:          * By default give a loadHistory value
michael@0:          */
michael@0:         uint32_t loadType = nsIDocShellLoadInfo::loadHistory;
michael@0:         mLSHE->GetLoadType(&loadType);  
michael@0:         // If the user did a shift-reload on this frameset page, 
michael@0:         // we don't want to load the subframes from history.
michael@0:         if (loadType == nsIDocShellLoadInfo::loadReloadBypassCache ||
michael@0:             loadType == nsIDocShellLoadInfo::loadReloadBypassProxy ||
michael@0:             loadType == nsIDocShellLoadInfo::loadReloadBypassProxyAndCache ||
michael@0:             loadType == nsIDocShellLoadInfo::loadRefresh)
michael@0:             return rv;
michael@0:         
michael@0:         /* If the user pressed reload and the parent frame has expired
michael@0:          *  from cache, we do not want to load the child frame from history.
michael@0:          */
michael@0:         if (parentExpired && (loadType == nsIDocShellLoadInfo::loadReloadNormal)) {
michael@0:             // The parent has expired. Return null.
michael@0:             *aResult = nullptr;
michael@0:             return rv;
michael@0:         }
michael@0: 
michael@0:         nsCOMPtr<nsISHContainer> container(do_QueryInterface(mLSHE));
michael@0:         if (container) {
michael@0:             // Get the child subframe from session history.
michael@0:             rv = container->GetChildAt(aChildOffset, aResult);            
michael@0:             if (*aResult) 
michael@0:                 (*aResult)->SetLoadType(loadType);            
michael@0:         }
michael@0:     }
michael@0:     return rv;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::AddChildSHEntry(nsISHEntry * aCloneRef, nsISHEntry * aNewEntry,
michael@0:                             int32_t aChildOffset, uint32_t loadType,
michael@0:                             bool aCloneChildren)
michael@0: {
michael@0:     nsresult rv;
michael@0: 
michael@0:     if (mLSHE && loadType != LOAD_PUSHSTATE) {
michael@0:         /* You get here if you are currently building a 
michael@0:          * hierarchy ie.,you just visited a frameset page
michael@0:          */
michael@0:         nsCOMPtr<nsISHContainer> container(do_QueryInterface(mLSHE, &rv));
michael@0:         if (container) {
michael@0:             rv = container->AddChild(aNewEntry, aChildOffset);
michael@0:         }
michael@0:     }
michael@0:     else if (!aCloneRef) {
michael@0:         /* This is an initial load in some subframe.  Just append it if we can */
michael@0:         nsCOMPtr<nsISHContainer> container(do_QueryInterface(mOSHE, &rv));
michael@0:         if (container) {
michael@0:             rv = container->AddChild(aNewEntry, aChildOffset);
michael@0:         }
michael@0:     }
michael@0:     else if (mSessionHistory) {
michael@0:         /* You are currently in the rootDocShell.
michael@0:          * You will get here when a subframe has a new url
michael@0:          * to load and you have walked up the tree all the 
michael@0:          * way to the top to clone the current SHEntry hierarchy
michael@0:          * and replace the subframe where a new url was loaded with
michael@0:          * a new entry.
michael@0:          */
michael@0:         int32_t index = -1;
michael@0:         nsCOMPtr<nsISHEntry> currentHE;
michael@0:         mSessionHistory->GetIndex(&index);
michael@0:         if (index < 0)
michael@0:             return NS_ERROR_FAILURE;
michael@0: 
michael@0:         rv = mSessionHistory->GetEntryAtIndex(index, false,
michael@0:                                               getter_AddRefs(currentHE));
michael@0:         NS_ENSURE_TRUE(currentHE, NS_ERROR_FAILURE);
michael@0: 
michael@0:         nsCOMPtr<nsISHEntry> currentEntry(do_QueryInterface(currentHE));
michael@0:         if (currentEntry) {
michael@0:             uint32_t cloneID = 0;
michael@0:             nsCOMPtr<nsISHEntry> nextEntry;
michael@0:             aCloneRef->GetID(&cloneID);
michael@0:             rv = CloneAndReplace(currentEntry, this, cloneID, aNewEntry,
michael@0:                                  aCloneChildren, getter_AddRefs(nextEntry));
michael@0: 
michael@0:             if (NS_SUCCEEDED(rv)) {
michael@0:                 nsCOMPtr<nsISHistoryInternal>
michael@0:                     shPrivate(do_QueryInterface(mSessionHistory));
michael@0:                 NS_ENSURE_TRUE(shPrivate, NS_ERROR_FAILURE);
michael@0:                 rv = shPrivate->AddEntry(nextEntry, true);
michael@0:             }
michael@0:         }
michael@0:     }
michael@0:     else {
michael@0:         /* Just pass this along */
michael@0:         nsCOMPtr<nsIDocShell> parent =
michael@0:             do_QueryInterface(GetAsSupports(mParent), &rv);
michael@0:         if (parent) {
michael@0:             rv = parent->AddChildSHEntry(aCloneRef, aNewEntry, aChildOffset,
michael@0:                                          loadType, aCloneChildren);
michael@0:         }          
michael@0:     }
michael@0:     return rv;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::DoAddChildSHEntry(nsISHEntry* aNewEntry, int32_t aChildOffset,
michael@0:                               bool aCloneChildren)
michael@0: {
michael@0:     /* You will get here when you are in a subframe and
michael@0:      * a new url has been loaded on you. 
michael@0:      * The mOSHE in this subframe will be the previous url's
michael@0:      * mOSHE. This mOSHE will be used as the identification
michael@0:      * for this subframe in the  CloneAndReplace function.
michael@0:      */
michael@0: 
michael@0:     // In this case, we will end up calling AddEntry, which increases the
michael@0:     // current index by 1
michael@0:     nsCOMPtr<nsISHistory> rootSH;
michael@0:     GetRootSessionHistory(getter_AddRefs(rootSH));
michael@0:     if (rootSH) {
michael@0:         rootSH->GetIndex(&mPreviousTransIndex);
michael@0:     }
michael@0: 
michael@0:     nsresult rv;
michael@0:     nsCOMPtr<nsIDocShell> parent =
michael@0:         do_QueryInterface(GetAsSupports(mParent), &rv);
michael@0:     if (parent) {
michael@0:         rv = parent->AddChildSHEntry(mOSHE, aNewEntry, aChildOffset, mLoadType,
michael@0:                                      aCloneChildren);
michael@0:     }
michael@0: 
michael@0: 
michael@0:     if (rootSH) {
michael@0:         rootSH->GetIndex(&mLoadedTransIndex);
michael@0: #ifdef DEBUG_PAGE_CACHE
michael@0:         printf("Previous index: %d, Loaded index: %d\n\n", mPreviousTransIndex,
michael@0:                mLoadedTransIndex);
michael@0: #endif
michael@0:     }
michael@0: 
michael@0:     return rv;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetUseGlobalHistory(bool aUseGlobalHistory)
michael@0: {
michael@0:     nsresult rv;
michael@0: 
michael@0:     mUseGlobalHistory = aUseGlobalHistory;
michael@0: 
michael@0:     if (!aUseGlobalHistory) {
michael@0:         mGlobalHistory = nullptr;
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     // No need to initialize mGlobalHistory if IHistory is available.
michael@0:     nsCOMPtr<IHistory> history = services::GetHistoryService();
michael@0:     if (history) {
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     if (mGlobalHistory) {
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     mGlobalHistory = do_GetService(NS_GLOBALHISTORY2_CONTRACTID, &rv);
michael@0:     return rv;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetUseGlobalHistory(bool *aUseGlobalHistory)
michael@0: {
michael@0:     *aUseGlobalHistory = mUseGlobalHistory;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::RemoveFromSessionHistory()
michael@0: {
michael@0:     nsCOMPtr<nsISHistoryInternal> internalHistory;
michael@0:     nsCOMPtr<nsISHistory> sessionHistory;
michael@0:     nsCOMPtr<nsIDocShellTreeItem> root;
michael@0:     GetSameTypeRootTreeItem(getter_AddRefs(root));
michael@0:     if (root) {
michael@0:         nsCOMPtr<nsIWebNavigation> rootAsWebnav =
michael@0:             do_QueryInterface(root);
michael@0:         if (rootAsWebnav) {
michael@0:             rootAsWebnav->GetSessionHistory(getter_AddRefs(sessionHistory));
michael@0:             internalHistory = do_QueryInterface(sessionHistory);
michael@0:         }
michael@0:     }
michael@0:     if (!internalHistory) {
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     int32_t index = 0;
michael@0:     sessionHistory->GetIndex(&index);
michael@0:     nsAutoTArray<uint64_t, 16> ids;
michael@0:     ids.AppendElement(mHistoryID);
michael@0:     internalHistory->RemoveEntries(ids, index);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetCreatedDynamically(bool aDynamic)
michael@0: {
michael@0:     mDynamicallyCreated = aDynamic;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetCreatedDynamically(bool* aDynamic)
michael@0: {
michael@0:     *aDynamic = mDynamicallyCreated;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetCurrentSHEntry(nsISHEntry** aEntry, bool* aOSHE)
michael@0: {
michael@0:     *aOSHE = false;
michael@0:     *aEntry = nullptr;
michael@0:     if (mLSHE) {
michael@0:         NS_ADDREF(*aEntry = mLSHE);
michael@0:     } else if (mOSHE) {
michael@0:         NS_ADDREF(*aEntry = mOSHE);
michael@0:         *aOSHE = true;
michael@0:     }
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: nsIScriptGlobalObject*
michael@0: nsDocShell::GetScriptGlobalObject()
michael@0: {
michael@0:     NS_ENSURE_SUCCESS(EnsureScriptEnvironment(), nullptr);
michael@0:     return mScriptGlobal;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetDeviceSizeIsPageSize(bool aValue)
michael@0: {
michael@0:     if (mDeviceSizeIsPageSize != aValue) {
michael@0:       mDeviceSizeIsPageSize = aValue;
michael@0:       nsRefPtr<nsPresContext> presContext;
michael@0:       GetPresContext(getter_AddRefs(presContext));
michael@0:       if (presContext) {
michael@0:           presContext->MediaFeatureValuesChanged(presContext->eAlwaysRebuildStyle);
michael@0:       }
michael@0:     }
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetDeviceSizeIsPageSize(bool* aValue)
michael@0: {
michael@0:     *aValue = mDeviceSizeIsPageSize;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsDocShell::ClearFrameHistory(nsISHEntry* aEntry)
michael@0: {
michael@0:   nsCOMPtr<nsISHContainer> shcontainer = do_QueryInterface(aEntry);
michael@0:   nsCOMPtr<nsISHistory> rootSH;
michael@0:   GetRootSessionHistory(getter_AddRefs(rootSH));
michael@0:   nsCOMPtr<nsISHistoryInternal> history = do_QueryInterface(rootSH);
michael@0:   if (!history || !shcontainer) {
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   int32_t count = 0;
michael@0:   shcontainer->GetChildCount(&count);
michael@0:   nsAutoTArray<uint64_t, 16> ids;
michael@0:   for (int32_t i = 0; i < count; ++i) {
michael@0:     nsCOMPtr<nsISHEntry> child;
michael@0:     shcontainer->GetChildAt(i, getter_AddRefs(child));
michael@0:     if (child) {
michael@0:       uint64_t id = 0;
michael@0:       child->GetDocshellID(&id);
michael@0:       ids.AppendElement(id);
michael@0:     }
michael@0:   }
michael@0:   int32_t index = 0;
michael@0:   rootSH->GetIndex(&index);
michael@0:   history->RemoveEntries(ids, index);
michael@0: }
michael@0: 
michael@0: //-------------------------------------
michael@0: //-- Helper Method for Print discovery
michael@0: //-------------------------------------
michael@0: bool 
michael@0: nsDocShell::IsPrintingOrPP(bool aDisplayErrorDialog)
michael@0: {
michael@0:   if (mIsPrintingOrPP && aDisplayErrorDialog) {
michael@0:     DisplayLoadError(NS_ERROR_DOCUMENT_IS_PRINTMODE, nullptr, nullptr, nullptr);
michael@0:   }
michael@0: 
michael@0:   return mIsPrintingOrPP;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsDocShell::IsNavigationAllowed(bool aDisplayPrintErrorDialog)
michael@0: {
michael@0:   bool isAllowed = !IsPrintingOrPP(aDisplayPrintErrorDialog) && !mFiredUnloadEvent;
michael@0:   if (!isAllowed) {
michael@0:     return false;
michael@0:   }
michael@0:   if (!mContentViewer) {
michael@0:     return true;
michael@0:   }
michael@0:   bool firingBeforeUnload;
michael@0:   mContentViewer->GetBeforeUnloadFiring(&firingBeforeUnload);
michael@0:   return !firingBeforeUnload;
michael@0: }
michael@0: 
michael@0: //*****************************************************************************
michael@0: // nsDocShell::nsIWebNavigation
michael@0: //*****************************************************************************   
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetCanGoBack(bool * aCanGoBack)
michael@0: {
michael@0:     if (!IsNavigationAllowed(false)) {
michael@0:       *aCanGoBack = false;
michael@0:       return NS_OK; // JS may not handle returning of an error code
michael@0:     }
michael@0:     nsresult rv;
michael@0:     nsCOMPtr<nsISHistory> rootSH;
michael@0:     rv = GetRootSessionHistory(getter_AddRefs(rootSH));
michael@0:     nsCOMPtr<nsIWebNavigation> webnav(do_QueryInterface(rootSH));
michael@0:     NS_ENSURE_TRUE(webnav, NS_ERROR_FAILURE);
michael@0:     rv = webnav->GetCanGoBack(aCanGoBack);   
michael@0:     return rv;
michael@0: 
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetCanGoForward(bool * aCanGoForward)
michael@0: {
michael@0:     if (!IsNavigationAllowed(false)) {
michael@0:       *aCanGoForward = false;
michael@0:       return NS_OK; // JS may not handle returning of an error code
michael@0:     }
michael@0:     nsresult rv;
michael@0:     nsCOMPtr<nsISHistory> rootSH;
michael@0:     rv = GetRootSessionHistory(getter_AddRefs(rootSH)); 
michael@0:     nsCOMPtr<nsIWebNavigation> webnav(do_QueryInterface(rootSH));
michael@0:     NS_ENSURE_TRUE(webnav, NS_ERROR_FAILURE);
michael@0:     rv = webnav->GetCanGoForward(aCanGoForward);
michael@0:     return rv;
michael@0: 
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GoBack()
michael@0: {
michael@0:     if (!IsNavigationAllowed()) {
michael@0:       return NS_OK; // JS may not handle returning of an error code
michael@0:     }
michael@0:     nsresult rv;
michael@0:     nsCOMPtr<nsISHistory> rootSH;
michael@0:     rv = GetRootSessionHistory(getter_AddRefs(rootSH));
michael@0:     nsCOMPtr<nsIWebNavigation> webnav(do_QueryInterface(rootSH));
michael@0:     NS_ENSURE_TRUE(webnav, NS_ERROR_FAILURE);
michael@0:     rv = webnav->GoBack();
michael@0:     return rv;
michael@0: 
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GoForward()
michael@0: {
michael@0:     if (!IsNavigationAllowed()) {
michael@0:       return NS_OK; // JS may not handle returning of an error code
michael@0:     }
michael@0:     nsresult rv;
michael@0:     nsCOMPtr<nsISHistory> rootSH;
michael@0:     rv = GetRootSessionHistory(getter_AddRefs(rootSH));
michael@0:     nsCOMPtr<nsIWebNavigation> webnav(do_QueryInterface(rootSH));
michael@0:     NS_ENSURE_TRUE(webnav, NS_ERROR_FAILURE);
michael@0:     rv = webnav->GoForward();
michael@0:     return rv;
michael@0: 
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP nsDocShell::GotoIndex(int32_t aIndex)
michael@0: {
michael@0:     if (!IsNavigationAllowed()) {
michael@0:       return NS_OK; // JS may not handle returning of an error code
michael@0:     }
michael@0:     nsresult rv;
michael@0:     nsCOMPtr<nsISHistory> rootSH;
michael@0:     rv = GetRootSessionHistory(getter_AddRefs(rootSH));
michael@0:     nsCOMPtr<nsIWebNavigation> webnav(do_QueryInterface(rootSH));
michael@0:     NS_ENSURE_TRUE(webnav, NS_ERROR_FAILURE);
michael@0:     rv = webnav->GotoIndex(aIndex);
michael@0:     return rv;
michael@0: 
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::LoadURI(const char16_t * aURI,
michael@0:                     uint32_t aLoadFlags,
michael@0:                     nsIURI * aReferringURI,
michael@0:                     nsIInputStream * aPostStream,
michael@0:                     nsIInputStream * aHeaderStream)
michael@0: {
michael@0:     return LoadURIWithBase(aURI, aLoadFlags, aReferringURI, aPostStream,
michael@0:                            aHeaderStream, nullptr);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::LoadURIWithBase(const char16_t * aURI,
michael@0:                             uint32_t aLoadFlags,
michael@0:                             nsIURI * aReferringURI,
michael@0:                             nsIInputStream * aPostStream,
michael@0:                             nsIInputStream * aHeaderStream,
michael@0:                             nsIURI * aBaseURI)
michael@0: {
michael@0:     NS_ASSERTION((aLoadFlags & 0xf) == 0, "Unexpected flags");
michael@0:     
michael@0:     if (!IsNavigationAllowed()) {
michael@0:       return NS_OK; // JS may not handle returning of an error code
michael@0:     }
michael@0:     nsCOMPtr<nsIURI> uri;
michael@0:     nsCOMPtr<nsIInputStream> postStream(aPostStream);
michael@0:     nsresult rv = NS_OK;
michael@0: 
michael@0:     // Create a URI from our string; if that succeeds, we want to
michael@0:     // change aLoadFlags to not include the ALLOW_THIRD_PARTY_FIXUP
michael@0:     // flag.
michael@0: 
michael@0:     NS_ConvertUTF16toUTF8 uriString(aURI);
michael@0:     // Cleanup the empty spaces that might be on each end.
michael@0:     uriString.Trim(" ");
michael@0:     // Eliminate embedded newlines, which single-line text fields now allow:
michael@0:     uriString.StripChars("\r\n");
michael@0:     NS_ENSURE_TRUE(!uriString.IsEmpty(), NS_ERROR_FAILURE);
michael@0: 
michael@0:     rv = NS_NewURI(getter_AddRefs(uri), uriString);
michael@0:     if (uri) {
michael@0:         aLoadFlags &= ~LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP;
michael@0:     }
michael@0:     
michael@0:     if (sURIFixup) {
michael@0:         // Call the fixup object.  This will clobber the rv from NS_NewURI
michael@0:         // above, but that's fine with us.  Note that we need to do this even
michael@0:         // if NS_NewURI returned a URI, because fixup handles nested URIs, etc
michael@0:         // (things like view-source:mozilla.org for example).
michael@0:         uint32_t fixupFlags = 0;
michael@0:         if (aLoadFlags & LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP) {
michael@0:           fixupFlags |= nsIURIFixup::FIXUP_FLAG_ALLOW_KEYWORD_LOOKUP;
michael@0:         }
michael@0:         if (aLoadFlags & LOAD_FLAGS_FIXUP_SCHEME_TYPOS) {
michael@0:           fixupFlags |= nsIURIFixup::FIXUP_FLAG_FIX_SCHEME_TYPOS;
michael@0:         }
michael@0:         nsCOMPtr<nsIInputStream> fixupStream;
michael@0:         rv = sURIFixup->CreateFixupURI(uriString, fixupFlags,
michael@0:                                        getter_AddRefs(fixupStream),
michael@0:                                        getter_AddRefs(uri));
michael@0:         if (fixupStream) {
michael@0:             // CreateFixupURI only returns a post data stream if it succeeded
michael@0:             // and changed the URI, in which case we should override the
michael@0:             // passed-in post data.
michael@0:             postStream = fixupStream;
michael@0:         }
michael@0:     }
michael@0:     // else no fixup service so just use the URI we created and see
michael@0:     // what happens
michael@0: 
michael@0:     if (NS_ERROR_MALFORMED_URI == rv) {
michael@0:         DisplayLoadError(rv, uri, aURI, nullptr);
michael@0:     }
michael@0: 
michael@0:     if (NS_FAILED(rv) || !uri)
michael@0:         return NS_ERROR_FAILURE;
michael@0: 
michael@0:     PopupControlState popupState;
michael@0:     if (aLoadFlags & LOAD_FLAGS_ALLOW_POPUPS) {
michael@0:         popupState = openAllowed;
michael@0:         aLoadFlags &= ~LOAD_FLAGS_ALLOW_POPUPS;
michael@0:     } else {
michael@0:         popupState = openOverridden;
michael@0:     }
michael@0:     nsAutoPopupStatePusher statePusher(popupState);
michael@0: 
michael@0:     // Don't pass certain flags that aren't needed and end up confusing
michael@0:     // ConvertLoadTypeToDocShellLoadInfo.  We do need to ensure that they are
michael@0:     // passed to LoadURI though, since it uses them.
michael@0:     uint32_t extraFlags = (aLoadFlags & EXTRA_LOAD_FLAGS);
michael@0:     aLoadFlags &= ~EXTRA_LOAD_FLAGS;
michael@0: 
michael@0:     nsCOMPtr<nsIDocShellLoadInfo> loadInfo;
michael@0:     rv = CreateLoadInfo(getter_AddRefs(loadInfo));
michael@0:     if (NS_FAILED(rv)) return rv;
michael@0: 
michael@0:     /*
michael@0:      * If the user "Disables Protection on This Page", we have to make sure to
michael@0:      * remember the users decision when opening links in child tabs [Bug 906190]
michael@0:      */
michael@0:     uint32_t loadType;
michael@0:     if (aLoadFlags & LOAD_FLAGS_ALLOW_MIXED_CONTENT) {
michael@0:       loadType = MAKE_LOAD_TYPE(LOAD_NORMAL_ALLOW_MIXED_CONTENT, aLoadFlags);
michael@0:     } else {
michael@0:       loadType = MAKE_LOAD_TYPE(LOAD_NORMAL, aLoadFlags);
michael@0:     }
michael@0: 
michael@0:     loadInfo->SetLoadType(ConvertLoadTypeToDocShellLoadInfo(loadType));
michael@0:     loadInfo->SetPostDataStream(postStream);
michael@0:     loadInfo->SetReferrer(aReferringURI);
michael@0:     loadInfo->SetHeadersStream(aHeaderStream);
michael@0:     loadInfo->SetBaseURI(aBaseURI);
michael@0: 
michael@0:     rv = LoadURI(uri, loadInfo, extraFlags, true);
michael@0: 
michael@0:     // Save URI string in case it's needed later when
michael@0:     // sending to search engine service in EndPageLoad()
michael@0:     mOriginalUriString = uriString; 
michael@0: 
michael@0:     return rv;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::DisplayLoadError(nsresult aError, nsIURI *aURI,
michael@0:                              const char16_t *aURL,
michael@0:                              nsIChannel* aFailedChannel)
michael@0: {
michael@0:     // Get prompt and string bundle servcies
michael@0:     nsCOMPtr<nsIPrompt> prompter;
michael@0:     nsCOMPtr<nsIStringBundle> stringBundle;
michael@0:     GetPromptAndStringBundle(getter_AddRefs(prompter),
michael@0:                              getter_AddRefs(stringBundle));
michael@0: 
michael@0:     NS_ENSURE_TRUE(stringBundle, NS_ERROR_FAILURE);
michael@0:     NS_ENSURE_TRUE(prompter, NS_ERROR_FAILURE);
michael@0: 
michael@0:     nsAutoString error;
michael@0:     const uint32_t kMaxFormatStrArgs = 3;
michael@0:     nsAutoString formatStrs[kMaxFormatStrArgs];
michael@0:     uint32_t formatStrCount = 0;
michael@0:     bool addHostPort = false;
michael@0:     nsresult rv = NS_OK;
michael@0:     nsAutoString messageStr;
michael@0:     nsAutoCString cssClass;
michael@0:     nsAutoCString errorPage;
michael@0: 
michael@0:     errorPage.AssignLiteral("neterror");
michael@0: 
michael@0:     // Turn the error code into a human readable error message.
michael@0:     if (NS_ERROR_UNKNOWN_PROTOCOL == aError) {
michael@0:         NS_ENSURE_ARG_POINTER(aURI);
michael@0: 
michael@0:         // Extract the schemes into a comma delimited list.
michael@0:         nsAutoCString scheme;
michael@0:         aURI->GetScheme(scheme);
michael@0:         CopyASCIItoUTF16(scheme, formatStrs[0]);
michael@0:         nsCOMPtr<nsINestedURI> nestedURI = do_QueryInterface(aURI);
michael@0:         while (nestedURI) {
michael@0:             nsCOMPtr<nsIURI> tempURI;
michael@0:             nsresult rv2;
michael@0:             rv2 = nestedURI->GetInnerURI(getter_AddRefs(tempURI));
michael@0:             if (NS_SUCCEEDED(rv2) && tempURI) {
michael@0:                 tempURI->GetScheme(scheme);
michael@0:                 formatStrs[0].Append(NS_LITERAL_STRING(", "));
michael@0:                 AppendASCIItoUTF16(scheme, formatStrs[0]);
michael@0:             }
michael@0:             nestedURI = do_QueryInterface(tempURI);
michael@0:         }
michael@0:         formatStrCount = 1;
michael@0:         error.AssignLiteral("unknownProtocolFound");
michael@0:     }
michael@0:     else if (NS_ERROR_FILE_NOT_FOUND == aError) {
michael@0:         NS_ENSURE_ARG_POINTER(aURI);
michael@0:         error.AssignLiteral("fileNotFound");
michael@0:     }
michael@0:     else if (NS_ERROR_UNKNOWN_HOST == aError) {
michael@0:         NS_ENSURE_ARG_POINTER(aURI);
michael@0:         // Get the host
michael@0:         nsAutoCString host;
michael@0:         nsCOMPtr<nsIURI> innermostURI = NS_GetInnermostURI(aURI);
michael@0:         innermostURI->GetHost(host);
michael@0:         CopyUTF8toUTF16(host, formatStrs[0]);
michael@0:         formatStrCount = 1;
michael@0:         error.AssignLiteral("dnsNotFound");
michael@0:     }
michael@0:     else if(NS_ERROR_CONNECTION_REFUSED == aError) {
michael@0:         NS_ENSURE_ARG_POINTER(aURI);
michael@0:         addHostPort = true;
michael@0:         error.AssignLiteral("connectionFailure");
michael@0:     }
michael@0:     else if(NS_ERROR_NET_INTERRUPT == aError) {
michael@0:         NS_ENSURE_ARG_POINTER(aURI);
michael@0:         addHostPort = true;
michael@0:         error.AssignLiteral("netInterrupt");
michael@0:     }
michael@0:     else if (NS_ERROR_NET_TIMEOUT == aError) {
michael@0:         NS_ENSURE_ARG_POINTER(aURI);
michael@0:         // Get the host
michael@0:         nsAutoCString host;
michael@0:         aURI->GetHost(host);
michael@0:         CopyUTF8toUTF16(host, formatStrs[0]);
michael@0:         formatStrCount = 1;
michael@0:         error.AssignLiteral("netTimeout");
michael@0:     }
michael@0:     else if (NS_ERROR_CSP_FRAME_ANCESTOR_VIOLATION == aError) {
michael@0:         // CSP error
michael@0:         cssClass.AssignLiteral("neterror");
michael@0:         error.AssignLiteral("cspFrameAncestorBlocked");
michael@0:     }
michael@0:     else if (NS_ERROR_GET_MODULE(aError) == NS_ERROR_MODULE_SECURITY) {
michael@0:         nsCOMPtr<nsINSSErrorsService> nsserr =
michael@0:             do_GetService(NS_NSS_ERRORS_SERVICE_CONTRACTID);
michael@0: 
michael@0:         uint32_t errorClass;
michael@0:         if (!nsserr ||
michael@0:             NS_FAILED(nsserr->GetErrorClass(aError, &errorClass))) {
michael@0:           errorClass = nsINSSErrorsService::ERROR_CLASS_SSL_PROTOCOL;
michael@0:         }
michael@0: 
michael@0:         nsCOMPtr<nsISupports> securityInfo;
michael@0:         nsCOMPtr<nsITransportSecurityInfo> tsi;
michael@0:         if (aFailedChannel)
michael@0:             aFailedChannel->GetSecurityInfo(getter_AddRefs(securityInfo));
michael@0:         tsi = do_QueryInterface(securityInfo);
michael@0:         if (tsi) {
michael@0:             // Usually we should have aFailedChannel and get a detailed message
michael@0:             tsi->GetErrorMessage(getter_Copies(messageStr));
michael@0:         }
michael@0:         else {
michael@0:             // No channel, let's obtain the generic error message
michael@0:             if (nsserr) {
michael@0:                 nsserr->GetErrorMessage(aError, messageStr);
michael@0:             }
michael@0:         }
michael@0:         if (!messageStr.IsEmpty()) {
michael@0:             if (errorClass == nsINSSErrorsService::ERROR_CLASS_BAD_CERT) {
michael@0:                 error.AssignLiteral("nssBadCert");
michael@0: 
michael@0:                 // if this is a Strict-Transport-Security host and the cert
michael@0:                 // is bad, don't allow overrides (STS Spec section 7.3).
michael@0:                 nsCOMPtr<nsISiteSecurityService> sss =
michael@0:                           do_GetService(NS_SSSERVICE_CONTRACTID, &rv);
michael@0:                 NS_ENSURE_SUCCESS(rv, rv);
michael@0:                 uint32_t flags =
michael@0:                   mInPrivateBrowsing ? nsISocketProvider::NO_PERMANENT_STORAGE : 0;
michael@0:                 
michael@0:                 bool isStsHost = false;
michael@0:                 rv = sss->IsSecureURI(nsISiteSecurityService::HEADER_HSTS,
michael@0:                                       aURI, flags, &isStsHost);
michael@0:                 NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:                 uint32_t bucketId;
michael@0:                 if (isStsHost) {
michael@0:                   cssClass.AssignLiteral("badStsCert");
michael@0:                   //measuring STS separately allows us to measure click through
michael@0:                   //rates easily
michael@0:                   bucketId = nsISecurityUITelemetry::WARNING_BAD_CERT_TOP_STS;
michael@0:                 } else {
michael@0:                   bucketId = nsISecurityUITelemetry::WARNING_BAD_CERT_TOP;
michael@0:                 }
michael@0: 
michael@0: 
michael@0:                 if (Preferences::GetBool(
michael@0:                         "browser.xul.error_pages.expert_bad_cert", false)) {
michael@0:                     cssClass.AssignLiteral("expertBadCert");
michael@0:                 }
michael@0: 
michael@0:                 // See if an alternate cert error page is registered
michael@0:                 nsAdoptingCString alternateErrorPage =
michael@0:                     Preferences::GetCString(
michael@0:                         "security.alternate_certificate_error_page");
michael@0:                 if (alternateErrorPage)
michael@0:                     errorPage.Assign(alternateErrorPage);
michael@0: 
michael@0:                 if (!IsFrame() && errorPage.EqualsIgnoreCase("certerror")) 
michael@0:                     mozilla::Telemetry::Accumulate(mozilla::Telemetry::SECURITY_UI, bucketId);
michael@0: 
michael@0:             } else {
michael@0:                 error.AssignLiteral("nssFailure2");
michael@0:             }
michael@0:         }
michael@0:     } else if (NS_ERROR_PHISHING_URI == aError || NS_ERROR_MALWARE_URI == aError) {
michael@0:         nsAutoCString host;
michael@0:         aURI->GetHost(host);
michael@0:         CopyUTF8toUTF16(host, formatStrs[0]);
michael@0:         formatStrCount = 1;
michael@0: 
michael@0:         // Malware and phishing detectors may want to use an alternate error
michael@0:         // page, but if the pref's not set, we'll fall back on the standard page
michael@0:         nsAdoptingCString alternateErrorPage =
michael@0:             Preferences::GetCString("urlclassifier.alternate_error_page");
michael@0:         if (alternateErrorPage)
michael@0:             errorPage.Assign(alternateErrorPage);
michael@0: 
michael@0:         uint32_t bucketId;
michael@0:         if (NS_ERROR_PHISHING_URI == aError) {
michael@0:             error.AssignLiteral("phishingBlocked");
michael@0:             bucketId = IsFrame() ? nsISecurityUITelemetry::WARNING_PHISHING_PAGE_FRAME :
michael@0:                                    nsISecurityUITelemetry::WARNING_PHISHING_PAGE_TOP ;
michael@0:         } else {
michael@0:             error.AssignLiteral("malwareBlocked");
michael@0:             bucketId = IsFrame() ? nsISecurityUITelemetry::WARNING_MALWARE_PAGE_FRAME :
michael@0:                                    nsISecurityUITelemetry::WARNING_MALWARE_PAGE_TOP ;
michael@0:         }
michael@0: 
michael@0:         if (errorPage.EqualsIgnoreCase("blocked"))
michael@0:             mozilla::Telemetry::Accumulate(mozilla::Telemetry::SECURITY_UI,
michael@0:                                            bucketId);
michael@0: 
michael@0:         cssClass.AssignLiteral("blacklist");
michael@0:     } else if (NS_ERROR_CONTENT_CRASHED == aError) {
michael@0:       errorPage.AssignLiteral("tabcrashed");
michael@0:       error.AssignLiteral("tabcrashed");
michael@0: 
michael@0:       nsCOMPtr<EventTarget> handler = mChromeEventHandler;
michael@0:       if (handler) {
michael@0:         nsCOMPtr<Element> element = do_QueryInterface(handler);
michael@0:         element->GetAttribute(NS_LITERAL_STRING("crashedPageTitle"), messageStr);
michael@0:       }
michael@0: 
michael@0:       // DisplayLoadError requires a non-empty messageStr to proceed and call LoadErrorPage.
michael@0:       // If the page doesn't have a title, we will use a blank space which will be trimmed
michael@0:       // and thus treated as empty by the front-end.
michael@0:       if (messageStr.IsEmpty()) {
michael@0:         messageStr.Assign(NS_LITERAL_STRING(" "));
michael@0:       }
michael@0:     }
michael@0:     else {
michael@0:         // Errors requiring simple formatting
michael@0:         switch (aError) {
michael@0:         case NS_ERROR_MALFORMED_URI:
michael@0:             // URI is malformed
michael@0:             error.AssignLiteral("malformedURI");
michael@0:             break;
michael@0:         case NS_ERROR_REDIRECT_LOOP:
michael@0:             // Doc failed to load because the server generated too many redirects
michael@0:             error.AssignLiteral("redirectLoop");
michael@0:             break;
michael@0:         case NS_ERROR_UNKNOWN_SOCKET_TYPE:
michael@0:             // Doc failed to load because PSM is not installed
michael@0:             error.AssignLiteral("unknownSocketType");
michael@0:             break;
michael@0:         case NS_ERROR_NET_RESET:
michael@0:             // Doc failed to load because the server kept reseting the connection
michael@0:             // before we could read any data from it
michael@0:             error.AssignLiteral("netReset");
michael@0:             break;
michael@0:         case NS_ERROR_DOCUMENT_NOT_CACHED:
michael@0:             // Doc failed to load because the cache does not contain a copy of
michael@0:             // the document.
michael@0:             error.AssignLiteral("notCached");
michael@0:             break;
michael@0:         case NS_ERROR_OFFLINE:
michael@0:             // Doc failed to load because we are offline.
michael@0:             error.AssignLiteral("netOffline");
michael@0:             break;
michael@0:         case NS_ERROR_DOCUMENT_IS_PRINTMODE:
michael@0:             // Doc navigation attempted while Printing or Print Preview
michael@0:             error.AssignLiteral("isprinting");
michael@0:             break;
michael@0:         case NS_ERROR_PORT_ACCESS_NOT_ALLOWED:
michael@0:             // Port blocked for security reasons
michael@0:             addHostPort = true;
michael@0:             error.AssignLiteral("deniedPortAccess");
michael@0:             break;
michael@0:         case NS_ERROR_UNKNOWN_PROXY_HOST:
michael@0:             // Proxy hostname could not be resolved.
michael@0:             error.AssignLiteral("proxyResolveFailure");
michael@0:             break;
michael@0:         case NS_ERROR_PROXY_CONNECTION_REFUSED:
michael@0:             // Proxy connection was refused.
michael@0:             error.AssignLiteral("proxyConnectFailure");
michael@0:             break;
michael@0:         case NS_ERROR_INVALID_CONTENT_ENCODING:
michael@0:             // Bad Content Encoding.
michael@0:             error.AssignLiteral("contentEncodingError");
michael@0:             break;
michael@0:         case NS_ERROR_REMOTE_XUL:
michael@0:         {
michael@0:             error.AssignLiteral("remoteXUL");
michael@0:             break;
michael@0:         }
michael@0:         case NS_ERROR_UNSAFE_CONTENT_TYPE:
michael@0:             // Channel refused to load from an unrecognized content type.
michael@0:             error.AssignLiteral("unsafeContentType");
michael@0:             break;
michael@0:         case NS_ERROR_CORRUPTED_CONTENT:
michael@0:             // Broken Content Detected. e.g. Content-MD5 check failure.
michael@0:             error.AssignLiteral("corruptedContentError");
michael@0:             break;
michael@0:         default:
michael@0:             break;
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // Test if the error should be displayed
michael@0:     if (error.IsEmpty()) {
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     // Test if the error needs to be formatted
michael@0:     if (!messageStr.IsEmpty()) {
michael@0:         // already obtained message
michael@0:     }
michael@0:     else {
michael@0:         if (addHostPort) {
michael@0:             // Build up the host:port string.
michael@0:             nsAutoCString hostport;
michael@0:             if (aURI) {
michael@0:                 aURI->GetHostPort(hostport);
michael@0:             } else {
michael@0:                 hostport.AssignLiteral("?");
michael@0:             }
michael@0:             CopyUTF8toUTF16(hostport, formatStrs[formatStrCount++]);
michael@0:         }
michael@0: 
michael@0:         nsAutoCString spec;
michael@0:         rv = NS_ERROR_NOT_AVAILABLE;
michael@0:         if (aURI) {
michael@0:             // displaying "file://" is aesthetically unpleasing and could even be
michael@0:             // confusing to the user
michael@0:             bool isFileURI = false;
michael@0:             rv = aURI->SchemeIs("file", &isFileURI);
michael@0:             if (NS_SUCCEEDED(rv) && isFileURI)
michael@0:                 aURI->GetPath(spec);
michael@0:             else
michael@0:                 aURI->GetSpec(spec);
michael@0: 
michael@0:             nsAutoCString charset;
michael@0:             // unescape and convert from origin charset
michael@0:             aURI->GetOriginCharset(charset);
michael@0:             nsCOMPtr<nsITextToSubURI> textToSubURI(
michael@0:                 do_GetService(NS_ITEXTTOSUBURI_CONTRACTID, &rv));
michael@0:             if (NS_SUCCEEDED(rv)) {
michael@0:                 rv = textToSubURI->UnEscapeURIForUI(charset, spec, formatStrs[formatStrCount]);
michael@0:             }
michael@0:         } else {
michael@0:             spec.AssignLiteral("?");
michael@0:         }
michael@0:         if (NS_FAILED(rv))
michael@0:             CopyUTF8toUTF16(spec, formatStrs[formatStrCount]);
michael@0:         rv = NS_OK;
michael@0:         ++formatStrCount;
michael@0: 
michael@0:         const char16_t *strs[kMaxFormatStrArgs];
michael@0:         for (uint32_t i = 0; i < formatStrCount; i++) {
michael@0:             strs[i] = formatStrs[i].get();
michael@0:         }
michael@0:         nsXPIDLString str;
michael@0:         rv = stringBundle->FormatStringFromName(
michael@0:             error.get(),
michael@0:             strs, formatStrCount, getter_Copies(str));
michael@0:         NS_ENSURE_SUCCESS(rv, rv);
michael@0:         messageStr.Assign(str.get());
michael@0:     }
michael@0: 
michael@0:     // Display the error as a page or an alert prompt
michael@0:     NS_ENSURE_FALSE(messageStr.IsEmpty(), NS_ERROR_FAILURE);
michael@0: 
michael@0:     if (UseErrorPages()) {
michael@0:         // Display an error page
michael@0:         LoadErrorPage(aURI, aURL, errorPage.get(), error.get(),
michael@0:                       messageStr.get(), cssClass.get(), aFailedChannel);
michael@0:     } 
michael@0:     else
michael@0:     {
michael@0:         // The prompter reqires that our private window has a document (or it
michael@0:         // asserts). Satisfy that assertion now since GetDoc will force
michael@0:         // creation of one if it hasn't already been created.
michael@0:         if (mScriptGlobal) {
michael@0:             unused << mScriptGlobal->GetDoc();
michael@0:         }
michael@0: 
michael@0:         // Display a message box
michael@0:         prompter->Alert(nullptr, messageStr.get());
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::LoadErrorPage(nsIURI *aURI, const char16_t *aURL,
michael@0:                           const char *aErrorPage,
michael@0:                           const char16_t *aErrorType,
michael@0:                           const char16_t *aDescription,
michael@0:                           const char *aCSSClass,
michael@0:                           nsIChannel* aFailedChannel)
michael@0: {
michael@0: #if defined(PR_LOGGING) && defined(DEBUG)
michael@0:     if (PR_LOG_TEST(gDocShellLog, PR_LOG_DEBUG)) {
michael@0:         nsAutoCString spec;
michael@0:         aURI->GetSpec(spec);
michael@0: 
michael@0:         nsAutoCString chanName;
michael@0:         if (aFailedChannel)
michael@0:             aFailedChannel->GetName(chanName);
michael@0:         else
michael@0:             chanName.AssignLiteral("<no channel>");
michael@0: 
michael@0:         PR_LOG(gDocShellLog, PR_LOG_DEBUG,
michael@0:                ("nsDocShell[%p]::LoadErrorPage(\"%s\", \"%s\", {...}, [%s])\n", this,
michael@0:                 spec.get(), NS_ConvertUTF16toUTF8(aURL).get(), chanName.get()));
michael@0:     }
michael@0: #endif
michael@0:     mFailedChannel = aFailedChannel;
michael@0:     mFailedURI = aURI;
michael@0:     mFailedLoadType = mLoadType;
michael@0: 
michael@0:     if (mLSHE) {
michael@0:         // Abandon mLSHE's BFCache entry and create a new one.  This way, if
michael@0:         // we go back or forward to another SHEntry with the same doc
michael@0:         // identifier, the error page won't persist.
michael@0:         mLSHE->AbandonBFCacheEntry();
michael@0:     }
michael@0: 
michael@0:     nsAutoCString url;
michael@0:     nsAutoCString charset;
michael@0:     if (aURI)
michael@0:     {
michael@0:         nsresult rv = aURI->GetSpec(url);
michael@0:         NS_ENSURE_SUCCESS(rv, rv);
michael@0:         rv = aURI->GetOriginCharset(charset);
michael@0:         NS_ENSURE_SUCCESS(rv, rv);
michael@0:     }
michael@0:     else if (aURL)
michael@0:     {
michael@0:         CopyUTF16toUTF8(aURL, url);
michael@0:     }
michael@0:     else
michael@0:     {
michael@0:         return NS_ERROR_INVALID_POINTER;
michael@0:     }
michael@0: 
michael@0:     // Create a URL to pass all the error information through to the page.
michael@0: 
michael@0: #undef SAFE_ESCAPE
michael@0: #define SAFE_ESCAPE(cstring, escArg1, escArg2)  \
michael@0:     {                                           \
michael@0:         char* s = nsEscape(escArg1, escArg2);   \
michael@0:         if (!s)                                 \
michael@0:             return NS_ERROR_OUT_OF_MEMORY;      \
michael@0:         cstring.Adopt(s);                       \
michael@0:     }
michael@0:     nsCString escapedUrl, escapedCharset, escapedError, escapedDescription,
michael@0:               escapedCSSClass;
michael@0:     SAFE_ESCAPE(escapedUrl, url.get(), url_Path);
michael@0:     SAFE_ESCAPE(escapedCharset, charset.get(), url_Path);
michael@0:     SAFE_ESCAPE(escapedError,
michael@0:                 NS_ConvertUTF16toUTF8(aErrorType).get(), url_Path);
michael@0:     SAFE_ESCAPE(escapedDescription,
michael@0:                 NS_ConvertUTF16toUTF8(aDescription).get(), url_Path);
michael@0:     if (aCSSClass) {
michael@0:         SAFE_ESCAPE(escapedCSSClass, aCSSClass, url_Path);
michael@0:     }
michael@0:     nsCString errorPageUrl("about:");
michael@0:     errorPageUrl.AppendASCII(aErrorPage);
michael@0:     errorPageUrl.AppendLiteral("?e=");
michael@0: 
michael@0:     errorPageUrl.AppendASCII(escapedError.get());
michael@0:     errorPageUrl.AppendLiteral("&u=");
michael@0:     errorPageUrl.AppendASCII(escapedUrl.get());
michael@0:     if (!escapedCSSClass.IsEmpty()) {
michael@0:         errorPageUrl.AppendLiteral("&s=");
michael@0:         errorPageUrl.AppendASCII(escapedCSSClass.get());
michael@0:     }
michael@0:     errorPageUrl.AppendLiteral("&c=");
michael@0:     errorPageUrl.AppendASCII(escapedCharset.get());
michael@0: 
michael@0:     nsAutoCString frameType(FrameTypeToString(mFrameType));
michael@0:     errorPageUrl.AppendLiteral("&f=");
michael@0:     errorPageUrl.AppendASCII(frameType.get());
michael@0: 
michael@0:     // Append the manifest URL if the error comes from an app.
michael@0:     nsString manifestURL;
michael@0:     nsresult rv = GetAppManifestURL(manifestURL);
michael@0:     if (manifestURL.Length() > 0) {
michael@0:       nsCString manifestParam;
michael@0:       SAFE_ESCAPE(manifestParam,
michael@0:                   NS_ConvertUTF16toUTF8(manifestURL).get(),
michael@0:                   url_Path);
michael@0:       errorPageUrl.AppendLiteral("&m=");
michael@0:       errorPageUrl.AppendASCII(manifestParam.get());
michael@0:     }
michael@0: 
michael@0:     // netError.xhtml's getDescription only handles the "d" parameter at the
michael@0:     // end of the URL, so append it last.
michael@0:     errorPageUrl.AppendLiteral("&d=");
michael@0:     errorPageUrl.AppendASCII(escapedDescription.get());
michael@0: 
michael@0:     nsCOMPtr<nsIURI> errorPageURI;
michael@0:     rv = NS_NewURI(getter_AddRefs(errorPageURI), errorPageUrl);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     return InternalLoad(errorPageURI, nullptr, nullptr,
michael@0:                         INTERNAL_LOAD_FLAGS_INHERIT_OWNER, nullptr, nullptr,
michael@0:                         NullString(), nullptr, nullptr, LOAD_ERROR_PAGE,
michael@0:                         nullptr, true, NullString(), this, nullptr, nullptr,
michael@0:                         nullptr);
michael@0: }
michael@0: 
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::Reload(uint32_t aReloadFlags)
michael@0: {
michael@0:     if (!IsNavigationAllowed()) {
michael@0:       return NS_OK; // JS may not handle returning of an error code
michael@0:     }
michael@0:     nsresult rv;
michael@0:     NS_ASSERTION(((aReloadFlags & 0xf) == 0),
michael@0:                  "Reload command not updated to use load flags!");
michael@0:     NS_ASSERTION((aReloadFlags & EXTRA_LOAD_FLAGS) == 0,
michael@0:                  "Don't pass these flags to Reload");
michael@0: 
michael@0:     uint32_t loadType = MAKE_LOAD_TYPE(LOAD_RELOAD_NORMAL, aReloadFlags);
michael@0:     NS_ENSURE_TRUE(IsValidLoadType(loadType), NS_ERROR_INVALID_ARG);
michael@0: 
michael@0:     // Send notifications to the HistoryListener if any, about the impending reload
michael@0:     nsCOMPtr<nsISHistory> rootSH;
michael@0:     rv = GetRootSessionHistory(getter_AddRefs(rootSH));
michael@0:     nsCOMPtr<nsISHistoryInternal> shistInt(do_QueryInterface(rootSH));
michael@0:     bool canReload = true;
michael@0:     if (rootSH) {
michael@0:       shistInt->NotifyOnHistoryReload(mCurrentURI, aReloadFlags, &canReload);
michael@0:     }
michael@0: 
michael@0:     if (!canReload)
michael@0:       return NS_OK;
michael@0: 
michael@0:     /* If you change this part of code, make sure bug 45297 does not re-occur */
michael@0:     if (mOSHE) {
michael@0:         rv = LoadHistoryEntry(mOSHE, loadType);
michael@0:     }
michael@0:     else if (mLSHE) { // In case a reload happened before the current load is done
michael@0:         rv = LoadHistoryEntry(mLSHE, loadType);
michael@0:     }
michael@0:     else {
michael@0:         nsCOMPtr<nsIDocument> doc(do_GetInterface(GetAsSupports(this)));
michael@0: 
michael@0:         // Do not inherit owner from document
michael@0:         uint32_t flags = INTERNAL_LOAD_FLAGS_NONE;
michael@0:         nsAutoString srcdoc;
michael@0:         nsIPrincipal* principal = nullptr;
michael@0:         nsAutoString contentTypeHint;
michael@0:         nsCOMPtr<nsIURI> baseURI;
michael@0:         if (doc) {
michael@0:             principal = doc->NodePrincipal();
michael@0:             doc->GetContentType(contentTypeHint);
michael@0: 
michael@0:             if (doc->IsSrcdocDocument()) {
michael@0:                 doc->GetSrcdocData(srcdoc);
michael@0:                 flags |= INTERNAL_LOAD_FLAGS_IS_SRCDOC;
michael@0:                 baseURI = doc->GetBaseURI();
michael@0:             }
michael@0:         }
michael@0:         rv = InternalLoad(mCurrentURI,
michael@0:                           mReferrerURI,
michael@0:                           principal,
michael@0:                           flags,
michael@0:                           nullptr,         // No window target
michael@0:                           NS_LossyConvertUTF16toASCII(contentTypeHint).get(),
michael@0:                           NullString(),    // No forced download
michael@0:                           nullptr,         // No post data
michael@0:                           nullptr,         // No headers data
michael@0:                           loadType,        // Load type
michael@0:                           nullptr,         // No SHEntry
michael@0:                           true,
michael@0:                           srcdoc,          // srcdoc argument for iframe
michael@0:                           this,            // For reloads we are the source
michael@0:                           baseURI,
michael@0:                           nullptr,         // No nsIDocShell
michael@0:                           nullptr);        // No nsIRequest
michael@0:     }
michael@0: 
michael@0:     return rv;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::Stop(uint32_t aStopFlags)
michael@0: {
michael@0:     // Revoke any pending event related to content viewer restoration
michael@0:     mRestorePresentationEvent.Revoke();
michael@0: 
michael@0:     if (mLoadType == LOAD_ERROR_PAGE) {
michael@0:         if (mLSHE) {
michael@0:             // Since error page loads never unset mLSHE, do so now
michael@0:             SetHistoryEntry(&mOSHE, mLSHE);
michael@0:             SetHistoryEntry(&mLSHE, nullptr);
michael@0:         }
michael@0: 
michael@0:         mFailedChannel = nullptr;
michael@0:         mFailedURI = nullptr;
michael@0:     }
michael@0: 
michael@0:     if (nsIWebNavigation::STOP_CONTENT & aStopFlags) {
michael@0:         // Stop the document loading
michael@0:         if (mContentViewer) {
michael@0:             nsCOMPtr<nsIContentViewer> cv = mContentViewer;
michael@0:             cv->Stop();
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     if (nsIWebNavigation::STOP_NETWORK & aStopFlags) {
michael@0:         // Suspend any timers that were set for this loader.  We'll clear
michael@0:         // them out for good in CreateContentViewer.
michael@0:         if (mRefreshURIList) {
michael@0:             SuspendRefreshURIs();
michael@0:             mSavedRefreshURIList.swap(mRefreshURIList);
michael@0:             mRefreshURIList = nullptr;
michael@0:         }
michael@0: 
michael@0:         // XXXbz We could also pass |this| to nsIURILoader::Stop.  That will
michael@0:         // just call Stop() on us as an nsIDocumentLoader... We need fewer
michael@0:         // redundant apis!
michael@0:         Stop();
michael@0:     }
michael@0: 
michael@0:     nsTObserverArray<nsDocLoader*>::ForwardIterator iter(mChildList);
michael@0:     while (iter.HasMore()) {
michael@0:         nsCOMPtr<nsIWebNavigation> shellAsNav(do_QueryObject(iter.GetNext()));
michael@0:         if (shellAsNav)
michael@0:             shellAsNav->Stop(aStopFlags);
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetDocument(nsIDOMDocument ** aDocument)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aDocument);
michael@0:     NS_ENSURE_SUCCESS(EnsureContentViewer(), NS_ERROR_FAILURE);
michael@0: 
michael@0:     return mContentViewer->GetDOMDocument(aDocument);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetCurrentURI(nsIURI ** aURI)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aURI);
michael@0: 
michael@0:     if (mCurrentURI) {
michael@0:         return NS_EnsureSafeToReturn(mCurrentURI, aURI);
michael@0:     }
michael@0: 
michael@0:     *aURI = nullptr;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetReferringURI(nsIURI ** aURI)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aURI);
michael@0: 
michael@0:     *aURI = mReferrerURI;
michael@0:     NS_IF_ADDREF(*aURI);
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetSessionHistory(nsISHistory * aSessionHistory)
michael@0: {
michael@0: 
michael@0:     NS_ENSURE_TRUE(aSessionHistory, NS_ERROR_FAILURE);
michael@0:     // make sure that we are the root docshell and
michael@0:     // set a handle to root docshell in SH.
michael@0: 
michael@0:     nsCOMPtr<nsIDocShellTreeItem> root;
michael@0:     /* Get the root docshell. If *this* is the root docshell
michael@0:      * then save a handle to *this* in SH. SH needs it to do
michael@0:      * traversions thro' its entries
michael@0:      */
michael@0:     GetSameTypeRootTreeItem(getter_AddRefs(root));
michael@0:     NS_ENSURE_TRUE(root, NS_ERROR_FAILURE);
michael@0:     if (root.get() == static_cast<nsIDocShellTreeItem *>(this)) {
michael@0:         mSessionHistory = aSessionHistory;
michael@0:         nsCOMPtr<nsISHistoryInternal>
michael@0:             shPrivate(do_QueryInterface(mSessionHistory));
michael@0:         NS_ENSURE_TRUE(shPrivate, NS_ERROR_FAILURE);
michael@0:         shPrivate->SetRootDocShell(this);
michael@0:         return NS_OK;
michael@0:     }
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0: }
michael@0: 
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetSessionHistory(nsISHistory ** aSessionHistory)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aSessionHistory);
michael@0:     *aSessionHistory = mSessionHistory;
michael@0:     NS_IF_ADDREF(*aSessionHistory);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: //*****************************************************************************
michael@0: // nsDocShell::nsIWebPageDescriptor
michael@0: //*****************************************************************************
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::LoadPage(nsISupports *aPageDescriptor, uint32_t aDisplayType)
michael@0: {
michael@0:     nsCOMPtr<nsISHEntry> shEntryIn(do_QueryInterface(aPageDescriptor));
michael@0: 
michael@0:     // Currently, the opaque 'page descriptor' is an nsISHEntry...
michael@0:     if (!shEntryIn) {
michael@0:         return NS_ERROR_INVALID_POINTER;
michael@0:     }
michael@0: 
michael@0:     // Now clone shEntryIn, since we might end up modifying it later on, and we
michael@0:     // want a page descriptor to be reusable.
michael@0:     nsCOMPtr<nsISHEntry> shEntry;
michael@0:     nsresult rv = shEntryIn->Clone(getter_AddRefs(shEntry));
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     // Give our cloned shEntry a new bfcache entry so this load is independent
michael@0:     // of all other loads.  (This is important, in particular, for bugs 582795
michael@0:     // and 585298.)
michael@0:     rv = shEntry->AbandonBFCacheEntry();
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     //
michael@0:     // load the page as view-source
michael@0:     //
michael@0:     if (nsIWebPageDescriptor::DISPLAY_AS_SOURCE == aDisplayType) {
michael@0:         nsCOMPtr<nsIURI> oldUri, newUri;
michael@0:         nsCString spec, newSpec;
michael@0: 
michael@0:         // Create a new view-source URI and replace the original.
michael@0:         rv = shEntry->GetURI(getter_AddRefs(oldUri));
michael@0:         if (NS_FAILED(rv))
michael@0:               return rv;
michael@0: 
michael@0:         oldUri->GetSpec(spec);
michael@0:         newSpec.AppendLiteral("view-source:");
michael@0:         newSpec.Append(spec);
michael@0: 
michael@0:         rv = NS_NewURI(getter_AddRefs(newUri), newSpec);
michael@0:         if (NS_FAILED(rv)) {
michael@0:             return rv;
michael@0:         }
michael@0:         shEntry->SetURI(newUri);
michael@0:     }
michael@0: 
michael@0:     rv = LoadHistoryEntry(shEntry, LOAD_HISTORY);
michael@0:     return rv;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetCurrentDescriptor(nsISupports **aPageDescriptor)
michael@0: {
michael@0:     NS_PRECONDITION(aPageDescriptor, "Null out param?");
michael@0: 
michael@0:     *aPageDescriptor = nullptr;
michael@0: 
michael@0:     nsISHEntry* src = mOSHE ? mOSHE : mLSHE;
michael@0:     if (src) {
michael@0:         nsCOMPtr<nsISHEntry> dest;
michael@0: 
michael@0:         nsresult rv = src->Clone(getter_AddRefs(dest));
michael@0:         if (NS_FAILED(rv)) {
michael@0:             return rv;
michael@0:         }
michael@0: 
michael@0:         // null out inappropriate cloned attributes...
michael@0:         dest->SetParent(nullptr);
michael@0:         dest->SetIsSubFrame(false);
michael@0:         
michael@0:         return CallQueryInterface(dest, aPageDescriptor);
michael@0:     }
michael@0: 
michael@0:     return NS_ERROR_NOT_AVAILABLE;
michael@0: }
michael@0: 
michael@0: 
michael@0: //*****************************************************************************
michael@0: // nsDocShell::nsIBaseWindow
michael@0: //*****************************************************************************   
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::InitWindow(nativeWindow parentNativeWindow,
michael@0:                        nsIWidget * parentWidget, int32_t x, int32_t y,
michael@0:                        int32_t cx, int32_t cy)
michael@0: {
michael@0:     SetParentWidget(parentWidget);
michael@0:     SetPositionAndSize(x, y, cx, cy, false);
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::Create()
michael@0: {
michael@0:     if (mCreated) {
michael@0:         // We've already been created
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     NS_ASSERTION(mItemType == typeContent || mItemType == typeChrome,
michael@0:                  "Unexpected item type in docshell");
michael@0: 
michael@0:     NS_ENSURE_TRUE(Preferences::GetRootBranch(), NS_ERROR_FAILURE);
michael@0:     mCreated = true;
michael@0: 
michael@0:     mAllowSubframes =
michael@0:         Preferences::GetBool("browser.frames.enabled", mAllowSubframes);
michael@0: 
michael@0:     if (gValidateOrigin == 0xffffffff) {
michael@0:         // Check pref to see if we should prevent frameset spoofing
michael@0:         gValidateOrigin =
michael@0:             Preferences::GetBool("browser.frame.validate_origin", true);
michael@0:     }
michael@0: 
michael@0:     // Should we use XUL error pages instead of alerts if possible?
michael@0:     mUseErrorPages =
michael@0:         Preferences::GetBool("browser.xul.error_pages.enabled", mUseErrorPages);
michael@0: 
michael@0:     if(!gAddedPreferencesVarCache) {
michael@0:         Preferences::AddBoolVarCache(&sUseErrorPages, 
michael@0:                                      "browser.xul.error_pages.enabled", 
michael@0:                                      mUseErrorPages);
michael@0:         gAddedPreferencesVarCache = true;
michael@0:     }
michael@0: 
michael@0:     mDeviceSizeIsPageSize =
michael@0:         Preferences::GetBool("docshell.device_size_is_page_size",
michael@0:                              mDeviceSizeIsPageSize);
michael@0: 
michael@0:     nsCOMPtr<nsIObserverService> serv = services::GetObserverService();
michael@0:     if (serv) {
michael@0:         const char* msg = mItemType == typeContent ?
michael@0:             NS_WEBNAVIGATION_CREATE : NS_CHROME_WEBNAVIGATION_CREATE;
michael@0:         serv->NotifyObservers(GetAsSupports(this), msg, nullptr);
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::Destroy()
michael@0: {
michael@0:     NS_ASSERTION(mItemType == typeContent || mItemType == typeChrome,
michael@0:                  "Unexpected item type in docshell");
michael@0: 
michael@0:     if (!mIsBeingDestroyed) {
michael@0:         nsCOMPtr<nsIObserverService> serv = services::GetObserverService();
michael@0:         if (serv) {
michael@0:             const char* msg = mItemType == typeContent ?
michael@0:                 NS_WEBNAVIGATION_DESTROY : NS_CHROME_WEBNAVIGATION_DESTROY;
michael@0:             serv->NotifyObservers(GetAsSupports(this), msg, nullptr);
michael@0:         }
michael@0:     }
michael@0:     
michael@0:     mIsBeingDestroyed = true;
michael@0: 
michael@0:     // Remove our pref observers
michael@0:     if (mObserveErrorPages) {
michael@0:         mObserveErrorPages = false;
michael@0:     }
michael@0: 
michael@0:     // Make sure to blow away our mLoadingURI just in case.  No loads
michael@0:     // from inside this pagehide.
michael@0:     mLoadingURI = nullptr;
michael@0: 
michael@0:     // Fire unload event before we blow anything away.
michael@0:     (void) FirePageHideNotification(true);
michael@0: 
michael@0:     // Clear pointers to any detached nsEditorData that's lying
michael@0:     // around in shistory entries. Breaks cycle. See bug 430921.
michael@0:     if (mOSHE)
michael@0:       mOSHE->SetEditorData(nullptr);
michael@0:     if (mLSHE)
michael@0:       mLSHE->SetEditorData(nullptr);
michael@0:       
michael@0:     // Note: mContentListener can be null if Init() failed and we're being
michael@0:     // called from the destructor.
michael@0:     if (mContentListener) {
michael@0:         mContentListener->DropDocShellreference();
michael@0:         mContentListener->SetParentContentListener(nullptr);
michael@0:         // Note that we do NOT set mContentListener to null here; that
michael@0:         // way if someone tries to do a load in us after this point
michael@0:         // the nsDSURIContentListener will block it.  All of which
michael@0:         // means that we should do this before calling Stop(), of
michael@0:         // course.
michael@0:     }
michael@0: 
michael@0:     // Stop any URLs that are currently being loaded...
michael@0:     Stop(nsIWebNavigation::STOP_ALL);
michael@0: 
michael@0:     mEditorData = nullptr;
michael@0: 
michael@0:     mTransferableHookData = nullptr;
michael@0: 
michael@0:     // Save the state of the current document, before destroying the window.
michael@0:     // This is needed to capture the state of a frameset when the new document
michael@0:     // causes the frameset to be destroyed...
michael@0:     PersistLayoutHistoryState();
michael@0: 
michael@0:     // Remove this docshell from its parent's child list
michael@0:     nsCOMPtr<nsIDocShellTreeItem> docShellParentAsItem =
michael@0:         do_QueryInterface(GetAsSupports(mParent));
michael@0:     if (docShellParentAsItem)
michael@0:         docShellParentAsItem->RemoveChild(this);
michael@0: 
michael@0:     if (mContentViewer) {
michael@0:         mContentViewer->Close(nullptr);
michael@0:         mContentViewer->Destroy();
michael@0:         mContentViewer = nullptr;
michael@0:     }
michael@0: 
michael@0:     nsDocLoader::Destroy();
michael@0:     
michael@0:     mParentWidget = nullptr;
michael@0:     mCurrentURI = nullptr;
michael@0: 
michael@0:     if (mScriptGlobal) {
michael@0:         mScriptGlobal->DetachFromDocShell();
michael@0:         mScriptGlobal = nullptr;
michael@0:     }
michael@0: 
michael@0:     if (mSessionHistory) {
michael@0:         // We want to destroy these content viewers now rather than
michael@0:         // letting their destruction wait for the session history
michael@0:         // entries to get garbage collected.  (Bug 488394)
michael@0:         nsCOMPtr<nsISHistoryInternal> shPrivate =
michael@0:             do_QueryInterface(mSessionHistory);
michael@0:         if (shPrivate) {
michael@0:             shPrivate->EvictAllContentViewers();
michael@0:         }
michael@0:         mSessionHistory = nullptr;
michael@0:     }
michael@0: 
michael@0:     SetTreeOwner(nullptr);
michael@0: 
michael@0:     mOnePermittedSandboxedNavigator = nullptr;
michael@0: 
michael@0:     // required to break ref cycle
michael@0:     mSecurityUI = nullptr;
michael@0: 
michael@0:     // Cancel any timers that were set for this docshell; this is needed
michael@0:     // to break the cycle between us and the timers.
michael@0:     CancelRefreshURITimers();
michael@0: 
michael@0:     if (mInPrivateBrowsing) {
michael@0:         mInPrivateBrowsing = false;
michael@0:         if (mAffectPrivateSessionLifetime) {
michael@0:             DecreasePrivateDocShellCount();
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetUnscaledDevicePixelsPerCSSPixel(double *aScale)
michael@0: {
michael@0:     if (mParentWidget) {
michael@0:         *aScale = mParentWidget->GetDefaultScale().scale;
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIBaseWindow> ownerWindow(do_QueryInterface(mTreeOwner));
michael@0:     if (ownerWindow) {
michael@0:         return ownerWindow->GetUnscaledDevicePixelsPerCSSPixel(aScale);
michael@0:     }
michael@0: 
michael@0:     *aScale = 1.0;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetPosition(int32_t x, int32_t y)
michael@0: {
michael@0:     mBounds.x = x;
michael@0:     mBounds.y = y;
michael@0: 
michael@0:     if (mContentViewer)
michael@0:         NS_ENSURE_SUCCESS(mContentViewer->Move(x, y), NS_ERROR_FAILURE);
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetPosition(int32_t * aX, int32_t * aY)
michael@0: {
michael@0:     int32_t dummyHolder;
michael@0:     return GetPositionAndSize(aX, aY, &dummyHolder, &dummyHolder);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetSize(int32_t aCX, int32_t aCY, bool aRepaint)
michael@0: {
michael@0:     int32_t x = 0, y = 0;
michael@0:     GetPosition(&x, &y);
michael@0:     return SetPositionAndSize(x, y, aCX, aCY, aRepaint);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetSize(int32_t * aCX, int32_t * aCY)
michael@0: {
michael@0:     int32_t dummyHolder;
michael@0:     return GetPositionAndSize(&dummyHolder, &dummyHolder, aCX, aCY);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetPositionAndSize(int32_t x, int32_t y, int32_t cx,
michael@0:                                int32_t cy, bool fRepaint)
michael@0: {
michael@0:     mBounds.x = x;
michael@0:     mBounds.y = y;
michael@0:     mBounds.width = cx;
michael@0:     mBounds.height = cy;
michael@0: 
michael@0:     // Hold strong ref, since SetBounds can make us null out mContentViewer
michael@0:     nsCOMPtr<nsIContentViewer> viewer = mContentViewer;
michael@0:     if (viewer) {
michael@0:         //XXX Border figured in here or is that handled elsewhere?
michael@0:         NS_ENSURE_SUCCESS(viewer->SetBounds(mBounds), NS_ERROR_FAILURE);
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetPositionAndSize(int32_t * x, int32_t * y, int32_t * cx,
michael@0:                                int32_t * cy)
michael@0: {
michael@0:     if (mParentWidget) {
michael@0:         // ensure size is up-to-date if window has changed resolution
michael@0:         nsIntRect r;
michael@0:         mParentWidget->GetClientBounds(r);
michael@0:         SetPositionAndSize(mBounds.x, mBounds.y, r.width, r.height, false);
michael@0:     }
michael@0: 
michael@0:     // We should really consider just getting this information from
michael@0:     // our window instead of duplicating the storage and code...
michael@0:     if (cx || cy) {
michael@0:         // Caller wants to know our size; make sure to give them up to
michael@0:         // date information.
michael@0:         nsCOMPtr<nsIDocument> doc(do_GetInterface(GetAsSupports(mParent)));
michael@0:         if (doc) {
michael@0:             doc->FlushPendingNotifications(Flush_Layout);
michael@0:         }
michael@0:     }
michael@0:     
michael@0:     DoGetPositionAndSize(x, y, cx, cy);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsDocShell::DoGetPositionAndSize(int32_t * x, int32_t * y, int32_t * cx,
michael@0:                                  int32_t * cy)
michael@0: {    
michael@0:     if (x)
michael@0:         *x = mBounds.x;
michael@0:     if (y)
michael@0:         *y = mBounds.y;
michael@0:     if (cx)
michael@0:         *cx = mBounds.width;
michael@0:     if (cy)
michael@0:         *cy = mBounds.height;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::Repaint(bool aForce)
michael@0: {
michael@0:     nsCOMPtr<nsIPresShell> presShell =GetPresShell();
michael@0:     NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
michael@0: 
michael@0:     nsViewManager* viewManager = presShell->GetViewManager();
michael@0:     NS_ENSURE_TRUE(viewManager, NS_ERROR_FAILURE);
michael@0: 
michael@0:     viewManager->InvalidateAllViews();
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetParentWidget(nsIWidget ** parentWidget)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(parentWidget);
michael@0: 
michael@0:     *parentWidget = mParentWidget;
michael@0:     NS_IF_ADDREF(*parentWidget);
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetParentWidget(nsIWidget * aParentWidget)
michael@0: {
michael@0:     mParentWidget = aParentWidget;
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetParentNativeWindow(nativeWindow * parentNativeWindow)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(parentNativeWindow);
michael@0: 
michael@0:     if (mParentWidget)
michael@0:         *parentNativeWindow = mParentWidget->GetNativeData(NS_NATIVE_WIDGET);
michael@0:     else
michael@0:         *parentNativeWindow = nullptr;
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetParentNativeWindow(nativeWindow parentNativeWindow)
michael@0: {
michael@0:     return NS_ERROR_NOT_IMPLEMENTED;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetNativeHandle(nsAString& aNativeHandle)
michael@0: {
michael@0:     // the nativeHandle should be accessed from nsIXULWindow
michael@0:     return NS_ERROR_NOT_IMPLEMENTED;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetVisibility(bool * aVisibility)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aVisibility);
michael@0: 
michael@0:     *aVisibility = false;
michael@0: 
michael@0:     if (!mContentViewer)
michael@0:         return NS_OK;
michael@0: 
michael@0:     nsCOMPtr<nsIPresShell> presShell = GetPresShell();
michael@0:     if (!presShell)
michael@0:         return NS_OK;
michael@0: 
michael@0:     // get the view manager
michael@0:     nsViewManager* vm = presShell->GetViewManager();
michael@0:     NS_ENSURE_TRUE(vm, NS_ERROR_FAILURE);
michael@0: 
michael@0:     // get the root view
michael@0:     nsView *view = vm->GetRootView(); // views are not ref counted
michael@0:     NS_ENSURE_TRUE(view, NS_ERROR_FAILURE);
michael@0: 
michael@0:     // if our root view is hidden, we are not visible
michael@0:     if (view->GetVisibility() == nsViewVisibility_kHide)
michael@0:         return NS_OK;
michael@0: 
michael@0:     // otherwise, we must walk up the document and view trees checking
michael@0:     // for a hidden view, unless we're an off screen browser, which 
michael@0:     // would make this test meaningless.
michael@0: 
michael@0:     nsCOMPtr<nsIDocShellTreeItem> treeItem = this;
michael@0:     nsCOMPtr<nsIDocShellTreeItem> parentItem;
michael@0:     treeItem->GetParent(getter_AddRefs(parentItem));
michael@0:     while (parentItem) {
michael@0:         nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(treeItem));
michael@0:         presShell = docShell->GetPresShell();
michael@0: 
michael@0:         nsCOMPtr<nsIDocShell> parentDS = do_QueryInterface(parentItem);
michael@0:         nsCOMPtr<nsIPresShell> pPresShell = parentDS->GetPresShell();
michael@0: 
michael@0:         // Null-check for crash in bug 267804
michael@0:         if (!pPresShell) {
michael@0:             NS_NOTREACHED("parent docshell has null pres shell");
michael@0:             return NS_OK;
michael@0:         }
michael@0: 
michael@0:         nsIContent *shellContent =
michael@0:             pPresShell->GetDocument()->FindContentForSubDocument(presShell->GetDocument());
michael@0:         NS_ASSERTION(shellContent, "subshell not in the map");
michael@0: 
michael@0:         nsIFrame* frame = shellContent ? shellContent->GetPrimaryFrame() : nullptr;
michael@0:         bool isDocShellOffScreen = false;
michael@0:         docShell->GetIsOffScreenBrowser(&isDocShellOffScreen);
michael@0:         if (frame &&
michael@0:             !frame->IsVisibleConsideringAncestors(nsIFrame::VISIBILITY_CROSS_CHROME_CONTENT_BOUNDARY) &&
michael@0:             !isDocShellOffScreen) {
michael@0:             return NS_OK;
michael@0:         }
michael@0: 
michael@0:         treeItem = parentItem;
michael@0:         treeItem->GetParent(getter_AddRefs(parentItem));
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIBaseWindow> treeOwnerAsWin(do_QueryInterface(mTreeOwner));
michael@0:     if (!treeOwnerAsWin) {
michael@0:         *aVisibility = true;
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     // Check with the tree owner as well to give embedders a chance to
michael@0:     // expose visibility as well.
michael@0:     return treeOwnerAsWin->GetVisibility(aVisibility);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetIsOffScreenBrowser(bool aIsOffScreen) 
michael@0: {
michael@0:     mIsOffScreenBrowser = aIsOffScreen;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetIsOffScreenBrowser(bool *aIsOffScreen) 
michael@0: {
michael@0:     *aIsOffScreen = mIsOffScreenBrowser;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetIsActive(bool aIsActive)
michael@0: {
michael@0:     // We disallow setting active on chrome docshells.
michael@0:     if (mItemType == nsIDocShellTreeItem::typeChrome)
michael@0:           return NS_ERROR_INVALID_ARG;
michael@0: 
michael@0:     // Keep track ourselves.
michael@0:     mIsActive = aIsActive;
michael@0: 
michael@0:     // Tell the PresShell about it.
michael@0:     nsCOMPtr<nsIPresShell> pshell = GetPresShell();
michael@0:     if (pshell)
michael@0:       pshell->SetIsActive(aIsActive);
michael@0: 
michael@0:     // Tell the window about it
michael@0:     if (mScriptGlobal) {
michael@0:         mScriptGlobal->SetIsBackground(!aIsActive);
michael@0:         if (nsCOMPtr<nsIDocument> doc = mScriptGlobal->GetExtantDoc()) {
michael@0:             doc->PostVisibilityUpdateEvent();
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // Recursively tell all of our children, but don't tell <iframe mozbrowser>
michael@0:     // children; they handle their state separately.
michael@0:     nsTObserverArray<nsDocLoader*>::ForwardIterator iter(mChildList);
michael@0:     while (iter.HasMore()) {
michael@0:         nsCOMPtr<nsIDocShell> docshell = do_QueryObject(iter.GetNext());
michael@0:         if (!docshell) {
michael@0:             continue;
michael@0:         }
michael@0: 
michael@0:         if (!docshell->GetIsBrowserOrApp()) {
michael@0:             docshell->SetIsActive(aIsActive);
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetIsActive(bool *aIsActive)
michael@0: {
michael@0:     *aIsActive = mIsActive;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetIsAppTab(bool aIsAppTab)
michael@0: {
michael@0:     mIsAppTab = aIsAppTab;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetIsAppTab(bool *aIsAppTab)
michael@0: {
michael@0:     *aIsAppTab = mIsAppTab;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetSandboxFlags(uint32_t aSandboxFlags)
michael@0: {
michael@0:     mSandboxFlags = aSandboxFlags;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetSandboxFlags(uint32_t  *aSandboxFlags)
michael@0: {
michael@0:     *aSandboxFlags = mSandboxFlags;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetOnePermittedSandboxedNavigator(nsIDocShell* aSandboxedNavigator)
michael@0: {
michael@0:     if (mOnePermittedSandboxedNavigator) {
michael@0:         NS_ERROR("One Permitted Sandboxed Navigator should only be set once.");
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     mOnePermittedSandboxedNavigator = do_GetWeakReference(aSandboxedNavigator);
michael@0:     NS_ASSERTION(mOnePermittedSandboxedNavigator,
michael@0:              "One Permitted Sandboxed Navigator must support weak references.");
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetOnePermittedSandboxedNavigator(nsIDocShell** aSandboxedNavigator)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aSandboxedNavigator);
michael@0:     nsCOMPtr<nsIDocShell> permittedNavigator =
michael@0:         do_QueryReferent(mOnePermittedSandboxedNavigator);
michael@0:     NS_IF_ADDREF(*aSandboxedNavigator = permittedNavigator);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetDefaultLoadFlags(uint32_t aDefaultLoadFlags)
michael@0: {
michael@0:     mDefaultLoadFlags = aDefaultLoadFlags;
michael@0: 
michael@0:     // Tell the load group to set these flags all requests in the group
michael@0:     if (mLoadGroup) {
michael@0:         mLoadGroup->SetDefaultLoadFlags(aDefaultLoadFlags);
michael@0:     } else {
michael@0:         NS_WARNING("nsDocShell::SetDefaultLoadFlags has no loadGroup to propagate the flags to");
michael@0:     }
michael@0: 
michael@0:     // Recursively tell all of our children.  We *do not* skip
michael@0:     // <iframe mozbrowser> children - if someone sticks custom flags in this
michael@0:     // docShell then they too get the same flags.
michael@0:     nsTObserverArray<nsDocLoader*>::ForwardIterator iter(mChildList);
michael@0:     while (iter.HasMore()) {
michael@0:         nsCOMPtr<nsIDocShell> docshell = do_QueryObject(iter.GetNext());
michael@0:         if (!docshell) {
michael@0:             continue;
michael@0:         }
michael@0:         docshell->SetDefaultLoadFlags(aDefaultLoadFlags);
michael@0:     }
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetDefaultLoadFlags(uint32_t *aDefaultLoadFlags)
michael@0: {
michael@0:     *aDefaultLoadFlags = mDefaultLoadFlags;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetMixedContentChannel(nsIChannel* aMixedContentChannel)
michael@0: {
michael@0: #ifdef DEBUG
michael@0:      // if the channel is non-null
michael@0:      if (aMixedContentChannel) {
michael@0:        // Get the root docshell.
michael@0:        nsCOMPtr<nsIDocShellTreeItem> root;
michael@0:        GetSameTypeRootTreeItem(getter_AddRefs(root));
michael@0:        NS_WARN_IF_FALSE(
michael@0:          root.get() == static_cast<nsIDocShellTreeItem *>(this), 
michael@0:          "Setting mMixedContentChannel on a docshell that is not the root docshell"
michael@0:        );
michael@0:     }
michael@0: #endif
michael@0:      mMixedContentChannel = aMixedContentChannel;
michael@0:      return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetMixedContentChannel(nsIChannel **aMixedContentChannel)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aMixedContentChannel);
michael@0:     NS_IF_ADDREF(*aMixedContentChannel = mMixedContentChannel);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetAllowMixedContentAndConnectionData(bool* aRootHasSecureConnection, bool* aAllowMixedContent, bool* aIsRootDocShell)
michael@0: {
michael@0:   *aRootHasSecureConnection = true;
michael@0:   *aAllowMixedContent = false;
michael@0:   *aIsRootDocShell = false;
michael@0: 
michael@0:   nsCOMPtr<nsIDocShellTreeItem> sameTypeRoot;
michael@0:   GetSameTypeRootTreeItem(getter_AddRefs(sameTypeRoot));
michael@0:   NS_ASSERTION(sameTypeRoot, "No document shell root tree item from document shell tree item!");
michael@0:   *aIsRootDocShell = sameTypeRoot.get() == static_cast<nsIDocShellTreeItem *>(this);
michael@0: 
michael@0:   // now get the document from sameTypeRoot
michael@0:   nsCOMPtr<nsIDocument> rootDoc = do_GetInterface(sameTypeRoot);
michael@0:   if (rootDoc) {
michael@0:     nsCOMPtr<nsIPrincipal> rootPrincipal = rootDoc->NodePrincipal();
michael@0: 
michael@0:     // For things with system principal (e.g. scratchpad) there is no uri
michael@0:     // aRootHasSecureConnection should be false.
michael@0:     nsCOMPtr<nsIURI> rootUri;
michael@0:     if (nsContentUtils::IsSystemPrincipal(rootPrincipal) ||
michael@0:         NS_FAILED(rootPrincipal->GetURI(getter_AddRefs(rootUri))) || !rootUri ||
michael@0:         NS_FAILED(rootUri->SchemeIs("https", aRootHasSecureConnection))) {
michael@0:       *aRootHasSecureConnection = false;
michael@0:     }
michael@0: 
michael@0:     // Check the root doc's channel against the root docShell's mMixedContentChannel to see
michael@0:     // if they are the same.  If they are the same, the user has overriden
michael@0:     // the block.
michael@0:     nsCOMPtr<nsIDocShell> rootDocShell = do_QueryInterface(sameTypeRoot);
michael@0:     nsCOMPtr<nsIChannel> mixedChannel;
michael@0:     rootDocShell->GetMixedContentChannel(getter_AddRefs(mixedChannel));
michael@0:     *aAllowMixedContent = mixedChannel && (mixedChannel == rootDoc->GetChannel());
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetVisibility(bool aVisibility)
michael@0: {
michael@0:     // Show()/Hide() may change mContentViewer.
michael@0:     nsCOMPtr<nsIContentViewer> cv = mContentViewer;
michael@0:     if (!cv)
michael@0:         return NS_OK;
michael@0:     if (aVisibility) {
michael@0:         cv->Show();
michael@0:     }
michael@0:     else {
michael@0:         cv->Hide();
michael@0:     }
michael@0:     
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetEnabled(bool *aEnabled)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aEnabled);
michael@0:   *aEnabled = true;
michael@0:   return NS_ERROR_NOT_IMPLEMENTED;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetEnabled(bool aEnabled)
michael@0: {
michael@0:   return NS_ERROR_NOT_IMPLEMENTED;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetFocus()
michael@0: {
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetMainWidget(nsIWidget ** aMainWidget)
michael@0: {
michael@0:     // We don't create our own widget, so simply return the parent one. 
michael@0:     return GetParentWidget(aMainWidget);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetTitle(char16_t ** aTitle)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aTitle);
michael@0: 
michael@0:     *aTitle = ToNewUnicode(mTitle);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetTitle(const char16_t * aTitle)
michael@0: {
michael@0:     // Store local title
michael@0:     mTitle = aTitle;
michael@0: 
michael@0:     nsCOMPtr<nsIDocShellTreeItem> parent;
michael@0:     GetSameTypeParent(getter_AddRefs(parent));
michael@0: 
michael@0:     // When title is set on the top object it should then be passed to the 
michael@0:     // tree owner.
michael@0:     if (!parent) {
michael@0:         nsCOMPtr<nsIBaseWindow>
michael@0:             treeOwnerAsWin(do_QueryInterface(mTreeOwner));
michael@0:         if (treeOwnerAsWin)
michael@0:             treeOwnerAsWin->SetTitle(aTitle);
michael@0:     }
michael@0: 
michael@0:     if (mCurrentURI && mLoadType != LOAD_ERROR_PAGE && mUseGlobalHistory &&
michael@0:         !mInPrivateBrowsing) {
michael@0:         nsCOMPtr<IHistory> history = services::GetHistoryService();
michael@0:         if (history) {
michael@0:             history->SetURITitle(mCurrentURI, mTitle);
michael@0:         }
michael@0:         else if (mGlobalHistory) {
michael@0:             mGlobalHistory->SetPageTitle(mCurrentURI, nsString(mTitle));
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // Update SessionHistory with the document's title.
michael@0:     if (mOSHE && mLoadType != LOAD_BYPASS_HISTORY &&
michael@0:         mLoadType != LOAD_ERROR_PAGE) {
michael@0: 
michael@0:         mOSHE->SetTitle(mTitle);    
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::GetCurScrollPos(int32_t scrollOrientation, int32_t * curPos)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(curPos);
michael@0: 
michael@0:     nsIScrollableFrame* sf = GetRootScrollFrame();
michael@0:     NS_ENSURE_TRUE(sf, NS_ERROR_FAILURE);
michael@0: 
michael@0:     nsPoint pt = sf->GetScrollPosition();
michael@0: 
michael@0:     switch (scrollOrientation) {
michael@0:     case ScrollOrientation_X:
michael@0:         *curPos = pt.x;
michael@0:         return NS_OK;
michael@0: 
michael@0:     case ScrollOrientation_Y:
michael@0:         *curPos = pt.y;
michael@0:         return NS_OK;
michael@0: 
michael@0:     default:
michael@0:         NS_ENSURE_TRUE(false, NS_ERROR_INVALID_ARG);
michael@0:     }
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::SetCurScrollPosEx(int32_t curHorizontalPos, int32_t curVerticalPos)
michael@0: {
michael@0:     nsIScrollableFrame* sf = GetRootScrollFrame();
michael@0:     NS_ENSURE_TRUE(sf, NS_ERROR_FAILURE);
michael@0: 
michael@0:     sf->ScrollTo(nsPoint(curHorizontalPos, curVerticalPos),
michael@0:                  nsIScrollableFrame::INSTANT);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: //*****************************************************************************
michael@0: // nsDocShell::nsIScrollable
michael@0: //*****************************************************************************   
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetDefaultScrollbarPreferences(int32_t scrollOrientation,
michael@0:                                            int32_t * scrollbarPref)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(scrollbarPref);
michael@0:     switch (scrollOrientation) {
michael@0:     case ScrollOrientation_X:
michael@0:         *scrollbarPref = mDefaultScrollbarPref.x;
michael@0:         return NS_OK;
michael@0: 
michael@0:     case ScrollOrientation_Y:
michael@0:         *scrollbarPref = mDefaultScrollbarPref.y;
michael@0:         return NS_OK;
michael@0: 
michael@0:     default:
michael@0:         NS_ENSURE_TRUE(false, NS_ERROR_INVALID_ARG);
michael@0:     }
michael@0:     return NS_ERROR_FAILURE;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetDefaultScrollbarPreferences(int32_t scrollOrientation,
michael@0:                                            int32_t scrollbarPref)
michael@0: {
michael@0:     switch (scrollOrientation) {
michael@0:     case ScrollOrientation_X:
michael@0:         mDefaultScrollbarPref.x = scrollbarPref;
michael@0:         return NS_OK;
michael@0: 
michael@0:     case ScrollOrientation_Y:
michael@0:         mDefaultScrollbarPref.y = scrollbarPref;
michael@0:         return NS_OK;
michael@0: 
michael@0:     default:
michael@0:         NS_ENSURE_TRUE(false, NS_ERROR_INVALID_ARG);
michael@0:     }
michael@0:     return NS_ERROR_FAILURE;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetScrollbarVisibility(bool * verticalVisible,
michael@0:                                    bool * horizontalVisible)
michael@0: {
michael@0:     nsIScrollableFrame* sf = GetRootScrollFrame();
michael@0:     NS_ENSURE_TRUE(sf, NS_ERROR_FAILURE);
michael@0: 
michael@0:     uint32_t scrollbarVisibility = sf->GetScrollbarVisibility();
michael@0:     if (verticalVisible)
michael@0:         *verticalVisible = (scrollbarVisibility & nsIScrollableFrame::VERTICAL) != 0;
michael@0:     if (horizontalVisible)
michael@0:         *horizontalVisible = (scrollbarVisibility & nsIScrollableFrame::HORIZONTAL) != 0;
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: //*****************************************************************************
michael@0: // nsDocShell::nsITextScroll
michael@0: //*****************************************************************************   
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::ScrollByLines(int32_t numLines)
michael@0: {
michael@0:     nsIScrollableFrame* sf = GetRootScrollFrame();
michael@0:     NS_ENSURE_TRUE(sf, NS_ERROR_FAILURE);
michael@0: 
michael@0:     sf->ScrollBy(nsIntPoint(0, numLines), nsIScrollableFrame::LINES,
michael@0:                  nsIScrollableFrame::SMOOTH);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::ScrollByPages(int32_t numPages)
michael@0: {
michael@0:     nsIScrollableFrame* sf = GetRootScrollFrame();
michael@0:     NS_ENSURE_TRUE(sf, NS_ERROR_FAILURE);
michael@0: 
michael@0:     sf->ScrollBy(nsIntPoint(0, numPages), nsIScrollableFrame::PAGES,
michael@0:                  nsIScrollableFrame::SMOOTH);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: //*****************************************************************************
michael@0: // nsDocShell::nsIRefreshURI
michael@0: //*****************************************************************************   
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::RefreshURI(nsIURI * aURI, int32_t aDelay, bool aRepeat,
michael@0:                        bool aMetaRefresh)
michael@0: {
michael@0:     NS_ENSURE_ARG(aURI);
michael@0: 
michael@0:     /* Check if Meta refresh/redirects are permitted. Some
michael@0:      * embedded applications may not want to do this.
michael@0:      * Must do this before sending out NOTIFY_REFRESH events
michael@0:      * because listeners may have side effects (e.g. displaying a
michael@0:      * button to manually trigger the refresh later).
michael@0:      */
michael@0:     bool allowRedirects = true;
michael@0:     GetAllowMetaRedirects(&allowRedirects);
michael@0:     if (!allowRedirects)
michael@0:         return NS_OK;
michael@0: 
michael@0:     // If any web progress listeners are listening for NOTIFY_REFRESH events,
michael@0:     // give them a chance to block this refresh.
michael@0:     bool sameURI;
michael@0:     nsresult rv = aURI->Equals(mCurrentURI, &sameURI);
michael@0:     if (NS_FAILED(rv))
michael@0:         sameURI = false;
michael@0:     if (!RefreshAttempted(this, aURI, aDelay, sameURI))
michael@0:         return NS_OK;
michael@0: 
michael@0:     nsRefreshTimer *refreshTimer = new nsRefreshTimer();
michael@0:     NS_ENSURE_TRUE(refreshTimer, NS_ERROR_OUT_OF_MEMORY);
michael@0:     uint32_t busyFlags = 0;
michael@0:     GetBusyFlags(&busyFlags);
michael@0: 
michael@0:     nsCOMPtr<nsISupports> dataRef = refreshTimer;    // Get the ref count to 1
michael@0: 
michael@0:     refreshTimer->mDocShell = this;
michael@0:     refreshTimer->mURI = aURI;
michael@0:     refreshTimer->mDelay = aDelay;
michael@0:     refreshTimer->mRepeat = aRepeat;
michael@0:     refreshTimer->mMetaRefresh = aMetaRefresh;
michael@0: 
michael@0:     if (!mRefreshURIList) {
michael@0:         NS_ENSURE_SUCCESS(NS_NewISupportsArray(getter_AddRefs(mRefreshURIList)),
michael@0:                           NS_ERROR_FAILURE);
michael@0:     }
michael@0: 
michael@0:     if (busyFlags & BUSY_FLAGS_BUSY) {
michael@0:         // We are busy loading another page. Don't create the
michael@0:         // timer right now. Instead queue up the request and trigger the
michael@0:         // timer in EndPageLoad(). 
michael@0:         mRefreshURIList->AppendElement(refreshTimer);
michael@0:     }
michael@0:     else {
michael@0:         // There is no page loading going on right now.  Create the
michael@0:         // timer and fire it right away.
michael@0:         nsCOMPtr<nsITimer> timer = do_CreateInstance("@mozilla.org/timer;1");
michael@0:         NS_ENSURE_TRUE(timer, NS_ERROR_FAILURE);
michael@0: 
michael@0:         mRefreshURIList->AppendElement(timer);      // owning timer ref
michael@0:         timer->InitWithCallback(refreshTimer, aDelay, nsITimer::TYPE_ONE_SHOT);
michael@0:     }
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::ForceRefreshURIFromTimer(nsIURI * aURI,
michael@0:                                      int32_t aDelay, 
michael@0:                                      bool aMetaRefresh,
michael@0:                                      nsITimer* aTimer)
michael@0: {
michael@0:     NS_PRECONDITION(aTimer, "Must have a timer here");
michael@0: 
michael@0:     // Remove aTimer from mRefreshURIList if needed
michael@0:     if (mRefreshURIList) {
michael@0:         uint32_t n = 0;
michael@0:         mRefreshURIList->Count(&n);
michael@0: 
michael@0:         for (uint32_t i = 0;  i < n; ++i) {
michael@0:             nsCOMPtr<nsITimer> timer = do_QueryElementAt(mRefreshURIList, i);
michael@0:             if (timer == aTimer) {
michael@0:                 mRefreshURIList->RemoveElementAt(i);
michael@0:                 break;
michael@0:             }
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     return ForceRefreshURI(aURI, aDelay, aMetaRefresh);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::ForceRefreshURI(nsIURI * aURI,
michael@0:                             int32_t aDelay, 
michael@0:                             bool aMetaRefresh)
michael@0: {
michael@0:     NS_ENSURE_ARG(aURI);
michael@0: 
michael@0:     nsCOMPtr<nsIDocShellLoadInfo> loadInfo;
michael@0:     CreateLoadInfo(getter_AddRefs(loadInfo));
michael@0:     NS_ENSURE_TRUE(loadInfo, NS_ERROR_OUT_OF_MEMORY);
michael@0: 
michael@0:     /* We do need to pass in a referrer, but we don't want it to
michael@0:      * be sent to the server.
michael@0:      */
michael@0:     loadInfo->SetSendReferrer(false);
michael@0: 
michael@0:     /* for most refreshes the current URI is an appropriate
michael@0:      * internal referrer
michael@0:      */
michael@0:     loadInfo->SetReferrer(mCurrentURI);
michael@0: 
michael@0:     /* Don't ever "guess" on which owner to use to avoid picking
michael@0:      * the current owner.
michael@0:      */
michael@0:     loadInfo->SetOwnerIsExplicit(true);
michael@0: 
michael@0:     /* Check if this META refresh causes a redirection
michael@0:      * to another site. 
michael@0:      */
michael@0:     bool equalUri = false;
michael@0:     nsresult rv = aURI->Equals(mCurrentURI, &equalUri);
michael@0:     if (NS_SUCCEEDED(rv) && (!equalUri) && aMetaRefresh &&
michael@0:         aDelay <= REFRESH_REDIRECT_TIMER) {
michael@0: 
michael@0:         /* It is a META refresh based redirection within the threshold time
michael@0:          * we have in mind (15000 ms as defined by REFRESH_REDIRECT_TIMER).
michael@0:          * Pass a REPLACE flag to LoadURI().
michael@0:          */
michael@0:         loadInfo->SetLoadType(nsIDocShellLoadInfo::loadNormalReplace);
michael@0:             
michael@0:         /* for redirects we mimic HTTP, which passes the
michael@0:          *  original referrer
michael@0:          */
michael@0:         nsCOMPtr<nsIURI> internalReferrer;
michael@0:         GetReferringURI(getter_AddRefs(internalReferrer));
michael@0:         if (internalReferrer) {
michael@0:             loadInfo->SetReferrer(internalReferrer);
michael@0:         }
michael@0:     }
michael@0:     else {
michael@0:         loadInfo->SetLoadType(nsIDocShellLoadInfo::loadRefresh);
michael@0:     }
michael@0: 
michael@0:     /*
michael@0:      * LoadURI(...) will cancel all refresh timers... This causes the
michael@0:      * Timer and its refreshData instance to be released...
michael@0:      */
michael@0:     LoadURI(aURI, loadInfo, nsIWebNavigation::LOAD_FLAGS_NONE, true);
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::SetupRefreshURIFromHeader(nsIURI * aBaseURI,
michael@0:                                       nsIPrincipal* aPrincipal,
michael@0:                                       const nsACString & aHeader)
michael@0: {
michael@0:     // Refresh headers are parsed with the following format in mind
michael@0:     // <META HTTP-EQUIV=REFRESH CONTENT="5; URL=http://uri">
michael@0:     // By the time we are here, the following is true:
michael@0:     // header = "REFRESH"
michael@0:     // content = "5; URL=http://uri" // note the URL attribute is
michael@0:     // optional, if it is absent, the currently loaded url is used.
michael@0:     // Also note that the seconds and URL separator can be either
michael@0:     // a ';' or a ','. The ',' separator should be illegal but CNN
michael@0:     // is using it.
michael@0:     // 
michael@0:     // We need to handle the following strings, where
michael@0:     //  - X is a set of digits
michael@0:     //  - URI is either a relative or absolute URI
michael@0:     //
michael@0:     // Note that URI should start with "url=" but we allow omission
michael@0:     //
michael@0:     // "" || ";" || "," 
michael@0:     //  empty string. use the currently loaded URI
michael@0:     //  and refresh immediately.
michael@0:     // "X" || "X;" || "X,"
michael@0:     //  Refresh the currently loaded URI in X seconds.
michael@0:     // "X; URI" || "X, URI"
michael@0:     //  Refresh using URI as the destination in X seconds.
michael@0:     // "URI" || "; URI" || ", URI"
michael@0:     //  Refresh immediately using URI as the destination.
michael@0:     // 
michael@0:     // Currently, anything immediately following the URI, if
michael@0:     // separated by any char in the set "'\"\t\r\n " will be
michael@0:     // ignored. So "10; url=go.html ; foo=bar" will work,
michael@0:     // and so will "10; url='go.html'; foo=bar". However,
michael@0:     // "10; url=go.html; foo=bar" will result in the uri
michael@0:     // "go.html;" since ';' and ',' are valid uri characters.
michael@0:     // 
michael@0:     // Note that we need to remove any tokens wrapping the URI.
michael@0:     // These tokens currently include spaces, double and single
michael@0:     // quotes.
michael@0: 
michael@0:     // when done, seconds is 0 or the given number of seconds
michael@0:     //            uriAttrib is empty or the URI specified
michael@0:     MOZ_ASSERT(aPrincipal);
michael@0: 
michael@0:     nsAutoCString uriAttrib;
michael@0:     int32_t seconds = 0;
michael@0:     bool specifiesSeconds = false;
michael@0: 
michael@0:     nsACString::const_iterator iter, tokenStart, doneIterating;
michael@0: 
michael@0:     aHeader.BeginReading(iter);
michael@0:     aHeader.EndReading(doneIterating);
michael@0: 
michael@0:     // skip leading whitespace
michael@0:     while (iter != doneIterating && nsCRT::IsAsciiSpace(*iter))
michael@0:         ++iter;
michael@0: 
michael@0:     tokenStart = iter;
michael@0: 
michael@0:     // skip leading + and -
michael@0:     if (iter != doneIterating && (*iter == '-' || *iter == '+'))
michael@0:         ++iter;
michael@0: 
michael@0:     // parse number
michael@0:     while (iter != doneIterating && (*iter >= '0' && *iter <= '9')) {
michael@0:         seconds = seconds * 10 + (*iter - '0');
michael@0:         specifiesSeconds = true;
michael@0:         ++iter;
michael@0:     }
michael@0: 
michael@0:     if (iter != doneIterating) {
michael@0:         // if we started with a '-', number is negative
michael@0:         if (*tokenStart == '-')
michael@0:             seconds = -seconds;
michael@0: 
michael@0:         // skip to next ';' or ','
michael@0:         nsACString::const_iterator iterAfterDigit = iter;
michael@0:         while (iter != doneIterating && !(*iter == ';' || *iter == ','))
michael@0:         {
michael@0:             if (specifiesSeconds)
michael@0:             {
michael@0:                 // Non-whitespace characters here mean that the string is
michael@0:                 // malformed but tolerate sites that specify a decimal point,
michael@0:                 // even though meta refresh only works on whole seconds.
michael@0:                 if (iter == iterAfterDigit &&
michael@0:                     !nsCRT::IsAsciiSpace(*iter) && *iter != '.')
michael@0:                 {
michael@0:                     // The characters between the seconds and the next
michael@0:                     // section are just garbage!
michael@0:                     //   e.g. content="2a0z+,URL=http://www.mozilla.org/"
michael@0:                     // Just ignore this redirect.
michael@0:                     return NS_ERROR_FAILURE;
michael@0:                 }
michael@0:                 else if (nsCRT::IsAsciiSpace(*iter))
michael@0:                 {
michael@0:                     // We've had at least one whitespace so tolerate the mistake
michael@0:                     // and drop through.
michael@0:                     // e.g. content="10 foo"
michael@0:                     ++iter;
michael@0:                     break;
michael@0:                 }
michael@0:             }
michael@0:             ++iter;
michael@0:         }
michael@0: 
michael@0:         // skip any remaining whitespace
michael@0:         while (iter != doneIterating && nsCRT::IsAsciiSpace(*iter))
michael@0:             ++iter;
michael@0: 
michael@0:         // skip ';' or ','
michael@0:         if (iter != doneIterating && (*iter == ';' || *iter == ',')) {
michael@0:             ++iter;
michael@0:         }
michael@0: 
michael@0:         // skip whitespace
michael@0:         while (iter != doneIterating && nsCRT::IsAsciiSpace(*iter))
michael@0:             ++iter;
michael@0:     }
michael@0: 
michael@0:     // possible start of URI
michael@0:     tokenStart = iter;
michael@0: 
michael@0:     // skip "url = " to real start of URI
michael@0:     if (iter != doneIterating && (*iter == 'u' || *iter == 'U')) {
michael@0:         ++iter;
michael@0:         if (iter != doneIterating && (*iter == 'r' || *iter == 'R')) {
michael@0:             ++iter;
michael@0:             if (iter != doneIterating && (*iter == 'l' || *iter == 'L')) {
michael@0:                 ++iter;
michael@0: 
michael@0:                 // skip whitespace
michael@0:                 while (iter != doneIterating && nsCRT::IsAsciiSpace(*iter))
michael@0:                     ++iter;
michael@0: 
michael@0:                 if (iter != doneIterating && *iter == '=') {
michael@0:                     ++iter;
michael@0: 
michael@0:                     // skip whitespace
michael@0:                     while (iter != doneIterating && nsCRT::IsAsciiSpace(*iter))
michael@0:                         ++iter;
michael@0: 
michael@0:                     // found real start of URI
michael@0:                     tokenStart = iter;
michael@0:                 }
michael@0:             }
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // skip a leading '"' or '\''.
michael@0: 
michael@0:     bool isQuotedURI = false;
michael@0:     if (tokenStart != doneIterating && (*tokenStart == '"' || *tokenStart == '\''))
michael@0:     {
michael@0:         isQuotedURI = true;
michael@0:         ++tokenStart;
michael@0:     }
michael@0: 
michael@0:     // set iter to start of URI
michael@0:     iter = tokenStart;
michael@0: 
michael@0:     // tokenStart here points to the beginning of URI
michael@0: 
michael@0:     // grab the rest of the URI
michael@0:     while (iter != doneIterating)
michael@0:     {
michael@0:         if (isQuotedURI && (*iter == '"' || *iter == '\''))
michael@0:             break;
michael@0:         ++iter;
michael@0:     }
michael@0: 
michael@0:     // move iter one back if the last character is a '"' or '\''
michael@0:     if (iter != tokenStart && isQuotedURI) {
michael@0:         --iter;
michael@0:         if (!(*iter == '"' || *iter == '\''))
michael@0:             ++iter;
michael@0:     }
michael@0: 
michael@0:     // URI is whatever's contained from tokenStart to iter.
michael@0:     // note: if tokenStart == doneIterating, so is iter.
michael@0: 
michael@0:     nsresult rv = NS_OK;
michael@0: 
michael@0:     nsCOMPtr<nsIURI> uri;
michael@0:     bool specifiesURI = false;
michael@0:     if (tokenStart == iter) {
michael@0:         uri = aBaseURI;
michael@0:     }
michael@0:     else {
michael@0:         uriAttrib = Substring(tokenStart, iter);
michael@0:         // NS_NewURI takes care of any whitespace surrounding the URL
michael@0:         rv = NS_NewURI(getter_AddRefs(uri), uriAttrib, nullptr, aBaseURI);
michael@0:         specifiesURI = true;
michael@0:     }
michael@0: 
michael@0:     // No URI or seconds were specified
michael@0:     if (!specifiesSeconds && !specifiesURI)
michael@0:     {
michael@0:         // Do nothing because the alternative is to spin around in a refresh
michael@0:         // loop forever!
michael@0:         return NS_ERROR_FAILURE;
michael@0:     }
michael@0: 
michael@0:     if (NS_SUCCEEDED(rv)) {
michael@0:         nsCOMPtr<nsIScriptSecurityManager>
michael@0:             securityManager(do_GetService
michael@0:                             (NS_SCRIPTSECURITYMANAGER_CONTRACTID, &rv));
michael@0:         if (NS_SUCCEEDED(rv)) {
michael@0:             rv = securityManager->
michael@0:                 CheckLoadURIWithPrincipal(aPrincipal, uri,
michael@0:                                           nsIScriptSecurityManager::LOAD_IS_AUTOMATIC_DOCUMENT_REPLACEMENT);
michael@0: 
michael@0:             if (NS_SUCCEEDED(rv)) {
michael@0:                 bool isjs = true;
michael@0:                 rv = NS_URIChainHasFlags(uri,
michael@0:                   nsIProtocolHandler::URI_OPENING_EXECUTES_SCRIPT, &isjs);
michael@0:                 NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:                 if (isjs) {
michael@0:                     return NS_ERROR_FAILURE;
michael@0:                 }
michael@0:             }
michael@0: 
michael@0:             if (NS_SUCCEEDED(rv)) {
michael@0:                 // Since we can't travel back in time yet, just pretend
michael@0:                 // negative numbers do nothing at all.
michael@0:                 if (seconds < 0)
michael@0:                     return NS_ERROR_FAILURE;
michael@0: 
michael@0:                 rv = RefreshURI(uri, seconds * 1000, false, true);
michael@0:             }
michael@0:         }
michael@0:     }
michael@0:     return rv;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP nsDocShell::SetupRefreshURI(nsIChannel * aChannel)
michael@0: {
michael@0:     nsresult rv;
michael@0:     nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(aChannel, &rv));
michael@0:     if (NS_SUCCEEDED(rv)) {
michael@0:         nsAutoCString refreshHeader;
michael@0:         rv = httpChannel->GetResponseHeader(NS_LITERAL_CSTRING("refresh"),
michael@0:                                             refreshHeader);
michael@0: 
michael@0:         if (!refreshHeader.IsEmpty()) {
michael@0:             nsCOMPtr<nsIScriptSecurityManager> secMan =
michael@0:                 do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID, &rv);
michael@0:             NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:             nsCOMPtr<nsIPrincipal> principal;
michael@0:             rv = secMan->GetChannelPrincipal(aChannel, getter_AddRefs(principal));
michael@0:             NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:             SetupReferrerFromChannel(aChannel);
michael@0:             rv = SetupRefreshURIFromHeader(mCurrentURI, principal, refreshHeader);
michael@0:             if (NS_SUCCEEDED(rv)) {
michael@0:                 return NS_REFRESHURI_HEADER_FOUND;
michael@0:             }
michael@0:         }
michael@0:     }
michael@0:     return rv;
michael@0: }
michael@0: 
michael@0: static void
michael@0: DoCancelRefreshURITimers(nsISupportsArray* aTimerList)
michael@0: {
michael@0:     if (!aTimerList)
michael@0:         return;
michael@0: 
michael@0:     uint32_t n=0;
michael@0:     aTimerList->Count(&n);
michael@0: 
michael@0:     while (n) {
michael@0:         nsCOMPtr<nsITimer> timer(do_QueryElementAt(aTimerList, --n));
michael@0: 
michael@0:         aTimerList->RemoveElementAt(n);    // bye bye owning timer ref
michael@0: 
michael@0:         if (timer)
michael@0:             timer->Cancel();        
michael@0:     }
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::CancelRefreshURITimers()
michael@0: {
michael@0:     DoCancelRefreshURITimers(mRefreshURIList);
michael@0:     DoCancelRefreshURITimers(mSavedRefreshURIList);
michael@0:     mRefreshURIList = nullptr;
michael@0:     mSavedRefreshURIList = nullptr;
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetRefreshPending(bool* _retval)
michael@0: {
michael@0:     if (!mRefreshURIList) {
michael@0:         *_retval = false;
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     uint32_t count;
michael@0:     nsresult rv = mRefreshURIList->Count(&count);
michael@0:     if (NS_SUCCEEDED(rv))
michael@0:         *_retval = (count != 0);
michael@0:     return rv;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SuspendRefreshURIs()
michael@0: {
michael@0:     if (mRefreshURIList) {
michael@0:         uint32_t n = 0;
michael@0:         mRefreshURIList->Count(&n);
michael@0: 
michael@0:         for (uint32_t i = 0;  i < n; ++i) {
michael@0:             nsCOMPtr<nsITimer> timer = do_QueryElementAt(mRefreshURIList, i);
michael@0:             if (!timer)
michael@0:                 continue;  // this must be a nsRefreshURI already
michael@0: 
michael@0:             // Replace this timer object with a nsRefreshTimer object.
michael@0:             nsCOMPtr<nsITimerCallback> callback;
michael@0:             timer->GetCallback(getter_AddRefs(callback));
michael@0: 
michael@0:             timer->Cancel();
michael@0: 
michael@0:             nsCOMPtr<nsITimerCallback> rt = do_QueryInterface(callback);
michael@0:             NS_ASSERTION(rt, "RefreshURIList timer callbacks should only be RefreshTimer objects");
michael@0: 
michael@0:             mRefreshURIList->ReplaceElementAt(rt, i);
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // Suspend refresh URIs for our child shells as well.
michael@0:     nsTObserverArray<nsDocLoader*>::ForwardIterator iter(mChildList);
michael@0:     while (iter.HasMore()) {
michael@0:         nsCOMPtr<nsIDocShell> shell = do_QueryObject(iter.GetNext());
michael@0:         if (shell)
michael@0:             shell->SuspendRefreshURIs();
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::ResumeRefreshURIs()
michael@0: {
michael@0:     RefreshURIFromQueue();
michael@0: 
michael@0:     // Resume refresh URIs for our child shells as well.
michael@0:     nsTObserverArray<nsDocLoader*>::ForwardIterator iter(mChildList);
michael@0:     while (iter.HasMore()) {
michael@0:         nsCOMPtr<nsIDocShell> shell = do_QueryObject(iter.GetNext());
michael@0:         if (shell)
michael@0:             shell->ResumeRefreshURIs();
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::RefreshURIFromQueue()
michael@0: {
michael@0:     if (!mRefreshURIList)
michael@0:         return NS_OK;
michael@0:     uint32_t n = 0;
michael@0:     mRefreshURIList->Count(&n);
michael@0: 
michael@0:     while (n) {
michael@0:         nsCOMPtr<nsISupports> element;
michael@0:         mRefreshURIList->GetElementAt(--n, getter_AddRefs(element));
michael@0:         nsCOMPtr<nsITimerCallback> refreshInfo(do_QueryInterface(element));
michael@0: 
michael@0:         if (refreshInfo) {   
michael@0:             // This is the nsRefreshTimer object, waiting to be
michael@0:             // setup in a timer object and fired.                         
michael@0:             // Create the timer and  trigger it.
michael@0:             uint32_t delay = static_cast<nsRefreshTimer*>(static_cast<nsITimerCallback*>(refreshInfo))->GetDelay();
michael@0:             nsCOMPtr<nsITimer> timer = do_CreateInstance("@mozilla.org/timer;1");
michael@0:             if (timer) {    
michael@0:                 // Replace the nsRefreshTimer element in the queue with
michael@0:                 // its corresponding timer object, so that in case another
michael@0:                 // load comes through before the timer can go off, the timer will
michael@0:                 // get cancelled in CancelRefreshURITimer()
michael@0:                 mRefreshURIList->ReplaceElementAt(timer, n);
michael@0:                 timer->InitWithCallback(refreshInfo, delay, nsITimer::TYPE_ONE_SHOT);
michael@0:             }           
michael@0:         }        
michael@0:     }  // while
michael@0:  
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: //*****************************************************************************
michael@0: // nsDocShell::nsIContentViewerContainer
michael@0: //*****************************************************************************   
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::Embed(nsIContentViewer * aContentViewer,
michael@0:                   const char *aCommand, nsISupports * aExtraInfo)
michael@0: {
michael@0:     // Save the LayoutHistoryState of the previous document, before
michael@0:     // setting up new document
michael@0:     PersistLayoutHistoryState();
michael@0: 
michael@0:     nsresult rv = SetupNewViewer(aContentViewer);
michael@0: 
michael@0:     // If we are loading a wyciwyg url from history, change the base URI for 
michael@0:     // the document to the original http url that created the document.write().
michael@0:     // This makes sure that all relative urls in a document.written page loaded
michael@0:     // via history work properly.
michael@0:     if (mCurrentURI &&
michael@0:        (mLoadType & LOAD_CMD_HISTORY ||
michael@0:         mLoadType == LOAD_RELOAD_NORMAL ||
michael@0:         mLoadType == LOAD_RELOAD_CHARSET_CHANGE)){
michael@0:         bool isWyciwyg = false;
michael@0:         // Check if the url is wyciwyg
michael@0:         rv = mCurrentURI->SchemeIs("wyciwyg", &isWyciwyg);      
michael@0:         if (isWyciwyg && NS_SUCCEEDED(rv))
michael@0:             SetBaseUrlForWyciwyg(aContentViewer);
michael@0:     }
michael@0:     // XXX What if SetupNewViewer fails?
michael@0:     if (mLSHE) {
michael@0:         // Restore the editing state, if it's stored in session history.
michael@0:         if (mLSHE->HasDetachedEditor()) {
michael@0:             ReattachEditorToWindow(mLSHE);
michael@0:         }
michael@0:         // Set history.state
michael@0:         SetDocCurrentStateObj(mLSHE);
michael@0: 
michael@0:         SetHistoryEntry(&mOSHE, mLSHE);
michael@0:     }
michael@0: 
michael@0:     bool updateHistory = true;
michael@0: 
michael@0:     // Determine if this type of load should update history
michael@0:     switch (mLoadType) {
michael@0:     case LOAD_NORMAL_REPLACE:
michael@0:     case LOAD_STOP_CONTENT_AND_REPLACE:
michael@0:     case LOAD_RELOAD_BYPASS_CACHE:
michael@0:     case LOAD_RELOAD_BYPASS_PROXY:
michael@0:     case LOAD_RELOAD_BYPASS_PROXY_AND_CACHE:
michael@0:     case LOAD_REPLACE_BYPASS_CACHE:
michael@0:         updateHistory = false;
michael@0:         break;
michael@0:     default:
michael@0:         break;
michael@0:     }
michael@0: 
michael@0:     if (!updateHistory)
michael@0:         SetLayoutHistoryState(nullptr);
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: /* void setIsPrinting (in boolean aIsPrinting); */
michael@0: NS_IMETHODIMP 
michael@0: nsDocShell::SetIsPrinting(bool aIsPrinting)
michael@0: {
michael@0:     mIsPrintingOrPP = aIsPrinting;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: //*****************************************************************************
michael@0: // nsDocShell::nsIWebProgressListener
michael@0: //*****************************************************************************   
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::OnProgressChange(nsIWebProgress * aProgress,
michael@0:                              nsIRequest * aRequest,
michael@0:                              int32_t aCurSelfProgress,
michael@0:                              int32_t aMaxSelfProgress,
michael@0:                              int32_t aCurTotalProgress,
michael@0:                              int32_t aMaxTotalProgress)
michael@0: {
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::OnStateChange(nsIWebProgress * aProgress, nsIRequest * aRequest,
michael@0:                           uint32_t aStateFlags, nsresult aStatus)
michael@0: {
michael@0:     if ((~aStateFlags & (STATE_START | STATE_IS_NETWORK)) == 0) {
michael@0:         // Save timing statistics.
michael@0:         nsCOMPtr<nsIChannel> channel(do_QueryInterface(aRequest));
michael@0:         nsCOMPtr<nsIURI> uri;
michael@0:         channel->GetURI(getter_AddRefs(uri));
michael@0:         nsAutoCString aURI;
michael@0:         uri->GetAsciiSpec(aURI);
michael@0: 
michael@0:         nsCOMPtr<nsIWyciwygChannel>  wcwgChannel(do_QueryInterface(aRequest));
michael@0:         nsCOMPtr<nsIWebProgress> webProgress =
michael@0:             do_QueryInterface(GetAsSupports(this));
michael@0: 
michael@0:         // We don't update navigation timing for wyciwyg channels
michael@0:         if (this == aProgress && !wcwgChannel){
michael@0:             MaybeInitTiming();
michael@0:             mTiming->NotifyFetchStart(uri, ConvertLoadTypeToNavigationType(mLoadType));
michael@0:         }
michael@0: 
michael@0:         // Was the wyciwyg document loaded on this docshell?
michael@0:         if (wcwgChannel && !mLSHE && (mItemType == typeContent) && aProgress == webProgress.get()) {
michael@0:             bool equalUri = true;
michael@0:             // Store the wyciwyg url in session history, only if it is
michael@0:             // being loaded fresh for the first time. We don't want 
michael@0:             // multiple entries for successive loads
michael@0:             if (mCurrentURI &&
michael@0:                 NS_SUCCEEDED(uri->Equals(mCurrentURI, &equalUri)) &&
michael@0:                 !equalUri) {
michael@0: 
michael@0:                 nsCOMPtr<nsIDocShellTreeItem> parentAsItem;
michael@0:                 GetSameTypeParent(getter_AddRefs(parentAsItem));
michael@0:                 nsCOMPtr<nsIDocShell> parentDS(do_QueryInterface(parentAsItem));
michael@0:                 bool inOnLoadHandler = false;
michael@0:                 if (parentDS) {
michael@0:                   parentDS->GetIsExecutingOnLoadHandler(&inOnLoadHandler);
michael@0:                 }
michael@0:                 if (inOnLoadHandler) {
michael@0:                     // We're handling parent's load event listener, which causes
michael@0:                     // document.write in a subdocument.
michael@0:                     // Need to clear the session history for all child
michael@0:                     // docshells so that we can handle them like they would
michael@0:                     // all be added dynamically.
michael@0:                     nsCOMPtr<nsIDocShell> parent =
michael@0:                         do_QueryInterface(parentAsItem);
michael@0:                     if (parent) {
michael@0:                         bool oshe = false;
michael@0:                         nsCOMPtr<nsISHEntry> entry;
michael@0:                         parent->GetCurrentSHEntry(getter_AddRefs(entry), &oshe);
michael@0:                         static_cast<nsDocShell*>(parent.get())->
michael@0:                             ClearFrameHistory(entry);
michael@0:                     }
michael@0:                 }
michael@0: 
michael@0:                 // This is a document.write(). Get the made-up url
michael@0:                 // from the channel and store it in session history.
michael@0:                 // Pass false for aCloneChildren, since we're creating
michael@0:                 // a new DOM here.
michael@0:                 AddToSessionHistory(uri, wcwgChannel, nullptr, false,
michael@0:                                     getter_AddRefs(mLSHE));
michael@0:                 SetCurrentURI(uri, aRequest, true, 0);
michael@0:                 // Save history state of the previous page
michael@0:                 PersistLayoutHistoryState();
michael@0:                 // We'll never get an Embed() for this load, so just go ahead
michael@0:                 // and SetHistoryEntry now.
michael@0:                 SetHistoryEntry(&mOSHE, mLSHE);
michael@0:             }
michael@0:         
michael@0:         }
michael@0:         // Page has begun to load
michael@0:         mBusyFlags = BUSY_FLAGS_BUSY | BUSY_FLAGS_BEFORE_PAGE_LOAD;
michael@0: 
michael@0:         if ((aStateFlags & STATE_RESTORING) == 0) {
michael@0:             // Show the progress cursor if the pref is set
michael@0:             if (Preferences::GetBool("ui.use_activity_cursor", false)) {
michael@0:                 nsCOMPtr<nsIWidget> mainWidget;
michael@0:                 GetMainWidget(getter_AddRefs(mainWidget));
michael@0:                 if (mainWidget) {
michael@0:                     mainWidget->SetCursor(eCursor_spinning);
michael@0:                 }
michael@0:             }
michael@0:         }
michael@0:     }
michael@0:     else if ((~aStateFlags & (STATE_TRANSFERRING | STATE_IS_DOCUMENT)) == 0) {
michael@0:         // Page is loading
michael@0:         mBusyFlags = BUSY_FLAGS_BUSY | BUSY_FLAGS_PAGE_LOADING;
michael@0:     }
michael@0:     else if ((aStateFlags & STATE_STOP) && (aStateFlags & STATE_IS_NETWORK)) {
michael@0:         // Page has finished loading
michael@0:         mBusyFlags = BUSY_FLAGS_NONE;
michael@0: 
michael@0:         // Hide the progress cursor if the pref is set
michael@0:         if (Preferences::GetBool("ui.use_activity_cursor", false)) {
michael@0:             nsCOMPtr<nsIWidget> mainWidget;
michael@0:             GetMainWidget(getter_AddRefs(mainWidget));
michael@0:             if (mainWidget) {
michael@0:                 mainWidget->SetCursor(eCursor_standard);
michael@0:             }
michael@0:         }
michael@0:     }
michael@0:     if ((~aStateFlags & (STATE_IS_DOCUMENT | STATE_STOP)) == 0) {
michael@0:         nsCOMPtr<nsIWebProgress> webProgress =
michael@0:             do_QueryInterface(GetAsSupports(this));
michael@0:         // Is the document stop notification for this document?
michael@0:         if (aProgress == webProgress.get()) {
michael@0:             nsCOMPtr<nsIChannel> channel(do_QueryInterface(aRequest));
michael@0:             EndPageLoad(aProgress, channel, aStatus);
michael@0:         }
michael@0:     }
michael@0:     // note that redirect state changes will go through here as well, but it
michael@0:     // is better to handle those in OnRedirectStateChange where more
michael@0:     // information is available.
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::OnLocationChange(nsIWebProgress * aProgress, nsIRequest * aRequest,
michael@0:                              nsIURI * aURI, uint32_t aFlags)
michael@0: {
michael@0:     NS_NOTREACHED("notification excluded in AddProgressListener(...)");
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsDocShell::OnRedirectStateChange(nsIChannel* aOldChannel,
michael@0:                                   nsIChannel* aNewChannel,
michael@0:                                   uint32_t aRedirectFlags,
michael@0:                                   uint32_t aStateFlags)
michael@0: {
michael@0:     NS_ASSERTION(aStateFlags & STATE_REDIRECTING,
michael@0:                  "Calling OnRedirectStateChange when there is no redirect");
michael@0:     if (!(aStateFlags & STATE_IS_DOCUMENT))
michael@0:         return; // not a toplevel document
michael@0: 
michael@0:     nsCOMPtr<nsIURI> oldURI, newURI;
michael@0:     aOldChannel->GetURI(getter_AddRefs(oldURI));
michael@0:     aNewChannel->GetURI(getter_AddRefs(newURI));
michael@0:     if (!oldURI || !newURI) {
michael@0:         return;
michael@0:     }
michael@0: 
michael@0:     // Check if we have a redirect registered for this url.
michael@0:     uint32_t appId;
michael@0:     nsresult rv = GetAppId(&appId);
michael@0:     if (NS_FAILED(rv)) {
michael@0:       return;
michael@0:     }
michael@0: 
michael@0:     if (appId != nsIScriptSecurityManager::NO_APP_ID &&
michael@0:         appId != nsIScriptSecurityManager::UNKNOWN_APP_ID) {
michael@0:       nsCOMPtr<nsIAppsService> appsService =
michael@0:         do_GetService(APPS_SERVICE_CONTRACTID);
michael@0:       NS_ASSERTION(appsService, "No AppsService available");
michael@0:       nsCOMPtr<nsIURI> redirect;
michael@0:       rv = appsService->GetRedirect(appId, newURI, getter_AddRefs(redirect));
michael@0:       if (NS_SUCCEEDED(rv) && redirect) {
michael@0:         aNewChannel->Cancel(NS_BINDING_ABORTED);
michael@0:         rv = LoadURI(redirect, nullptr, 0, false);
michael@0:         if (NS_SUCCEEDED(rv)) {
michael@0:           return;
michael@0:         }
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     // Below a URI visit is saved (see AddURIVisit method doc).
michael@0:     // The visit chain looks something like:
michael@0:     //   ...
michael@0:     //   Site N - 1
michael@0:     //                =>  Site N
michael@0:     //   (redirect to =>) Site N + 1 (we are here!)
michael@0: 
michael@0:     // Get N - 1 and transition type
michael@0:     nsCOMPtr<nsIURI> previousURI;
michael@0:     uint32_t previousFlags = 0;
michael@0:     ExtractLastVisit(aOldChannel, getter_AddRefs(previousURI), &previousFlags);
michael@0: 
michael@0:     if (aRedirectFlags & nsIChannelEventSink::REDIRECT_INTERNAL ||
michael@0:         ChannelIsPost(aOldChannel)) {
michael@0:         // 1. Internal redirects are ignored because they are specific to the
michael@0:         //    channel implementation.
michael@0:         // 2. POSTs are not saved by global history.
michael@0:         //
michael@0:         // Regardless, we need to propagate the previous visit to the new
michael@0:         // channel.
michael@0:         SaveLastVisit(aNewChannel, previousURI, previousFlags);
michael@0:     }
michael@0:     else {
michael@0:         nsCOMPtr<nsIURI> referrer;
michael@0:         // Treat referrer as null if there is an error getting it.
michael@0:         (void)NS_GetReferrerFromChannel(aOldChannel,
michael@0:                                         getter_AddRefs(referrer));
michael@0: 
michael@0:         // Get the HTTP response code, if available.
michael@0:         uint32_t responseStatus = 0;
michael@0:         nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aOldChannel);
michael@0:         if (httpChannel) {
michael@0:             (void)httpChannel->GetResponseStatus(&responseStatus);
michael@0:         }
michael@0: 
michael@0:         // Add visit N -1 => N
michael@0:         AddURIVisit(oldURI, referrer, previousURI, previousFlags,
michael@0:                     responseStatus);
michael@0: 
michael@0:         // Since N + 1 could be the final destination, we will not save N => N + 1
michael@0:         // here.  OnNewURI will do that, so we will cache it.
michael@0:         SaveLastVisit(aNewChannel, oldURI, aRedirectFlags);
michael@0:     }
michael@0: 
michael@0:     // check if the new load should go through the application cache.
michael@0:     nsCOMPtr<nsIApplicationCacheChannel> appCacheChannel =
michael@0:         do_QueryInterface(aNewChannel);
michael@0:     if (appCacheChannel) {
michael@0:         if (GeckoProcessType_Default != XRE_GetProcessType()) {
michael@0:             // Permission will be checked in the parent process.
michael@0:             appCacheChannel->SetChooseApplicationCache(true);
michael@0:         } else {
michael@0:             nsCOMPtr<nsIScriptSecurityManager> secMan =
michael@0:                 do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID);
michael@0: 
michael@0:             if (secMan) {
michael@0:                 nsCOMPtr<nsIPrincipal> principal;
michael@0:                 secMan->GetDocShellCodebasePrincipal(newURI, this, getter_AddRefs(principal));
michael@0:                 appCacheChannel->SetChooseApplicationCache(NS_ShouldCheckAppCache(principal,
michael@0:                     mInPrivateBrowsing));
michael@0:             }
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     if (!(aRedirectFlags & nsIChannelEventSink::REDIRECT_INTERNAL) && 
michael@0:         mLoadType & (LOAD_CMD_RELOAD | LOAD_CMD_HISTORY)) {
michael@0:         mLoadType = LOAD_NORMAL_REPLACE;
michael@0:         SetHistoryEntry(&mLSHE, nullptr);
michael@0:     }
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::OnStatusChange(nsIWebProgress * aWebProgress,
michael@0:                            nsIRequest * aRequest,
michael@0:                            nsresult aStatus, const char16_t * aMessage)
michael@0: {
michael@0:     NS_NOTREACHED("notification excluded in AddProgressListener(...)");
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::OnSecurityChange(nsIWebProgress * aWebProgress,
michael@0:                              nsIRequest * aRequest, uint32_t state)
michael@0: {
michael@0:     NS_NOTREACHED("notification excluded in AddProgressListener(...)");
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::EndPageLoad(nsIWebProgress * aProgress,
michael@0:                         nsIChannel * aChannel, nsresult aStatus)
michael@0: {
michael@0:     if(!aChannel)
michael@0:         return NS_ERROR_NULL_POINTER;
michael@0:     
michael@0:     MOZ_EVENT_TRACER_DONE(this, "docshell::pageload");
michael@0: 
michael@0:     nsCOMPtr<nsIURI> url;
michael@0:     nsresult rv = aChannel->GetURI(getter_AddRefs(url));
michael@0:     if (NS_FAILED(rv)) return rv;
michael@0: 
michael@0:     nsCOMPtr<nsITimedChannel> timingChannel =
michael@0:         do_QueryInterface(aChannel);
michael@0:     if (timingChannel) {
michael@0:         TimeStamp channelCreationTime;
michael@0:         rv = timingChannel->GetChannelCreation(&channelCreationTime);
michael@0:         if (NS_SUCCEEDED(rv) && !channelCreationTime.IsNull()) {
michael@0:             Telemetry::AccumulateTimeDelta(
michael@0:                 Telemetry::TOTAL_CONTENT_PAGE_LOAD_TIME,
michael@0:                 channelCreationTime);
michael@0:             nsCOMPtr<nsPILoadGroupInternal> internalLoadGroup =
michael@0:                 do_QueryInterface(mLoadGroup);
michael@0:             if (internalLoadGroup)
michael@0:                 internalLoadGroup->OnEndPageLoad(aChannel);
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // Timing is picked up by the window, we don't need it anymore
michael@0:     mTiming = nullptr;
michael@0: 
michael@0:     // clean up reload state for meta charset
michael@0:     if (eCharsetReloadRequested == mCharsetReloadState)
michael@0:         mCharsetReloadState = eCharsetReloadStopOrigional;
michael@0:     else 
michael@0:         mCharsetReloadState = eCharsetReloadInit;
michael@0: 
michael@0:     // Save a pointer to the currently-loading history entry.
michael@0:     // nsDocShell::EndPageLoad will clear mLSHE, but we may need this history
michael@0:     // entry further down in this method.
michael@0:     nsCOMPtr<nsISHEntry> loadingSHE = mLSHE;
michael@0:   
michael@0:     //
michael@0:     // one of many safeguards that prevent death and destruction if
michael@0:     // someone is so very very rude as to bring this window down
michael@0:     // during this load handler.
michael@0:     //
michael@0:     nsCOMPtr<nsIDocShell> kungFuDeathGrip(this);
michael@0: 
michael@0:     // Notify the ContentViewer that the Document has finished loading.  This
michael@0:     // will cause any OnLoad(...) and PopState(...) handlers to fire.
michael@0:     if (!mEODForCurrentDocument && mContentViewer) {
michael@0:         mIsExecutingOnLoadHandler = true;
michael@0:         mContentViewer->LoadComplete(aStatus);
michael@0:         mIsExecutingOnLoadHandler = false;
michael@0: 
michael@0:         mEODForCurrentDocument = true;
michael@0: 
michael@0:         // If all documents have completed their loading
michael@0:         // favor native event dispatch priorities
michael@0:         // over performance
michael@0:         if (--gNumberOfDocumentsLoading == 0) {
michael@0:           // Hint to use normal native event dispatch priorities 
michael@0:           FavorPerformanceHint(false);
michael@0:         }
michael@0:     }
michael@0:     /* Check if the httpChannel has any cache-control related response headers,
michael@0:      * like no-store, no-cache. If so, update SHEntry so that 
michael@0:      * when a user goes back/forward to this page, we appropriately do 
michael@0:      * form value restoration or load from server.
michael@0:      */
michael@0:     nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(aChannel));
michael@0:     if (!httpChannel) // HttpChannel could be hiding underneath a Multipart channel.    
michael@0:         GetHttpChannel(aChannel, getter_AddRefs(httpChannel));
michael@0: 
michael@0:     if (httpChannel) {
michael@0:         // figure out if SH should be saving layout state.
michael@0:         bool discardLayoutState = ShouldDiscardLayoutState(httpChannel);       
michael@0:         if (mLSHE && discardLayoutState && (mLoadType & LOAD_CMD_NORMAL) &&
michael@0:             (mLoadType != LOAD_BYPASS_HISTORY) && (mLoadType != LOAD_ERROR_PAGE))
michael@0:             mLSHE->SetSaveLayoutStateFlag(false);            
michael@0:     }
michael@0: 
michael@0:     // Clear mLSHE after calling the onLoadHandlers. This way, if the
michael@0:     // onLoadHandler tries to load something different in
michael@0:     // itself or one of its children, we can deal with it appropriately.
michael@0:     if (mLSHE) {
michael@0:         mLSHE->SetLoadType(nsIDocShellLoadInfo::loadHistory);
michael@0: 
michael@0:         // Clear the mLSHE reference to indicate document loading is done one
michael@0:         // way or another.
michael@0:         SetHistoryEntry(&mLSHE, nullptr);
michael@0:     }
michael@0:     // if there's a refresh header in the channel, this method
michael@0:     // will set it up for us. 
michael@0:     RefreshURIFromQueue();
michael@0: 
michael@0:     // Test whether this is the top frame or a subframe
michael@0:     bool isTopFrame = true;
michael@0:     nsCOMPtr<nsIDocShellTreeItem> targetParentTreeItem;
michael@0:     rv = GetSameTypeParent(getter_AddRefs(targetParentTreeItem));
michael@0:     if (NS_SUCCEEDED(rv) && targetParentTreeItem) {
michael@0:         isTopFrame = false;
michael@0:     }
michael@0: 
michael@0:     //
michael@0:     // If the page load failed, then deal with the error condition...
michael@0:     // Errors are handled as follows:
michael@0:     //   1. Check to see if it's a file not found error or bad content
michael@0:     //      encoding error.
michael@0:     //   2. Send the URI to a keyword server (if enabled)
michael@0:     //   3. If the error was DNS failure, then add www and .com to the URI
michael@0:     //      (if appropriate).
michael@0:     //   4. Throw an error dialog box...
michael@0:     //
michael@0:     if (url && NS_FAILED(aStatus)) {
michael@0:         if (aStatus == NS_ERROR_FILE_NOT_FOUND ||
michael@0:             aStatus == NS_ERROR_CORRUPTED_CONTENT ||
michael@0:             aStatus == NS_ERROR_INVALID_CONTENT_ENCODING) {
michael@0:             DisplayLoadError(aStatus, url, nullptr, aChannel);
michael@0:             return NS_OK;
michael@0:         }
michael@0: 
michael@0:         if (sURIFixup) {
michael@0:             //
michael@0:             // Try and make an alternative URI from the old one
michael@0:             //
michael@0:             nsCOMPtr<nsIURI> newURI;
michael@0:             nsCOMPtr<nsIInputStream> newPostData;
michael@0: 
michael@0:             nsAutoCString oldSpec;
michael@0:             url->GetSpec(oldSpec);
michael@0:       
michael@0:             //
michael@0:             // First try keyword fixup
michael@0:             //
michael@0:             if (aStatus == NS_ERROR_UNKNOWN_HOST && mAllowKeywordFixup) {
michael@0:                 bool keywordsEnabled =
michael@0:                     Preferences::GetBool("keyword.enabled", false);
michael@0: 
michael@0:                 nsAutoCString host;
michael@0:                 url->GetHost(host);
michael@0: 
michael@0:                 nsAutoCString scheme;
michael@0:                 url->GetScheme(scheme);
michael@0: 
michael@0:                 int32_t dotLoc = host.FindChar('.');
michael@0: 
michael@0:                 // we should only perform a keyword search under the following
michael@0:                 // conditions:
michael@0:                 // (0) Pref keyword.enabled is true
michael@0:                 // (1) the url scheme is http (or https)
michael@0:                 // (2) the url does not have a protocol scheme
michael@0:                 // If we don't enforce such a policy, then we end up doing
michael@0:                 // keyword searchs on urls we don't intend like imap, file,
michael@0:                 // mailbox, etc. This could lead to a security problem where we
michael@0:                 // send data to the keyword server that we shouldn't be.
michael@0:                 // Someone needs to clean up keywords in general so we can
michael@0:                 // determine on a per url basis if we want keywords
michael@0:                 // enabled...this is just a bandaid...
michael@0:                 if (keywordsEnabled && !scheme.IsEmpty() &&
michael@0:                     (scheme.Find("http") != 0)) {
michael@0:                     keywordsEnabled = false;
michael@0:                 }
michael@0: 
michael@0:                 if (keywordsEnabled && (kNotFound == dotLoc)) {
michael@0:                     // only send non-qualified hosts to the keyword server
michael@0:                     if (!mOriginalUriString.IsEmpty()) {
michael@0:                         sURIFixup->KeywordToURI(mOriginalUriString,
michael@0:                                                 getter_AddRefs(newPostData),
michael@0:                                                 getter_AddRefs(newURI));
michael@0:                     }
michael@0:                     else {
michael@0:                         //
michael@0:                         // If this string was passed through nsStandardURL by
michael@0:                         // chance, then it may have been converted from UTF-8 to
michael@0:                         // ACE, which would result in a completely bogus keyword
michael@0:                         // query.  Here we try to recover the original Unicode
michael@0:                         // value, but this is not 100% correct since the value may
michael@0:                         // have been normalized per the IDN normalization rules.
michael@0:                         //
michael@0:                         // Since we don't have access to the exact original string
michael@0:                         // that was entered by the user, this will just have to do.
michael@0:                         bool isACE;
michael@0:                         nsAutoCString utf8Host;
michael@0:                         nsCOMPtr<nsIIDNService> idnSrv =
michael@0:                             do_GetService(NS_IDNSERVICE_CONTRACTID);
michael@0:                         if (idnSrv &&
michael@0:                             NS_SUCCEEDED(idnSrv->IsACE(host, &isACE)) && isACE &&
michael@0:                             NS_SUCCEEDED(idnSrv->ConvertACEtoUTF8(host, utf8Host))) {
michael@0:                             sURIFixup->KeywordToURI(utf8Host,
michael@0:                                                     getter_AddRefs(newPostData),
michael@0:                                                     getter_AddRefs(newURI));
michael@0:                         } else {
michael@0:                             sURIFixup->KeywordToURI(host,
michael@0:                                                     getter_AddRefs(newPostData),
michael@0:                                                     getter_AddRefs(newURI));
michael@0:                         }
michael@0:                     }
michael@0:                 } // end keywordsEnabled
michael@0:             }
michael@0: 
michael@0:             //
michael@0:             // Now try change the address, e.g. turn http://foo into
michael@0:             // http://www.foo.com
michael@0:             //
michael@0:             if (aStatus == NS_ERROR_UNKNOWN_HOST ||
michael@0:                 aStatus == NS_ERROR_NET_RESET) {
michael@0:                 bool doCreateAlternate = true;
michael@0: 
michael@0:                 // Skip fixup for anything except a normal document load
michael@0:                 // operation on the topframe.
michael@0:         
michael@0:                 if (mLoadType != LOAD_NORMAL || !isTopFrame) {
michael@0:                     doCreateAlternate = false;
michael@0:                 }
michael@0:                 else {
michael@0:                     // Test if keyword lookup produced a new URI or not
michael@0:                     if (newURI) {
michael@0:                         bool sameURI = false;
michael@0:                         url->Equals(newURI, &sameURI);
michael@0:                         if (!sameURI) {
michael@0:                             // Keyword lookup made a new URI so no need to try
michael@0:                             // an alternate one.
michael@0:                             doCreateAlternate = false;
michael@0:                         }
michael@0:                     }
michael@0:                 }
michael@0:                 if (doCreateAlternate) {
michael@0:                     newURI = nullptr;
michael@0:                     newPostData = nullptr;
michael@0:                     sURIFixup->CreateFixupURI(oldSpec,
michael@0:                       nsIURIFixup::FIXUP_FLAGS_MAKE_ALTERNATE_URI,
michael@0:                                               getter_AddRefs(newPostData),
michael@0:                                               getter_AddRefs(newURI));
michael@0:                 }
michael@0:             }
michael@0: 
michael@0:             // Did we make a new URI that is different to the old one? If so
michael@0:             // load it.
michael@0:             //
michael@0:             if (newURI) {
michael@0:                 // Make sure the new URI is different from the old one,
michael@0:                 // otherwise there's little point trying to load it again.
michael@0:                 bool sameURI = false;
michael@0:                 url->Equals(newURI, &sameURI);
michael@0:                 if (!sameURI) {
michael@0:                     nsAutoCString newSpec;
michael@0:                     newURI->GetSpec(newSpec);
michael@0:                     NS_ConvertUTF8toUTF16 newSpecW(newSpec);
michael@0: 
michael@0:                     return LoadURI(newSpecW.get(),  // URI string
michael@0:                                    LOAD_FLAGS_NONE, // Load flags
michael@0:                                    nullptr,          // Referring URI
michael@0:                                    newPostData,      // Post data stream
michael@0:                                    nullptr);         // Headers stream
michael@0:                 }
michael@0:             }
michael@0:         }
michael@0: 
michael@0:         // Well, fixup didn't work :-(
michael@0:         // It is time to throw an error dialog box, and be done with it...
michael@0: 
michael@0:         // Errors to be shown only on top-level frames
michael@0:         if ((aStatus == NS_ERROR_UNKNOWN_HOST || 
michael@0:              aStatus == NS_ERROR_CONNECTION_REFUSED ||
michael@0:              aStatus == NS_ERROR_UNKNOWN_PROXY_HOST || 
michael@0:              aStatus == NS_ERROR_PROXY_CONNECTION_REFUSED) &&
michael@0:             (isTopFrame || UseErrorPages())) {
michael@0:             DisplayLoadError(aStatus, url, nullptr, aChannel);
michael@0:         }
michael@0:         // Errors to be shown for any frame
michael@0:         else if (aStatus == NS_ERROR_NET_TIMEOUT ||
michael@0:                  aStatus == NS_ERROR_REDIRECT_LOOP ||
michael@0:                  aStatus == NS_ERROR_UNKNOWN_SOCKET_TYPE ||
michael@0:                  aStatus == NS_ERROR_NET_INTERRUPT ||
michael@0:                  aStatus == NS_ERROR_NET_RESET ||
michael@0:                  aStatus == NS_ERROR_OFFLINE ||
michael@0:                  aStatus == NS_ERROR_MALWARE_URI ||
michael@0:                  aStatus == NS_ERROR_PHISHING_URI ||
michael@0:                  aStatus == NS_ERROR_UNSAFE_CONTENT_TYPE ||
michael@0:                  aStatus == NS_ERROR_REMOTE_XUL ||
michael@0:                  aStatus == NS_ERROR_OFFLINE ||
michael@0:                  NS_ERROR_GET_MODULE(aStatus) == NS_ERROR_MODULE_SECURITY) {
michael@0:             DisplayLoadError(aStatus, url, nullptr, aChannel);
michael@0:         }
michael@0:         else if (aStatus == NS_ERROR_DOCUMENT_NOT_CACHED) {
michael@0:             // Non-caching channels will simply return NS_ERROR_OFFLINE.
michael@0:             // Caching channels would have to look at their flags to work
michael@0:             // out which error to return. Or we can fix up the error here.
michael@0:             if (!(mLoadType & LOAD_CMD_HISTORY))
michael@0:                 aStatus = NS_ERROR_OFFLINE;
michael@0:             DisplayLoadError(aStatus, url, nullptr, aChannel);
michael@0:         }
michael@0:     } // if we have a host
michael@0:     else if (url && NS_SUCCEEDED(aStatus)) {
michael@0:         mozilla::net::SeerLearnRedirect(url, aChannel, this);
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: 
michael@0: //*****************************************************************************
michael@0: // nsDocShell: Content Viewer Management
michael@0: //*****************************************************************************   
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::EnsureContentViewer()
michael@0: {
michael@0:     if (mContentViewer)
michael@0:         return NS_OK;
michael@0:     if (mIsBeingDestroyed)
michael@0:         return NS_ERROR_FAILURE;
michael@0: 
michael@0:     nsCOMPtr<nsIURI> baseURI;
michael@0:     nsIPrincipal* principal = GetInheritedPrincipal(false);
michael@0:     nsCOMPtr<nsIDocShellTreeItem> parentItem;
michael@0:     GetSameTypeParent(getter_AddRefs(parentItem));
michael@0:     if (parentItem) {
michael@0:         nsCOMPtr<nsPIDOMWindow> domWin = do_GetInterface(GetAsSupports(this));
michael@0:         if (domWin) {
michael@0:             nsCOMPtr<nsIContent> parentContent =
michael@0:                 do_QueryInterface(domWin->GetFrameElementInternal());
michael@0:             if (parentContent) {
michael@0:                 baseURI = parentContent->GetBaseURI();
michael@0:             }
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     nsresult rv = CreateAboutBlankContentViewer(principal, baseURI);
michael@0: 
michael@0:     if (NS_SUCCEEDED(rv)) {
michael@0:         nsCOMPtr<nsIDocument> doc(do_GetInterface(GetAsSupports(this)));
michael@0:         NS_ASSERTION(doc,
michael@0:                      "Should have doc if CreateAboutBlankContentViewer "
michael@0:                      "succeeded!");
michael@0: 
michael@0:         doc->SetIsInitialDocument(true);
michael@0:     }
michael@0: 
michael@0:     return rv;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::CreateAboutBlankContentViewer(nsIPrincipal* aPrincipal,
michael@0:                                           nsIURI* aBaseURI,
michael@0:                                           bool aTryToSaveOldPresentation)
michael@0: {
michael@0:   nsCOMPtr<nsIDocument> blankDoc;
michael@0:   nsCOMPtr<nsIContentViewer> viewer;
michael@0:   nsresult rv = NS_ERROR_FAILURE;
michael@0: 
michael@0:   /* mCreatingDocument should never be true at this point. However, it's
michael@0:      a theoretical possibility. We want to know about it and make it stop,
michael@0:      and this sounds like a job for an assertion. */
michael@0:   NS_ASSERTION(!mCreatingDocument, "infinite(?) loop creating document averted");
michael@0:   if (mCreatingDocument)
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   mCreatingDocument = true;
michael@0: 
michael@0:   // mContentViewer->PermitUnload may release |this| docshell.
michael@0:   nsCOMPtr<nsIDocShell> kungFuDeathGrip(this);
michael@0:   
michael@0:   // Make sure timing is created.  But first record whether we had it
michael@0:   // already, so we don't clobber the timing for an in-progress load.
michael@0:   bool hadTiming = mTiming;
michael@0:   MaybeInitTiming();
michael@0:   if (mContentViewer) {
michael@0:     // We've got a content viewer already. Make sure the user
michael@0:     // permits us to discard the current document and replace it
michael@0:     // with about:blank. And also ensure we fire the unload events
michael@0:     // in the current document.
michael@0: 
michael@0:     // Unload gets fired first for
michael@0:     // document loaded from the session history.
michael@0:     mTiming->NotifyBeforeUnload();
michael@0: 
michael@0:     bool okToUnload;
michael@0:     rv = mContentViewer->PermitUnload(false, &okToUnload);
michael@0: 
michael@0:     if (NS_SUCCEEDED(rv) && !okToUnload) {
michael@0:       // The user chose not to unload the page, interrupt the load.
michael@0:       return NS_ERROR_FAILURE;
michael@0:     }
michael@0: 
michael@0:     mSavingOldViewer = aTryToSaveOldPresentation && 
michael@0:                        CanSavePresentation(LOAD_NORMAL, nullptr, nullptr);
michael@0: 
michael@0:     if (mTiming) {
michael@0:       mTiming->NotifyUnloadAccepted(mCurrentURI);
michael@0:     }
michael@0: 
michael@0:     // Make sure to blow away our mLoadingURI just in case.  No loads
michael@0:     // from inside this pagehide.
michael@0:     mLoadingURI = nullptr;
michael@0:     
michael@0:     // Stop any in-progress loading, so that we don't accidentally trigger any
michael@0:     // PageShow notifications from Embed() interrupting our loading below.
michael@0:     Stop();
michael@0: 
michael@0:     // Notify the current document that it is about to be unloaded!!
michael@0:     //
michael@0:     // It is important to fire the unload() notification *before* any state
michael@0:     // is changed within the DocShell - otherwise, javascript will get the
michael@0:     // wrong information :-(
michael@0:     //
michael@0:     (void) FirePageHideNotification(!mSavingOldViewer);
michael@0:   }
michael@0: 
michael@0:   // Now make sure we don't think we're in the middle of firing unload after
michael@0:   // this point.  This will make us fire unload when the about:blank document
michael@0:   // unloads... but that's ok, more or less.  Would be nice if it fired load
michael@0:   // too, of course.
michael@0:   mFiredUnloadEvent = false;
michael@0: 
michael@0:   nsCOMPtr<nsIDocumentLoaderFactory> docFactory =
michael@0:       nsContentUtils::FindInternalContentViewer("text/html");
michael@0: 
michael@0:   if (docFactory) {
michael@0:     nsCOMPtr<nsIPrincipal> principal;
michael@0:     if (mSandboxFlags & SANDBOXED_ORIGIN) {
michael@0:       principal = do_CreateInstance("@mozilla.org/nullprincipal;1");
michael@0:     } else {
michael@0:       principal = aPrincipal;
michael@0:     }
michael@0:     // generate (about:blank) document to load
michael@0:     docFactory->CreateBlankDocument(mLoadGroup, principal,
michael@0:                                     getter_AddRefs(blankDoc));
michael@0:     if (blankDoc) {
michael@0:       // Hack: set the base URI manually, since this document never
michael@0:       // got Reset() with a channel.
michael@0:       blankDoc->SetBaseURI(aBaseURI);
michael@0: 
michael@0:       blankDoc->SetContainer(this);
michael@0: 
michael@0:       // Copy our sandbox flags to the document. These are immutable
michael@0:       // after being set here.
michael@0:       blankDoc->SetSandboxFlags(mSandboxFlags);
michael@0: 
michael@0:       // create a content viewer for us and the new document
michael@0:       docFactory->CreateInstanceForDocument(NS_ISUPPORTS_CAST(nsIDocShell *, this),
michael@0:                     blankDoc, "view", getter_AddRefs(viewer));
michael@0: 
michael@0:       // hook 'em up
michael@0:       if (viewer) {
michael@0:         viewer->SetContainer(this);
michael@0:         Embed(viewer, "", 0);
michael@0: 
michael@0:         SetCurrentURI(blankDoc->GetDocumentURI(), nullptr, true, 0);
michael@0:         rv = mIsBeingDestroyed ? NS_ERROR_NOT_AVAILABLE : NS_OK;
michael@0:       }
michael@0:     }
michael@0:   }
michael@0:   mCreatingDocument = false;
michael@0: 
michael@0:   // The transient about:blank viewer doesn't have a session history entry.
michael@0:   SetHistoryEntry(&mOSHE, nullptr);
michael@0: 
michael@0:   // Clear out our mTiming like we would in EndPageLoad, if we didn't
michael@0:   // have one before entering this function.
michael@0:   if (!hadTiming) {
michael@0:     mTiming = nullptr;
michael@0:   }
michael@0: 
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::CreateAboutBlankContentViewer(nsIPrincipal *aPrincipal)
michael@0: {
michael@0:     return CreateAboutBlankContentViewer(aPrincipal, nullptr);
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsDocShell::CanSavePresentation(uint32_t aLoadType,
michael@0:                                 nsIRequest *aNewRequest,
michael@0:                                 nsIDocument *aNewDocument)
michael@0: {
michael@0:     if (!mOSHE)
michael@0:         return false; // no entry to save into
michael@0: 
michael@0:     nsCOMPtr<nsIContentViewer> viewer;
michael@0:     mOSHE->GetContentViewer(getter_AddRefs(viewer));
michael@0:     if (viewer) {
michael@0:         NS_WARNING("mOSHE already has a content viewer!");
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     // Only save presentation for "normal" loads and link loads.  Anything else
michael@0:     // probably wants to refetch the page, so caching the old presentation
michael@0:     // would be incorrect.
michael@0:     if (aLoadType != LOAD_NORMAL &&
michael@0:         aLoadType != LOAD_HISTORY &&
michael@0:         aLoadType != LOAD_LINK &&
michael@0:         aLoadType != LOAD_STOP_CONTENT &&
michael@0:         aLoadType != LOAD_STOP_CONTENT_AND_REPLACE &&
michael@0:         aLoadType != LOAD_ERROR_PAGE)
michael@0:         return false;
michael@0: 
michael@0:     // If the session history entry has the saveLayoutState flag set to false,
michael@0:     // then we should not cache the presentation.
michael@0:     bool canSaveState;
michael@0:     mOSHE->GetSaveLayoutStateFlag(&canSaveState);
michael@0:     if (!canSaveState)
michael@0:         return false;
michael@0: 
michael@0:     // If the document is not done loading, don't cache it.
michael@0:     if (!mScriptGlobal || mScriptGlobal->IsLoading())
michael@0:         return false;
michael@0: 
michael@0:     if (mScriptGlobal->WouldReuseInnerWindow(aNewDocument))
michael@0:         return false;
michael@0: 
michael@0:     // Avoid doing the work of saving the presentation state in the case where
michael@0:     // the content viewer cache is disabled.
michael@0:     if (nsSHistory::GetMaxTotalViewers() == 0)
michael@0:         return false;
michael@0: 
michael@0:     // Don't cache the content viewer if we're in a subframe and the subframe
michael@0:     // pref is disabled.
michael@0:     bool cacheFrames =
michael@0:         Preferences::GetBool("browser.sessionhistory.cache_subframes",
michael@0:                              false);
michael@0:     if (!cacheFrames) {
michael@0:         nsCOMPtr<nsIDocShellTreeItem> root;
michael@0:         GetSameTypeParent(getter_AddRefs(root));
michael@0:         if (root && root != this) {
michael@0:             return false;  // this is a subframe load
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // If the document does not want its presentation cached, then don't.
michael@0:     nsCOMPtr<nsIDocument> doc = mScriptGlobal->GetExtantDoc();
michael@0:     return doc && doc->CanSavePresentation(aNewRequest);
michael@0: }
michael@0: 
michael@0: void
michael@0: nsDocShell::ReattachEditorToWindow(nsISHEntry *aSHEntry)
michael@0: {
michael@0:     NS_ASSERTION(!mEditorData,
michael@0:                  "Why reattach an editor when we already have one?");
michael@0:     NS_ASSERTION(aSHEntry && aSHEntry->HasDetachedEditor(),
michael@0:                  "Reattaching when there's not a detached editor.");
michael@0: 
michael@0:     if (mEditorData || !aSHEntry)
michael@0:         return;
michael@0: 
michael@0:     mEditorData = aSHEntry->ForgetEditorData();
michael@0:     if (mEditorData) {
michael@0: #ifdef DEBUG
michael@0:         nsresult rv =
michael@0: #endif
michael@0:         mEditorData->ReattachToWindow(this);
michael@0:         NS_ASSERTION(NS_SUCCEEDED(rv), "Failed to reattach editing session");
michael@0:     }
michael@0: }
michael@0: 
michael@0: void
michael@0: nsDocShell::DetachEditorFromWindow()
michael@0: {
michael@0:     if (!mEditorData || mEditorData->WaitingForLoad()) {
michael@0:         // If there's nothing to detach, or if the editor data is actually set
michael@0:         // up for the _new_ page that's coming in, don't detach.
michael@0:         return;
michael@0:     }
michael@0: 
michael@0:     NS_ASSERTION(!mOSHE || !mOSHE->HasDetachedEditor(),
michael@0:                  "Detaching editor when it's already detached.");
michael@0: 
michael@0:     nsresult res = mEditorData->DetachFromWindow();
michael@0:     NS_ASSERTION(NS_SUCCEEDED(res), "Failed to detach editor");
michael@0: 
michael@0:     if (NS_SUCCEEDED(res)) {
michael@0:         // Make mOSHE hold the owning ref to the editor data.
michael@0:         if (mOSHE)
michael@0:             mOSHE->SetEditorData(mEditorData.forget());
michael@0:         else
michael@0:             mEditorData = nullptr;
michael@0:     }
michael@0: 
michael@0: #ifdef DEBUG
michael@0:     {
michael@0:         bool isEditable;
michael@0:         GetEditable(&isEditable);
michael@0:         NS_ASSERTION(!isEditable,
michael@0:                      "Window is still editable after detaching editor.");
michael@0:     }
michael@0: #endif // DEBUG
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::CaptureState()
michael@0: {
michael@0:     if (!mOSHE || mOSHE == mLSHE) {
michael@0:         // No entry to save into, or we're replacing the existing entry.
michael@0:         return NS_ERROR_FAILURE;
michael@0:     }
michael@0: 
michael@0:     if (!mScriptGlobal)
michael@0:         return NS_ERROR_FAILURE;
michael@0: 
michael@0:     nsCOMPtr<nsISupports> windowState = mScriptGlobal->SaveWindowState();
michael@0:     NS_ENSURE_TRUE(windowState, NS_ERROR_FAILURE);
michael@0: 
michael@0: #ifdef DEBUG_PAGE_CACHE
michael@0:     nsCOMPtr<nsIURI> uri;
michael@0:     mOSHE->GetURI(getter_AddRefs(uri));
michael@0:     nsAutoCString spec;
michael@0:     if (uri)
michael@0:         uri->GetSpec(spec);
michael@0:     printf("Saving presentation into session history\n");
michael@0:     printf("  SH URI: %s\n", spec.get());
michael@0: #endif
michael@0: 
michael@0:     nsresult rv = mOSHE->SetWindowState(windowState);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     // Suspend refresh URIs and save off the timer queue
michael@0:     rv = mOSHE->SetRefreshURIList(mSavedRefreshURIList);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     // Capture the current content viewer bounds.
michael@0:     if (mContentViewer) {
michael@0:         nsIntRect bounds;
michael@0:         mContentViewer->GetBounds(bounds);
michael@0:         rv = mOSHE->SetViewerBounds(bounds);
michael@0:         NS_ENSURE_SUCCESS(rv, rv);
michael@0:     }
michael@0: 
michael@0:     // Capture the docshell hierarchy.
michael@0:     mOSHE->ClearChildShells();
michael@0: 
michael@0:     uint32_t childCount = mChildList.Length();
michael@0:     for (uint32_t i = 0; i < childCount; ++i) {
michael@0:         nsCOMPtr<nsIDocShellTreeItem> childShell = do_QueryInterface(ChildAt(i));
michael@0:         NS_ASSERTION(childShell, "null child shell");
michael@0: 
michael@0:         mOSHE->AddChildShell(childShell);
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::RestorePresentationEvent::Run()
michael@0: {
michael@0:     if (mDocShell && NS_FAILED(mDocShell->RestoreFromHistory()))
michael@0:         NS_WARNING("RestoreFromHistory failed");
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::BeginRestore(nsIContentViewer *aContentViewer, bool aTop)
michael@0: {
michael@0:     nsresult rv;
michael@0:     if (!aContentViewer) {
michael@0:         rv = EnsureContentViewer();
michael@0:         NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:         aContentViewer = mContentViewer;
michael@0:     }
michael@0: 
michael@0:     // Dispatch events for restoring the presentation.  We try to simulate
michael@0:     // the progress notifications loading the document would cause, so we add
michael@0:     // the document's channel to the loadgroup to initiate stateChange
michael@0:     // notifications.
michael@0: 
michael@0:     nsCOMPtr<nsIDOMDocument> domDoc;
michael@0:     aContentViewer->GetDOMDocument(getter_AddRefs(domDoc));
michael@0:     nsCOMPtr<nsIDocument> doc = do_QueryInterface(domDoc);
michael@0:     if (doc) {
michael@0:         nsIChannel *channel = doc->GetChannel();
michael@0:         if (channel) {
michael@0:             mEODForCurrentDocument = false;
michael@0:             mIsRestoringDocument = true;
michael@0:             mLoadGroup->AddRequest(channel, nullptr);
michael@0:             mIsRestoringDocument = false;
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     if (!aTop) {
michael@0:         // This point corresponds to us having gotten OnStartRequest or
michael@0:         // STATE_START, so do the same thing that CreateContentViewer does at
michael@0:         // this point to ensure that unload/pagehide events for this document
michael@0:         // will fire when it's unloaded again.
michael@0:         mFiredUnloadEvent = false;
michael@0: 
michael@0:         // For non-top frames, there is no notion of making sure that the
michael@0:         // previous document is in the domwindow when STATE_START notifications
michael@0:         // happen.  We can just call BeginRestore for all of the child shells
michael@0:         // now.
michael@0:         rv = BeginRestoreChildren();
michael@0:         NS_ENSURE_SUCCESS(rv, rv);
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::BeginRestoreChildren()
michael@0: {
michael@0:     nsTObserverArray<nsDocLoader*>::ForwardIterator iter(mChildList);
michael@0:     while (iter.HasMore()) {
michael@0:         nsCOMPtr<nsIDocShell> child = do_QueryObject(iter.GetNext());
michael@0:         if (child) {
michael@0:             nsresult rv = child->BeginRestore(nullptr, false);
michael@0:             NS_ENSURE_SUCCESS(rv, rv);
michael@0:         }
michael@0:     }
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::FinishRestore()
michael@0: {
michael@0:     // First we call finishRestore() on our children.  In the simulated load,
michael@0:     // all of the child frames finish loading before the main document.
michael@0: 
michael@0:     nsTObserverArray<nsDocLoader*>::ForwardIterator iter(mChildList);
michael@0:     while (iter.HasMore()) {
michael@0:         nsCOMPtr<nsIDocShell> child = do_QueryObject(iter.GetNext());
michael@0:         if (child) {
michael@0:             child->FinishRestore();
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     if (mOSHE && mOSHE->HasDetachedEditor()) {
michael@0:       ReattachEditorToWindow(mOSHE);
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIDocument> doc = do_GetInterface(GetAsSupports(this));
michael@0:     if (doc) {
michael@0:         // Finally, we remove the request from the loadgroup.  This will
michael@0:         // cause onStateChange(STATE_STOP) to fire, which will fire the
michael@0:         // pageshow event to the chrome.
michael@0: 
michael@0:         nsIChannel *channel = doc->GetChannel();
michael@0:         if (channel) {
michael@0:             mIsRestoringDocument = true;
michael@0:             mLoadGroup->RemoveRequest(channel, nullptr, NS_OK);
michael@0:             mIsRestoringDocument = false;
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetRestoringDocument(bool *aRestoring)
michael@0: {
michael@0:     *aRestoring = mIsRestoringDocument;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::RestorePresentation(nsISHEntry *aSHEntry, bool *aRestoring)
michael@0: {
michael@0:     NS_ASSERTION(mLoadType & LOAD_CMD_HISTORY,
michael@0:                  "RestorePresentation should only be called for history loads");
michael@0: 
michael@0:     nsCOMPtr<nsIContentViewer> viewer;
michael@0:     aSHEntry->GetContentViewer(getter_AddRefs(viewer));
michael@0: 
michael@0: #ifdef DEBUG_PAGE_CACHE
michael@0:     nsCOMPtr<nsIURI> uri;
michael@0:     aSHEntry->GetURI(getter_AddRefs(uri));
michael@0: 
michael@0:     nsAutoCString spec;
michael@0:     if (uri)
michael@0:         uri->GetSpec(spec);
michael@0: #endif
michael@0: 
michael@0:     *aRestoring = false;
michael@0: 
michael@0:     if (!viewer) {
michael@0: #ifdef DEBUG_PAGE_CACHE
michael@0:         printf("no saved presentation for uri: %s\n", spec.get());
michael@0: #endif
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     // We need to make sure the content viewer's container is this docshell.
michael@0:     // In subframe navigation, it's possible for the docshell that the
michael@0:     // content viewer was originally loaded into to be replaced with a
michael@0:     // different one.  We don't currently support restoring the presentation
michael@0:     // in that case.
michael@0: 
michael@0:     nsCOMPtr<nsIDocShell> container;
michael@0:     viewer->GetContainer(getter_AddRefs(container));
michael@0:     if (!::SameCOMIdentity(container, GetAsSupports(this))) {
michael@0: #ifdef DEBUG_PAGE_CACHE
michael@0:         printf("No valid container, clearing presentation\n");
michael@0: #endif
michael@0:         aSHEntry->SetContentViewer(nullptr);
michael@0:         return NS_ERROR_FAILURE;
michael@0:     }
michael@0: 
michael@0:     NS_ASSERTION(mContentViewer != viewer, "Restoring existing presentation");
michael@0: 
michael@0: #ifdef DEBUG_PAGE_CACHE
michael@0:     printf("restoring presentation from session history: %s\n", spec.get());
michael@0: #endif
michael@0: 
michael@0:     SetHistoryEntry(&mLSHE, aSHEntry);
michael@0: 
michael@0:     // Add the request to our load group.  We do this before swapping out
michael@0:     // the content viewers so that consumers of STATE_START can access
michael@0:     // the old document.  We only deal with the toplevel load at this time --
michael@0:     // to be consistent with normal document loading, subframes cannot start
michael@0:     // loading until after data arrives, which is after STATE_START completes.
michael@0: 
michael@0:     BeginRestore(viewer, true);
michael@0: 
michael@0:     // Post an event that will remove the request after we've returned
michael@0:     // to the event loop.  This mimics the way it is called by nsIChannel
michael@0:     // implementations.
michael@0: 
michael@0:     // Revoke any pending restore (just in case)
michael@0:     NS_ASSERTION(!mRestorePresentationEvent.IsPending(),
michael@0:         "should only have one RestorePresentationEvent");
michael@0:     mRestorePresentationEvent.Revoke();
michael@0: 
michael@0:     nsRefPtr<RestorePresentationEvent> evt = new RestorePresentationEvent(this);
michael@0:     nsresult rv = NS_DispatchToCurrentThread(evt);
michael@0:     if (NS_SUCCEEDED(rv)) {
michael@0:         mRestorePresentationEvent = evt.get();
michael@0:         // The rest of the restore processing will happen on our event
michael@0:         // callback.
michael@0:         *aRestoring = true;
michael@0:     }
michael@0: 
michael@0:     return rv;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::RestoreFromHistory()
michael@0: {
michael@0:     mRestorePresentationEvent.Forget();
michael@0: 
michael@0:     // This section of code follows the same ordering as CreateContentViewer.
michael@0:     if (!mLSHE)
michael@0:         return NS_ERROR_FAILURE;
michael@0: 
michael@0:     nsCOMPtr<nsIContentViewer> viewer;
michael@0:     mLSHE->GetContentViewer(getter_AddRefs(viewer));
michael@0:     if (!viewer)
michael@0:         return NS_ERROR_FAILURE;
michael@0: 
michael@0:     if (mSavingOldViewer) {
michael@0:         // We determined that it was safe to cache the document presentation
michael@0:         // at the time we initiated the new load.  We need to check whether
michael@0:         // it's still safe to do so, since there may have been DOM mutations
michael@0:         // or new requests initiated.
michael@0:         nsCOMPtr<nsIDOMDocument> domDoc;
michael@0:         viewer->GetDOMDocument(getter_AddRefs(domDoc));
michael@0:         nsCOMPtr<nsIDocument> doc = do_QueryInterface(domDoc);
michael@0:         nsIRequest *request = nullptr;
michael@0:         if (doc)
michael@0:             request = doc->GetChannel();
michael@0:         mSavingOldViewer = CanSavePresentation(mLoadType, request, doc);
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIMarkupDocumentViewer> oldMUDV(
michael@0:         do_QueryInterface(mContentViewer));
michael@0:     nsCOMPtr<nsIMarkupDocumentViewer> newMUDV(
michael@0:         do_QueryInterface(viewer));
michael@0:     int32_t minFontSize = 0;
michael@0:     float textZoom = 1.0f;
michael@0:     float pageZoom = 1.0f;
michael@0:     bool styleDisabled = false;
michael@0:     if (oldMUDV && newMUDV) {
michael@0:         oldMUDV->GetMinFontSize(&minFontSize);
michael@0:         oldMUDV->GetTextZoom(&textZoom);
michael@0:         oldMUDV->GetFullZoom(&pageZoom);
michael@0:         oldMUDV->GetAuthorStyleDisabled(&styleDisabled);
michael@0:     }
michael@0: 
michael@0:     // Protect against mLSHE going away via a load triggered from
michael@0:     // pagehide or unload.
michael@0:     nsCOMPtr<nsISHEntry> origLSHE = mLSHE;
michael@0: 
michael@0:     // Make sure to blow away our mLoadingURI just in case.  No loads
michael@0:     // from inside this pagehide.
michael@0:     mLoadingURI = nullptr;
michael@0: 
michael@0:     // Notify the old content viewer that it's being hidden.
michael@0:     FirePageHideNotification(!mSavingOldViewer);
michael@0: 
michael@0:     // If mLSHE was changed as a result of the pagehide event, then
michael@0:     // something else was loaded.  Don't finish restoring.
michael@0:     if (mLSHE != origLSHE)
michael@0:       return NS_OK;
michael@0: 
michael@0:     // Set mFiredUnloadEvent = false so that the unload handler for the
michael@0:     // *new* document will fire.
michael@0:     mFiredUnloadEvent = false;
michael@0: 
michael@0:     mURIResultedInDocument = true;
michael@0:     nsCOMPtr<nsISHistory> rootSH;
michael@0:     GetRootSessionHistory(getter_AddRefs(rootSH));
michael@0:     if (rootSH) {
michael@0:         nsCOMPtr<nsISHistoryInternal> hist = do_QueryInterface(rootSH);
michael@0:         rootSH->GetIndex(&mPreviousTransIndex);
michael@0:         hist->UpdateIndex();
michael@0:         rootSH->GetIndex(&mLoadedTransIndex);
michael@0: #ifdef DEBUG_PAGE_CACHE
michael@0:         printf("Previous index: %d, Loaded index: %d\n\n", mPreviousTransIndex,
michael@0:                    mLoadedTransIndex);
michael@0: #endif
michael@0:     }
michael@0: 
michael@0:     // Rather than call Embed(), we will retrieve the viewer from the session
michael@0:     // history entry and swap it in.
michael@0:     // XXX can we refactor this so that we can just call Embed()?
michael@0:     PersistLayoutHistoryState();
michael@0:     nsresult rv;
michael@0:     if (mContentViewer) {
michael@0:         if (mSavingOldViewer && NS_FAILED(CaptureState())) {
michael@0:             if (mOSHE) {
michael@0:                 mOSHE->SyncPresentationState();
michael@0:             }
michael@0:             mSavingOldViewer = false;
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     mSavedRefreshURIList = nullptr;
michael@0: 
michael@0:     // In cases where we use a transient about:blank viewer between loads,
michael@0:     // we never show the transient viewer, so _its_ previous viewer is never
michael@0:     // unhooked from the view hierarchy.  Destroy any such previous viewer now,
michael@0:     // before we grab the root view sibling, so that we don't grab a view
michael@0:     // that's about to go away.
michael@0: 
michael@0:     if (mContentViewer) {
michael@0:         nsCOMPtr<nsIContentViewer> previousViewer;
michael@0:         mContentViewer->GetPreviousViewer(getter_AddRefs(previousViewer));
michael@0:         if (previousViewer) {
michael@0:             mContentViewer->SetPreviousViewer(nullptr);
michael@0:             previousViewer->Destroy();
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // Save off the root view's parent and sibling so that we can insert the
michael@0:     // new content viewer's root view at the same position.  Also save the
michael@0:     // bounds of the root view's widget.
michael@0: 
michael@0:     nsView *rootViewSibling = nullptr, *rootViewParent = nullptr;
michael@0:     nsIntRect newBounds(0, 0, 0, 0);
michael@0: 
michael@0:     nsCOMPtr<nsIPresShell> oldPresShell = GetPresShell();
michael@0:     if (oldPresShell) {
michael@0:         nsViewManager *vm = oldPresShell->GetViewManager();
michael@0:         if (vm) {
michael@0:             nsView *oldRootView = vm->GetRootView();
michael@0: 
michael@0:             if (oldRootView) {
michael@0:                 rootViewSibling = oldRootView->GetNextSibling();
michael@0:                 rootViewParent = oldRootView->GetParent();
michael@0: 
michael@0:                 mContentViewer->GetBounds(newBounds);
michael@0:             }
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIContent> container;
michael@0:     nsCOMPtr<nsIDocument> sibling;
michael@0:     if (rootViewParent && rootViewParent->GetParent()) {
michael@0:         nsIFrame* frame = rootViewParent->GetParent()->GetFrame();
michael@0:         container = frame ? frame->GetContent() : nullptr;
michael@0:     }
michael@0:     if (rootViewSibling) {
michael@0:         nsIFrame *frame = rootViewSibling->GetFrame();
michael@0:         sibling = frame ? frame->PresContext()->PresShell()->GetDocument() : nullptr;
michael@0:     }
michael@0: 
michael@0:     // Transfer ownership to mContentViewer.  By ensuring that either the
michael@0:     // docshell or the session history, but not both, have references to the
michael@0:     // content viewer, we prevent the viewer from being torn down after
michael@0:     // Destroy() is called.
michael@0: 
michael@0:     if (mContentViewer) {
michael@0:         mContentViewer->Close(mSavingOldViewer ? mOSHE.get() : nullptr);
michael@0:         viewer->SetPreviousViewer(mContentViewer);
michael@0:     }
michael@0:     if (mOSHE && (!mContentViewer || !mSavingOldViewer)) {
michael@0:         // We don't plan to save a viewer in mOSHE; tell it to drop
michael@0:         // any other state it's holding.
michael@0:         mOSHE->SyncPresentationState();
michael@0:     }
michael@0: 
michael@0:     // Order the mContentViewer setup just like Embed does.
michael@0:     mContentViewer = nullptr;
michael@0: 
michael@0:     // Now that we're about to switch documents, forget all of our children.
michael@0:     // Note that we cached them as needed up in CaptureState above.
michael@0:     DestroyChildren();
michael@0: 
michael@0:     mContentViewer.swap(viewer);
michael@0: 
michael@0:     // Grab all of the related presentation from the SHEntry now.
michael@0:     // Clearing the viewer from the SHEntry will clear all of this state.
michael@0:     nsCOMPtr<nsISupports> windowState;
michael@0:     mLSHE->GetWindowState(getter_AddRefs(windowState));
michael@0:     mLSHE->SetWindowState(nullptr);
michael@0: 
michael@0:     bool sticky;
michael@0:     mLSHE->GetSticky(&sticky);
michael@0: 
michael@0:     nsCOMPtr<nsIDOMDocument> domDoc;
michael@0:     mContentViewer->GetDOMDocument(getter_AddRefs(domDoc));
michael@0: 
michael@0:     nsCOMArray<nsIDocShellTreeItem> childShells;
michael@0:     int32_t i = 0;
michael@0:     nsCOMPtr<nsIDocShellTreeItem> child;
michael@0:     while (NS_SUCCEEDED(mLSHE->ChildShellAt(i++, getter_AddRefs(child))) &&
michael@0:            child) {
michael@0:         childShells.AppendObject(child);
michael@0:     }
michael@0: 
michael@0:     // get the previous content viewer size
michael@0:     nsIntRect oldBounds(0, 0, 0, 0);
michael@0:     mLSHE->GetViewerBounds(oldBounds);
michael@0: 
michael@0:     // Restore the refresh URI list.  The refresh timers will be restarted
michael@0:     // when EndPageLoad() is called.
michael@0:     nsCOMPtr<nsISupportsArray> refreshURIList;
michael@0:     mLSHE->GetRefreshURIList(getter_AddRefs(refreshURIList));
michael@0: 
michael@0:     // Reattach to the window object.
michael@0:     mIsRestoringDocument = true; // for MediaDocument::BecomeInteractive
michael@0:     rv = mContentViewer->Open(windowState, mLSHE);
michael@0:     mIsRestoringDocument = false;
michael@0: 
michael@0:     // Hack to keep nsDocShellEditorData alive across the
michael@0:     // SetContentViewer(nullptr) call below.
michael@0:     nsAutoPtr<nsDocShellEditorData> data(mLSHE->ForgetEditorData());
michael@0: 
michael@0:     // Now remove it from the cached presentation.
michael@0:     mLSHE->SetContentViewer(nullptr);
michael@0:     mEODForCurrentDocument = false;
michael@0: 
michael@0:     mLSHE->SetEditorData(data.forget());
michael@0: 
michael@0: #ifdef DEBUG
michael@0:  {
michael@0:      nsCOMPtr<nsISupportsArray> refreshURIs;
michael@0:      mLSHE->GetRefreshURIList(getter_AddRefs(refreshURIs));
michael@0:      nsCOMPtr<nsIDocShellTreeItem> childShell;
michael@0:      mLSHE->ChildShellAt(0, getter_AddRefs(childShell));
michael@0:      NS_ASSERTION(!refreshURIs && !childShell,
michael@0:                   "SHEntry should have cleared presentation state");
michael@0:  }
michael@0: #endif
michael@0: 
michael@0:     // Restore the sticky state of the viewer.  The viewer has set this state
michael@0:     // on the history entry in Destroy() just before marking itself non-sticky,
michael@0:     // to avoid teardown of the presentation.
michael@0:     mContentViewer->SetSticky(sticky);
michael@0: 
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     // mLSHE is now our currently-loaded document.
michael@0:     SetHistoryEntry(&mOSHE, mLSHE);
michael@0: 
michael@0:     // XXX special wyciwyg handling in Embed()?
michael@0: 
michael@0:     // We aren't going to restore any items from the LayoutHistoryState,
michael@0:     // but we don't want them to stay around in case the page is reloaded.
michael@0:     SetLayoutHistoryState(nullptr);
michael@0: 
michael@0:     // This is the end of our Embed() replacement
michael@0: 
michael@0:     mSavingOldViewer = false;
michael@0:     mEODForCurrentDocument = false;
michael@0: 
michael@0:     // Tell the event loop to favor plevents over user events, see comments
michael@0:     // in CreateContentViewer.
michael@0:     if (++gNumberOfDocumentsLoading == 1)
michael@0:         FavorPerformanceHint(true);
michael@0: 
michael@0: 
michael@0:     if (oldMUDV && newMUDV) {
michael@0:         newMUDV->SetMinFontSize(minFontSize);
michael@0:         newMUDV->SetTextZoom(textZoom);
michael@0:         newMUDV->SetFullZoom(pageZoom);
michael@0:         newMUDV->SetAuthorStyleDisabled(styleDisabled);
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIDocument> document = do_QueryInterface(domDoc);
michael@0:     uint32_t parentSuspendCount = 0;
michael@0:     if (document) {
michael@0:         nsCOMPtr<nsIDocShellTreeItem> parent;
michael@0:         GetParent(getter_AddRefs(parent));
michael@0:         nsCOMPtr<nsIDocument> d = do_GetInterface(parent);
michael@0:         if (d) {
michael@0:             if (d->EventHandlingSuppressed()) {
michael@0:                 document->SuppressEventHandling(nsIDocument::eEvents,
michael@0:                                                 d->EventHandlingSuppressed());
michael@0:             }
michael@0: 
michael@0:             // Ick, it'd be nicer to not rewalk all of the subdocs here.
michael@0:             if (d->AnimationsPaused()) {
michael@0:                 document->SuppressEventHandling(nsIDocument::eAnimationsOnly,
michael@0:                                                 d->AnimationsPaused());
michael@0:             }
michael@0: 
michael@0:             nsCOMPtr<nsPIDOMWindow> parentWindow = d->GetWindow();
michael@0:             if (parentWindow) {
michael@0:                 parentSuspendCount = parentWindow->TimeoutSuspendCount();
michael@0:             }
michael@0:         }
michael@0: 
michael@0:         // Use the uri from the mLSHE we had when we entered this function
michael@0:         // (which need not match the document's URI if anchors are involved),
michael@0:         // since that's the history entry we're loading.  Note that if we use
michael@0:         // origLSHE we don't have to worry about whether the entry in question
michael@0:         // is still mLSHE or whether it's now mOSHE.
michael@0:         nsCOMPtr<nsIURI> uri;
michael@0:         origLSHE->GetURI(getter_AddRefs(uri));
michael@0:         SetCurrentURI(uri, document->GetChannel(), true, 0);
michael@0:     }
michael@0: 
michael@0:     // This is the end of our CreateContentViewer() replacement.
michael@0:     // Now we simulate a load.  First, we restore the state of the javascript
michael@0:     // window object.
michael@0:     nsCOMPtr<nsPIDOMWindow> privWin =
michael@0:         do_GetInterface(static_cast<nsIInterfaceRequestor*>(this));
michael@0:     NS_ASSERTION(privWin, "could not get nsPIDOMWindow interface");
michael@0: 
michael@0:     rv = privWin->RestoreWindowState(windowState);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     // Now, dispatch a title change event which would happen as the
michael@0:     // <head> is parsed.
michael@0:     document->NotifyPossibleTitleChange(false);
michael@0: 
michael@0:     // Now we simulate appending child docshells for subframes.
michael@0:     for (i = 0; i < childShells.Count(); ++i) {
michael@0:         nsIDocShellTreeItem *childItem = childShells.ObjectAt(i);
michael@0:         nsCOMPtr<nsIDocShell> childShell = do_QueryInterface(childItem);
michael@0: 
michael@0:         // Make sure to not clobber the state of the child.  Since AddChild
michael@0:         // always clobbers it, save it off first.
michael@0:         bool allowPlugins;
michael@0:         childShell->GetAllowPlugins(&allowPlugins);
michael@0: 
michael@0:         bool allowJavascript;
michael@0:         childShell->GetAllowJavascript(&allowJavascript);
michael@0: 
michael@0:         bool allowRedirects;
michael@0:         childShell->GetAllowMetaRedirects(&allowRedirects);
michael@0: 
michael@0:         bool allowSubframes;
michael@0:         childShell->GetAllowSubframes(&allowSubframes);
michael@0: 
michael@0:         bool allowImages;
michael@0:         childShell->GetAllowImages(&allowImages);
michael@0: 
michael@0:         bool allowMedia = childShell->GetAllowMedia();
michael@0: 
michael@0:         bool allowDNSPrefetch;
michael@0:         childShell->GetAllowDNSPrefetch(&allowDNSPrefetch);
michael@0: 
michael@0:         bool allowContentRetargeting = childShell->GetAllowContentRetargeting();
michael@0: 
michael@0:         uint32_t defaultLoadFlags;
michael@0:         childShell->GetDefaultLoadFlags(&defaultLoadFlags);
michael@0: 
michael@0:         // this.AddChild(child) calls child.SetDocLoaderParent(this), meaning
michael@0:         // that the child inherits our state. Among other things, this means
michael@0:         // that the child inherits our mIsActive and mInPrivateBrowsing, which
michael@0:         // is what we want.
michael@0:         AddChild(childItem);
michael@0: 
michael@0:         childShell->SetAllowPlugins(allowPlugins);
michael@0:         childShell->SetAllowJavascript(allowJavascript);
michael@0:         childShell->SetAllowMetaRedirects(allowRedirects);
michael@0:         childShell->SetAllowSubframes(allowSubframes);
michael@0:         childShell->SetAllowImages(allowImages);
michael@0:         childShell->SetAllowMedia(allowMedia);
michael@0:         childShell->SetAllowDNSPrefetch(allowDNSPrefetch);
michael@0:         childShell->SetAllowContentRetargeting(allowContentRetargeting);
michael@0:         childShell->SetDefaultLoadFlags(defaultLoadFlags);
michael@0: 
michael@0:         rv = childShell->BeginRestore(nullptr, false);
michael@0:         NS_ENSURE_SUCCESS(rv, rv);
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIPresShell> shell = GetPresShell();
michael@0: 
michael@0:     // We may be displayed on a different monitor (or in a different
michael@0:     // HiDPI mode) than when we got into the history list.  So we need
michael@0:     // to check if this has happened. See bug 838239.
michael@0: 
michael@0:     // Because the prescontext normally handles resolution changes via
michael@0:     // a runnable (see nsPresContext::UIResolutionChanged), its device
michael@0:     // context won't be -immediately- updated as a result of calling
michael@0:     // shell->BackingScaleFactorChanged().
michael@0: 
michael@0:     // But we depend on that device context when adjusting the view size
michael@0:     // via mContentViewer->SetBounds(newBounds) below. So we need to
michael@0:     // explicitly tell it to check for changed resolution here.
michael@0:     if (shell && shell->GetPresContext()->DeviceContext()->CheckDPIChange()) {
michael@0:         shell->BackingScaleFactorChanged();
michael@0:     }
michael@0: 
michael@0:     nsViewManager *newVM = shell ? shell->GetViewManager() : nullptr;
michael@0:     nsView *newRootView = newVM ? newVM->GetRootView() : nullptr;
michael@0: 
michael@0:     // Insert the new root view at the correct location in the view tree.
michael@0:     if (container) {
michael@0:         nsSubDocumentFrame* subDocFrame = do_QueryFrame(container->GetPrimaryFrame());
michael@0:         rootViewParent = subDocFrame ? subDocFrame->EnsureInnerView() : nullptr;
michael@0:     }
michael@0:     if (sibling &&
michael@0:         sibling->GetShell() &&
michael@0:         sibling->GetShell()->GetViewManager()) {
michael@0:         rootViewSibling = sibling->GetShell()->GetViewManager()->GetRootView();
michael@0:     } else {
michael@0:         rootViewSibling = nullptr;
michael@0:     }
michael@0:     if (rootViewParent && newRootView && newRootView->GetParent() != rootViewParent) {
michael@0:         nsViewManager *parentVM = rootViewParent->GetViewManager();
michael@0:         if (parentVM) {
michael@0:             // InsertChild(parent, child, sib, true) inserts the child after
michael@0:             // sib in content order, which is before sib in view order. BUT
michael@0:             // when sib is null it inserts at the end of the the document
michael@0:             // order, i.e., first in view order.  But when oldRootSibling is
michael@0:             // null, the old root as at the end of the view list --- last in
michael@0:             // content order --- and we want to call InsertChild(parent, child,
michael@0:             // nullptr, false) in that case.
michael@0:             parentVM->InsertChild(rootViewParent, newRootView,
michael@0:                                   rootViewSibling,
michael@0:                                   rootViewSibling ? true : false);
michael@0: 
michael@0:             NS_ASSERTION(newRootView->GetNextSibling() == rootViewSibling,
michael@0:                          "error in InsertChild");
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // If parent is suspended, increase suspension count.
michael@0:     // This can't be done as early as event suppression since this
michael@0:     // depends on docshell tree.
michael@0:     if (parentSuspendCount) {
michael@0:       privWin->SuspendTimeouts(parentSuspendCount, false);
michael@0:     }
michael@0: 
michael@0:     // Now that all of the child docshells have been put into place, we can
michael@0:     // restart the timers for the window and all of the child frames.
michael@0:     privWin->ResumeTimeouts();
michael@0: 
michael@0:     // Restore the refresh URI list.  The refresh timers will be restarted
michael@0:     // when EndPageLoad() is called.
michael@0:     mRefreshURIList = refreshURIList;
michael@0: 
michael@0:     // Meta-refresh timers have been restarted for this shell, but not
michael@0:     // for our children.  Walk the child shells and restart their timers.
michael@0:     nsTObserverArray<nsDocLoader*>::ForwardIterator iter(mChildList);
michael@0:     while (iter.HasMore()) {
michael@0:         nsCOMPtr<nsIDocShell> child = do_QueryObject(iter.GetNext());
michael@0:         if (child)
michael@0:             child->ResumeRefreshURIs();
michael@0:     }
michael@0: 
michael@0:     // Make sure this presentation is the same size as the previous
michael@0:     // presentation.  If this is not the same size we showed it at last time,
michael@0:     // then we need to resize the widget.
michael@0: 
michael@0:     // XXXbryner   This interacts poorly with Firefox's infobar.  If the old
michael@0:     // presentation had the infobar visible, then we will resize the new
michael@0:     // presentation to that smaller size.  However, firing the locationchanged
michael@0:     // event will hide the infobar, which will immediately resize the window
michael@0:     // back to the larger size.  A future optimization might be to restore
michael@0:     // the presentation at the "wrong" size, then fire the locationchanged
michael@0:     // event and check whether the docshell's new size is the same as the
michael@0:     // cached viewer size (skipping the resize if they are equal).
michael@0: 
michael@0:     if (newRootView) {
michael@0:         if (!newBounds.IsEmpty() && !newBounds.IsEqualEdges(oldBounds)) {
michael@0: #ifdef DEBUG_PAGE_CACHE
michael@0:             printf("resize widget(%d, %d, %d, %d)\n", newBounds.x,
michael@0:                    newBounds.y, newBounds.width, newBounds.height);
michael@0: #endif
michael@0:             mContentViewer->SetBounds(newBounds);
michael@0:         } else {
michael@0:             nsIScrollableFrame *rootScrollFrame =
michael@0:               shell->GetRootScrollFrameAsScrollableExternal();
michael@0:             if (rootScrollFrame) {
michael@0:                 rootScrollFrame->PostScrolledAreaEventForCurrentArea();
michael@0:             }
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // The FinishRestore call below can kill these, null them out so we don't
michael@0:     // have invalid pointer lying around.
michael@0:     newRootView = rootViewSibling = rootViewParent = nullptr;
michael@0:     newVM = nullptr;
michael@0: 
michael@0:     // Simulate the completion of the load.
michael@0:     nsDocShell::FinishRestore();
michael@0: 
michael@0:     // Restart plugins, and paint the content.
michael@0:     if (shell) {
michael@0:         shell->Thaw();
michael@0:     }
michael@0: 
michael@0:     return privWin->FireDelayedDOMEvents();
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::CreateContentViewer(const char *aContentType,
michael@0:                                 nsIRequest * request,
michael@0:                                 nsIStreamListener ** aContentHandler)
michael@0: {
michael@0:     *aContentHandler = nullptr;
michael@0: 
michael@0:     // Can we check the content type of the current content viewer
michael@0:     // and reuse it without destroying it and re-creating it?
michael@0: 
michael@0:     NS_ASSERTION(mLoadGroup, "Someone ignored return from Init()?");
michael@0: 
michael@0:     // Instantiate the content viewer object
michael@0:     nsCOMPtr<nsIContentViewer> viewer;
michael@0:     nsresult rv = NewContentViewerObj(aContentType, request, mLoadGroup,
michael@0:                                       aContentHandler, getter_AddRefs(viewer));
michael@0: 
michael@0:     if (NS_FAILED(rv))
michael@0:         return rv;
michael@0: 
michael@0:     // Notify the current document that it is about to be unloaded!!
michael@0:     //
michael@0:     // It is important to fire the unload() notification *before* any state
michael@0:     // is changed within the DocShell - otherwise, javascript will get the
michael@0:     // wrong information :-(
michael@0:     //
michael@0: 
michael@0:     if (mSavingOldViewer) {
michael@0:         // We determined that it was safe to cache the document presentation
michael@0:         // at the time we initiated the new load.  We need to check whether
michael@0:         // it's still safe to do so, since there may have been DOM mutations
michael@0:         // or new requests initiated.
michael@0:         nsCOMPtr<nsIDOMDocument> domDoc;
michael@0:         viewer->GetDOMDocument(getter_AddRefs(domDoc));
michael@0:         nsCOMPtr<nsIDocument> doc = do_QueryInterface(domDoc);
michael@0:         mSavingOldViewer = CanSavePresentation(mLoadType, request, doc);
michael@0:     }
michael@0: 
michael@0:     NS_ASSERTION(!mLoadingURI, "Re-entering unload?");
michael@0:     
michael@0:     nsCOMPtr<nsIChannel> aOpenedChannel = do_QueryInterface(request);
michael@0:     if (aOpenedChannel) {
michael@0:         aOpenedChannel->GetURI(getter_AddRefs(mLoadingURI));
michael@0:     }
michael@0:     FirePageHideNotification(!mSavingOldViewer);
michael@0:     mLoadingURI = nullptr;
michael@0: 
michael@0:     // Set mFiredUnloadEvent = false so that the unload handler for the
michael@0:     // *new* document will fire.
michael@0:     mFiredUnloadEvent = false;
michael@0: 
michael@0:     // we've created a new document so go ahead and call
michael@0:     // OnLoadingSite(), but don't fire OnLocationChange()
michael@0:     // notifications before we've called Embed(). See bug 284993.
michael@0:     mURIResultedInDocument = true;
michael@0: 
michael@0:     if (mLoadType == LOAD_ERROR_PAGE) {
michael@0:         // We need to set the SH entry and our current URI here and not
michael@0:         // at the moment we load the page. We want the same behavior 
michael@0:         // of Stop() as for a normal page load. See bug 514232 for details.
michael@0: 
michael@0:         // Revert mLoadType to load type to state the page load failed,
michael@0:         // following function calls need it.
michael@0:         mLoadType = mFailedLoadType;
michael@0: 
michael@0:         nsCOMPtr<nsIChannel> failedChannel = mFailedChannel;
michael@0: 
michael@0:         // Make sure we have a URI to set currentURI.
michael@0:         nsCOMPtr<nsIURI> failedURI;
michael@0:         if (failedChannel) {
michael@0:             NS_GetFinalChannelURI(failedChannel, getter_AddRefs(failedURI));
michael@0:         }
michael@0: 
michael@0:         if (!failedURI) {
michael@0:             failedURI = mFailedURI;
michael@0:         }
michael@0:         if (!failedURI) {
michael@0:             // We need a URI object to store a session history entry, so make up a URI
michael@0:             NS_NewURI(getter_AddRefs(failedURI), "about:blank");
michael@0:         }
michael@0: 
michael@0:         // When we don't have failedURI, something wrong will happen. See
michael@0:         // bug 291876.
michael@0:         MOZ_ASSERT(failedURI, "We don't have a URI for history APIs.");
michael@0: 
michael@0:         mFailedChannel = nullptr;
michael@0:         mFailedURI = nullptr;
michael@0: 
michael@0:         // Create an shistory entry for the old load.
michael@0:         if (failedURI) {
michael@0:             bool errorOnLocationChangeNeeded =
michael@0:                 OnNewURI(failedURI, failedChannel, nullptr, mLoadType, false,
michael@0:                          false, false);
michael@0: 
michael@0:             if (errorOnLocationChangeNeeded) {
michael@0:                 FireOnLocationChange(this, failedChannel, failedURI,
michael@0:                                      LOCATION_CHANGE_ERROR_PAGE);
michael@0:             }
michael@0:         }
michael@0: 
michael@0:         // Be sure to have a correct mLSHE, it may have been cleared by
michael@0:         // EndPageLoad. See bug 302115.
michael@0:         if (mSessionHistory && !mLSHE) {
michael@0:             int32_t idx;
michael@0:             mSessionHistory->GetRequestedIndex(&idx);
michael@0:             if (idx == -1)
michael@0:                 mSessionHistory->GetIndex(&idx);
michael@0:             mSessionHistory->GetEntryAtIndex(idx, false,
michael@0:                                              getter_AddRefs(mLSHE));
michael@0:         }
michael@0: 
michael@0:         mLoadType = LOAD_ERROR_PAGE;
michael@0:     }
michael@0: 
michael@0:     bool onLocationChangeNeeded = OnLoadingSite(aOpenedChannel, false);
michael@0: 
michael@0:     // let's try resetting the load group if we need to...
michael@0:     nsCOMPtr<nsILoadGroup> currentLoadGroup;
michael@0:     NS_ENSURE_SUCCESS(aOpenedChannel->
michael@0:                       GetLoadGroup(getter_AddRefs(currentLoadGroup)),
michael@0:                       NS_ERROR_FAILURE);
michael@0: 
michael@0:     if (currentLoadGroup != mLoadGroup) {
michael@0:         nsLoadFlags loadFlags = 0;
michael@0: 
michael@0:         //Cancel any URIs that are currently loading...
michael@0:         /// XXX: Need to do this eventually      Stop();
michael@0:         //
michael@0:         // Retarget the document to this loadgroup...
michael@0:         //
michael@0:         /* First attach the channel to the right loadgroup
michael@0:          * and then remove from the old loadgroup. This 
michael@0:          * puts the notifications in the right order and
michael@0:          * we don't null-out mLSHE in OnStateChange() for 
michael@0:          * all redirected urls
michael@0:          */
michael@0:         aOpenedChannel->SetLoadGroup(mLoadGroup);
michael@0: 
michael@0:         // Mark the channel as being a document URI...
michael@0:         aOpenedChannel->GetLoadFlags(&loadFlags);
michael@0:         loadFlags |= nsIChannel::LOAD_DOCUMENT_URI;
michael@0: 
michael@0:         aOpenedChannel->SetLoadFlags(loadFlags);
michael@0: 
michael@0:         mLoadGroup->AddRequest(request, nullptr);
michael@0:         if (currentLoadGroup)
michael@0:             currentLoadGroup->RemoveRequest(request, nullptr,
michael@0:                                             NS_BINDING_RETARGETED);
michael@0: 
michael@0:         // Update the notification callbacks, so that progress and
michael@0:         // status information are sent to the right docshell...
michael@0:         aOpenedChannel->SetNotificationCallbacks(this);
michael@0:     }
michael@0: 
michael@0:     NS_ENSURE_SUCCESS(Embed(viewer, "", (nsISupports *) nullptr),
michael@0:                       NS_ERROR_FAILURE);
michael@0: 
michael@0:     mSavedRefreshURIList = nullptr;
michael@0:     mSavingOldViewer = false;
michael@0:     mEODForCurrentDocument = false;
michael@0: 
michael@0:     // if this document is part of a multipart document,
michael@0:     // the ID can be used to distinguish it from the other parts.
michael@0:     nsCOMPtr<nsIMultiPartChannel> multiPartChannel(do_QueryInterface(request));
michael@0:     if (multiPartChannel) {
michael@0:       nsCOMPtr<nsIPresShell> shell = GetPresShell();
michael@0:       if (NS_SUCCEEDED(rv) && shell) {
michael@0:         nsIDocument *doc = shell->GetDocument();
michael@0:         if (doc) {
michael@0:           uint32_t partID;
michael@0:           multiPartChannel->GetPartID(&partID);
michael@0:           doc->SetPartID(partID);
michael@0:         }
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     // Give hint to native plevent dispatch mechanism. If a document
michael@0:     // is loading the native plevent dispatch mechanism should favor
michael@0:     // performance over normal native event dispatch priorities.
michael@0:     if (++gNumberOfDocumentsLoading == 1) {
michael@0:       // Hint to favor performance for the plevent notification mechanism.
michael@0:       // We want the pages to load as fast as possible even if its means 
michael@0:       // native messages might be starved.
michael@0:       FavorPerformanceHint(true);
michael@0:     }
michael@0: 
michael@0:     if (onLocationChangeNeeded) {
michael@0:       FireOnLocationChange(this, request, mCurrentURI, 0);
michael@0:     }
michael@0:   
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::NewContentViewerObj(const char *aContentType,
michael@0:                                 nsIRequest * request, nsILoadGroup * aLoadGroup,
michael@0:                                 nsIStreamListener ** aContentHandler,
michael@0:                                 nsIContentViewer ** aViewer)
michael@0: {
michael@0:     nsCOMPtr<nsIChannel> aOpenedChannel = do_QueryInterface(request);
michael@0: 
michael@0:     nsCOMPtr<nsIDocumentLoaderFactory> docLoaderFactory =
michael@0:         nsContentUtils::FindInternalContentViewer(aContentType);
michael@0:     if (!docLoaderFactory) {
michael@0:         return NS_ERROR_FAILURE;
michael@0:     }
michael@0: 
michael@0:     // Now create an instance of the content viewer
michael@0:     // nsLayoutDLF makes the determination if it should be a "view-source" instead of "view"
michael@0:     nsresult rv = docLoaderFactory->CreateInstance("view",
michael@0:                                                    aOpenedChannel,
michael@0:                                                    aLoadGroup, aContentType,
michael@0:                                                    this,
michael@0:                                                    nullptr,
michael@0:                                                    aContentHandler,
michael@0:                                                    aViewer);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     (*aViewer)->SetContainer(this);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetupNewViewer(nsIContentViewer * aNewViewer)
michael@0: {
michael@0:     //
michael@0:     // Copy content viewer state from previous or parent content viewer.
michael@0:     //
michael@0:     // The following logic is mirrored in nsHTMLDocument::StartDocumentLoad!
michael@0:     //
michael@0:     // Do NOT to maintain a reference to the old content viewer outside
michael@0:     // of this "copying" block, or it will not be destroyed until the end of
michael@0:     // this routine and all <SCRIPT>s and event handlers fail! (bug 20315)
michael@0:     //
michael@0:     // In this block of code, if we get an error result, we return it
michael@0:     // but if we get a null pointer, that's perfectly legal for parent
michael@0:     // and parentContentViewer.
michael@0:     //
michael@0: 
michael@0:     int32_t x = 0;
michael@0:     int32_t y = 0;
michael@0:     int32_t cx = 0;
michael@0:     int32_t cy = 0;
michael@0: 
michael@0:     // This will get the size from the current content viewer or from the
michael@0:     // Init settings
michael@0:     DoGetPositionAndSize(&x, &y, &cx, &cy);
michael@0: 
michael@0:     nsCOMPtr<nsIDocShellTreeItem> parentAsItem;
michael@0:     NS_ENSURE_SUCCESS(GetSameTypeParent(getter_AddRefs(parentAsItem)),
michael@0:                       NS_ERROR_FAILURE);
michael@0:     nsCOMPtr<nsIDocShell> parent(do_QueryInterface(parentAsItem));
michael@0: 
michael@0:     nsAutoCString forceCharset;
michael@0:     nsAutoCString hintCharset;
michael@0:     int32_t hintCharsetSource;
michael@0:     int32_t minFontSize;
michael@0:     float textZoom;
michael@0:     float pageZoom;
michael@0:     bool styleDisabled;
michael@0:     // |newMUDV| also serves as a flag to set the data from the above vars
michael@0:     nsCOMPtr<nsIMarkupDocumentViewer> newMUDV;
michael@0: 
michael@0:     if (mContentViewer || parent) {
michael@0:         nsCOMPtr<nsIMarkupDocumentViewer> oldMUDV;
michael@0:         if (mContentViewer) {
michael@0:             // Get any interesting state from old content viewer
michael@0:             // XXX: it would be far better to just reuse the document viewer ,
michael@0:             //      since we know we're just displaying the same document as before
michael@0:             oldMUDV = do_QueryInterface(mContentViewer);
michael@0: 
michael@0:             // Tell the old content viewer to hibernate in session history when
michael@0:             // it is destroyed.
michael@0: 
michael@0:             if (mSavingOldViewer && NS_FAILED(CaptureState())) {
michael@0:                 if (mOSHE) {
michael@0:                     mOSHE->SyncPresentationState();
michael@0:                 }
michael@0:                 mSavingOldViewer = false;
michael@0:             }
michael@0:         }
michael@0:         else {
michael@0:             // No old content viewer, so get state from parent's content viewer
michael@0:             nsCOMPtr<nsIContentViewer> parentContentViewer;
michael@0:             parent->GetContentViewer(getter_AddRefs(parentContentViewer));
michael@0:             oldMUDV = do_QueryInterface(parentContentViewer);
michael@0:         }
michael@0: 
michael@0:         if (oldMUDV) {
michael@0:             nsresult rv;
michael@0: 
michael@0:             newMUDV = do_QueryInterface(aNewViewer,&rv);
michael@0:             if (newMUDV) {
michael@0:                 NS_ENSURE_SUCCESS(oldMUDV->
michael@0:                                   GetForceCharacterSet(forceCharset),
michael@0:                                   NS_ERROR_FAILURE);
michael@0:                 NS_ENSURE_SUCCESS(oldMUDV->
michael@0:                                   GetHintCharacterSet(hintCharset),
michael@0:                                   NS_ERROR_FAILURE);
michael@0:                 NS_ENSURE_SUCCESS(oldMUDV->
michael@0:                                   GetHintCharacterSetSource(&hintCharsetSource),
michael@0:                                   NS_ERROR_FAILURE);
michael@0:                 NS_ENSURE_SUCCESS(oldMUDV->
michael@0:                                   GetMinFontSize(&minFontSize),
michael@0:                                   NS_ERROR_FAILURE);
michael@0:                 NS_ENSURE_SUCCESS(oldMUDV->
michael@0:                                   GetTextZoom(&textZoom),
michael@0:                                   NS_ERROR_FAILURE);
michael@0:                 NS_ENSURE_SUCCESS(oldMUDV->
michael@0:                                   GetFullZoom(&pageZoom),
michael@0:                                   NS_ERROR_FAILURE);
michael@0:                 NS_ENSURE_SUCCESS(oldMUDV->
michael@0:                                   GetAuthorStyleDisabled(&styleDisabled),
michael@0:                                   NS_ERROR_FAILURE);
michael@0:             }
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     nscolor bgcolor = NS_RGBA(0, 0, 0, 0);
michael@0:     // Ensure that the content viewer is destroyed *after* the GC - bug 71515
michael@0:     nsCOMPtr<nsIContentViewer> kungfuDeathGrip = mContentViewer;
michael@0:     if (mContentViewer) {
michael@0:         // Stop any activity that may be happening in the old document before
michael@0:         // releasing it...
michael@0:         mContentViewer->Stop();
michael@0: 
michael@0:         // Try to extract the canvas background color from the old
michael@0:         // presentation shell, so we can use it for the next document.
michael@0:         nsCOMPtr<nsIPresShell> shell;
michael@0:         mContentViewer->GetPresShell(getter_AddRefs(shell));
michael@0: 
michael@0:         if (shell) {
michael@0:             bgcolor = shell->GetCanvasBackground();
michael@0:         }
michael@0: 
michael@0:         mContentViewer->Close(mSavingOldViewer ? mOSHE.get() : nullptr);
michael@0:         aNewViewer->SetPreviousViewer(mContentViewer);
michael@0:     }
michael@0:     if (mOSHE && (!mContentViewer || !mSavingOldViewer)) {
michael@0:         // We don't plan to save a viewer in mOSHE; tell it to drop
michael@0:         // any other state it's holding.
michael@0:         mOSHE->SyncPresentationState();
michael@0:     }
michael@0: 
michael@0:     mContentViewer = nullptr;
michael@0: 
michael@0:     // Now that we're about to switch documents, forget all of our children.
michael@0:     // Note that we cached them as needed up in CaptureState above.
michael@0:     DestroyChildren();
michael@0: 
michael@0:     mContentViewer = aNewViewer;
michael@0: 
michael@0:     nsCOMPtr<nsIWidget> widget;
michael@0:     NS_ENSURE_SUCCESS(GetMainWidget(getter_AddRefs(widget)), NS_ERROR_FAILURE);
michael@0: 
michael@0:     nsIntRect bounds(x, y, cx, cy);
michael@0: 
michael@0:     mContentViewer->SetNavigationTiming(mTiming);
michael@0: 
michael@0:     if (NS_FAILED(mContentViewer->Init(widget, bounds))) {
michael@0:         mContentViewer = nullptr;
michael@0:         NS_ERROR("ContentViewer Initialization failed");
michael@0:         return NS_ERROR_FAILURE;
michael@0:     }
michael@0: 
michael@0:     // If we have old state to copy, set the old state onto the new content
michael@0:     // viewer
michael@0:     if (newMUDV) {
michael@0:         NS_ENSURE_SUCCESS(newMUDV->SetForceCharacterSet(forceCharset),
michael@0:                           NS_ERROR_FAILURE);
michael@0:         NS_ENSURE_SUCCESS(newMUDV->SetHintCharacterSet(hintCharset),
michael@0:                           NS_ERROR_FAILURE);
michael@0:         NS_ENSURE_SUCCESS(newMUDV->
michael@0:                           SetHintCharacterSetSource(hintCharsetSource),
michael@0:                           NS_ERROR_FAILURE);
michael@0:         NS_ENSURE_SUCCESS(newMUDV->SetMinFontSize(minFontSize),
michael@0:                           NS_ERROR_FAILURE);
michael@0:         NS_ENSURE_SUCCESS(newMUDV->SetTextZoom(textZoom),
michael@0:                           NS_ERROR_FAILURE);
michael@0:         NS_ENSURE_SUCCESS(newMUDV->SetFullZoom(pageZoom),
michael@0:                           NS_ERROR_FAILURE);
michael@0:         NS_ENSURE_SUCCESS(newMUDV->SetAuthorStyleDisabled(styleDisabled),
michael@0:                           NS_ERROR_FAILURE);
michael@0:     }
michael@0: 
michael@0:     // Stuff the bgcolor from the old pres shell into the new
michael@0:     // pres shell. This improves page load continuity.
michael@0:     nsCOMPtr<nsIPresShell> shell;
michael@0:     mContentViewer->GetPresShell(getter_AddRefs(shell));
michael@0: 
michael@0:     if (shell) {
michael@0:         shell->SetCanvasBackground(bgcolor);
michael@0:     }
michael@0: 
michael@0: // XXX: It looks like the LayoutState gets restored again in Embed()
michael@0: //      right after the call to SetupNewViewer(...)
michael@0: 
michael@0:     // We don't show the mContentViewer yet, since we want to draw the old page
michael@0:     // until we have enough of the new page to show.  Just return with the new
michael@0:     // viewer still set to hidden.
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::SetDocCurrentStateObj(nsISHEntry *shEntry)
michael@0: {
michael@0:     nsCOMPtr<nsIDocument> document = do_GetInterface(GetAsSupports(this));
michael@0:     NS_ENSURE_TRUE(document, NS_ERROR_FAILURE);
michael@0: 
michael@0:     nsCOMPtr<nsIStructuredCloneContainer> scContainer;
michael@0:     if (shEntry) {
michael@0:         nsresult rv = shEntry->GetStateData(getter_AddRefs(scContainer));
michael@0:         NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:         // If shEntry is null, just set the document's state object to null.
michael@0:     }
michael@0: 
michael@0:     // It's OK for scContainer too be null here; that just means there's no
michael@0:     // state data associated with this history entry.
michael@0:     document->SetStateObject(scContainer);
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::CheckLoadingPermissions()
michael@0: {
michael@0:     // This method checks whether the caller may load content into
michael@0:     // this docshell. Even though we've done our best to hide windows
michael@0:     // from code that doesn't have the right to access them, it's
michael@0:     // still possible for an evil site to open a window and access
michael@0:     // frames in the new window through window.frames[] (which is
michael@0:     // allAccess for historic reasons), so we still need to do this
michael@0:     // check on load.
michael@0:     nsresult rv = NS_OK, sameOrigin = NS_OK;
michael@0: 
michael@0:     if (!gValidateOrigin || !IsFrame()) {
michael@0:         // Origin validation was turned off, or we're not a frame.
michael@0:         // Permit all loads.
michael@0: 
michael@0:         return rv;
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIScriptSecurityManager> securityManager =
michael@0:       do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID, &rv);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     // We're a frame. Check that the caller has write permission to
michael@0:     // the parent before allowing it to load anything into this
michael@0:     // docshell.
michael@0:     nsCOMPtr<nsIPrincipal> subjPrincipal;
michael@0:     rv = securityManager->GetSubjectPrincipal(getter_AddRefs(subjPrincipal));
michael@0:     NS_ENSURE_TRUE(NS_SUCCEEDED(rv) && subjPrincipal, rv);
michael@0: 
michael@0:     // Check if the caller is from the same origin as this docshell,
michael@0:     // or any of its ancestors.
michael@0:     nsCOMPtr<nsIDocShellTreeItem> item(this);
michael@0:     do {
michael@0:         nsCOMPtr<nsIScriptGlobalObject> sgo(do_GetInterface(item));
michael@0:         nsCOMPtr<nsIScriptObjectPrincipal> sop(do_QueryInterface(sgo));
michael@0: 
michael@0:         nsIPrincipal *p;
michael@0:         if (!sop || !(p = sop->GetPrincipal())) {
michael@0:             return NS_ERROR_UNEXPECTED;
michael@0:         }
michael@0: 
michael@0:         // Compare origins
michael@0:         bool subsumes;
michael@0:         sameOrigin = subjPrincipal->Subsumes(p, &subsumes);
michael@0:         if (NS_SUCCEEDED(sameOrigin)) {
michael@0:             if (subsumes) {
michael@0:                 // Same origin, permit load
michael@0: 
michael@0:                 return sameOrigin;
michael@0:             }
michael@0: 
michael@0:             sameOrigin = NS_ERROR_DOM_PROP_ACCESS_DENIED;
michael@0:         }
michael@0: 
michael@0:         nsCOMPtr<nsIDocShellTreeItem> tmp;
michael@0:         item->GetSameTypeParent(getter_AddRefs(tmp));
michael@0:         item.swap(tmp);
michael@0:     } while (item);
michael@0: 
michael@0:     return sameOrigin;
michael@0: }
michael@0: 
michael@0: //*****************************************************************************
michael@0: // nsDocShell: Site Loading
michael@0: //*****************************************************************************   
michael@0: namespace
michael@0: {
michael@0: 
michael@0: #ifdef MOZ_PLACES
michael@0: // Callback used by CopyFavicon to inform the favicon service that one URI
michael@0: // (mNewURI) has the same favicon URI (OnComplete's aFaviconURI) as another.
michael@0: class nsCopyFaviconCallback MOZ_FINAL : public nsIFaviconDataCallback
michael@0: {
michael@0: public:
michael@0:     NS_DECL_ISUPPORTS
michael@0: 
michael@0:     nsCopyFaviconCallback(nsIURI *aNewURI, bool aInPrivateBrowsing)
michael@0:       : mNewURI(aNewURI)
michael@0:       , mInPrivateBrowsing(aInPrivateBrowsing)
michael@0:     {
michael@0:     }
michael@0: 
michael@0:     NS_IMETHODIMP
michael@0:     OnComplete(nsIURI *aFaviconURI, uint32_t aDataLen,
michael@0:                const uint8_t *aData, const nsACString &aMimeType)
michael@0:     {
michael@0:         // Continue only if there is an associated favicon.
michael@0:         if (!aFaviconURI) {
michael@0:           return NS_OK;
michael@0:         }
michael@0: 
michael@0:         NS_ASSERTION(aDataLen == 0,
michael@0:                      "We weren't expecting the callback to deliver data.");
michael@0:         nsCOMPtr<mozIAsyncFavicons> favSvc =
michael@0:             do_GetService("@mozilla.org/browser/favicon-service;1");
michael@0:         NS_ENSURE_STATE(favSvc);
michael@0: 
michael@0:         return favSvc->SetAndFetchFaviconForPage(mNewURI, aFaviconURI,
michael@0:                                                  false,
michael@0:                                                  mInPrivateBrowsing ?
michael@0:                                                    nsIFaviconService::FAVICON_LOAD_PRIVATE :
michael@0:                                                    nsIFaviconService::FAVICON_LOAD_NON_PRIVATE,
michael@0:                                                  nullptr);
michael@0:     }
michael@0: 
michael@0: private:
michael@0:     nsCOMPtr<nsIURI> mNewURI;
michael@0:     bool mInPrivateBrowsing;
michael@0: };
michael@0: 
michael@0: NS_IMPL_ISUPPORTS(nsCopyFaviconCallback, nsIFaviconDataCallback)
michael@0: #endif
michael@0: 
michael@0: // Tell the favicon service that aNewURI has the same favicon as aOldURI.
michael@0: void CopyFavicon(nsIURI *aOldURI, nsIURI *aNewURI, bool inPrivateBrowsing)
michael@0: {
michael@0: #ifdef MOZ_PLACES
michael@0:     nsCOMPtr<mozIAsyncFavicons> favSvc =
michael@0:         do_GetService("@mozilla.org/browser/favicon-service;1");
michael@0:     if (favSvc) {
michael@0:         nsCOMPtr<nsIFaviconDataCallback> callback =
michael@0:             new nsCopyFaviconCallback(aNewURI, inPrivateBrowsing);
michael@0:         favSvc->GetFaviconURLForPage(aOldURI, callback);
michael@0:     }
michael@0: #endif
michael@0: }
michael@0: 
michael@0: } // anonymous namespace
michael@0: 
michael@0: class InternalLoadEvent : public nsRunnable
michael@0: {
michael@0: public:
michael@0:     InternalLoadEvent(nsDocShell* aDocShell, nsIURI * aURI, nsIURI * aReferrer,
michael@0:                       nsISupports * aOwner, uint32_t aFlags,
michael@0:                       const char* aTypeHint, nsIInputStream * aPostData,
michael@0:                       nsIInputStream * aHeadersData, uint32_t aLoadType,
michael@0:                       nsISHEntry * aSHEntry, bool aFirstParty,
michael@0:                       const nsAString &aSrcdoc, nsIDocShell* aSourceDocShell,
michael@0:                       nsIURI * aBaseURI) :
michael@0:         mSrcdoc(aSrcdoc),
michael@0:         mDocShell(aDocShell),
michael@0:         mURI(aURI),
michael@0:         mReferrer(aReferrer),
michael@0:         mOwner(aOwner),
michael@0:         mPostData(aPostData),
michael@0:         mHeadersData(aHeadersData),
michael@0:         mSHEntry(aSHEntry),
michael@0:         mFlags(aFlags),
michael@0:         mLoadType(aLoadType),
michael@0:         mFirstParty(aFirstParty),
michael@0:         mSourceDocShell(aSourceDocShell),
michael@0:         mBaseURI(aBaseURI)
michael@0:     {
michael@0:         // Make sure to keep null things null as needed
michael@0:         if (aTypeHint) {
michael@0:             mTypeHint = aTypeHint;
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     NS_IMETHOD Run() {
michael@0:         return mDocShell->InternalLoad(mURI, mReferrer, mOwner, mFlags,
michael@0:                                        nullptr, mTypeHint.get(),
michael@0:                                        NullString(), mPostData, mHeadersData,
michael@0:                                        mLoadType, mSHEntry, mFirstParty,
michael@0:                                        mSrcdoc, mSourceDocShell, mBaseURI,
michael@0:                                        nullptr, nullptr);
michael@0:     }
michael@0: 
michael@0: private:
michael@0: 
michael@0:     // Use IDL strings so .get() returns null by default
michael@0:     nsXPIDLString mWindowTarget;
michael@0:     nsXPIDLCString mTypeHint;
michael@0:     nsString mSrcdoc;
michael@0: 
michael@0:     nsRefPtr<nsDocShell> mDocShell;
michael@0:     nsCOMPtr<nsIURI> mURI;
michael@0:     nsCOMPtr<nsIURI> mReferrer;
michael@0:     nsCOMPtr<nsISupports> mOwner;
michael@0:     nsCOMPtr<nsIInputStream> mPostData;
michael@0:     nsCOMPtr<nsIInputStream> mHeadersData;
michael@0:     nsCOMPtr<nsISHEntry> mSHEntry;
michael@0:     uint32_t mFlags;
michael@0:     uint32_t mLoadType;
michael@0:     bool mFirstParty;
michael@0:     nsCOMPtr<nsIDocShell> mSourceDocShell;
michael@0:     nsCOMPtr<nsIURI> mBaseURI;
michael@0: };
michael@0: 
michael@0: /**
michael@0:  * Returns true if we started an asynchronous load (i.e., from the network), but
michael@0:  * the document we're loading there hasn't yet become this docshell's active
michael@0:  * document.
michael@0:  *
michael@0:  * When JustStartedNetworkLoad is true, you should be careful about modifying
michael@0:  * mLoadType and mLSHE.  These are both set when the asynchronous load first
michael@0:  * starts, and the load expects that, when it eventually runs InternalLoad,
michael@0:  * mLoadType and mLSHE will have their original values.
michael@0:  */
michael@0: bool
michael@0: nsDocShell::JustStartedNetworkLoad()
michael@0: {
michael@0:     return mDocumentRequest &&
michael@0:            mDocumentRequest != GetCurrentDocChannel();
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::InternalLoad(nsIURI * aURI,
michael@0:                          nsIURI * aReferrer,
michael@0:                          nsISupports * aOwner,
michael@0:                          uint32_t aFlags,
michael@0:                          const char16_t *aWindowTarget,
michael@0:                          const char* aTypeHint,
michael@0:                          const nsAString& aFileName,
michael@0:                          nsIInputStream * aPostData,
michael@0:                          nsIInputStream * aHeadersData,
michael@0:                          uint32_t aLoadType,
michael@0:                          nsISHEntry * aSHEntry,
michael@0:                          bool aFirstParty,
michael@0:                          const nsAString &aSrcdoc,
michael@0:                          nsIDocShell* aSourceDocShell,
michael@0:                          nsIURI* aBaseURI,
michael@0:                          nsIDocShell** aDocShell,
michael@0:                          nsIRequest** aRequest)
michael@0: {
michael@0:     nsresult rv = NS_OK;
michael@0:     mOriginalUriString.Truncate();
michael@0: 
michael@0: #ifdef PR_LOGGING
michael@0:     if (gDocShellLeakLog && PR_LOG_TEST(gDocShellLeakLog, PR_LOG_DEBUG)) {
michael@0:         nsAutoCString spec;
michael@0:         if (aURI)
michael@0:             aURI->GetSpec(spec);
michael@0:         PR_LogPrint("DOCSHELL %p InternalLoad %s\n", this, spec.get());
michael@0:     }
michael@0: #endif
michael@0:     // Initialize aDocShell/aRequest
michael@0:     if (aDocShell) {
michael@0:         *aDocShell = nullptr;
michael@0:     }
michael@0:     if (aRequest) {
michael@0:         *aRequest = nullptr;
michael@0:     }
michael@0: 
michael@0:     if (!aURI) {
michael@0:         return NS_ERROR_NULL_POINTER;
michael@0:     }
michael@0: 
michael@0:     NS_ENSURE_TRUE(IsValidLoadType(aLoadType), NS_ERROR_INVALID_ARG);
michael@0: 
michael@0:     NS_ENSURE_TRUE(!mIsBeingDestroyed, NS_ERROR_NOT_AVAILABLE);
michael@0: 
michael@0:     // wyciwyg urls can only be loaded through history. Any normal load of
michael@0:     // wyciwyg through docshell is  illegal. Disallow such loads.
michael@0:     if (aLoadType & LOAD_CMD_NORMAL) {
michael@0:         bool isWyciwyg = false;
michael@0:         rv = aURI->SchemeIs("wyciwyg", &isWyciwyg);   
michael@0:         if ((isWyciwyg && NS_SUCCEEDED(rv)) || NS_FAILED(rv)) 
michael@0:             return NS_ERROR_FAILURE;
michael@0:     }
michael@0: 
michael@0:     bool bIsJavascript = false;
michael@0:     if (NS_FAILED(aURI->SchemeIs("javascript", &bIsJavascript))) {
michael@0:         bIsJavascript = false;
michael@0:     }
michael@0: 
michael@0:     //
michael@0:     // First, notify any nsIContentPolicy listeners about the document load.
michael@0:     // Only abort the load if a content policy listener explicitly vetos it!
michael@0:     //
michael@0:     nsCOMPtr<Element> requestingElement;
michael@0:     // Use nsPIDOMWindow since we _want_ to cross the chrome boundary if needed
michael@0:     if (mScriptGlobal)
michael@0:         requestingElement = mScriptGlobal->GetFrameElementInternal();
michael@0: 
michael@0:     nsRefPtr<nsGlobalWindow> MMADeathGrip = mScriptGlobal;
michael@0: 
michael@0:     int16_t shouldLoad = nsIContentPolicy::ACCEPT;
michael@0:     uint32_t contentType;
michael@0:     bool isNewDocShell = false;
michael@0:     bool isTargetTopLevelDocShell = false;
michael@0:     nsCOMPtr<nsIDocShell> targetDocShell;
michael@0:     if (aWindowTarget && *aWindowTarget) {
michael@0:         // Locate the target DocShell.
michael@0:         nsCOMPtr<nsIDocShellTreeItem> targetItem;
michael@0:         rv = FindItemWithName(aWindowTarget, nullptr, this,
michael@0:                               getter_AddRefs(targetItem));
michael@0:         NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:         targetDocShell = do_QueryInterface(targetItem);
michael@0:         // If the targetDocShell doesn't exist, then this is a new docShell
michael@0:         // and we should consider this a TYPE_DOCUMENT load
michael@0:         isNewDocShell = !targetDocShell;
michael@0: 
michael@0:         // If the targetDocShell and the rootDocShell are the same, then the
michael@0:         // targetDocShell is the top level document and hence we should
michael@0:         // consider this TYPE_DOCUMENT
michael@0:         if (targetDocShell) {
michael@0:           nsCOMPtr<nsIDocShellTreeItem> sameTypeRoot;
michael@0:           targetDocShell->GetSameTypeRootTreeItem(getter_AddRefs(sameTypeRoot));
michael@0:           NS_ASSERTION(sameTypeRoot, "No document shell root tree item from targetDocShell!");
michael@0:           nsCOMPtr<nsIDocShell> rootShell = do_QueryInterface(sameTypeRoot);
michael@0:           NS_ASSERTION(rootShell, "No root docshell from document shell root tree item.");
michael@0: 
michael@0:           if (targetDocShell == rootShell) {
michael@0:             isTargetTopLevelDocShell = true;
michael@0:           }
michael@0:         }
michael@0:     }
michael@0:     if (IsFrame() && !isNewDocShell && !isTargetTopLevelDocShell) {
michael@0:         NS_ASSERTION(requestingElement, "A frame but no DOM element!?");
michael@0:         contentType = nsIContentPolicy::TYPE_SUBDOCUMENT;
michael@0:     } else {
michael@0:         contentType = nsIContentPolicy::TYPE_DOCUMENT;
michael@0:     }
michael@0: 
michael@0:     nsISupports* context = requestingElement;
michael@0:     if (!context) {
michael@0:         context = ToSupports(mScriptGlobal);
michael@0:     }
michael@0: 
michael@0:     // XXXbz would be nice to know the loading principal here... but we don't
michael@0:     nsCOMPtr<nsIPrincipal> loadingPrincipal = do_QueryInterface(aOwner);
michael@0:     if (!loadingPrincipal && aReferrer) {
michael@0:         nsCOMPtr<nsIScriptSecurityManager> secMan =
michael@0:             do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID, &rv);
michael@0:         NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:         rv = secMan->GetSimpleCodebasePrincipal(aReferrer,
michael@0:                                                 getter_AddRefs(loadingPrincipal));
michael@0:     }
michael@0: 
michael@0:     rv = NS_CheckContentLoadPolicy(contentType,
michael@0:                                    aURI,
michael@0:                                    loadingPrincipal,
michael@0:                                    context,
michael@0:                                    EmptyCString(), //mime guess
michael@0:                                    nullptr,         //extra
michael@0:                                    &shouldLoad);
michael@0: 
michael@0:     if (NS_FAILED(rv) || NS_CP_REJECTED(shouldLoad)) {
michael@0:         if (NS_SUCCEEDED(rv) && shouldLoad == nsIContentPolicy::REJECT_TYPE) {
michael@0:             return NS_ERROR_CONTENT_BLOCKED_SHOW_ALT;
michael@0:         }
michael@0: 
michael@0:         return NS_ERROR_CONTENT_BLOCKED;
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsISupports> owner(aOwner);
michael@0:     //
michael@0:     // Get an owner from the current document if necessary.  Note that we only
michael@0:     // do this for URIs that inherit a security context and local file URIs;
michael@0:     // in particular we do NOT do this for about:blank.  This way, random
michael@0:     // about:blank loads that have no owner (which basically means they were
michael@0:     // done by someone from chrome manually messing with our nsIWebNavigation
michael@0:     // or by C++ setting document.location) don't get a funky principal.  If
michael@0:     // callers want something interesting to happen with the about:blank
michael@0:     // principal in this case, they should pass an owner in.
michael@0:     //
michael@0:     {
michael@0:         bool inherits;
michael@0:         // One more twist: Don't inherit the owner for external loads.
michael@0:         if (aLoadType != LOAD_NORMAL_EXTERNAL && !owner &&
michael@0:             (aFlags & INTERNAL_LOAD_FLAGS_INHERIT_OWNER) &&
michael@0:             NS_SUCCEEDED(nsContentUtils::URIInheritsSecurityContext(aURI,
michael@0:                                                                     &inherits)) &&
michael@0:             inherits) {
michael@0: 
michael@0:             owner = GetInheritedPrincipal(true);
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // Don't allow loads that would inherit our security context
michael@0:     // if this document came from an unsafe channel.
michael@0:     {
michael@0:         bool willInherit;
michael@0:         // This condition needs to match the one in
michael@0:         // nsContentUtils::SetUpChannelOwner.
michael@0:         // Except we reverse the rv check to be safe in case
michael@0:         // nsContentUtils::URIInheritsSecurityContext fails here and
michael@0:         // succeeds there.
michael@0:         rv = nsContentUtils::URIInheritsSecurityContext(aURI, &willInherit);
michael@0:         if (NS_FAILED(rv) || willInherit || NS_IsAboutBlank(aURI)) {
michael@0:             nsCOMPtr<nsIDocShellTreeItem> treeItem = this;
michael@0:             do {
michael@0:                 nsCOMPtr<nsIDocShell> itemDocShell =
michael@0:                     do_QueryInterface(treeItem);
michael@0:                 bool isUnsafe;
michael@0:                 if (itemDocShell &&
michael@0:                     NS_SUCCEEDED(itemDocShell->GetChannelIsUnsafe(&isUnsafe)) &&
michael@0:                     isUnsafe) {
michael@0:                     return NS_ERROR_DOM_SECURITY_ERR;
michael@0:                 }
michael@0: 
michael@0:                 nsCOMPtr<nsIDocShellTreeItem> parent;
michael@0:                 treeItem->GetSameTypeParent(getter_AddRefs(parent));
michael@0:                 parent.swap(treeItem);
michael@0:             } while (treeItem);
michael@0:         }
michael@0:     }
michael@0:     
michael@0:     //
michael@0:     // Resolve the window target before going any further...
michael@0:     // If the load has been targeted to another DocShell, then transfer the
michael@0:     // load to it...
michael@0:     //
michael@0:     if (aWindowTarget && *aWindowTarget) {
michael@0:         // We've already done our owner-inheriting.  Mask out that bit, so we
michael@0:         // don't try inheriting an owner from the target window if we came up
michael@0:         // with a null owner above.
michael@0:         aFlags = aFlags & ~INTERNAL_LOAD_FLAGS_INHERIT_OWNER;
michael@0:         
michael@0:         bool isNewWindow = false;
michael@0:         if (!targetDocShell) {
michael@0:             // If the docshell's document is sandboxed, only open a new window
michael@0:             // if the document's SANDBOXED_AUXILLARY_NAVIGATION flag is not set.
michael@0:             // (i.e. if allow-popups is specified)
michael@0:             NS_ENSURE_TRUE(mContentViewer, NS_ERROR_FAILURE);
michael@0:             nsIDocument* doc = mContentViewer->GetDocument();
michael@0:             uint32_t sandboxFlags = 0;
michael@0: 
michael@0:             if (doc) {
michael@0:                 sandboxFlags = doc->GetSandboxFlags();
michael@0:                 if (sandboxFlags & SANDBOXED_AUXILIARY_NAVIGATION) {
michael@0:                     return NS_ERROR_DOM_INVALID_ACCESS_ERR;
michael@0:                 }
michael@0:             }
michael@0: 
michael@0:             nsCOMPtr<nsPIDOMWindow> win =
michael@0:                 do_GetInterface(GetAsSupports(this));
michael@0:             NS_ENSURE_TRUE(win, NS_ERROR_NOT_AVAILABLE);
michael@0: 
michael@0:             nsDependentString name(aWindowTarget);
michael@0:             nsCOMPtr<nsIDOMWindow> newWin;
michael@0:             nsAutoCString spec;
michael@0:             if (aURI)
michael@0:                 aURI->GetSpec(spec);
michael@0:             rv = win->OpenNoNavigate(NS_ConvertUTF8toUTF16(spec),
michael@0:                                      name,          // window name
michael@0:                                      EmptyString(), // Features
michael@0:                                      getter_AddRefs(newWin));
michael@0: 
michael@0:             // In some cases the Open call doesn't actually result in a new
michael@0:             // window being opened.  We can detect these cases by examining the
michael@0:             // document in |newWin|, if any.
michael@0:             nsCOMPtr<nsPIDOMWindow> piNewWin = do_QueryInterface(newWin);
michael@0:             if (piNewWin) {
michael@0:                 nsCOMPtr<nsIDocument> newDoc = piNewWin->GetExtantDoc();
michael@0:                 if (!newDoc || newDoc->IsInitialDocument()) {
michael@0:                     isNewWindow = true;
michael@0:                     aFlags |= INTERNAL_LOAD_FLAGS_FIRST_LOAD;
michael@0:                 }
michael@0:             }
michael@0: 
michael@0:             nsCOMPtr<nsIWebNavigation> webNav = do_GetInterface(newWin);
michael@0:             targetDocShell = do_QueryInterface(webNav);
michael@0:         }
michael@0: 
michael@0:         //
michael@0:         // Transfer the load to the target DocShell...  Pass nullptr as the
michael@0:         // window target name from to prevent recursive retargeting!
michael@0:         //
michael@0:         if (NS_SUCCEEDED(rv) && targetDocShell) {
michael@0:             rv = targetDocShell->InternalLoad(aURI,
michael@0:                                               aReferrer,
michael@0:                                               owner,
michael@0:                                               aFlags,
michael@0:                                               nullptr,         // No window target
michael@0:                                               aTypeHint,
michael@0:                                               NullString(),    // No forced download
michael@0:                                               aPostData,
michael@0:                                               aHeadersData,
michael@0:                                               aLoadType,
michael@0:                                               aSHEntry,
michael@0:                                               aFirstParty,
michael@0:                                               aSrcdoc,
michael@0:                                               aSourceDocShell,
michael@0:                                               aBaseURI,
michael@0:                                               aDocShell,
michael@0:                                               aRequest);
michael@0:             if (rv == NS_ERROR_NO_CONTENT) {
michael@0:                 // XXXbz except we never reach this code!
michael@0:                 if (isNewWindow) {
michael@0:                     //
michael@0:                     // At this point, a new window has been created, but the
michael@0:                     // URI did not have any data associated with it...
michael@0:                     //
michael@0:                     // So, the best we can do, is to tear down the new window
michael@0:                     // that was just created!
michael@0:                     //
michael@0:                     nsCOMPtr<nsIDOMWindow> domWin =
michael@0:                         do_GetInterface(targetDocShell);
michael@0:                     if (domWin) {
michael@0:                         domWin->Close();
michael@0:                     }
michael@0:                 }
michael@0:                 //
michael@0:                 // NS_ERROR_NO_CONTENT should not be returned to the
michael@0:                 // caller... This is an internal error code indicating that
michael@0:                 // the URI had no data associated with it - probably a 
michael@0:                 // helper-app style protocol (ie. mailto://)
michael@0:                 //
michael@0:                 rv = NS_OK;
michael@0:             }
michael@0:             else if (isNewWindow) {
michael@0:                 // XXX: Once new windows are created hidden, the new
michael@0:                 //      window will need to be made visible...  For now,
michael@0:                 //      do nothing.
michael@0:             }
michael@0:         }
michael@0: 
michael@0:         // Else we ran out of memory, or were a popup and got blocked,
michael@0:         // or something.
michael@0:         
michael@0:         return rv;
michael@0:     }
michael@0: 
michael@0:     //
michael@0:     // Load is being targetted at this docshell so return an error if the
michael@0:     // docshell is in the process of being destroyed.
michael@0:     //
michael@0:     if (mIsBeingDestroyed) {
michael@0:         return NS_ERROR_FAILURE;
michael@0:     }
michael@0: 
michael@0:     NS_ENSURE_STATE(!HasUnloadedParent());
michael@0: 
michael@0:     rv = CheckLoadingPermissions();
michael@0:     if (NS_FAILED(rv)) {
michael@0:         return rv;
michael@0:     }
michael@0: 
michael@0:     if (mFiredUnloadEvent) {
michael@0:         if (IsOKToLoadURI(aURI)) {
michael@0:             NS_PRECONDITION(!aWindowTarget || !*aWindowTarget,
michael@0:                             "Shouldn't have a window target here!");
michael@0: 
michael@0:             // If this is a replace load, make whatever load triggered
michael@0:             // the unload event also a replace load, so we don't
michael@0:             // create extra history entries.
michael@0:             if (LOAD_TYPE_HAS_FLAGS(aLoadType, LOAD_FLAGS_REPLACE_HISTORY)) {
michael@0:                 mLoadType = LOAD_NORMAL_REPLACE;
michael@0:             }
michael@0:             
michael@0:             // Do this asynchronously
michael@0:             nsCOMPtr<nsIRunnable> ev =
michael@0:                 new InternalLoadEvent(this, aURI, aReferrer, aOwner, aFlags,
michael@0:                                       aTypeHint, aPostData, aHeadersData,
michael@0:                                       aLoadType, aSHEntry, aFirstParty, aSrcdoc,
michael@0:                                       aSourceDocShell, aBaseURI);
michael@0:             return NS_DispatchToCurrentThread(ev);
michael@0:         }
michael@0: 
michael@0:         // Just ignore this load attempt
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     // If a source docshell has been passed, check to see if we are sandboxed
michael@0:     // from it as the result of an iframe or CSP sandbox.
michael@0:     if (aSourceDocShell && aSourceDocShell->IsSandboxedFrom(this)) {
michael@0:         return NS_ERROR_DOM_INVALID_ACCESS_ERR;
michael@0:     }
michael@0: 
michael@0:     // If this docshell is owned by a frameloader, make sure to cancel
michael@0:     // possible frameloader initialization before loading a new page.
michael@0:     nsCOMPtr<nsIDocShellTreeItem> parent;
michael@0:     GetParent(getter_AddRefs(parent));
michael@0:     if (parent) {
michael@0:         nsCOMPtr<nsIDocument> doc = do_GetInterface(parent);
michael@0:         if (doc) {
michael@0:             doc->TryCancelFrameLoaderInitialization(this);
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // Before going any further vet loads initiated by external programs.
michael@0:     if (aLoadType == LOAD_NORMAL_EXTERNAL) {
michael@0:         // Disallow external chrome: loads targetted at content windows
michael@0:         bool isChrome = false;
michael@0:         if (NS_SUCCEEDED(aURI->SchemeIs("chrome", &isChrome)) && isChrome) {
michael@0:             NS_WARNING("blocked external chrome: url -- use '-chrome' option");
michael@0:             return NS_ERROR_FAILURE;
michael@0:         }
michael@0: 
michael@0:         // clear the decks to prevent context bleed-through (bug 298255)
michael@0:         rv = CreateAboutBlankContentViewer(nullptr, nullptr);
michael@0:         if (NS_FAILED(rv))
michael@0:             return NS_ERROR_FAILURE;
michael@0: 
michael@0:         // reset loadType so we don't have to add lots of tests for
michael@0:         // LOAD_NORMAL_EXTERNAL after this point
michael@0:         aLoadType = LOAD_NORMAL;
michael@0:     }
michael@0: 
michael@0:     mAllowKeywordFixup =
michael@0:       (aFlags & INTERNAL_LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP) != 0;
michael@0:     mURIResultedInDocument = false;  // reset the clock...
michael@0: 
michael@0:     if (aLoadType == LOAD_NORMAL ||
michael@0:         aLoadType == LOAD_STOP_CONTENT ||
michael@0:         LOAD_TYPE_HAS_FLAGS(aLoadType, LOAD_FLAGS_REPLACE_HISTORY) ||
michael@0:         aLoadType == LOAD_HISTORY ||
michael@0:         aLoadType == LOAD_LINK) {
michael@0: 
michael@0:         nsCOMPtr<nsIURI> currentURI = mCurrentURI;
michael@0:         // Split currentURI and aURI on the '#' character.  Make sure we read
michael@0:         // the return values of SplitURIAtHash; if it fails, we don't want to
michael@0:         // allow a short-circuited navigation.
michael@0:         nsAutoCString curBeforeHash, curHash, newBeforeHash, newHash;
michael@0:         nsresult splitRv1, splitRv2;
michael@0:         splitRv1 = currentURI ?
michael@0:             nsContentUtils::SplitURIAtHash(currentURI,
michael@0:                                            curBeforeHash, curHash) :
michael@0:             NS_ERROR_FAILURE;
michael@0:         splitRv2 = nsContentUtils::SplitURIAtHash(aURI, newBeforeHash, newHash);
michael@0: 
michael@0:         bool sameExceptHashes = NS_SUCCEEDED(splitRv1) &&
michael@0:                                   NS_SUCCEEDED(splitRv2) &&
michael@0:                                   curBeforeHash.Equals(newBeforeHash);
michael@0: 
michael@0:         if (!sameExceptHashes && sURIFixup && currentURI &&
michael@0:             NS_SUCCEEDED(splitRv2)) {
michael@0:           // Maybe aURI came from the exposable form of currentURI?
michael@0:           nsCOMPtr<nsIURI> currentExposableURI;
michael@0:           rv = sURIFixup->CreateExposableURI(currentURI,
michael@0:                                              getter_AddRefs(currentExposableURI));
michael@0:           NS_ENSURE_SUCCESS(rv, rv);
michael@0:           splitRv1 = nsContentUtils::SplitURIAtHash(currentExposableURI,
michael@0:                                                     curBeforeHash, curHash);
michael@0:           sameExceptHashes = NS_SUCCEEDED(splitRv1) &&
michael@0:             curBeforeHash.Equals(newBeforeHash);
michael@0:         }
michael@0: 
michael@0:         bool historyNavBetweenSameDoc = false;
michael@0:         if (mOSHE && aSHEntry) {
michael@0:             // We're doing a history load.
michael@0: 
michael@0:             mOSHE->SharesDocumentWith(aSHEntry, &historyNavBetweenSameDoc);
michael@0: 
michael@0: #ifdef DEBUG
michael@0:             if (historyNavBetweenSameDoc) {
michael@0:                 nsCOMPtr<nsIInputStream> currentPostData;
michael@0:                 mOSHE->GetPostData(getter_AddRefs(currentPostData));
michael@0:                 NS_ASSERTION(currentPostData == aPostData,
michael@0:                              "Different POST data for entries for the same page?");
michael@0:             }
michael@0: #endif
michael@0:         }
michael@0: 
michael@0:         // A short-circuited load happens when we navigate between two SHEntries
michael@0:         // for the same document.  We do a short-circuited load under two
michael@0:         // circumstances.  Either
michael@0:         //
michael@0:         //  a) we're navigating between two different SHEntries which share a
michael@0:         //     document, or
michael@0:         //
michael@0:         //  b) we're navigating to a new shentry whose URI differs from the
michael@0:         //     current URI only in its hash, the new hash is non-empty, and
michael@0:         //     we're not doing a POST.
michael@0:         //
michael@0:         // The restriction tha the SHEntries in (a) must be different ensures
michael@0:         // that history.go(0) and the like trigger full refreshes, rather than
michael@0:         // short-circuited loads.
michael@0:         bool doShortCircuitedLoad =
michael@0:           (historyNavBetweenSameDoc && mOSHE != aSHEntry) ||
michael@0:           (!aSHEntry && aPostData == nullptr &&
michael@0:            sameExceptHashes && !newHash.IsEmpty());
michael@0: 
michael@0:         if (doShortCircuitedLoad) {
michael@0:             // Save the position of the scrollers.
michael@0:             nscoord cx = 0, cy = 0;
michael@0:             GetCurScrollPos(ScrollOrientation_X, &cx);
michael@0:             GetCurScrollPos(ScrollOrientation_Y, &cy);
michael@0: 
michael@0:             // ScrollToAnchor doesn't necessarily cause us to scroll the window;
michael@0:             // the function decides whether a scroll is appropriate based on the
michael@0:             // arguments it receives.  But even if we don't end up scrolling,
michael@0:             // ScrollToAnchor performs other important tasks, such as informing
michael@0:             // the presShell that we have a new hash.  See bug 680257.
michael@0:             rv = ScrollToAnchor(curHash, newHash, aLoadType);
michael@0:             NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:             // Reset mLoadType to its original value once we exit this block,
michael@0:             // because this short-circuited load might have started after a
michael@0:             // normal, network load, and we don't want to clobber its load type.
michael@0:             // See bug 737307.
michael@0:             AutoRestore<uint32_t> loadTypeResetter(mLoadType);
michael@0: 
michael@0:             // If a non-short-circuit load (i.e., a network load) is pending,
michael@0:             // make this a replacement load, so that we don't add a SHEntry here
michael@0:             // and the network load goes into the SHEntry it expects to.
michael@0:             if (JustStartedNetworkLoad() && (aLoadType & LOAD_CMD_NORMAL)) {
michael@0:                 mLoadType = LOAD_NORMAL_REPLACE;
michael@0:             }
michael@0:             else {
michael@0:                 mLoadType = aLoadType;
michael@0:             }
michael@0: 
michael@0:             mURIResultedInDocument = true;
michael@0: 
michael@0:             nsCOMPtr<nsISHEntry> oldLSHE = mLSHE;
michael@0: 
michael@0:             /* we need to assign mLSHE to aSHEntry right here, so that on History loads,
michael@0:              * SetCurrentURI() called from OnNewURI() will send proper
michael@0:              * onLocationChange() notifications to the browser to update
michael@0:              * back/forward buttons.
michael@0:              */
michael@0:             SetHistoryEntry(&mLSHE, aSHEntry);
michael@0: 
michael@0:             /* This is a anchor traversal with in the same page.
michael@0:              * call OnNewURI() so that, this traversal will be 
michael@0:              * recorded in session and global history.
michael@0:              */
michael@0:             nsCOMPtr<nsISupports> owner;
michael@0:             if (mOSHE) {
michael@0:                 mOSHE->GetOwner(getter_AddRefs(owner));
michael@0:             }
michael@0:             // Pass true for aCloneSHChildren, since we're not
michael@0:             // changing documents here, so all of our subframes are
michael@0:             // still relevant to the new session history entry.
michael@0:             //
michael@0:             // It also makes OnNewURI(...) set LOCATION_CHANGE_SAME_DOCUMENT
michael@0:             // flag on firing onLocationChange(...).
michael@0:             // Anyway, aCloneSHChildren param is simply reflecting
michael@0:             // doShortCircuitedLoad in this scope.
michael@0:             OnNewURI(aURI, nullptr, owner, mLoadType, true, true, true);
michael@0: 
michael@0:             nsCOMPtr<nsIInputStream> postData;
michael@0:             nsCOMPtr<nsISupports> cacheKey;
michael@0: 
michael@0:             if (mOSHE) {
michael@0:                 /* save current position of scroller(s) (bug 59774) */
michael@0:                 mOSHE->SetScrollPosition(cx, cy);
michael@0:                 // Get the postdata and page ident from the current page, if
michael@0:                 // the new load is being done via normal means.  Note that
michael@0:                 // "normal means" can be checked for just by checking for
michael@0:                 // LOAD_CMD_NORMAL, given the loadType and allowScroll check
michael@0:                 // above -- it filters out some LOAD_CMD_NORMAL cases that we
michael@0:                 // wouldn't want here.
michael@0:                 if (aLoadType & LOAD_CMD_NORMAL) {
michael@0:                     mOSHE->GetPostData(getter_AddRefs(postData));
michael@0:                     mOSHE->GetCacheKey(getter_AddRefs(cacheKey));
michael@0: 
michael@0:                     // Link our new SHEntry to the old SHEntry's back/forward
michael@0:                     // cache data, since the two SHEntries correspond to the
michael@0:                     // same document.
michael@0:                     if (mLSHE)
michael@0:                         mLSHE->AdoptBFCacheEntry(mOSHE);
michael@0:                 }
michael@0:             }
michael@0: 
michael@0:             /* Assign mOSHE to mLSHE. This will either be a new entry created
michael@0:              * by OnNewURI() for normal loads or aSHEntry for history loads.
michael@0:              */
michael@0:             if (mLSHE) {
michael@0:                 SetHistoryEntry(&mOSHE, mLSHE);
michael@0:                 // Save the postData obtained from the previous page
michael@0:                 // in to the session history entry created for the 
michael@0:                 // anchor page, so that any history load of the anchor
michael@0:                 // page will restore the appropriate postData.
michael@0:                 if (postData)
michael@0:                     mOSHE->SetPostData(postData);
michael@0: 
michael@0:                 // Make sure we won't just repost without hitting the
michael@0:                 // cache first
michael@0:                 if (cacheKey)
michael@0:                     mOSHE->SetCacheKey(cacheKey);
michael@0:             }
michael@0: 
michael@0:             /* restore previous position of scroller(s), if we're moving
michael@0:              * back in history (bug 59774)
michael@0:              */
michael@0:             if (mOSHE && (aLoadType == LOAD_HISTORY || aLoadType == LOAD_RELOAD_NORMAL))
michael@0:             {
michael@0:                 nscoord bx, by;
michael@0:                 mOSHE->GetScrollPosition(&bx, &by);
michael@0:                 SetCurScrollPosEx(bx, by);
michael@0:             }
michael@0: 
michael@0:             /* Restore the original LSHE if we were loading something
michael@0:              * while short-circuited load was initiated.
michael@0:              */
michael@0:             SetHistoryEntry(&mLSHE, oldLSHE);
michael@0:             /* Set the title for the SH entry for this target url. so that
michael@0:              * SH menus in go/back/forward buttons won't be empty for this.
michael@0:              */
michael@0:             if (mSessionHistory) {
michael@0:                 int32_t index = -1;
michael@0:                 mSessionHistory->GetIndex(&index);
michael@0:                 nsCOMPtr<nsISHEntry> shEntry;
michael@0:                 mSessionHistory->GetEntryAtIndex(index, false,
michael@0:                                                  getter_AddRefs(shEntry));
michael@0:                 NS_ENSURE_TRUE(shEntry, NS_ERROR_FAILURE);
michael@0:                 shEntry->SetTitle(mTitle);
michael@0:             }
michael@0: 
michael@0:             /* Set the title for the Global History entry for this anchor url.
michael@0:              */
michael@0:             if (mUseGlobalHistory && !mInPrivateBrowsing) {
michael@0:                 nsCOMPtr<IHistory> history = services::GetHistoryService();
michael@0:                 if (history) {
michael@0:                     history->SetURITitle(aURI, mTitle);
michael@0:                 }
michael@0:                 else if (mGlobalHistory) {
michael@0:                     mGlobalHistory->SetPageTitle(aURI, mTitle);
michael@0:                 }
michael@0:             }
michael@0: 
michael@0:             // Set the doc's URI according to the new history entry's URI.
michael@0:             nsCOMPtr<nsIDocument> doc =
michael@0:               do_GetInterface(GetAsSupports(this));
michael@0:             NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
michael@0:             doc->SetDocumentURI(aURI);
michael@0: 
michael@0:             SetDocCurrentStateObj(mOSHE);
michael@0: 
michael@0:             // Dispatch the popstate and hashchange events, as appropriate.
michael@0:             //
michael@0:             // The event dispatch below can cause us to re-enter script and
michael@0:             // destroy the docshell, nulling out mScriptGlobal. Hold a stack
michael@0:             // reference to avoid null derefs. See bug 914521.
michael@0:             nsRefPtr<nsGlobalWindow> win = mScriptGlobal;
michael@0:             if (win) {
michael@0:                 // Fire a hashchange event URIs differ, and only in their hashes.
michael@0:                 bool doHashchange = sameExceptHashes && !curHash.Equals(newHash);
michael@0: 
michael@0:                 if (historyNavBetweenSameDoc || doHashchange) {
michael@0:                     win->DispatchSyncPopState();
michael@0:                 }
michael@0: 
michael@0:                 if (doHashchange) {
michael@0:                     // Note that currentURI hasn't changed because it's on the
michael@0:                     // stack, so we can just use it directly as the old URI.
michael@0:                     win->DispatchAsyncHashchange(currentURI, aURI);
michael@0:                 }
michael@0:             }
michael@0: 
michael@0:             // Inform the favicon service that the favicon for oldURI also
michael@0:             // applies to aURI.
michael@0:             CopyFavicon(currentURI, aURI, mInPrivateBrowsing);
michael@0: 
michael@0:             return NS_OK;
michael@0:         }
michael@0:     }
michael@0:     
michael@0:     // mContentViewer->PermitUnload can destroy |this| docShell, which
michael@0:     // causes the next call of CanSavePresentation to crash. 
michael@0:     // Hold onto |this| until we return, to prevent a crash from happening. 
michael@0:     // (bug#331040)
michael@0:     nsCOMPtr<nsIDocShell> kungFuDeathGrip(this);
michael@0: 
michael@0:     // Don't init timing for javascript:, since it generally doesn't
michael@0:     // actually start a load or anything.  If it does, we'll init
michael@0:     // timing then, from OnStateChange.
michael@0: 
michael@0:     // XXXbz mTiming should know what channel it's for, so we don't
michael@0:     // need this hackery.  Note that this is still broken in cases
michael@0:     // when we're loading something that's not javascript: and the
michael@0:     // beforeunload handler denies the load.  That will screw up
michael@0:     // timing for the next load!
michael@0:     if (!bIsJavascript) {
michael@0:         MaybeInitTiming();
michael@0:     }
michael@0:     bool timeBeforeUnload = aFileName.IsVoid();
michael@0:     if (mTiming && timeBeforeUnload) {
michael@0:       mTiming->NotifyBeforeUnload();
michael@0:     }
michael@0:     // Check if the page doesn't want to be unloaded. The javascript:
michael@0:     // protocol handler deals with this for javascript: URLs.
michael@0:     if (!bIsJavascript && aFileName.IsVoid() && mContentViewer) {
michael@0:         bool okToUnload;
michael@0:         rv = mContentViewer->PermitUnload(false, &okToUnload);
michael@0: 
michael@0:         if (NS_SUCCEEDED(rv) && !okToUnload) {
michael@0:             // The user chose not to unload the page, interrupt the
michael@0:             // load.
michael@0:             return NS_OK;
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     if (mTiming && timeBeforeUnload) {
michael@0:       mTiming->NotifyUnloadAccepted(mCurrentURI);
michael@0:     }
michael@0: 
michael@0:     // Check for saving the presentation here, before calling Stop().
michael@0:     // This is necessary so that we can catch any pending requests.
michael@0:     // Since the new request has not been created yet, we pass null for the
michael@0:     // new request parameter.
michael@0:     // Also pass nullptr for the document, since it doesn't affect the return
michael@0:     // value for our purposes here.
michael@0:     bool savePresentation = CanSavePresentation(aLoadType, nullptr, nullptr);
michael@0: 
michael@0:     // Don't stop current network activity for javascript: URL's since
michael@0:     // they might not result in any data, and thus nothing should be
michael@0:     // stopped in those cases. In the case where they do result in
michael@0:     // data, the javascript: URL channel takes care of stopping
michael@0:     // current network activity.
michael@0:     if (!bIsJavascript && aFileName.IsVoid()) {
michael@0:         // Stop any current network activity.
michael@0:         // Also stop content if this is a zombie doc. otherwise 
michael@0:         // the onload will be delayed by other loads initiated in the 
michael@0:         // background by the first document that
michael@0:         // didn't fully load before the next load was initiated.
michael@0:         // If not a zombie, don't stop content until data 
michael@0:         // starts arriving from the new URI...
michael@0: 
michael@0:         nsCOMPtr<nsIContentViewer> zombieViewer;
michael@0:         if (mContentViewer) {
michael@0:             mContentViewer->GetPreviousViewer(getter_AddRefs(zombieViewer));
michael@0:         }
michael@0: 
michael@0:         if (zombieViewer ||
michael@0:             LOAD_TYPE_HAS_FLAGS(aLoadType, LOAD_FLAGS_STOP_CONTENT)) {
michael@0:             rv = Stop(nsIWebNavigation::STOP_ALL);
michael@0:         } else {
michael@0:             rv = Stop(nsIWebNavigation::STOP_NETWORK);
michael@0:         }
michael@0: 
michael@0:         if (NS_FAILED(rv)) 
michael@0:             return rv;
michael@0:     }
michael@0: 
michael@0:     mLoadType = aLoadType;
michael@0: 
michael@0:     // mLSHE should be assigned to aSHEntry, only after Stop() has
michael@0:     // been called. But when loading an error page, do not clear the
michael@0:     // mLSHE for the real page.
michael@0:     if (mLoadType != LOAD_ERROR_PAGE)
michael@0:         SetHistoryEntry(&mLSHE, aSHEntry);
michael@0: 
michael@0:     mSavingOldViewer = savePresentation;
michael@0: 
michael@0:     // If we have a saved content viewer in history, restore and show it now.
michael@0:     if (aSHEntry && (mLoadType & LOAD_CMD_HISTORY)) {
michael@0:         // Make sure our history ID points to the same ID as
michael@0:         // SHEntry's docshell ID.
michael@0:         aSHEntry->GetDocshellID(&mHistoryID);
michael@0: 
michael@0:         // It's possible that the previous viewer of mContentViewer is the
michael@0:         // viewer that will end up in aSHEntry when it gets closed.  If that's
michael@0:         // the case, we need to go ahead and force it into its shentry so we
michael@0:         // can restore it.
michael@0:         if (mContentViewer) {
michael@0:             nsCOMPtr<nsIContentViewer> prevViewer;
michael@0:             mContentViewer->GetPreviousViewer(getter_AddRefs(prevViewer));
michael@0:             if (prevViewer) {
michael@0: #ifdef DEBUG
michael@0:                 nsCOMPtr<nsIContentViewer> prevPrevViewer;
michael@0:                 prevViewer->GetPreviousViewer(getter_AddRefs(prevPrevViewer));
michael@0:                 NS_ASSERTION(!prevPrevViewer, "Should never have viewer chain here");
michael@0: #endif
michael@0:                 nsCOMPtr<nsISHEntry> viewerEntry;
michael@0:                 prevViewer->GetHistoryEntry(getter_AddRefs(viewerEntry));
michael@0:                 if (viewerEntry == aSHEntry) {
michael@0:                     // Make sure this viewer ends up in the right place
michael@0:                     mContentViewer->SetPreviousViewer(nullptr);
michael@0:                     prevViewer->Destroy();
michael@0:                 }
michael@0:             }
michael@0:         }
michael@0:         nsCOMPtr<nsISHEntry> oldEntry = mOSHE;
michael@0:         bool restoring;
michael@0:         rv = RestorePresentation(aSHEntry, &restoring);
michael@0:         if (restoring)
michael@0:             return rv;
michael@0: 
michael@0:         // We failed to restore the presentation, so clean up.
michael@0:         // Both the old and new history entries could potentially be in
michael@0:         // an inconsistent state.
michael@0:         if (NS_FAILED(rv)) {
michael@0:             if (oldEntry)
michael@0:                 oldEntry->SyncPresentationState();
michael@0: 
michael@0:             aSHEntry->SyncPresentationState();
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     nsAutoString srcdoc;
michael@0:     if (aFlags & INTERNAL_LOAD_FLAGS_IS_SRCDOC)
michael@0:       srcdoc = aSrcdoc;
michael@0:     else
michael@0:       srcdoc = NullString();
michael@0: 
michael@0:     mozilla::net::SeerPredict(aURI, nullptr, nsINetworkSeer::PREDICT_LOAD,
michael@0:                               this, nullptr);
michael@0: 
michael@0:     nsCOMPtr<nsIRequest> req;
michael@0:     rv = DoURILoad(aURI, aReferrer,
michael@0:                    !(aFlags & INTERNAL_LOAD_FLAGS_DONT_SEND_REFERRER),
michael@0:                    owner, aTypeHint, aFileName, aPostData, aHeadersData,
michael@0:                    aFirstParty, aDocShell, getter_AddRefs(req),
michael@0:                    (aFlags & INTERNAL_LOAD_FLAGS_FIRST_LOAD) != 0,
michael@0:                    (aFlags & INTERNAL_LOAD_FLAGS_BYPASS_CLASSIFIER) != 0,
michael@0:                    (aFlags & INTERNAL_LOAD_FLAGS_FORCE_ALLOW_COOKIES) != 0,
michael@0:                    srcdoc, aBaseURI);
michael@0:     if (req && aRequest)
michael@0:         NS_ADDREF(*aRequest = req);
michael@0: 
michael@0:     if (NS_FAILED(rv)) {
michael@0:         nsCOMPtr<nsIChannel> chan(do_QueryInterface(req));
michael@0:         DisplayLoadError(rv, aURI, nullptr, chan);
michael@0:     }
michael@0: 
michael@0:     return rv;
michael@0: }
michael@0: 
michael@0: nsIPrincipal*
michael@0: nsDocShell::GetInheritedPrincipal(bool aConsiderCurrentDocument)
michael@0: {
michael@0:     nsCOMPtr<nsIDocument> document;
michael@0:     bool inheritedFromCurrent = false;
michael@0: 
michael@0:     if (aConsiderCurrentDocument && mContentViewer) {
michael@0:         document = mContentViewer->GetDocument();
michael@0:         inheritedFromCurrent = true;
michael@0:     }
michael@0: 
michael@0:     if (!document) {
michael@0:         nsCOMPtr<nsIDocShellTreeItem> parentItem;
michael@0:         GetSameTypeParent(getter_AddRefs(parentItem));
michael@0:         if (parentItem) {
michael@0:             document = do_GetInterface(parentItem);
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     if (!document) {
michael@0:         if (!aConsiderCurrentDocument) {
michael@0:             return nullptr;
michael@0:         }
michael@0: 
michael@0:         // Make sure we end up with _something_ as the principal no matter
michael@0:         // what.
michael@0:         EnsureContentViewer();  // If this fails, we'll just get a null
michael@0:                                 // docViewer and bail.
michael@0: 
michael@0:         if (!mContentViewer)
michael@0:             return nullptr;
michael@0:         document = mContentViewer->GetDocument();
michael@0:     }
michael@0: 
michael@0:     //-- Get the document's principal
michael@0:     if (document) {
michael@0:         nsIPrincipal *docPrincipal = document->NodePrincipal();
michael@0: 
michael@0:         // Don't allow loads in typeContent docShells to inherit the system
michael@0:         // principal from existing documents.
michael@0:         if (inheritedFromCurrent &&
michael@0:             mItemType == typeContent &&
michael@0:             nsContentUtils::IsSystemPrincipal(docPrincipal)) {
michael@0:             return nullptr;
michael@0:         }
michael@0: 
michael@0:         return docPrincipal;
michael@0:     }
michael@0: 
michael@0:     return nullptr;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::DoURILoad(nsIURI * aURI,
michael@0:                       nsIURI * aReferrerURI,
michael@0:                       bool aSendReferrer,
michael@0:                       nsISupports * aOwner,
michael@0:                       const char * aTypeHint,
michael@0:                       const nsAString & aFileName,
michael@0:                       nsIInputStream * aPostData,
michael@0:                       nsIInputStream * aHeadersData,
michael@0:                       bool aFirstParty,
michael@0:                       nsIDocShell ** aDocShell,
michael@0:                       nsIRequest ** aRequest,
michael@0:                       bool aIsNewWindowTarget,
michael@0:                       bool aBypassClassifier,
michael@0:                       bool aForceAllowCookies,
michael@0:                       const nsAString &aSrcdoc,
michael@0:                       nsIURI * aBaseURI)
michael@0: {
michael@0: #ifdef MOZ_VISUAL_EVENT_TRACER
michael@0:     nsAutoCString urlSpec;
michael@0:     aURI->GetAsciiSpec(urlSpec);
michael@0:     MOZ_EVENT_TRACER_NAME_OBJECT(this, urlSpec.BeginReading());
michael@0:     MOZ_EVENT_TRACER_EXEC(this, "docshell::pageload");
michael@0: #endif
michael@0: 
michael@0:     nsresult rv;
michael@0:     nsCOMPtr<nsIURILoader> uriLoader;
michael@0: 
michael@0:     uriLoader = do_GetService(NS_URI_LOADER_CONTRACTID, &rv);
michael@0:     if (NS_FAILED(rv)) return rv;
michael@0: 
michael@0:     nsLoadFlags loadFlags = mDefaultLoadFlags;
michael@0:     if (aFirstParty) {
michael@0:         // tag first party URL loads
michael@0:         loadFlags |= nsIChannel::LOAD_INITIAL_DOCUMENT_URI;
michael@0:     }
michael@0: 
michael@0:     if (mLoadType == LOAD_ERROR_PAGE) {
michael@0:         // Error pages are LOAD_BACKGROUND
michael@0:         loadFlags |= nsIChannel::LOAD_BACKGROUND;
michael@0:     }
michael@0: 
michael@0:     // check for Content Security Policy to pass along with the
michael@0:     // new channel we are creating
michael@0:     nsCOMPtr<nsIChannelPolicy> channelPolicy;
michael@0:     if (IsFrame()) {
michael@0:         // check the parent docshell for a CSP
michael@0:         nsCOMPtr<nsIContentSecurityPolicy> csp;
michael@0:         nsCOMPtr<nsIDocShellTreeItem> parentItem;
michael@0:         GetSameTypeParent(getter_AddRefs(parentItem));
michael@0:         nsCOMPtr<nsIDocument> doc = do_GetInterface(parentItem);
michael@0:         if (doc) {
michael@0:             rv = doc->NodePrincipal()->GetCsp(getter_AddRefs(csp));
michael@0:             NS_ENSURE_SUCCESS(rv, rv);
michael@0:             if (csp) {
michael@0:                 channelPolicy = do_CreateInstance("@mozilla.org/nschannelpolicy;1");
michael@0:                 channelPolicy->SetContentSecurityPolicy(csp);
michael@0:                 channelPolicy->SetLoadType(nsIContentPolicy::TYPE_SUBDOCUMENT);
michael@0:             }
michael@0:         }
michael@0: 
michael@0:         // Only allow view-source scheme in top-level docshells. view-source is
michael@0:         // the only scheme to which this applies at the moment due to potential
michael@0:         // timing attacks to read data from cross-origin iframes. If this widens
michael@0:         // we should add a protocol flag for whether the scheme is allowed in
michael@0:         // frames and use something like nsNetUtil::NS_URIChainHasFlags.
michael@0:         nsCOMPtr<nsIURI> tempURI = aURI;
michael@0:         nsCOMPtr<nsINestedURI> nestedURI = do_QueryInterface(tempURI);
michael@0:         while (nestedURI) {
michael@0:             // view-source should always be an nsINestedURI, loop and check the
michael@0:             // scheme on this and all inner URIs that are also nested URIs.
michael@0:             bool isViewSource = false;
michael@0:             rv = tempURI->SchemeIs("view-source", &isViewSource);
michael@0:             if (NS_FAILED(rv) || isViewSource) {
michael@0:                 return NS_ERROR_UNKNOWN_PROTOCOL;
michael@0:             }
michael@0:             nestedURI->GetInnerURI(getter_AddRefs(tempURI));
michael@0:             nestedURI = do_QueryInterface(tempURI);
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // open a channel for the url
michael@0:     nsCOMPtr<nsIChannel> channel;
michael@0: 
michael@0:     bool isSrcdoc = !aSrcdoc.IsVoid();
michael@0:     if (!isSrcdoc) {
michael@0:         rv = NS_NewChannel(getter_AddRefs(channel),
michael@0:                            aURI,
michael@0:                            nullptr,
michael@0:                            nullptr,
michael@0:                            static_cast<nsIInterfaceRequestor *>(this),
michael@0:                            loadFlags,
michael@0:                            channelPolicy);
michael@0:         if (NS_FAILED(rv)) {
michael@0:             if (rv == NS_ERROR_UNKNOWN_PROTOCOL) {
michael@0:                 // This is a uri with a protocol scheme we don't know how
michael@0:                 // to handle.  Embedders might still be interested in
michael@0:                 // handling the load, though, so we fire a notification
michael@0:                 // before throwing the load away.
michael@0:                 bool abort = false;
michael@0:                 nsresult rv2 = mContentListener->OnStartURIOpen(aURI, &abort);
michael@0:                 if (NS_SUCCEEDED(rv2) && abort) {
michael@0:                     // Hey, they're handling the load for us!  How convenient!
michael@0:                     return NS_OK;
michael@0:                 }
michael@0:             }
michael@0:             return rv;
michael@0:         }
michael@0:         if (aBaseURI) {
michael@0:             nsCOMPtr<nsIViewSourceChannel> vsc = do_QueryInterface(channel);
michael@0:             if (vsc) {
michael@0:                 vsc->SetBaseURI(aBaseURI);
michael@0:             }
michael@0:         }
michael@0:     }
michael@0:     else {
michael@0:         nsAutoCString scheme;
michael@0:         rv = aURI->GetScheme(scheme);
michael@0:         NS_ENSURE_SUCCESS(rv,rv);
michael@0:         bool isViewSource;
michael@0:         aURI->SchemeIs("view-source",&isViewSource);
michael@0: 
michael@0:         if (isViewSource) {
michael@0:             nsViewSourceHandler *vsh = nsViewSourceHandler::GetInstance();
michael@0:             NS_ENSURE_TRUE(vsh,NS_ERROR_FAILURE);
michael@0: 
michael@0:             rv = vsh->NewSrcdocChannel(aURI, aSrcdoc, aBaseURI,
michael@0:                                        getter_AddRefs(channel));
michael@0:             NS_ENSURE_SUCCESS(rv, rv);
michael@0:         }
michael@0:         else {
michael@0:             rv = NS_NewInputStreamChannel(getter_AddRefs(channel),aURI,
michael@0:                                           aSrcdoc,
michael@0:                                           NS_LITERAL_CSTRING("text/html"),
michael@0:                                           true);
michael@0:             NS_ENSURE_SUCCESS(rv, rv);
michael@0:             nsCOMPtr<nsIInputStreamChannel> isc = do_QueryInterface(channel);
michael@0:             MOZ_ASSERT(isc);
michael@0:             isc->SetBaseURI(aBaseURI);
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIApplicationCacheChannel> appCacheChannel =
michael@0:         do_QueryInterface(channel);
michael@0:     if (appCacheChannel) {
michael@0:         // Any document load should not inherit application cache.
michael@0:         appCacheChannel->SetInheritApplicationCache(false);
michael@0: 
michael@0:         // Loads with the correct permissions should check for a matching
michael@0:         // application cache.
michael@0:         if (GeckoProcessType_Default != XRE_GetProcessType()) {
michael@0:             // Permission will be checked in the parent process
michael@0:             appCacheChannel->SetChooseApplicationCache(true);
michael@0:         } else {
michael@0:             nsCOMPtr<nsIScriptSecurityManager> secMan =
michael@0:                 do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID);
michael@0: 
michael@0:             if (secMan) {
michael@0:                 nsCOMPtr<nsIPrincipal> principal;
michael@0:                 secMan->GetDocShellCodebasePrincipal(aURI, this, getter_AddRefs(principal));
michael@0:                 appCacheChannel->SetChooseApplicationCache(
michael@0:                     NS_ShouldCheckAppCache(principal, mInPrivateBrowsing));
michael@0:             }
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // Make sure to give the caller a channel if we managed to create one
michael@0:     // This is important for correct error page/session history interaction
michael@0:     if (aRequest)
michael@0:         NS_ADDREF(*aRequest = channel);
michael@0: 
michael@0:     channel->SetOriginalURI(aURI);
michael@0:     if (aTypeHint && *aTypeHint) {
michael@0:         channel->SetContentType(nsDependentCString(aTypeHint));
michael@0:         mContentTypeHint = aTypeHint;
michael@0:     } else {
michael@0:         mContentTypeHint.Truncate();
michael@0:     }
michael@0: 
michael@0:     if (!aFileName.IsVoid()) {
michael@0:         rv = channel->SetContentDisposition(nsIChannel::DISPOSITION_ATTACHMENT);
michael@0:         NS_ENSURE_SUCCESS(rv, rv);
michael@0:         if (!aFileName.IsEmpty()) {
michael@0:             rv = channel->SetContentDispositionFilename(aFileName);
michael@0:             NS_ENSURE_SUCCESS(rv, rv);
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     if (mLoadType == LOAD_NORMAL_ALLOW_MIXED_CONTENT ||
michael@0:         mLoadType == LOAD_RELOAD_ALLOW_MIXED_CONTENT) {
michael@0:           rv = SetMixedContentChannel(channel);
michael@0:           NS_ENSURE_SUCCESS(rv, rv);
michael@0:     } else if (mMixedContentChannel) {
michael@0:       /*
michael@0:        * If the user "Disables Protection on This Page", we call
michael@0:        * SetMixedContentChannel for the first time, otherwise
michael@0:        * mMixedContentChannel is still null.
michael@0:        * Later, if the new channel passes a same orign check, we remember the
michael@0:        * users decision by calling SetMixedContentChannel using the new channel.
michael@0:        * This way, the user does not have to click the disable protection button
michael@0:        * over and over for browsing the same site.
michael@0:        */
michael@0:       rv = nsContentUtils::CheckSameOrigin(mMixedContentChannel, channel);
michael@0:       if (NS_FAILED(rv) || NS_FAILED(SetMixedContentChannel(channel))) {
michael@0:         SetMixedContentChannel(nullptr);
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     //hack
michael@0:     nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(channel));
michael@0:     nsCOMPtr<nsIHttpChannelInternal> httpChannelInternal(do_QueryInterface(channel));
michael@0:     if (httpChannelInternal) {
michael@0:       if (aForceAllowCookies) {
michael@0:         httpChannelInternal->SetForceAllowThirdPartyCookie(true);
michael@0:       } 
michael@0:       if (aFirstParty) {
michael@0:         httpChannelInternal->SetDocumentURI(aURI);
michael@0:       } else {
michael@0:         httpChannelInternal->SetDocumentURI(aReferrerURI);
michael@0:       }
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIWritablePropertyBag2> props(do_QueryInterface(channel));
michael@0:     if (props)
michael@0:     {
michael@0:       // save true referrer for those who need it (e.g. xpinstall whitelisting)
michael@0:       // Currently only http and ftp channels support this.
michael@0:       props->SetPropertyAsInterface(NS_LITERAL_STRING("docshell.internalReferrer"),
michael@0:                                     aReferrerURI);
michael@0:     }
michael@0: 
michael@0:     //
michael@0:     // If this is a HTTP channel, then set up the HTTP specific information
michael@0:     // (ie. POST data, referrer, ...)
michael@0:     //
michael@0:     if (httpChannel) {
michael@0:         nsCOMPtr<nsICachingChannel>  cacheChannel(do_QueryInterface(httpChannel));
michael@0:         /* Get the cache Key from SH */
michael@0:         nsCOMPtr<nsISupports> cacheKey;
michael@0:         if (mLSHE) {
michael@0:             mLSHE->GetCacheKey(getter_AddRefs(cacheKey));
michael@0:         }
michael@0:         else if (mOSHE)          // for reload cases
michael@0:             mOSHE->GetCacheKey(getter_AddRefs(cacheKey));
michael@0: 
michael@0:         // figure out if we need to set the post data stream on the channel...
michael@0:         // right now, this is only done for http channels.....
michael@0:         if (aPostData) {
michael@0:             // XXX it's a bit of a hack to rewind the postdata stream here but
michael@0:             // it has to be done in case the post data is being reused multiple
michael@0:             // times.
michael@0:             nsCOMPtr<nsISeekableStream>
michael@0:                 postDataSeekable(do_QueryInterface(aPostData));
michael@0:             if (postDataSeekable) {
michael@0:                 rv = postDataSeekable->Seek(nsISeekableStream::NS_SEEK_SET, 0);
michael@0:                 NS_ENSURE_SUCCESS(rv, rv);
michael@0:             }
michael@0: 
michael@0:             nsCOMPtr<nsIUploadChannel> uploadChannel(do_QueryInterface(httpChannel));
michael@0:             NS_ASSERTION(uploadChannel, "http must support nsIUploadChannel");
michael@0: 
michael@0:             // we really need to have a content type associated with this stream!!
michael@0:             uploadChannel->SetUploadStream(aPostData, EmptyCString(), -1);
michael@0:             /* If there is a valid postdata *and* it is a History Load,
michael@0:              * set up the cache key on the channel, to retrieve the
michael@0:              * data *only* from the cache. If it is a normal reload, the 
michael@0:              * cache is free to go to the server for updated postdata. 
michael@0:              */
michael@0:             if (cacheChannel && cacheKey) {
michael@0:                 if (mLoadType == LOAD_HISTORY || mLoadType == LOAD_RELOAD_CHARSET_CHANGE) {
michael@0:                     cacheChannel->SetCacheKey(cacheKey);
michael@0:                     uint32_t loadFlags;
michael@0:                     if (NS_SUCCEEDED(channel->GetLoadFlags(&loadFlags)))
michael@0:                         channel->SetLoadFlags(loadFlags | nsICachingChannel::LOAD_ONLY_FROM_CACHE);
michael@0:                 }
michael@0:                 else if (mLoadType == LOAD_RELOAD_NORMAL)
michael@0:                     cacheChannel->SetCacheKey(cacheKey);
michael@0:             }         
michael@0:         }
michael@0:         else {
michael@0:             /* If there is no postdata, set the cache key on the channel, and
michael@0:              * do not set the LOAD_ONLY_FROM_CACHE flag, so that the channel
michael@0:              * will be free to get it from net if it is not found in cache.
michael@0:              * New cache may use it creatively on CGI pages with GET
michael@0:              * method and even on those that say "no-cache"
michael@0:              */
michael@0:             if (mLoadType == LOAD_HISTORY || mLoadType == LOAD_RELOAD_NORMAL 
michael@0:                 || mLoadType == LOAD_RELOAD_CHARSET_CHANGE) {
michael@0:                 if (cacheChannel && cacheKey)
michael@0:                     cacheChannel->SetCacheKey(cacheKey);
michael@0:             }
michael@0:         }
michael@0:         if (aHeadersData) {
michael@0:             rv = AddHeadersToChannel(aHeadersData, httpChannel);
michael@0:         }
michael@0:         // Set the referrer explicitly
michael@0:         if (aReferrerURI && aSendReferrer) {
michael@0:             // Referrer is currenly only set for link clicks here.
michael@0:             httpChannel->SetReferrer(aReferrerURI);
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIPrincipal> ownerPrincipal;
michael@0: 
michael@0:     // If the content being loaded should be sandboxed with respect to origin
michael@0:     // we need to create a new null principal here, and then tell
michael@0:     // nsContentUtils::SetUpChannelOwner to force it to be set as the
michael@0:     // channel owner.
michael@0:     if (mSandboxFlags & SANDBOXED_ORIGIN) {
michael@0:         ownerPrincipal = do_CreateInstance("@mozilla.org/nullprincipal;1");
michael@0:     } else {
michael@0:         // Not sandboxed - we allow the content to assume its natural owner.
michael@0:         ownerPrincipal = do_QueryInterface(aOwner);
michael@0:     }
michael@0: 
michael@0:     nsContentUtils::SetUpChannelOwner(ownerPrincipal, channel, aURI, true,
michael@0:                                       (mSandboxFlags & SANDBOXED_ORIGIN) ||
michael@0:                                       isSrcdoc);
michael@0: 
michael@0:     nsCOMPtr<nsIScriptChannel> scriptChannel = do_QueryInterface(channel);
michael@0:     if (scriptChannel) {
michael@0:         // Allow execution against our context if the principals match
michael@0:         scriptChannel->
michael@0:             SetExecutionPolicy(nsIScriptChannel::EXECUTE_NORMAL);
michael@0:     }
michael@0: 
michael@0:     if (aIsNewWindowTarget) {
michael@0:         nsCOMPtr<nsIWritablePropertyBag2> props = do_QueryInterface(channel);
michael@0:         if (props) {
michael@0:             props->SetPropertyAsBool(
michael@0:                 NS_LITERAL_STRING("docshell.newWindowTarget"),
michael@0:                 true);
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsITimedChannel> timedChannel(do_QueryInterface(channel));
michael@0:     if (timedChannel) {
michael@0:         timedChannel->SetTimingEnabled(true);
michael@0:         if (IsFrame()) {
michael@0:             timedChannel->SetInitiatorType(NS_LITERAL_STRING("subdocument"));
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     rv = DoChannelLoad(channel, uriLoader, aBypassClassifier);
michael@0: 
michael@0:     //
michael@0:     // If the channel load failed, we failed and nsIWebProgress just ain't
michael@0:     // gonna happen.
michael@0:     //
michael@0:     if (NS_SUCCEEDED(rv)) {
michael@0:         if (aDocShell) {
michael@0:           *aDocShell = this;
michael@0:           NS_ADDREF(*aDocShell);
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     return rv;
michael@0: }
michael@0: 
michael@0: static NS_METHOD
michael@0: AppendSegmentToString(nsIInputStream *in,
michael@0:                       void *closure,
michael@0:                       const char *fromRawSegment,
michael@0:                       uint32_t toOffset,
michael@0:                       uint32_t count,
michael@0:                       uint32_t *writeCount)
michael@0: {
michael@0:     // aFromSegment now contains aCount bytes of data.
michael@0: 
michael@0:     nsAutoCString *buf = static_cast<nsAutoCString *>(closure);
michael@0:     buf->Append(fromRawSegment, count);
michael@0: 
michael@0:     // Indicate that we have consumed all of aFromSegment
michael@0:     *writeCount = count;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::AddHeadersToChannel(nsIInputStream *aHeadersData,
michael@0:                                 nsIChannel *aGenericChannel)
michael@0: {
michael@0:     nsCOMPtr<nsIHttpChannel> httpChannel = do_QueryInterface(aGenericChannel);
michael@0:     NS_ENSURE_STATE(httpChannel);
michael@0: 
michael@0:     uint32_t numRead;
michael@0:     nsAutoCString headersString;
michael@0:     nsresult rv = aHeadersData->ReadSegments(AppendSegmentToString,
michael@0:                                              &headersString,
michael@0:                                              UINT32_MAX,
michael@0:                                              &numRead);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     // used during the manipulation of the String from the InputStream
michael@0:     nsAutoCString headerName;
michael@0:     nsAutoCString headerValue;
michael@0:     int32_t crlf;
michael@0:     int32_t colon;
michael@0: 
michael@0:     //
michael@0:     // Iterate over the headersString: for each "\r\n" delimited chunk,
michael@0:     // add the value as a header to the nsIHttpChannel
michael@0:     //
michael@0: 
michael@0:     static const char kWhitespace[] = "\b\t\r\n ";
michael@0:     while (true) {
michael@0:         crlf = headersString.Find("\r\n");
michael@0:         if (crlf == kNotFound)
michael@0:             return NS_OK;
michael@0: 
michael@0:         const nsCSubstring &oneHeader = StringHead(headersString, crlf);
michael@0: 
michael@0:         colon = oneHeader.FindChar(':');
michael@0:         if (colon == kNotFound)
michael@0:             return NS_ERROR_UNEXPECTED;
michael@0: 
michael@0:         headerName = StringHead(oneHeader, colon);
michael@0:         headerValue = Substring(oneHeader, colon + 1);
michael@0: 
michael@0:         headerName.Trim(kWhitespace);
michael@0:         headerValue.Trim(kWhitespace);
michael@0: 
michael@0:         headersString.Cut(0, crlf + 2);
michael@0: 
michael@0:         //
michael@0:         // FINALLY: we can set the header!
michael@0:         // 
michael@0: 
michael@0:         rv = httpChannel->SetRequestHeader(headerName, headerValue, true);
michael@0:         NS_ENSURE_SUCCESS(rv, rv);
michael@0:     }
michael@0: 
michael@0:     NS_NOTREACHED("oops");
michael@0:     return NS_ERROR_UNEXPECTED;
michael@0: }
michael@0: 
michael@0: nsresult nsDocShell::DoChannelLoad(nsIChannel * aChannel,
michael@0:                                    nsIURILoader * aURILoader,
michael@0:                                    bool aBypassClassifier)
michael@0: {
michael@0:     nsresult rv;
michael@0:     // Mark the channel as being a document URI and allow content sniffing...
michael@0:     nsLoadFlags loadFlags = 0;
michael@0:     (void) aChannel->GetLoadFlags(&loadFlags);
michael@0:     loadFlags |= nsIChannel::LOAD_DOCUMENT_URI |
michael@0:                  nsIChannel::LOAD_CALL_CONTENT_SNIFFERS;
michael@0: 
michael@0:     // Load attributes depend on load type...
michael@0:     switch (mLoadType) {
michael@0:     case LOAD_HISTORY:
michael@0:         {
michael@0:             // Only send VALIDATE_NEVER if mLSHE's URI was never changed via
michael@0:             // push/replaceState (bug 669671).
michael@0:             bool uriModified = false;
michael@0:             if (mLSHE) {
michael@0:                 mLSHE->GetURIWasModified(&uriModified);
michael@0:             }
michael@0: 
michael@0:             if (!uriModified)
michael@0:                 loadFlags |= nsIRequest::VALIDATE_NEVER;
michael@0:         }
michael@0:         break;
michael@0: 
michael@0:     case LOAD_RELOAD_CHARSET_CHANGE:
michael@0:         loadFlags |= nsIRequest::LOAD_FROM_CACHE;
michael@0:         break;
michael@0:     
michael@0:     case LOAD_RELOAD_NORMAL:
michael@0:     case LOAD_REFRESH:
michael@0:         loadFlags |= nsIRequest::VALIDATE_ALWAYS;
michael@0:         break;
michael@0: 
michael@0:     case LOAD_NORMAL_BYPASS_CACHE:
michael@0:     case LOAD_NORMAL_BYPASS_PROXY:
michael@0:     case LOAD_NORMAL_BYPASS_PROXY_AND_CACHE:
michael@0:     case LOAD_NORMAL_ALLOW_MIXED_CONTENT:
michael@0:     case LOAD_RELOAD_BYPASS_CACHE:
michael@0:     case LOAD_RELOAD_BYPASS_PROXY:
michael@0:     case LOAD_RELOAD_BYPASS_PROXY_AND_CACHE:
michael@0:     case LOAD_RELOAD_ALLOW_MIXED_CONTENT:
michael@0:     case LOAD_REPLACE_BYPASS_CACHE:
michael@0:         loadFlags |= nsIRequest::LOAD_BYPASS_CACHE |
michael@0:                      nsIRequest::LOAD_FRESH_CONNECTION;
michael@0:         break;
michael@0: 
michael@0:     case LOAD_NORMAL:
michael@0:     case LOAD_LINK:
michael@0:         // Set cache checking flags
michael@0:         switch (Preferences::GetInt("browser.cache.check_doc_frequency", -1)) {
michael@0:         case 0:
michael@0:             loadFlags |= nsIRequest::VALIDATE_ONCE_PER_SESSION;
michael@0:             break;
michael@0:         case 1:
michael@0:             loadFlags |= nsIRequest::VALIDATE_ALWAYS;
michael@0:             break;
michael@0:         case 2:
michael@0:             loadFlags |= nsIRequest::VALIDATE_NEVER;
michael@0:             break;
michael@0:         }
michael@0:         break;
michael@0:     }
michael@0: 
michael@0:     if (!aBypassClassifier) {
michael@0:         loadFlags |= nsIChannel::LOAD_CLASSIFY_URI;
michael@0:     }
michael@0: 
michael@0:     (void) aChannel->SetLoadFlags(loadFlags);
michael@0: 
michael@0:     uint32_t openFlags = 0;
michael@0:     if (mLoadType == LOAD_LINK) {
michael@0:         openFlags |= nsIURILoader::IS_CONTENT_PREFERRED;
michael@0:     }
michael@0:     if (!mAllowContentRetargeting) {
michael@0:         openFlags |= nsIURILoader::DONT_RETARGET;
michael@0:     }
michael@0:     rv = aURILoader->OpenURI(aChannel, openFlags, this);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::ScrollToAnchor(nsACString & aCurHash, nsACString & aNewHash,
michael@0:                            uint32_t aLoadType)
michael@0: {
michael@0:     if (!mCurrentURI) {
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIPresShell> shell = GetPresShell();
michael@0:     if (!shell) {
michael@0:         // If we failed to get the shell, or if there is no shell,
michael@0:         // nothing left to do here.
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     nsIScrollableFrame* rootScroll = shell->GetRootScrollFrameAsScrollable();
michael@0:     if (rootScroll) {
michael@0:         rootScroll->ClearDidHistoryRestore();
michael@0:     }
michael@0: 
michael@0:     // If we have no new anchor, we do not want to scroll, unless there is a
michael@0:     // current anchor and we are doing a history load.  So return if we have no
michael@0:     // new anchor, and there is no current anchor or the load is not a history
michael@0:     // load.
michael@0:     if ((aCurHash.IsEmpty() || aLoadType != LOAD_HISTORY) &&
michael@0:         aNewHash.IsEmpty()) {
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     // Take the '#' off aNewHash to get the ref name.  (aNewHash might be empty,
michael@0:     // but that's fine.)
michael@0:     nsDependentCSubstring newHashName(aNewHash, 1);
michael@0: 
michael@0:     // Both the new and current URIs refer to the same page. We can now
michael@0:     // browse to the hash stored in the new URI.
michael@0: 
michael@0:     if (!newHashName.IsEmpty()) {
michael@0:         // anchor is there, but if it's a load from history,
michael@0:         // we don't have any anchor jumping to do
michael@0:         bool scroll = aLoadType != LOAD_HISTORY &&
michael@0:                         aLoadType != LOAD_RELOAD_NORMAL;
michael@0: 
michael@0:         char *str = ToNewCString(newHashName);
michael@0:         if (!str) {
michael@0:             return NS_ERROR_OUT_OF_MEMORY;
michael@0:         }
michael@0: 
michael@0:         // nsUnescape modifies the string that is passed into it.
michael@0:         nsUnescape(str);
michael@0: 
michael@0:         // We assume that the bytes are in UTF-8, as it says in the
michael@0:         // spec:
michael@0:         // http://www.w3.org/TR/html4/appendix/notes.html#h-B.2.1
michael@0: 
michael@0:         // We try the UTF-8 string first, and then try the document's
michael@0:         // charset (see below).  If the string is not UTF-8,
michael@0:         // conversion will fail and give us an empty Unicode string.
michael@0:         // In that case, we should just fall through to using the
michael@0:         // page's charset.
michael@0:         nsresult rv = NS_ERROR_FAILURE;
michael@0:         NS_ConvertUTF8toUTF16 uStr(str);
michael@0:         if (!uStr.IsEmpty()) {
michael@0:             rv = shell->GoToAnchor(NS_ConvertUTF8toUTF16(str), scroll);
michael@0:         }
michael@0:         nsMemory::Free(str);
michael@0: 
michael@0:         // Above will fail if the anchor name is not UTF-8.  Need to
michael@0:         // convert from document charset to unicode.
michael@0:         if (NS_FAILED(rv)) {
michael@0:                 
michael@0:             // Get a document charset
michael@0:             NS_ENSURE_TRUE(mContentViewer, NS_ERROR_FAILURE);
michael@0:             nsIDocument* doc = mContentViewer->GetDocument();
michael@0:             NS_ENSURE_TRUE(doc, NS_ERROR_FAILURE);
michael@0:             const nsACString &aCharset = doc->GetDocumentCharacterSet();
michael@0: 
michael@0:             nsCOMPtr<nsITextToSubURI> textToSubURI =
michael@0:                 do_GetService(NS_ITEXTTOSUBURI_CONTRACTID, &rv);
michael@0:             NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:             // Unescape and convert to unicode
michael@0:             nsXPIDLString uStr;
michael@0: 
michael@0:             rv = textToSubURI->UnEscapeAndConvert(PromiseFlatCString(aCharset).get(),
michael@0:                                                   PromiseFlatCString(newHashName).get(),
michael@0:                                                   getter_Copies(uStr));
michael@0:             NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:             // Ignore return value of GoToAnchor, since it will return an error
michael@0:             // if there is no such anchor in the document, which is actually a
michael@0:             // success condition for us (we want to update the session history
michael@0:             // with the new URI no matter whether we actually scrolled
michael@0:             // somewhere).
michael@0:             //
michael@0:             // When newHashName contains "%00", unescaped string may be empty.
michael@0:             // And GoToAnchor asserts if we ask it to scroll to an empty ref.
michael@0:             shell->GoToAnchor(uStr, scroll && !uStr.IsEmpty());
michael@0:         }
michael@0:     }
michael@0:     else {
michael@0: 
michael@0:         // Tell the shell it's at an anchor, without scrolling.
michael@0:         shell->GoToAnchor(EmptyString(), false);
michael@0:         
michael@0:         // An empty anchor was found, but if it's a load from history,
michael@0:         // we don't have to jump to the top of the page. Scrollbar 
michael@0:         // position will be restored by the caller, based on positions
michael@0:         // stored in session history.
michael@0:         if (aLoadType == LOAD_HISTORY || aLoadType == LOAD_RELOAD_NORMAL)
michael@0:             return NS_OK;
michael@0:         // An empty anchor. Scroll to the top of the page.  Ignore the
michael@0:         // return value; failure to scroll here (e.g. if there is no
michael@0:         // root scrollframe) is not grounds for canceling the load!
michael@0:         SetCurScrollPosEx(0, 0);
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsDocShell::SetupReferrerFromChannel(nsIChannel * aChannel)
michael@0: {
michael@0:     nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(aChannel));
michael@0:     if (httpChannel) {
michael@0:         nsCOMPtr<nsIURI> referrer;
michael@0:         nsresult rv = httpChannel->GetReferrer(getter_AddRefs(referrer));
michael@0:         if (NS_SUCCEEDED(rv)) {
michael@0:             SetReferrerURI(referrer);
michael@0:         }
michael@0:     }
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsDocShell::OnNewURI(nsIURI * aURI, nsIChannel * aChannel, nsISupports* aOwner,
michael@0:                      uint32_t aLoadType, bool aFireOnLocationChange,
michael@0:                      bool aAddToGlobalHistory, bool aCloneSHChildren)
michael@0: {
michael@0:     NS_PRECONDITION(aURI, "uri is null");
michael@0:     NS_PRECONDITION(!aChannel || !aOwner, "Shouldn't have both set");
michael@0: 
michael@0: #if defined(PR_LOGGING) && defined(DEBUG)
michael@0:     if (PR_LOG_TEST(gDocShellLog, PR_LOG_DEBUG)) {
michael@0:         nsAutoCString spec;
michael@0:         aURI->GetSpec(spec);
michael@0: 
michael@0:         nsAutoCString chanName;
michael@0:         if (aChannel)
michael@0:             aChannel->GetName(chanName);
michael@0:         else
michael@0:             chanName.AssignLiteral("<no channel>");
michael@0: 
michael@0:         PR_LOG(gDocShellLog, PR_LOG_DEBUG,
michael@0:                ("nsDocShell[%p]::OnNewURI(\"%s\", [%s], 0x%x)\n", this, spec.get(),
michael@0:                 chanName.get(), aLoadType));
michael@0:     }
michael@0: #endif
michael@0: 
michael@0:     bool equalUri = false;
michael@0: 
michael@0:     // Get the post data and the HTTP response code from the channel.
michael@0:     uint32_t responseStatus = 0;
michael@0:     nsCOMPtr<nsIInputStream> inputStream;
michael@0:     if (aChannel) {
michael@0:         nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(aChannel));
michael@0: 
michael@0:         // Check if the HTTPChannel is hiding under a multiPartChannel
michael@0:         if (!httpChannel)  {
michael@0:             GetHttpChannel(aChannel, getter_AddRefs(httpChannel));
michael@0:         }
michael@0: 
michael@0:         if (httpChannel) {
michael@0:             nsCOMPtr<nsIUploadChannel> uploadChannel(do_QueryInterface(httpChannel));
michael@0:             if (uploadChannel) {
michael@0:                 uploadChannel->GetUploadStream(getter_AddRefs(inputStream));
michael@0:             }
michael@0: 
michael@0:             // If the response status indicates an error, unlink this session
michael@0:             // history entry from any entries sharing its document.
michael@0:             nsresult rv = httpChannel->GetResponseStatus(&responseStatus);
michael@0:             if (mLSHE && NS_SUCCEEDED(rv) && responseStatus >= 400) {
michael@0:                 mLSHE->AbandonBFCacheEntry();
michael@0:             }
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // Determine if this type of load should update history.
michael@0:     bool updateGHistory = !(aLoadType == LOAD_BYPASS_HISTORY ||
michael@0:                             aLoadType == LOAD_ERROR_PAGE ||
michael@0:                             aLoadType & LOAD_CMD_HISTORY);
michael@0: 
michael@0:     // We don't update session history on reload.
michael@0:     bool updateSHistory = updateGHistory && (!(aLoadType & LOAD_CMD_RELOAD));
michael@0: 
michael@0:     /* Create SH Entry (mLSHE) only if there is a  SessionHistory object (mSessionHistory) in
michael@0:      * the current frame or in the root docshell
michael@0:      */
michael@0:     nsCOMPtr<nsISHistory> rootSH = mSessionHistory;
michael@0:     if (!rootSH) {
michael@0:         // Get the handle to SH from the root docshell          
michael@0:         GetRootSessionHistory(getter_AddRefs(rootSH));
michael@0:         if (!rootSH) {
michael@0:             updateSHistory = false;
michael@0:             updateGHistory = false; // XXX Why global history too?
michael@0:         }
michael@0:     }  // rootSH
michael@0: 
michael@0:     // Check if the url to be loaded is the same as the one already loaded.
michael@0:     if (mCurrentURI)
michael@0:         aURI->Equals(mCurrentURI, &equalUri);
michael@0: 
michael@0: #ifdef DEBUG
michael@0:     bool shAvailable = (rootSH != nullptr);
michael@0: 
michael@0:     // XXX This log message is almost useless because |updateSHistory|
michael@0:     //     and |updateGHistory| are not correct at this point.
michael@0: 
michael@0:     PR_LOG(gDocShellLog, PR_LOG_DEBUG,
michael@0:            ("  shAvailable=%i updateSHistory=%i updateGHistory=%i"
michael@0:             " equalURI=%i\n",
michael@0:             shAvailable, updateSHistory, updateGHistory, equalUri));
michael@0: 
michael@0:     if (shAvailable && mCurrentURI && !mOSHE && aLoadType != LOAD_ERROR_PAGE) {
michael@0:         NS_ASSERTION(NS_IsAboutBlank(mCurrentURI), "no SHEntry for a non-transient viewer?");
michael@0:     }
michael@0: #endif
michael@0: 
michael@0:     /* If the url to be loaded is the same as the one already there,
michael@0:      * and the original loadType is LOAD_NORMAL, LOAD_LINK, or
michael@0:      * LOAD_STOP_CONTENT, set loadType to LOAD_NORMAL_REPLACE so that
michael@0:      * AddToSessionHistory() won't mess with the current SHEntry and
michael@0:      * if this page has any frame children, it also will be handled
michael@0:      * properly. see bug 83684
michael@0:      *
michael@0:      * NB: If mOSHE is null but we have a current URI, then it means
michael@0:      * that we must be at the transient about:blank content viewer
michael@0:      * (asserted above) and we should let the normal load continue,
michael@0:      * since there's nothing to replace.
michael@0:      *
michael@0:      * XXX Hopefully changing the loadType at this time will not hurt  
michael@0:      *  anywhere. The other way to take care of sequentially repeating
michael@0:      *  frameset pages is to add new methods to nsIDocShellTreeItem.
michael@0:      * Hopefully I don't have to do that. 
michael@0:      */
michael@0:     if (equalUri &&
michael@0:         mOSHE &&
michael@0:         (mLoadType == LOAD_NORMAL ||
michael@0:          mLoadType == LOAD_LINK ||
michael@0:          mLoadType == LOAD_STOP_CONTENT) &&
michael@0:         !inputStream)
michael@0:     {
michael@0:         mLoadType = LOAD_NORMAL_REPLACE;
michael@0:     }
michael@0: 
michael@0:     // If this is a refresh to the currently loaded url, we don't
michael@0:     // have to update session or global history.
michael@0:     if (mLoadType == LOAD_REFRESH && !inputStream && equalUri) {
michael@0:         SetHistoryEntry(&mLSHE, mOSHE);
michael@0:     }
michael@0: 
michael@0:     /* If the user pressed shift-reload, cache will create a new cache key
michael@0:      * for the page. Save the new cacheKey in Session History. 
michael@0:      * see bug 90098
michael@0:      */
michael@0:     if (aChannel &&
michael@0:         (aLoadType == LOAD_RELOAD_BYPASS_CACHE ||
michael@0:          aLoadType == LOAD_RELOAD_BYPASS_PROXY ||
michael@0:          aLoadType == LOAD_RELOAD_BYPASS_PROXY_AND_CACHE ||
michael@0:          aLoadType == LOAD_RELOAD_ALLOW_MIXED_CONTENT)) {
michael@0:         NS_ASSERTION(!updateSHistory,
michael@0:                      "We shouldn't be updating session history for forced"
michael@0:                      " reloads!");
michael@0:         
michael@0:         nsCOMPtr<nsICachingChannel> cacheChannel(do_QueryInterface(aChannel));
michael@0:         nsCOMPtr<nsISupports>  cacheKey;
michael@0:         // Get the Cache Key and store it in SH.
michael@0:         if (cacheChannel)
michael@0:             cacheChannel->GetCacheKey(getter_AddRefs(cacheKey));
michael@0:         // If we already have a loading history entry, store the new cache key
michael@0:         // in it.  Otherwise, since we're doing a reload and won't be updating
michael@0:         // our history entry, store the cache key in our current history entry.
michael@0:         if (mLSHE)
michael@0:             mLSHE->SetCacheKey(cacheKey);
michael@0:         else if (mOSHE)
michael@0:             mOSHE->SetCacheKey(cacheKey);
michael@0: 
michael@0:         // Since we're force-reloading, clear all the sub frame history.
michael@0:         ClearFrameHistory(mLSHE);
michael@0:         ClearFrameHistory(mOSHE);
michael@0:     }
michael@0: 
michael@0:     if (aLoadType == LOAD_RELOAD_NORMAL) {
michael@0:         nsCOMPtr<nsISHEntry> currentSH;
michael@0:         bool oshe = false;
michael@0:         GetCurrentSHEntry(getter_AddRefs(currentSH), &oshe);
michael@0:         bool dynamicallyAddedChild = false;
michael@0:         if (currentSH) {
michael@0:           currentSH->HasDynamicallyAddedChild(&dynamicallyAddedChild);
michael@0:         }
michael@0:         if (dynamicallyAddedChild) {
michael@0:           ClearFrameHistory(currentSH);
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     if (aLoadType == LOAD_REFRESH) {
michael@0:         ClearFrameHistory(mLSHE);
michael@0:         ClearFrameHistory(mOSHE);
michael@0:     }
michael@0: 
michael@0:     if (updateSHistory) { 
michael@0:         // Update session history if necessary...
michael@0:         if (!mLSHE && (mItemType == typeContent) && mURIResultedInDocument) {
michael@0:             /* This is  a fresh page getting loaded for the first time
michael@0:              *.Create a Entry for it and add it to SH, if this is the
michael@0:              * rootDocShell
michael@0:              */
michael@0:             (void) AddToSessionHistory(aURI, aChannel, aOwner, aCloneSHChildren,
michael@0:                                        getter_AddRefs(mLSHE));
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // If this is a POST request, we do not want to include this in global
michael@0:     // history.
michael@0:     if (updateGHistory &&
michael@0:         aAddToGlobalHistory && 
michael@0:         !ChannelIsPost(aChannel)) {
michael@0:         nsCOMPtr<nsIURI> previousURI;
michael@0:         uint32_t previousFlags = 0;
michael@0: 
michael@0:         if (aLoadType & LOAD_CMD_RELOAD) {
michael@0:             // On a reload request, we don't set redirecting flags.
michael@0:             previousURI = aURI;
michael@0:         } else {
michael@0:             ExtractLastVisit(aChannel, getter_AddRefs(previousURI),
michael@0:                              &previousFlags);
michael@0:         }
michael@0: 
michael@0:         // Note: We don't use |referrer| when our global history is
michael@0:         //       based on IHistory.
michael@0:         nsCOMPtr<nsIURI> referrer;
michael@0:         // Treat referrer as null if there is an error getting it.
michael@0:         (void)NS_GetReferrerFromChannel(aChannel, getter_AddRefs(referrer));
michael@0: 
michael@0:         AddURIVisit(aURI, referrer, previousURI, previousFlags, responseStatus);
michael@0:     }
michael@0: 
michael@0:     // If this was a history load or a refresh,
michael@0:     // update the index in SH. 
michael@0:     if (rootSH && (mLoadType & (LOAD_CMD_HISTORY | LOAD_CMD_RELOAD))) {
michael@0:         nsCOMPtr<nsISHistoryInternal> shInternal(do_QueryInterface(rootSH));
michael@0:         if (shInternal) {
michael@0:             rootSH->GetIndex(&mPreviousTransIndex);
michael@0:             shInternal->UpdateIndex();
michael@0:             rootSH->GetIndex(&mLoadedTransIndex);
michael@0: #ifdef DEBUG_PAGE_CACHE
michael@0:             printf("Previous index: %d, Loaded index: %d\n\n",
michael@0:                    mPreviousTransIndex, mLoadedTransIndex);
michael@0: #endif
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // aCloneSHChildren exactly means "we are not loading a new document".
michael@0:     uint32_t locationFlags = aCloneSHChildren?
michael@0:                                  uint32_t(LOCATION_CHANGE_SAME_DOCUMENT) : 0;
michael@0: 
michael@0:     bool onLocationChangeNeeded = SetCurrentURI(aURI, aChannel,
michael@0:                                                 aFireOnLocationChange,
michael@0:                                                 locationFlags);
michael@0:     // Make sure to store the referrer from the channel, if any
michael@0:     SetupReferrerFromChannel(aChannel);
michael@0:     return onLocationChangeNeeded;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsDocShell::OnLoadingSite(nsIChannel * aChannel, bool aFireOnLocationChange,
michael@0:                           bool aAddToGlobalHistory)
michael@0: {
michael@0:     nsCOMPtr<nsIURI> uri;
michael@0:     // If this a redirect, use the final url (uri)
michael@0:     // else use the original url
michael@0:     //
michael@0:     // Note that this should match what documents do (see nsDocument::Reset).
michael@0:     NS_GetFinalChannelURI(aChannel, getter_AddRefs(uri));
michael@0:     NS_ENSURE_TRUE(uri, false);
michael@0: 
michael@0:     // Pass false for aCloneSHChildren, since we're loading a new page here.
michael@0:     return OnNewURI(uri, aChannel, nullptr, mLoadType, aFireOnLocationChange,
michael@0:                     aAddToGlobalHistory, false);
michael@0: 
michael@0: }
michael@0: 
michael@0: void
michael@0: nsDocShell::SetReferrerURI(nsIURI * aURI)
michael@0: {
michael@0:     mReferrerURI = aURI;        // This assigment addrefs
michael@0: }
michael@0: 
michael@0: //*****************************************************************************
michael@0: // nsDocShell: Session History
michael@0: //*****************************************************************************
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::AddState(JS::Handle<JS::Value> aData, const nsAString& aTitle,
michael@0:                      const nsAString& aURL, bool aReplace, JSContext* aCx)
michael@0: {
michael@0:     // Implements History.pushState and History.replaceState
michael@0: 
michael@0:     // Here's what we do, roughly in the order specified by HTML5:
michael@0:     // 1. Serialize aData using structured clone.
michael@0:     // 2. If the third argument is present,
michael@0:     //     a. Resolve the url, relative to the first script's base URL
michael@0:     //     b. If (a) fails, raise a SECURITY_ERR
michael@0:     //     c. Compare the resulting absolute URL to the document's address.  If
michael@0:     //        any part of the URLs difer other than the <path>, <query>, and
michael@0:     //        <fragment> components, raise a SECURITY_ERR and abort.
michael@0:     // 3. If !aReplace:
michael@0:     //     Remove from the session history all entries after the current entry,
michael@0:     //     as we would after a regular navigation, and save the current
michael@0:     //     entry's scroll position (bug 590573).
michael@0:     // 4. As apropriate, either add a state object entry to the session history
michael@0:     //    after the current entry with the following properties, or modify the
michael@0:     //    current session history entry to set
michael@0:     //      a. cloned data as the state object,
michael@0:     //      b. if the third argument was present, the absolute URL found in
michael@0:     //         step 2
michael@0:     //    Also clear the new history entry's POST data (see bug 580069).
michael@0:     // 5. If aReplace is false (i.e. we're doing a pushState instead of a
michael@0:     //    replaceState), notify bfcache that we've navigated to a new page.
michael@0:     // 6. If the third argument is present, set the document's current address
michael@0:     //    to the absolute URL found in step 2.
michael@0:     //
michael@0:     // It's important that this function not run arbitrary scripts after step 1
michael@0:     // and before completing step 5.  For example, if a script called
michael@0:     // history.back() before we completed step 5, bfcache might destroy an
michael@0:     // active content viewer.  Since EvictOutOfRangeContentViewers at the end of
michael@0:     // step 5 might run script, we can't just put a script blocker around the
michael@0:     // critical section.
michael@0:     //
michael@0:     // Note that we completely ignore the aTitle parameter.
michael@0: 
michael@0:     nsresult rv;
michael@0: 
michael@0:     // Don't clobber the load type of an existing network load.
michael@0:     AutoRestore<uint32_t> loadTypeResetter(mLoadType);
michael@0: 
michael@0:     // pushState effectively becomes replaceState when we've started a network
michael@0:     // load but haven't adopted its document yet.  This mirrors what we do with
michael@0:     // changes to the hash at this stage of the game.
michael@0:     if (JustStartedNetworkLoad()) {
michael@0:         aReplace = true;
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIDocument> document = do_GetInterface(GetAsSupports(this));
michael@0:     NS_ENSURE_TRUE(document, NS_ERROR_FAILURE);
michael@0: 
michael@0:     // Step 1: Serialize aData using structured clone.
michael@0:     nsCOMPtr<nsIStructuredCloneContainer> scContainer;
michael@0: 
michael@0:     // scContainer->Init might cause arbitrary JS to run, and this code might
michael@0:     // navigate the page we're on, potentially to a different origin! (bug
michael@0:     // 634834)  To protect against this, we abort if our principal changes due
michael@0:     // to the InitFromJSVal() call.
michael@0:     {
michael@0:         nsCOMPtr<nsIDocument> origDocument =
michael@0:             do_GetInterface(GetAsSupports(this));
michael@0:         if (!origDocument)
michael@0:             return NS_ERROR_DOM_SECURITY_ERR;
michael@0:         nsCOMPtr<nsIPrincipal> origPrincipal = origDocument->NodePrincipal();
michael@0: 
michael@0:         scContainer = new nsStructuredCloneContainer();
michael@0:         JSContext *cx = aCx;
michael@0:         nsCxPusher pusher;
michael@0:         if (!cx) {
michael@0:             cx = nsContentUtils::GetContextFromDocument(document);
michael@0:             pusher.Push(cx);
michael@0:         }
michael@0:         rv = scContainer->InitFromJSVal(aData, cx);
michael@0: 
michael@0:         // If we're running in the document's context and the structured clone
michael@0:         // failed, clear the context's pending exception.  See bug 637116.
michael@0:         if (NS_FAILED(rv) && !aCx) {
michael@0:             JS_ClearPendingException(aCx);
michael@0:         }
michael@0:         NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:         nsCOMPtr<nsIDocument> newDocument =
michael@0:             do_GetInterface(GetAsSupports(this));
michael@0:         if (!newDocument)
michael@0:             return NS_ERROR_DOM_SECURITY_ERR;
michael@0:         nsCOMPtr<nsIPrincipal> newPrincipal = newDocument->NodePrincipal();
michael@0: 
michael@0:         bool principalsEqual = false;
michael@0:         origPrincipal->Equals(newPrincipal, &principalsEqual);
michael@0:         NS_ENSURE_TRUE(principalsEqual, NS_ERROR_DOM_SECURITY_ERR);
michael@0:     }
michael@0: 
michael@0:     // Check that the state object isn't too long.
michael@0:     // Default max length: 640k bytes.
michael@0:     int32_t maxStateObjSize =
michael@0:         Preferences::GetInt("browser.history.maxStateObjectSize", 0xA0000);
michael@0:     if (maxStateObjSize < 0) {
michael@0:         maxStateObjSize = 0;
michael@0:     }
michael@0: 
michael@0:     uint64_t scSize;
michael@0:     rv = scContainer->GetSerializedNBytes(&scSize);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     NS_ENSURE_TRUE(scSize <= (uint32_t)maxStateObjSize,
michael@0:                    NS_ERROR_ILLEGAL_VALUE);
michael@0: 
michael@0:     // Step 2: Resolve aURL
michael@0:     bool equalURIs = true;
michael@0:     nsCOMPtr<nsIURI> currentURI;
michael@0:     if (sURIFixup && mCurrentURI) {
michael@0:         rv = sURIFixup->CreateExposableURI(mCurrentURI,
michael@0:                                            getter_AddRefs(currentURI));
michael@0:         NS_ENSURE_SUCCESS(rv, rv);
michael@0:     } else {
michael@0:         currentURI = mCurrentURI;
michael@0:     }
michael@0:     nsCOMPtr<nsIURI> oldURI = currentURI;
michael@0:     nsCOMPtr<nsIURI> newURI;
michael@0:     if (aURL.Length() == 0) {
michael@0:         newURI = currentURI;
michael@0:     }
michael@0:     else {
michael@0:         // 2a: Resolve aURL relative to mURI
michael@0: 
michael@0:         nsIURI* docBaseURI = document->GetDocBaseURI();
michael@0:         if (!docBaseURI)
michael@0:             return NS_ERROR_FAILURE;
michael@0: 
michael@0:         nsAutoCString spec;
michael@0:         docBaseURI->GetSpec(spec);
michael@0: 
michael@0:         nsAutoCString charset;
michael@0:         rv = docBaseURI->GetOriginCharset(charset);
michael@0:         NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
michael@0: 
michael@0:         rv = NS_NewURI(getter_AddRefs(newURI), aURL,
michael@0:                        charset.get(), docBaseURI);
michael@0: 
michael@0:         // 2b: If 2a fails, raise a SECURITY_ERR
michael@0:         if (NS_FAILED(rv)) {
michael@0:             return NS_ERROR_DOM_SECURITY_ERR;
michael@0:         }
michael@0: 
michael@0:         // 2c: Same-origin check.
michael@0:         if (!nsContentUtils::URIIsLocalFile(newURI)) {
michael@0:             // In addition to checking that the security manager says that
michael@0:             // the new URI has the same origin as our current URI, we also
michael@0:             // check that the two URIs have the same userpass. (The
michael@0:             // security manager says that |http://foo.com| and
michael@0:             // |http://me@foo.com| have the same origin.)  currentURI
michael@0:             // won't contain the password part of the userpass, so this
michael@0:             // means that it's never valid to specify a password in a
michael@0:             // pushState or replaceState URI.
michael@0: 
michael@0:             nsCOMPtr<nsIScriptSecurityManager> secMan =
michael@0:                 do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID);
michael@0:             NS_ENSURE_TRUE(secMan, NS_ERROR_FAILURE);
michael@0: 
michael@0:             // It's very important that we check that newURI is of the same
michael@0:             // origin as currentURI, not docBaseURI, because a page can
michael@0:             // set docBaseURI arbitrarily to any domain.
michael@0:             nsAutoCString currentUserPass, newUserPass;
michael@0:             NS_ENSURE_SUCCESS(currentURI->GetUserPass(currentUserPass),
michael@0:                               NS_ERROR_FAILURE);
michael@0:             NS_ENSURE_SUCCESS(newURI->GetUserPass(newUserPass),
michael@0:                               NS_ERROR_FAILURE);
michael@0:             if (NS_FAILED(secMan->CheckSameOriginURI(currentURI,
michael@0:                                                      newURI, true)) ||
michael@0:                 !currentUserPass.Equals(newUserPass)) {
michael@0: 
michael@0:                 return NS_ERROR_DOM_SECURITY_ERR;
michael@0:             }
michael@0:         }
michael@0:         else {
michael@0:             // It's a file:// URI
michael@0:             nsCOMPtr<nsIScriptObjectPrincipal> docScriptObj =
michael@0:                 do_QueryInterface(document);
michael@0: 
michael@0:             if (!docScriptObj) {
michael@0:                 return NS_ERROR_DOM_SECURITY_ERR;
michael@0:             }
michael@0: 
michael@0:             nsCOMPtr<nsIPrincipal> principal = docScriptObj->GetPrincipal();
michael@0: 
michael@0:             if (!principal ||
michael@0:                 NS_FAILED(principal->CheckMayLoad(newURI, true, false))) {
michael@0: 
michael@0:                 return NS_ERROR_DOM_SECURITY_ERR;
michael@0:             }
michael@0:         }
michael@0: 
michael@0:         if (currentURI) {
michael@0:             currentURI->Equals(newURI, &equalURIs);
michael@0:         }
michael@0:         else {
michael@0:             equalURIs = false;
michael@0:         }
michael@0: 
michael@0:     } // end of same-origin check
michael@0: 
michael@0:     // Step 3: Create a new entry in the session history. This will erase
michael@0:     // all SHEntries after the new entry and make this entry the current
michael@0:     // one.  This operation may modify mOSHE, which we need later, so we
michael@0:     // keep a reference here.
michael@0:     NS_ENSURE_TRUE(mOSHE, NS_ERROR_FAILURE);
michael@0:     nsCOMPtr<nsISHEntry> oldOSHE = mOSHE;
michael@0: 
michael@0:     mLoadType = LOAD_PUSHSTATE;
michael@0: 
michael@0:     nsCOMPtr<nsISHEntry> newSHEntry;
michael@0:     if (!aReplace) {
michael@0:         // Save the current scroll position (bug 590573).
michael@0:         nscoord cx = 0, cy = 0;
michael@0:         GetCurScrollPos(ScrollOrientation_X, &cx);
michael@0:         GetCurScrollPos(ScrollOrientation_Y, &cy);
michael@0:         mOSHE->SetScrollPosition(cx, cy);
michael@0: 
michael@0:         // Since we're not changing which page we have loaded, pass
michael@0:         // true for aCloneChildren.
michael@0:         rv = AddToSessionHistory(newURI, nullptr, nullptr, true,
michael@0:                                  getter_AddRefs(newSHEntry));
michael@0:         NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:         NS_ENSURE_TRUE(newSHEntry, NS_ERROR_FAILURE);
michael@0: 
michael@0:         // Link the new SHEntry to the old SHEntry's BFCache entry, since the
michael@0:         // two entries correspond to the same document.
michael@0:         NS_ENSURE_SUCCESS(newSHEntry->AdoptBFCacheEntry(oldOSHE),
michael@0:                           NS_ERROR_FAILURE);
michael@0: 
michael@0:         // Set the new SHEntry's title (bug 655273).
michael@0:         nsString title;
michael@0:         mOSHE->GetTitle(getter_Copies(title));
michael@0:         newSHEntry->SetTitle(title);
michael@0: 
michael@0:         // AddToSessionHistory may not modify mOSHE.  In case it doesn't,
michael@0:         // we'll just set mOSHE here.
michael@0:         mOSHE = newSHEntry;
michael@0: 
michael@0:     } else {
michael@0:         newSHEntry = mOSHE;
michael@0:         newSHEntry->SetURI(newURI);
michael@0:     }
michael@0: 
michael@0:     // Step 4: Modify new/original session history entry and clear its POST
michael@0:     // data, if there is any.
michael@0:     newSHEntry->SetStateData(scContainer);
michael@0:     newSHEntry->SetPostData(nullptr);
michael@0: 
michael@0:     // If this push/replaceState changed the document's current URI and the new
michael@0:     // URI differs from the old URI in more than the hash, or if the old
michael@0:     // SHEntry's URI was modified in this way by a push/replaceState call
michael@0:     // set URIWasModified to true for the current SHEntry (bug 669671).
michael@0:     bool sameExceptHashes = true, oldURIWasModified = false;
michael@0:     newURI->EqualsExceptRef(currentURI, &sameExceptHashes);
michael@0:     oldOSHE->GetURIWasModified(&oldURIWasModified);
michael@0:     newSHEntry->SetURIWasModified(!sameExceptHashes || oldURIWasModified);
michael@0: 
michael@0:     // Step 5: If aReplace is false, indicating that we're doing a pushState
michael@0:     // rather than a replaceState, notify bfcache that we've added a page to
michael@0:     // the history so it can evict content viewers if appropriate. Otherwise
michael@0:     // call ReplaceEntry so that we notify nsIHistoryListeners that an entry
michael@0:     // was replaced.
michael@0:     nsCOMPtr<nsISHistory> rootSH;
michael@0:     GetRootSessionHistory(getter_AddRefs(rootSH));
michael@0:     NS_ENSURE_TRUE(rootSH, NS_ERROR_UNEXPECTED);
michael@0: 
michael@0:     nsCOMPtr<nsISHistoryInternal> internalSH =
michael@0:         do_QueryInterface(rootSH);
michael@0:     NS_ENSURE_TRUE(internalSH, NS_ERROR_UNEXPECTED);
michael@0: 
michael@0:     if (!aReplace) {
michael@0:         int32_t curIndex = -1;
michael@0:         rv = rootSH->GetIndex(&curIndex);
michael@0:         if (NS_SUCCEEDED(rv) && curIndex > -1) {
michael@0:             internalSH->EvictOutOfRangeContentViewers(curIndex);
michael@0:         }
michael@0:     } else {
michael@0:         nsCOMPtr<nsISHEntry> rootSHEntry = GetRootSHEntry(newSHEntry);
michael@0: 
michael@0:         int32_t index = -1;
michael@0:         rv = rootSH->GetIndexOfEntry(rootSHEntry, &index);
michael@0:         if (NS_SUCCEEDED(rv) && index > -1) {
michael@0:             internalSH->ReplaceEntry(index, rootSHEntry);
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // Step 6: If the document's URI changed, update document's URI and update
michael@0:     // global history.
michael@0:     //
michael@0:     // We need to call FireOnLocationChange so that the browser's address bar
michael@0:     // gets updated and the back button is enabled, but we only need to
michael@0:     // explicitly call FireOnLocationChange if we're not calling SetCurrentURI,
michael@0:     // since SetCurrentURI will call FireOnLocationChange for us.
michael@0:     //
michael@0:     // Both SetCurrentURI(...) and FireDummyOnLocationChange() pass
michael@0:     // nullptr for aRequest param to FireOnLocationChange(...). Such an update
michael@0:     // notification is allowed only when we know docshell is not loading a new
michael@0:     // document and it requires LOCATION_CHANGE_SAME_DOCUMENT flag. Otherwise,
michael@0:     // FireOnLocationChange(...) breaks security UI.
michael@0:     if (!equalURIs) {
michael@0:         SetCurrentURI(newURI, nullptr, true, LOCATION_CHANGE_SAME_DOCUMENT);
michael@0:         document->SetDocumentURI(newURI);
michael@0: 
michael@0:         AddURIVisit(newURI, oldURI, oldURI, 0);
michael@0: 
michael@0:         // AddURIVisit doesn't set the title for the new URI in global history,
michael@0:         // so do that here.
michael@0:         if (mUseGlobalHistory && !mInPrivateBrowsing) {
michael@0:             nsCOMPtr<IHistory> history = services::GetHistoryService();
michael@0:             if (history) {
michael@0:                 history->SetURITitle(newURI, mTitle);
michael@0:             }
michael@0:             else if (mGlobalHistory) {
michael@0:                 mGlobalHistory->SetPageTitle(newURI, mTitle);
michael@0:             }
michael@0:         }
michael@0: 
michael@0:         // Inform the favicon service that our old favicon applies to this new
michael@0:         // URI.
michael@0:         CopyFavicon(oldURI, newURI, mInPrivateBrowsing);
michael@0:     }
michael@0:     else {
michael@0:         FireDummyOnLocationChange();
michael@0:     }
michael@0:     document->SetStateObject(scContainer);
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsDocShell::ShouldAddToSessionHistory(nsIURI * aURI)
michael@0: {
michael@0:     // I believe none of the about: urls should go in the history. But then
michael@0:     // that could just be me... If the intent is only deny about:blank then we
michael@0:     // should just do a spec compare, rather than two gets of the scheme and
michael@0:     // then the path.  -Gagan
michael@0:     nsresult rv;
michael@0:     nsAutoCString buf, pref;
michael@0: 
michael@0:     rv = aURI->GetScheme(buf);
michael@0:     if (NS_FAILED(rv))
michael@0:         return false;
michael@0: 
michael@0:     if (buf.Equals("about")) {
michael@0:         rv = aURI->GetPath(buf);
michael@0:         if (NS_FAILED(rv))
michael@0:             return false;
michael@0: 
michael@0:         if (buf.Equals("blank")) {
michael@0:             return false;
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     rv = Preferences::GetDefaultCString("browser.newtab.url", &pref);
michael@0: 
michael@0:     if (NS_FAILED(rv)) {
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     rv = aURI->GetSpec(buf);
michael@0:     NS_ENSURE_SUCCESS(rv, true);
michael@0: 
michael@0:     return !buf.Equals(pref);
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::AddToSessionHistory(nsIURI * aURI, nsIChannel * aChannel,
michael@0:                                 nsISupports* aOwner, bool aCloneChildren,
michael@0:                                 nsISHEntry ** aNewEntry)
michael@0: {
michael@0:     NS_PRECONDITION(aURI, "uri is null");
michael@0:     NS_PRECONDITION(!aChannel || !aOwner, "Shouldn't have both set");
michael@0: 
michael@0: #if defined(PR_LOGGING) && defined(DEBUG)
michael@0:     if (PR_LOG_TEST(gDocShellLog, PR_LOG_DEBUG)) {
michael@0:         nsAutoCString spec;
michael@0:         aURI->GetSpec(spec);
michael@0: 
michael@0:         nsAutoCString chanName;
michael@0:         if (aChannel)
michael@0:             aChannel->GetName(chanName);
michael@0:         else
michael@0:             chanName.AssignLiteral("<no channel>");
michael@0: 
michael@0:         PR_LOG(gDocShellLog, PR_LOG_DEBUG,
michael@0:                ("nsDocShell[%p]::AddToSessionHistory(\"%s\", [%s])\n", this, spec.get(),
michael@0:                 chanName.get()));
michael@0:     }
michael@0: #endif
michael@0: 
michael@0:     nsresult rv = NS_OK;
michael@0:     nsCOMPtr<nsISHEntry> entry;
michael@0:     bool shouldPersist;
michael@0: 
michael@0:     shouldPersist = ShouldAddToSessionHistory(aURI);
michael@0: 
michael@0:     // Get a handle to the root docshell 
michael@0:     nsCOMPtr<nsIDocShellTreeItem> root;
michael@0:     GetSameTypeRootTreeItem(getter_AddRefs(root));     
michael@0:     /*
michael@0:      * If this is a LOAD_FLAGS_REPLACE_HISTORY in a subframe, we use
michael@0:      * the existing SH entry in the page and replace the url and
michael@0:      * other vitalities.
michael@0:      */
michael@0:     if (LOAD_TYPE_HAS_FLAGS(mLoadType, LOAD_FLAGS_REPLACE_HISTORY) &&
michael@0:         root != static_cast<nsIDocShellTreeItem *>(this)) {
michael@0:         // This is a subframe 
michael@0:         entry = mOSHE;
michael@0:         nsCOMPtr<nsISHContainer> shContainer(do_QueryInterface(entry));
michael@0:         if (shContainer) {
michael@0:             int32_t childCount = 0;
michael@0:             shContainer->GetChildCount(&childCount);
michael@0:             // Remove all children of this entry 
michael@0:             for (int32_t i = childCount - 1; i >= 0; i--) {
michael@0:                 nsCOMPtr<nsISHEntry> child;
michael@0:                 shContainer->GetChildAt(i, getter_AddRefs(child));
michael@0:                 shContainer->RemoveChild(child);
michael@0:             }  // for
michael@0:             entry->AbandonBFCacheEntry();
michael@0:         }  // shContainer
michael@0:     }
michael@0: 
michael@0:     // Create a new entry if necessary.
michael@0:     if (!entry) {
michael@0:         entry = do_CreateInstance(NS_SHENTRY_CONTRACTID);
michael@0: 
michael@0:         if (!entry) {
michael@0:             return NS_ERROR_OUT_OF_MEMORY;
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     // Get the post data & referrer
michael@0:     nsCOMPtr<nsIInputStream> inputStream;
michael@0:     nsCOMPtr<nsIURI> referrerURI;
michael@0:     nsCOMPtr<nsISupports> cacheKey;
michael@0:     nsCOMPtr<nsISupports> owner = aOwner;
michael@0:     bool expired = false;
michael@0:     bool discardLayoutState = false;
michael@0:     nsCOMPtr<nsICachingChannel> cacheChannel;
michael@0:     if (aChannel) {
michael@0:         cacheChannel = do_QueryInterface(aChannel);
michael@0: 
michael@0:         /* If there is a caching channel, get the Cache Key and store it
michael@0:          * in SH.
michael@0:          */
michael@0:         if (cacheChannel) {
michael@0:             cacheChannel->GetCacheKey(getter_AddRefs(cacheKey));
michael@0:         }
michael@0:         nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(aChannel));
michael@0:         
michael@0:         // Check if the httpChannel is hiding under a multipartChannel
michael@0:         if (!httpChannel) {
michael@0:             GetHttpChannel(aChannel, getter_AddRefs(httpChannel));
michael@0:         }
michael@0:         if (httpChannel) {
michael@0:             nsCOMPtr<nsIUploadChannel> uploadChannel(do_QueryInterface(httpChannel));
michael@0:             if (uploadChannel) {
michael@0:                 uploadChannel->GetUploadStream(getter_AddRefs(inputStream));
michael@0:             }
michael@0:             httpChannel->GetReferrer(getter_AddRefs(referrerURI));
michael@0: 
michael@0:             discardLayoutState = ShouldDiscardLayoutState(httpChannel);
michael@0:         }
michael@0:         aChannel->GetOwner(getter_AddRefs(owner));
michael@0:     }
michael@0: 
michael@0:     //Title is set in nsDocShell::SetTitle()
michael@0:     entry->Create(aURI,              // uri
michael@0:                   EmptyString(),     // Title
michael@0:                   inputStream,       // Post data stream
michael@0:                   nullptr,            // LayoutHistory state
michael@0:                   cacheKey,          // CacheKey
michael@0:                   mContentTypeHint,  // Content-type
michael@0:                   owner,             // Channel or provided owner
michael@0:                   mHistoryID,
michael@0:                   mDynamicallyCreated);
michael@0:     entry->SetReferrerURI(referrerURI);
michael@0:     nsCOMPtr<nsIInputStreamChannel> inStrmChan = do_QueryInterface(aChannel);
michael@0:     if (inStrmChan) {
michael@0:         bool isSrcdocChannel;
michael@0:         inStrmChan->GetIsSrcdocChannel(&isSrcdocChannel);
michael@0:         if (isSrcdocChannel) {
michael@0:             nsAutoString srcdoc;
michael@0:             inStrmChan->GetSrcdocData(srcdoc);
michael@0:             entry->SetSrcdocData(srcdoc);
michael@0:             nsCOMPtr<nsIURI> baseURI;
michael@0:             inStrmChan->GetBaseURI(getter_AddRefs(baseURI));
michael@0:             entry->SetBaseURI(baseURI);
michael@0:         }
michael@0:     }
michael@0:     /* If cache got a 'no-store', ask SH not to store
michael@0:      * HistoryLayoutState. By default, SH will set this
michael@0:      * flag to true and save HistoryLayoutState.
michael@0:      */    
michael@0:     if (discardLayoutState) {
michael@0:         entry->SetSaveLayoutStateFlag(false);
michael@0:     }
michael@0:     if (cacheChannel) {
michael@0:         // Check if the page has expired from cache
michael@0:         uint32_t expTime = 0;
michael@0:         cacheChannel->GetCacheTokenExpirationTime(&expTime);
michael@0:         uint32_t now = PRTimeToSeconds(PR_Now());
michael@0:         if (expTime <=  now)
michael@0:             expired = true;
michael@0:     }
michael@0:     if (expired)
michael@0:         entry->SetExpirationStatus(true);
michael@0: 
michael@0: 
michael@0:     if (root == static_cast<nsIDocShellTreeItem *>(this) && mSessionHistory) {
michael@0:         // If we need to clone our children onto the new session
michael@0:         // history entry, do so now.
michael@0:         if (aCloneChildren && mOSHE) {
michael@0:             uint32_t cloneID;
michael@0:             mOSHE->GetID(&cloneID);
michael@0:             nsCOMPtr<nsISHEntry> newEntry;
michael@0:             CloneAndReplace(mOSHE, this, cloneID, entry, true, getter_AddRefs(newEntry));
michael@0:             NS_ASSERTION(entry == newEntry, "The new session history should be in the new entry");
michael@0:         }
michael@0: 
michael@0:         // This is the root docshell
michael@0:         if (LOAD_TYPE_HAS_FLAGS(mLoadType, LOAD_FLAGS_REPLACE_HISTORY)) {            
michael@0:             // Replace current entry in session history.
michael@0:             int32_t  index = 0;   
michael@0:             mSessionHistory->GetIndex(&index);
michael@0:             nsCOMPtr<nsISHistoryInternal>   shPrivate(do_QueryInterface(mSessionHistory));
michael@0:             // Replace the current entry with the new entry
michael@0:             if (shPrivate)
michael@0:                 rv = shPrivate->ReplaceEntry(index, entry);          
michael@0:         }
michael@0:         else {
michael@0:             // Add to session history
michael@0:             nsCOMPtr<nsISHistoryInternal>
michael@0:                 shPrivate(do_QueryInterface(mSessionHistory));
michael@0:             NS_ENSURE_TRUE(shPrivate, NS_ERROR_FAILURE);
michael@0:             mSessionHistory->GetIndex(&mPreviousTransIndex);
michael@0:             rv = shPrivate->AddEntry(entry, shouldPersist);
michael@0:             mSessionHistory->GetIndex(&mLoadedTransIndex);
michael@0: #ifdef DEBUG_PAGE_CACHE
michael@0:             printf("Previous index: %d, Loaded index: %d\n\n",
michael@0:                    mPreviousTransIndex, mLoadedTransIndex);
michael@0: #endif
michael@0:         }
michael@0:     }
michael@0:     else {  
michael@0:         // This is a subframe.
michael@0:         if (!mOSHE || !LOAD_TYPE_HAS_FLAGS(mLoadType,
michael@0:                                            LOAD_FLAGS_REPLACE_HISTORY))
michael@0:             rv = DoAddChildSHEntry(entry, mChildOffset, aCloneChildren);
michael@0:     }
michael@0: 
michael@0:     // Return the new SH entry...
michael@0:     if (aNewEntry) {
michael@0:         *aNewEntry = nullptr;
michael@0:         if (NS_SUCCEEDED(rv)) {
michael@0:             *aNewEntry = entry;
michael@0:             NS_ADDREF(*aNewEntry);
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     return rv;
michael@0: }
michael@0: 
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::LoadHistoryEntry(nsISHEntry * aEntry, uint32_t aLoadType)
michael@0: {
michael@0:     if (!IsNavigationAllowed()) {
michael@0:         return NS_OK;
michael@0:     }
michael@0:     
michael@0:     nsCOMPtr<nsIURI> uri;
michael@0:     nsCOMPtr<nsIInputStream> postData;
michael@0:     nsCOMPtr<nsIURI> referrerURI;
michael@0:     nsAutoCString contentType;
michael@0:     nsCOMPtr<nsISupports> owner;
michael@0: 
michael@0:     NS_ENSURE_TRUE(aEntry, NS_ERROR_FAILURE);
michael@0: 
michael@0:     NS_ENSURE_SUCCESS(aEntry->GetURI(getter_AddRefs(uri)), NS_ERROR_FAILURE);
michael@0:     NS_ENSURE_SUCCESS(aEntry->GetReferrerURI(getter_AddRefs(referrerURI)),
michael@0:                       NS_ERROR_FAILURE);
michael@0:     NS_ENSURE_SUCCESS(aEntry->GetPostData(getter_AddRefs(postData)),
michael@0:                       NS_ERROR_FAILURE);
michael@0:     NS_ENSURE_SUCCESS(aEntry->GetContentType(contentType), NS_ERROR_FAILURE);
michael@0:     NS_ENSURE_SUCCESS(aEntry->GetOwner(getter_AddRefs(owner)),
michael@0:                       NS_ERROR_FAILURE);
michael@0: 
michael@0:     // Calling CreateAboutBlankContentViewer can set mOSHE to null, and if
michael@0:     // that's the only thing holding a ref to aEntry that will cause aEntry to
michael@0:     // die while we're loading it.  So hold a strong ref to aEntry here, just
michael@0:     // in case.
michael@0:     nsCOMPtr<nsISHEntry> kungFuDeathGrip(aEntry);
michael@0:     bool isJS;
michael@0:     nsresult rv = uri->SchemeIs("javascript", &isJS);
michael@0:     if (NS_FAILED(rv) || isJS) {
michael@0:         // We're loading a URL that will execute script from inside asyncOpen.
michael@0:         // Replace the current document with about:blank now to prevent
michael@0:         // anything from the current document from leaking into any JavaScript
michael@0:         // code in the URL.
michael@0:         nsCOMPtr<nsIPrincipal> prin = do_QueryInterface(owner);
michael@0:         // Don't cache the presentation if we're going to just reload the
michael@0:         // current entry. Caching would lead to trying to save the different
michael@0:         // content viewers in the same nsISHEntry object.
michael@0:         rv = CreateAboutBlankContentViewer(prin, nullptr, aEntry != mOSHE);
michael@0: 
michael@0:         if (NS_FAILED(rv)) {
michael@0:             // The creation of the intermittent about:blank content
michael@0:             // viewer failed for some reason (potentially because the
michael@0:             // user prevented it). Interrupt the history load.
michael@0:             return NS_OK;
michael@0:         }
michael@0: 
michael@0:         if (!owner) {
michael@0:             // Ensure that we have an owner.  Otherwise javascript: URIs will
michael@0:             // pick it up from the about:blank page we just loaded, and we
michael@0:             // don't really want even that in this case.
michael@0:             owner = do_CreateInstance("@mozilla.org/nullprincipal;1");
michael@0:             NS_ENSURE_TRUE(owner, NS_ERROR_OUT_OF_MEMORY);
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     /* If there is a valid postdata *and* the user pressed
michael@0:      * reload or shift-reload, take user's permission before we  
michael@0:      * repost the data to the server.
michael@0:      */
michael@0:     if ((aLoadType & LOAD_CMD_RELOAD) && postData) {
michael@0:       bool repost;
michael@0:       rv = ConfirmRepost(&repost);
michael@0:       if (NS_FAILED(rv)) return rv;
michael@0: 
michael@0:       // If the user pressed cancel in the dialog, return.  We're done here.
michael@0:       if (!repost)
michael@0:         return NS_BINDING_ABORTED;
michael@0:     }
michael@0: 
michael@0:     // Do not inherit owner from document (security-critical!);
michael@0:     uint32_t flags = INTERNAL_LOAD_FLAGS_NONE;
michael@0: 
michael@0:     nsAutoString srcdoc;
michael@0:     bool isSrcdoc;
michael@0:     nsCOMPtr<nsIURI> baseURI;
michael@0:     aEntry->GetIsSrcdocEntry(&isSrcdoc);
michael@0:     if (isSrcdoc) {
michael@0:         aEntry->GetSrcdocData(srcdoc);
michael@0:         aEntry->GetBaseURI(getter_AddRefs(baseURI));
michael@0:         flags |= INTERNAL_LOAD_FLAGS_IS_SRCDOC;
michael@0:     }
michael@0:     else {
michael@0:         srcdoc = NullString();
michael@0:     }
michael@0: 
michael@0:     // Passing nullptr as aSourceDocShell gives the same behaviour as before
michael@0:     // aSourceDocShell was introduced. According to spec we should be passing
michael@0:     // the source browsing context that was used when the history entry was
michael@0:     // first created. bug 947716 has been created to address this issue.
michael@0:     rv = InternalLoad(uri,
michael@0:                       referrerURI,
michael@0:                       owner,
michael@0:                       flags,
michael@0:                       nullptr,            // No window target
michael@0:                       contentType.get(),  // Type hint
michael@0:                       NullString(),       // No forced file download
michael@0:                       postData,           // Post data stream
michael@0:                       nullptr,            // No headers stream
michael@0:                       aLoadType,          // Load type
michael@0:                       aEntry,             // SHEntry
michael@0:                       true,
michael@0:                       srcdoc,
michael@0:                       nullptr,            // Source docshell, see comment above
michael@0:                       baseURI,
michael@0:                       nullptr,            // No nsIDocShell
michael@0:                       nullptr);           // No nsIRequest
michael@0:     return rv;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP nsDocShell::GetShouldSaveLayoutState(bool* aShould)
michael@0: {
michael@0:     *aShould = false;
michael@0:     if (mOSHE) {
michael@0:         // Don't capture historystate and save it in history
michael@0:         // if the page asked not to do so.
michael@0:         mOSHE->GetSaveLayoutStateFlag(aShould);
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP nsDocShell::PersistLayoutHistoryState()
michael@0: {
michael@0:     nsresult  rv = NS_OK;
michael@0:     
michael@0:     if (mOSHE) {
michael@0:         nsCOMPtr<nsIPresShell> shell = GetPresShell();
michael@0:         if (shell) {
michael@0:             nsCOMPtr<nsILayoutHistoryState> layoutState;
michael@0:             rv = shell->CaptureHistoryState(getter_AddRefs(layoutState));
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     return rv;
michael@0: }
michael@0: 
michael@0: /* static */ nsresult
michael@0: nsDocShell::WalkHistoryEntries(nsISHEntry *aRootEntry,
michael@0:                                nsDocShell *aRootShell,
michael@0:                                WalkHistoryEntriesFunc aCallback,
michael@0:                                void *aData)
michael@0: {
michael@0:     NS_ENSURE_TRUE(aRootEntry, NS_ERROR_FAILURE);
michael@0: 
michael@0:     nsCOMPtr<nsISHContainer> container(do_QueryInterface(aRootEntry));
michael@0:     if (!container)
michael@0:         return NS_ERROR_FAILURE;
michael@0: 
michael@0:     int32_t childCount;
michael@0:     container->GetChildCount(&childCount);
michael@0:     for (int32_t i = 0; i < childCount; i++) {
michael@0:         nsCOMPtr<nsISHEntry> childEntry;
michael@0:         container->GetChildAt(i, getter_AddRefs(childEntry));
michael@0:         if (!childEntry) {
michael@0:             // childEntry can be null for valid reasons, for example if the
michael@0:             // docshell at index i never loaded anything useful.
michael@0:             // Remember to clone also nulls in the child array (bug 464064).
michael@0:             aCallback(nullptr, nullptr, i, aData);
michael@0:             continue;
michael@0:         }
michael@0: 
michael@0:         nsDocShell *childShell = nullptr;
michael@0:         if (aRootShell) {
michael@0:             // Walk the children of aRootShell and see if one of them
michael@0:             // has srcChild as a SHEntry.
michael@0: 
michael@0:             nsTObserverArray<nsDocLoader*>::ForwardIterator iter(aRootShell->mChildList);
michael@0:             while (iter.HasMore()) {
michael@0:                 nsDocShell *child = static_cast<nsDocShell*>(iter.GetNext());
michael@0: 
michael@0:                 if (child->HasHistoryEntry(childEntry)) {
michael@0:                     childShell = child;
michael@0:                     break;
michael@0:                 }
michael@0:             }
michael@0:         }
michael@0:         nsresult rv = aCallback(childEntry, childShell, i, aData);
michael@0:         NS_ENSURE_SUCCESS(rv, rv);
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: // callback data for WalkHistoryEntries
michael@0: struct MOZ_STACK_CLASS CloneAndReplaceData
michael@0: {
michael@0:     CloneAndReplaceData(uint32_t aCloneID, nsISHEntry *aReplaceEntry,
michael@0:                         bool aCloneChildren, nsISHEntry *aDestTreeParent)
michael@0:         : cloneID(aCloneID),
michael@0:           cloneChildren(aCloneChildren),
michael@0:           replaceEntry(aReplaceEntry),
michael@0:           destTreeParent(aDestTreeParent) { }
michael@0: 
michael@0:     uint32_t              cloneID;
michael@0:     bool                  cloneChildren;
michael@0:     nsISHEntry           *replaceEntry;
michael@0:     nsISHEntry           *destTreeParent;
michael@0:     nsCOMPtr<nsISHEntry>  resultEntry;
michael@0: };
michael@0: 
michael@0: /* static */ nsresult
michael@0: nsDocShell::CloneAndReplaceChild(nsISHEntry *aEntry, nsDocShell *aShell,
michael@0:                                  int32_t aEntryIndex, void *aData)
michael@0: {
michael@0:     nsCOMPtr<nsISHEntry> dest;
michael@0: 
michael@0:     CloneAndReplaceData *data = static_cast<CloneAndReplaceData*>(aData);
michael@0:     uint32_t cloneID = data->cloneID;
michael@0:     nsISHEntry *replaceEntry = data->replaceEntry;
michael@0: 
michael@0:     nsCOMPtr<nsISHContainer> container =
michael@0:       do_QueryInterface(data->destTreeParent);
michael@0:     if (!aEntry) {
michael@0:         if (container) {
michael@0:             container->AddChild(nullptr, aEntryIndex);
michael@0:         }
michael@0:         return NS_OK;
michael@0:     }
michael@0:     
michael@0:     uint32_t srcID;
michael@0:     aEntry->GetID(&srcID);
michael@0: 
michael@0:     nsresult rv = NS_OK;
michael@0:     if (srcID == cloneID) {
michael@0:         // Replace the entry
michael@0:         dest = replaceEntry;
michael@0:     } else {
michael@0:         // Clone the SHEntry...
michael@0:         rv = aEntry->Clone(getter_AddRefs(dest));
michael@0:         NS_ENSURE_SUCCESS(rv, rv);
michael@0:     }
michael@0:     dest->SetIsSubFrame(true);
michael@0: 
michael@0:     if (srcID != cloneID || data->cloneChildren) {
michael@0:         // Walk the children
michael@0:         CloneAndReplaceData childData(cloneID, replaceEntry,
michael@0:                                       data->cloneChildren, dest);
michael@0:         rv = WalkHistoryEntries(aEntry, aShell,
michael@0:                                 CloneAndReplaceChild, &childData);
michael@0:         NS_ENSURE_SUCCESS(rv, rv);
michael@0:     }
michael@0: 
michael@0:     if (srcID != cloneID && aShell) {
michael@0:         aShell->SwapHistoryEntries(aEntry, dest);
michael@0:     }
michael@0: 
michael@0:     if (container)
michael@0:         container->AddChild(dest, aEntryIndex);
michael@0: 
michael@0:     data->resultEntry = dest;
michael@0:     return rv;
michael@0: }
michael@0: 
michael@0: /* static */ nsresult
michael@0: nsDocShell::CloneAndReplace(nsISHEntry *aSrcEntry,
michael@0:                                    nsDocShell *aSrcShell,
michael@0:                                    uint32_t aCloneID,
michael@0:                                    nsISHEntry *aReplaceEntry,
michael@0:                                    bool aCloneChildren,
michael@0:                                    nsISHEntry **aResultEntry)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aResultEntry);
michael@0:     NS_ENSURE_TRUE(aReplaceEntry, NS_ERROR_FAILURE);
michael@0: 
michael@0:     CloneAndReplaceData data(aCloneID, aReplaceEntry, aCloneChildren, nullptr);
michael@0:     nsresult rv = CloneAndReplaceChild(aSrcEntry, aSrcShell, 0, &data);
michael@0: 
michael@0:     data.resultEntry.swap(*aResultEntry);
michael@0:     return rv;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsDocShell::SwapHistoryEntries(nsISHEntry *aOldEntry, nsISHEntry *aNewEntry)
michael@0: {
michael@0:     if (aOldEntry == mOSHE)
michael@0:         mOSHE = aNewEntry;
michael@0: 
michael@0:     if (aOldEntry == mLSHE)
michael@0:         mLSHE = aNewEntry;
michael@0: }
michael@0: 
michael@0: 
michael@0: struct SwapEntriesData
michael@0: {
michael@0:     nsDocShell *ignoreShell;     // constant; the shell to ignore
michael@0:     nsISHEntry *destTreeRoot;    // constant; the root of the dest tree
michael@0:     nsISHEntry *destTreeParent;  // constant; the node under destTreeRoot
michael@0:                                  // whose children will correspond to aEntry
michael@0: };
michael@0: 
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::SetChildHistoryEntry(nsISHEntry *aEntry, nsDocShell *aShell,
michael@0:                                  int32_t aEntryIndex, void *aData)
michael@0: {
michael@0:     SwapEntriesData *data = static_cast<SwapEntriesData*>(aData);
michael@0:     nsDocShell *ignoreShell = data->ignoreShell;
michael@0: 
michael@0:     if (!aShell || aShell == ignoreShell)
michael@0:         return NS_OK;
michael@0: 
michael@0:     nsISHEntry *destTreeRoot = data->destTreeRoot;
michael@0: 
michael@0:     nsCOMPtr<nsISHEntry> destEntry;
michael@0:     nsCOMPtr<nsISHContainer> container =
michael@0:         do_QueryInterface(data->destTreeParent);
michael@0: 
michael@0:     if (container) {
michael@0:         // aEntry is a clone of some child of destTreeParent, but since the
michael@0:         // trees aren't necessarily in sync, we'll have to locate it.
michael@0:         // Note that we could set aShell's entry to null if we don't find a
michael@0:         // corresponding entry under destTreeParent.
michael@0: 
michael@0:         uint32_t targetID, id;
michael@0:         aEntry->GetID(&targetID);
michael@0: 
michael@0:         // First look at the given index, since this is the common case.
michael@0:         nsCOMPtr<nsISHEntry> entry;
michael@0:         container->GetChildAt(aEntryIndex, getter_AddRefs(entry));
michael@0:         if (entry && NS_SUCCEEDED(entry->GetID(&id)) && id == targetID) {
michael@0:             destEntry.swap(entry);
michael@0:         } else {
michael@0:             int32_t childCount;
michael@0:             container->GetChildCount(&childCount);
michael@0:             for (int32_t i = 0; i < childCount; ++i) {
michael@0:                 container->GetChildAt(i, getter_AddRefs(entry));
michael@0:                 if (!entry)
michael@0:                     continue;
michael@0: 
michael@0:                 entry->GetID(&id);
michael@0:                 if (id == targetID) {
michael@0:                     destEntry.swap(entry);
michael@0:                     break;
michael@0:                 }
michael@0:             }
michael@0:         }
michael@0:     } else {
michael@0:         destEntry = destTreeRoot;
michael@0:     }
michael@0: 
michael@0:     aShell->SwapHistoryEntries(aEntry, destEntry);
michael@0: 
michael@0:     // Now handle the children of aEntry.
michael@0:     SwapEntriesData childData = { ignoreShell, destTreeRoot, destEntry };
michael@0:     return WalkHistoryEntries(aEntry, aShell,
michael@0:                               SetChildHistoryEntry, &childData);
michael@0: }
michael@0: 
michael@0: 
michael@0: static nsISHEntry*
michael@0: GetRootSHEntry(nsISHEntry *aEntry)
michael@0: {
michael@0:     nsCOMPtr<nsISHEntry> rootEntry = aEntry;
michael@0:     nsISHEntry *result = nullptr;
michael@0:     while (rootEntry) {
michael@0:         result = rootEntry;
michael@0:         result->GetParent(getter_AddRefs(rootEntry));
michael@0:     }
michael@0: 
michael@0:     return result;
michael@0: }
michael@0: 
michael@0: 
michael@0: void
michael@0: nsDocShell::SetHistoryEntry(nsCOMPtr<nsISHEntry> *aPtr, nsISHEntry *aEntry)
michael@0: {
michael@0:     // We need to sync up the docshell and session history trees for
michael@0:     // subframe navigation.  If the load was in a subframe, we forward up to
michael@0:     // the root docshell, which will then recursively sync up all docshells
michael@0:     // to their corresponding entries in the new session history tree.
michael@0:     // If we don't do this, then we can cache a content viewer on the wrong
michael@0:     // cloned entry, and subsequently restore it at the wrong time.
michael@0: 
michael@0:     nsISHEntry *newRootEntry = GetRootSHEntry(aEntry);
michael@0:     if (newRootEntry) {
michael@0:         // newRootEntry is now the new root entry.
michael@0:         // Find the old root entry as well.
michael@0: 
michael@0:         // Need a strong ref. on |oldRootEntry| so it isn't destroyed when
michael@0:         // SetChildHistoryEntry() does SwapHistoryEntries() (bug 304639).
michael@0:         nsCOMPtr<nsISHEntry> oldRootEntry = GetRootSHEntry(*aPtr);
michael@0:         if (oldRootEntry) {
michael@0:             nsCOMPtr<nsIDocShellTreeItem> rootAsItem;
michael@0:             GetSameTypeRootTreeItem(getter_AddRefs(rootAsItem));
michael@0:             nsCOMPtr<nsIDocShell> rootShell = do_QueryInterface(rootAsItem);
michael@0:             if (rootShell) { // if we're the root just set it, nothing to swap
michael@0:                 SwapEntriesData data = { this, newRootEntry };
michael@0:                 nsIDocShell *rootIDocShell =
michael@0:                     static_cast<nsIDocShell*>(rootShell);
michael@0:                 nsDocShell *rootDocShell = static_cast<nsDocShell*>
michael@0:                                                       (rootIDocShell);
michael@0: 
michael@0: #ifdef DEBUG
michael@0:                 nsresult rv =
michael@0: #endif
michael@0:                 SetChildHistoryEntry(oldRootEntry, rootDocShell,
michael@0:                                                    0, &data);
michael@0:                 NS_ASSERTION(NS_SUCCEEDED(rv), "SetChildHistoryEntry failed");
michael@0:             }
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     *aPtr = aEntry;
michael@0: }
michael@0: 
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::GetRootSessionHistory(nsISHistory ** aReturn)
michael@0: {
michael@0:     nsresult rv;
michael@0: 
michael@0:     nsCOMPtr<nsIDocShellTreeItem> root;
michael@0:     //Get the root docshell
michael@0:     rv = GetSameTypeRootTreeItem(getter_AddRefs(root));
michael@0:     // QI to nsIWebNavigation
michael@0:     nsCOMPtr<nsIWebNavigation> rootAsWebnav(do_QueryInterface(root));
michael@0:     if (rootAsWebnav) {
michael@0:         // Get the handle to SH from the root docshell
michael@0:         rv = rootAsWebnav->GetSessionHistory(aReturn);
michael@0:     }
michael@0:     return rv;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::GetHttpChannel(nsIChannel * aChannel, nsIHttpChannel ** aReturn)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aReturn);
michael@0:     if (!aChannel)
michael@0:         return NS_ERROR_FAILURE;
michael@0: 
michael@0:     nsCOMPtr<nsIMultiPartChannel>  multiPartChannel(do_QueryInterface(aChannel));
michael@0:     if (multiPartChannel) {
michael@0:         nsCOMPtr<nsIChannel> baseChannel;
michael@0:         multiPartChannel->GetBaseChannel(getter_AddRefs(baseChannel));
michael@0:         nsCOMPtr<nsIHttpChannel>  httpChannel(do_QueryInterface(baseChannel));
michael@0:         *aReturn = httpChannel;
michael@0:         NS_IF_ADDREF(*aReturn);
michael@0:     }
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: bool 
michael@0: nsDocShell::ShouldDiscardLayoutState(nsIHttpChannel * aChannel)
michael@0: {    
michael@0:     // By default layout State will be saved. 
michael@0:     if (!aChannel)
michael@0:         return false;
michael@0: 
michael@0:     // figure out if SH should be saving layout state 
michael@0:     nsCOMPtr<nsISupports> securityInfo;
michael@0:     bool noStore = false, noCache = false;
michael@0:     aChannel->GetSecurityInfo(getter_AddRefs(securityInfo));
michael@0:     aChannel->IsNoStoreResponse(&noStore);
michael@0:     aChannel->IsNoCacheResponse(&noCache);
michael@0: 
michael@0:     return (noStore || (noCache && securityInfo));
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP nsDocShell::GetEditor(nsIEditor * *aEditor)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aEditor);
michael@0: 
michael@0:   if (!mEditorData) {
michael@0:     *aEditor = nullptr;
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   return mEditorData->GetEditor(aEditor);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP nsDocShell::SetEditor(nsIEditor * aEditor)
michael@0: {
michael@0:   nsresult rv = EnsureEditorData();
michael@0:   if (NS_FAILED(rv)) return rv;
michael@0: 
michael@0:   return mEditorData->SetEditor(aEditor);
michael@0: }
michael@0: 
michael@0: 
michael@0: NS_IMETHODIMP nsDocShell::GetEditable(bool *aEditable)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aEditable);
michael@0:   *aEditable = mEditorData && mEditorData->GetEditable();
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: 
michael@0: NS_IMETHODIMP nsDocShell::GetHasEditingSession(bool *aHasEditingSession)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(aHasEditingSession);
michael@0:   
michael@0:   if (mEditorData)
michael@0:   {
michael@0:     nsCOMPtr<nsIEditingSession> editingSession;
michael@0:     mEditorData->GetEditingSession(getter_AddRefs(editingSession));
michael@0:     *aHasEditingSession = (editingSession.get() != nullptr);
michael@0:   }
michael@0:   else
michael@0:   {
michael@0:     *aHasEditingSession = false;
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP nsDocShell::MakeEditable(bool inWaitForUriLoad)
michael@0: {
michael@0:   nsresult rv = EnsureEditorData();
michael@0:   if (NS_FAILED(rv)) return rv;
michael@0: 
michael@0:   return mEditorData->MakeEditable(inWaitForUriLoad);
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsDocShell::ChannelIsPost(nsIChannel* aChannel)
michael@0: {
michael@0:     nsCOMPtr<nsIHttpChannel> httpChannel(do_QueryInterface(aChannel));
michael@0:     if (!httpChannel) {
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     nsAutoCString method;
michael@0:     httpChannel->GetRequestMethod(method);
michael@0:     return method.Equals("POST");
michael@0: }
michael@0: 
michael@0: void
michael@0: nsDocShell::ExtractLastVisit(nsIChannel* aChannel,
michael@0:                              nsIURI** aURI,
michael@0:                              uint32_t* aChannelRedirectFlags)
michael@0: {
michael@0:     nsCOMPtr<nsIPropertyBag2> props(do_QueryInterface(aChannel));
michael@0:     if (!props) {
michael@0:         return;
michael@0:     }
michael@0: 
michael@0:     nsresult rv = props->GetPropertyAsInterface(
michael@0:         NS_LITERAL_STRING("docshell.previousURI"),
michael@0:         NS_GET_IID(nsIURI),
michael@0:         reinterpret_cast<void**>(aURI)
michael@0:     );
michael@0: 
michael@0:     if (NS_FAILED(rv)) {
michael@0:         // There is no last visit for this channel, so this must be the first
michael@0:         // link.  Link the visit to the referrer of this request, if any.
michael@0:         // Treat referrer as null if there is an error getting it.
michael@0:         (void)NS_GetReferrerFromChannel(aChannel, aURI);
michael@0:     }
michael@0:     else {
michael@0:       rv = props->GetPropertyAsUint32(
michael@0:           NS_LITERAL_STRING("docshell.previousFlags"),
michael@0:           aChannelRedirectFlags
michael@0:       );
michael@0: 
michael@0:       NS_WARN_IF_FALSE(
michael@0:           NS_SUCCEEDED(rv),
michael@0:           "Could not fetch previous flags, URI will be treated like referrer"
michael@0:       );
michael@0:     }
michael@0: }
michael@0: 
michael@0: void
michael@0: nsDocShell::SaveLastVisit(nsIChannel* aChannel,
michael@0:                           nsIURI* aURI,
michael@0:                           uint32_t aChannelRedirectFlags)
michael@0: {
michael@0:     nsCOMPtr<nsIWritablePropertyBag2> props(do_QueryInterface(aChannel));
michael@0:     if (!props || !aURI) {
michael@0:         return;
michael@0:     }
michael@0: 
michael@0:     props->SetPropertyAsInterface(NS_LITERAL_STRING("docshell.previousURI"),
michael@0:                                   aURI);
michael@0:     props->SetPropertyAsUint32(NS_LITERAL_STRING("docshell.previousFlags"),
michael@0:                                aChannelRedirectFlags);
michael@0: }
michael@0: 
michael@0: void
michael@0: nsDocShell::AddURIVisit(nsIURI* aURI,
michael@0:                         nsIURI* aReferrerURI,
michael@0:                         nsIURI* aPreviousURI,
michael@0:                         uint32_t aChannelRedirectFlags,
michael@0:                         uint32_t aResponseStatus)
michael@0: {
michael@0:     MOZ_ASSERT(aURI, "Visited URI is null!");
michael@0:     MOZ_ASSERT(mLoadType != LOAD_ERROR_PAGE &&
michael@0:                mLoadType != LOAD_BYPASS_HISTORY,
michael@0:                "Do not add error or bypass pages to global history");
michael@0: 
michael@0:     // Only content-type docshells save URI visits.  Also don't do
michael@0:     // anything here if we're not supposed to use global history.
michael@0:     if (mItemType != typeContent || !mUseGlobalHistory || mInPrivateBrowsing) {
michael@0:         return;
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<IHistory> history = services::GetHistoryService();
michael@0: 
michael@0:     if (history) {
michael@0:         uint32_t visitURIFlags = 0;
michael@0: 
michael@0:         if (!IsFrame()) {
michael@0:             visitURIFlags |= IHistory::TOP_LEVEL;
michael@0:         }
michael@0: 
michael@0:         if (aChannelRedirectFlags & nsIChannelEventSink::REDIRECT_TEMPORARY) {
michael@0:             visitURIFlags |= IHistory::REDIRECT_TEMPORARY;
michael@0:         }
michael@0:         else if (aChannelRedirectFlags &
michael@0:                  nsIChannelEventSink::REDIRECT_PERMANENT) {
michael@0:             visitURIFlags |= IHistory::REDIRECT_PERMANENT;
michael@0:         }
michael@0: 
michael@0:         if (aResponseStatus >= 300 && aResponseStatus < 400) {
michael@0:             visitURIFlags |= IHistory::REDIRECT_SOURCE;
michael@0:         }
michael@0:         // Errors 400-501 and 505 are considered unrecoverable, in the sense a
michael@0:         // simple retry attempt by the user is unlikely to solve them.
michael@0:         // 408 is special cased, since may actually indicate a temporary
michael@0:         // connection problem.
michael@0:         else if (aResponseStatus != 408 &&
michael@0:                  ((aResponseStatus >= 400 && aResponseStatus <= 501) ||
michael@0:                    aResponseStatus == 505)) {
michael@0:             visitURIFlags |= IHistory::UNRECOVERABLE_ERROR;
michael@0:         }
michael@0: 
michael@0:         (void)history->VisitURI(aURI, aPreviousURI, visitURIFlags);
michael@0:     }
michael@0:     else if (mGlobalHistory) {
michael@0:         // Falls back to sync global history interface.
michael@0:         (void)mGlobalHistory->AddURI(aURI,
michael@0:                                      !!aChannelRedirectFlags,
michael@0:                                      !IsFrame(),
michael@0:                                      aReferrerURI);
michael@0:     }
michael@0: }
michael@0: 
michael@0: //*****************************************************************************
michael@0: // nsDocShell: Helper Routines
michael@0: //*****************************************************************************
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetLoadType(uint32_t aLoadType)
michael@0: {
michael@0:     mLoadType = aLoadType;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetLoadType(uint32_t * aLoadType)
michael@0: {
michael@0:     *aLoadType = mLoadType;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::ConfirmRepost(bool * aRepost)
michael@0: {
michael@0:   nsCOMPtr<nsIPrompt> prompter;
michael@0:   CallGetInterface(this, static_cast<nsIPrompt**>(getter_AddRefs(prompter)));
michael@0:   if (!prompter) {
michael@0:       return NS_ERROR_NOT_AVAILABLE;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIStringBundleService> stringBundleService =
michael@0:     mozilla::services::GetStringBundleService();
michael@0:   if (!stringBundleService)
michael@0:     return NS_ERROR_FAILURE;
michael@0: 
michael@0:   nsCOMPtr<nsIStringBundle> appBundle;
michael@0:   nsresult rv = stringBundleService->CreateBundle(kAppstringsBundleURL,
michael@0:                                                   getter_AddRefs(appBundle));
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   nsCOMPtr<nsIStringBundle> brandBundle;
michael@0:   rv = stringBundleService->CreateBundle(kBrandBundleURL, getter_AddRefs(brandBundle));
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   NS_ASSERTION(prompter && brandBundle && appBundle,
michael@0:                "Unable to set up repost prompter.");
michael@0: 
michael@0:   nsXPIDLString brandName;
michael@0:   rv = brandBundle->GetStringFromName(MOZ_UTF16("brandShortName"),
michael@0:                                       getter_Copies(brandName));
michael@0: 
michael@0:   nsXPIDLString msgString, button0Title;
michael@0:   if (NS_FAILED(rv)) { // No brand, use the generic version.
michael@0:     rv = appBundle->GetStringFromName(MOZ_UTF16("confirmRepostPrompt"),
michael@0:                                       getter_Copies(msgString));
michael@0:   }
michael@0:   else {
michael@0:     // Brand available - if the app has an override file with formatting, the app name will
michael@0:     // be included. Without an override, the prompt will look like the generic version.
michael@0:     const char16_t *formatStrings[] = { brandName.get() };
michael@0:     rv = appBundle->FormatStringFromName(MOZ_UTF16("confirmRepostPrompt"),
michael@0:                                          formatStrings, ArrayLength(formatStrings),
michael@0:                                          getter_Copies(msgString));
michael@0:   }
michael@0:   if (NS_FAILED(rv)) return rv;
michael@0: 
michael@0:   rv = appBundle->GetStringFromName(MOZ_UTF16("resendButton.label"),
michael@0:                                     getter_Copies(button0Title));
michael@0:   if (NS_FAILED(rv)) return rv;
michael@0: 
michael@0:   int32_t buttonPressed;
michael@0:   // The actual value here is irrelevant, but we can't pass an invalid
michael@0:   // bool through XPConnect.
michael@0:   bool checkState = false;
michael@0:   rv = prompter->
michael@0:          ConfirmEx(nullptr, msgString.get(),
michael@0:                    (nsIPrompt::BUTTON_POS_0 * nsIPrompt::BUTTON_TITLE_IS_STRING) +
michael@0:                    (nsIPrompt::BUTTON_POS_1 * nsIPrompt::BUTTON_TITLE_CANCEL),
michael@0:                    button0Title.get(), nullptr, nullptr, nullptr, &checkState, &buttonPressed);
michael@0:   if (NS_FAILED(rv)) return rv;
michael@0: 
michael@0:   *aRepost = (buttonPressed == 0);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetPromptAndStringBundle(nsIPrompt ** aPrompt,
michael@0:                                      nsIStringBundle ** aStringBundle)
michael@0: {
michael@0:     NS_ENSURE_SUCCESS(GetInterface(NS_GET_IID(nsIPrompt), (void **) aPrompt),
michael@0:                       NS_ERROR_FAILURE);
michael@0: 
michael@0:     nsCOMPtr<nsIStringBundleService> stringBundleService =
michael@0:       mozilla::services::GetStringBundleService();
michael@0:     NS_ENSURE_TRUE(stringBundleService, NS_ERROR_FAILURE);
michael@0: 
michael@0:     NS_ENSURE_SUCCESS(stringBundleService->
michael@0:                       CreateBundle(kAppstringsBundleURL,
michael@0:                                    aStringBundle),
michael@0:                       NS_ERROR_FAILURE);
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetChildOffset(nsIDOMNode * aChild, nsIDOMNode * aParent,
michael@0:                            int32_t * aOffset)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aChild || aParent);
michael@0: 
michael@0:     nsCOMPtr<nsIDOMNodeList> childNodes;
michael@0:     NS_ENSURE_SUCCESS(aParent->GetChildNodes(getter_AddRefs(childNodes)),
michael@0:                       NS_ERROR_FAILURE);
michael@0:     NS_ENSURE_TRUE(childNodes, NS_ERROR_FAILURE);
michael@0: 
michael@0:     int32_t i = 0;
michael@0: 
michael@0:     for (; true; i++) {
michael@0:         nsCOMPtr<nsIDOMNode> childNode;
michael@0:         NS_ENSURE_SUCCESS(childNodes->Item(i, getter_AddRefs(childNode)),
michael@0:                           NS_ERROR_FAILURE);
michael@0:         NS_ENSURE_TRUE(childNode, NS_ERROR_FAILURE);
michael@0: 
michael@0:         if (childNode.get() == aChild) {
michael@0:             *aOffset = i;
michael@0:             return NS_OK;
michael@0:         }
michael@0:     }
michael@0: 
michael@0:     return NS_ERROR_FAILURE;
michael@0: }
michael@0: 
michael@0: nsIScrollableFrame *
michael@0: nsDocShell::GetRootScrollFrame()
michael@0: {
michael@0:     nsCOMPtr<nsIPresShell> shell = GetPresShell();
michael@0:     NS_ENSURE_TRUE(shell, nullptr);
michael@0: 
michael@0:     return shell->GetRootScrollFrameAsScrollableExternal();
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::EnsureScriptEnvironment()
michael@0: {
michael@0:     if (mScriptGlobal)
michael@0:         return NS_OK;
michael@0: 
michael@0:     if (mIsBeingDestroyed) {
michael@0:         return NS_ERROR_NOT_AVAILABLE;
michael@0:     }
michael@0: 
michael@0: #ifdef DEBUG
michael@0:     NS_ASSERTION(!mInEnsureScriptEnv,
michael@0:                  "Infinite loop! Calling EnsureScriptEnvironment() from "
michael@0:                  "within EnsureScriptEnvironment()!");
michael@0: 
michael@0:     // Yeah, this isn't re-entrant safe, but that's ok since if we
michael@0:     // re-enter this method, we'll infinitely loop...
michael@0:     AutoRestore<bool> boolSetter(mInEnsureScriptEnv);
michael@0:     mInEnsureScriptEnv = true;
michael@0: #endif
michael@0: 
michael@0:     nsCOMPtr<nsIWebBrowserChrome> browserChrome(do_GetInterface(mTreeOwner));
michael@0:     NS_ENSURE_TRUE(browserChrome, NS_ERROR_NOT_AVAILABLE);
michael@0: 
michael@0:     uint32_t chromeFlags;
michael@0:     browserChrome->GetChromeFlags(&chromeFlags);
michael@0: 
michael@0:     bool isModalContentWindow = (mItemType == typeContent) &&
michael@0:         (chromeFlags & nsIWebBrowserChrome::CHROME_MODAL_CONTENT_WINDOW);
michael@0:     // There can be various other content docshells associated with the
michael@0:     // top-level window, like sidebars. Make sure that we only create an
michael@0:     // nsGlobalModalWindow for the primary content shell.
michael@0:     if (isModalContentWindow) {
michael@0:         nsCOMPtr<nsIDocShellTreeItem> primaryItem;
michael@0:         nsresult rv = mTreeOwner->GetPrimaryContentShell(getter_AddRefs(primaryItem));
michael@0:         NS_ENSURE_SUCCESS(rv, rv);
michael@0:         isModalContentWindow = (primaryItem == this);
michael@0:     }
michael@0: 
michael@0:     // If our window is modal and we're not opened as chrome, make
michael@0:     // this window a modal content window.
michael@0:     mScriptGlobal =
michael@0:         NS_NewScriptGlobalObject(mItemType == typeChrome, isModalContentWindow);
michael@0:     MOZ_ASSERT(mScriptGlobal);
michael@0: 
michael@0:     mScriptGlobal->SetDocShell(this);
michael@0: 
michael@0:     // Ensure the script object is set up to run script.
michael@0:     return mScriptGlobal->EnsureScriptEnvironment();
michael@0: }
michael@0: 
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::EnsureEditorData()
michael@0: {
michael@0:     bool openDocHasDetachedEditor = mOSHE && mOSHE->HasDetachedEditor();
michael@0:     if (!mEditorData && !mIsBeingDestroyed && !openDocHasDetachedEditor) {
michael@0:         // We shouldn't recreate the editor data if it already exists, or
michael@0:         // we're shutting down, or we already have a detached editor data
michael@0:         // stored in the session history. We should only have one editordata
michael@0:         // per docshell.
michael@0:         mEditorData = new nsDocShellEditorData(this);
michael@0:     }
michael@0: 
michael@0:     return mEditorData ? NS_OK : NS_ERROR_NOT_AVAILABLE;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::EnsureTransferableHookData()
michael@0: {
michael@0:     if (!mTransferableHookData) {
michael@0:         mTransferableHookData = new nsTransferableHookData();
michael@0:         if (!mTransferableHookData) return NS_ERROR_OUT_OF_MEMORY;
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: 
michael@0: NS_IMETHODIMP nsDocShell::EnsureFind()
michael@0: {
michael@0:     nsresult rv;
michael@0:     if (!mFind)
michael@0:     {
michael@0:         mFind = do_CreateInstance("@mozilla.org/embedcomp/find;1", &rv);
michael@0:         if (NS_FAILED(rv)) return rv;
michael@0:     }
michael@0:     
michael@0:     // we promise that the nsIWebBrowserFind that we return has been set
michael@0:     // up to point to the focused, or content window, so we have to
michael@0:     // set that up each time.
michael@0: 
michael@0:     nsIScriptGlobalObject* scriptGO = GetScriptGlobalObject();
michael@0:     NS_ENSURE_TRUE(scriptGO, NS_ERROR_UNEXPECTED);
michael@0: 
michael@0:     // default to our window
michael@0:     nsCOMPtr<nsPIDOMWindow> ourWindow = do_QueryInterface(scriptGO);
michael@0:     nsCOMPtr<nsPIDOMWindow> windowToSearch;
michael@0:     nsFocusManager::GetFocusedDescendant(ourWindow, true, getter_AddRefs(windowToSearch));
michael@0: 
michael@0:     nsCOMPtr<nsIWebBrowserFindInFrames> findInFrames = do_QueryInterface(mFind);
michael@0:     if (!findInFrames) return NS_ERROR_NO_INTERFACE;
michael@0:     
michael@0:     rv = findInFrames->SetRootSearchFrame(ourWindow);
michael@0:     if (NS_FAILED(rv)) return rv;
michael@0:     rv = findInFrames->SetCurrentSearchFrame(windowToSearch);
michael@0:     if (NS_FAILED(rv)) return rv;
michael@0:     
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsDocShell::IsFrame()
michael@0: {
michael@0:     nsCOMPtr<nsIDocShellTreeItem> parent;
michael@0:     GetSameTypeParent(getter_AddRefs(parent));
michael@0:     return !!parent;
michael@0: }
michael@0: 
michael@0: /* boolean IsBeingDestroyed (); */
michael@0: NS_IMETHODIMP 
michael@0: nsDocShell::IsBeingDestroyed(bool *aDoomed)
michael@0: {
michael@0:   NS_ENSURE_ARG(aDoomed);
michael@0:   *aDoomed = mIsBeingDestroyed;
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: 
michael@0: NS_IMETHODIMP 
michael@0: nsDocShell::GetIsExecutingOnLoadHandler(bool *aResult)
michael@0: {
michael@0:   NS_ENSURE_ARG(aResult);
michael@0:   *aResult = mIsExecutingOnLoadHandler;
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetLayoutHistoryState(nsILayoutHistoryState **aLayoutHistoryState)
michael@0: {
michael@0:   if (mOSHE)
michael@0:     mOSHE->GetLayoutHistoryState(aLayoutHistoryState);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetLayoutHistoryState(nsILayoutHistoryState *aLayoutHistoryState)
michael@0: {
michael@0:   if (mOSHE)
michael@0:     mOSHE->SetLayoutHistoryState(aLayoutHistoryState);
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: //*****************************************************************************
michael@0: //***    nsRefreshTimer: Object Management
michael@0: //*****************************************************************************
michael@0: 
michael@0: nsRefreshTimer::nsRefreshTimer()
michael@0:     : mDelay(0), mRepeat(false), mMetaRefresh(false)
michael@0: {
michael@0: }
michael@0: 
michael@0: nsRefreshTimer::~nsRefreshTimer()
michael@0: {
michael@0: }
michael@0: 
michael@0: //*****************************************************************************
michael@0: // nsRefreshTimer::nsISupports
michael@0: //*****************************************************************************   
michael@0: 
michael@0: NS_IMPL_ADDREF(nsRefreshTimer)
michael@0: NS_IMPL_RELEASE(nsRefreshTimer)
michael@0: 
michael@0: NS_INTERFACE_MAP_BEGIN(nsRefreshTimer)
michael@0:     NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsITimerCallback)
michael@0:     NS_INTERFACE_MAP_ENTRY(nsITimerCallback)
michael@0: NS_INTERFACE_MAP_END_THREADSAFE
michael@0: 
michael@0: ///*****************************************************************************
michael@0: // nsRefreshTimer::nsITimerCallback
michael@0: //******************************************************************************
michael@0: NS_IMETHODIMP
michael@0: nsRefreshTimer::Notify(nsITimer * aTimer)
michael@0: {
michael@0:     NS_ASSERTION(mDocShell, "DocShell is somehow null");
michael@0: 
michael@0:     if (mDocShell && aTimer) {
michael@0:         // Get the delay count to determine load type
michael@0:         uint32_t delay = 0;
michael@0:         aTimer->GetDelay(&delay);
michael@0:         mDocShell->ForceRefreshURIFromTimer(mURI, delay, mMetaRefresh, aTimer);
michael@0:     }
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: //*****************************************************************************
michael@0: // nsDocShell::InterfaceRequestorProxy
michael@0: //*****************************************************************************
michael@0: nsDocShell::InterfaceRequestorProxy::InterfaceRequestorProxy(nsIInterfaceRequestor* p)
michael@0: {
michael@0:     if (p) {
michael@0:         mWeakPtr = do_GetWeakReference(p);
michael@0:     }
michael@0: }
michael@0:  
michael@0: nsDocShell::InterfaceRequestorProxy::~InterfaceRequestorProxy()
michael@0: {
michael@0:     mWeakPtr = nullptr;
michael@0: }
michael@0: 
michael@0: NS_IMPL_ISUPPORTS(nsDocShell::InterfaceRequestorProxy, nsIInterfaceRequestor) 
michael@0:   
michael@0: NS_IMETHODIMP 
michael@0: nsDocShell::InterfaceRequestorProxy::GetInterface(const nsIID & aIID, void **aSink)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(aSink);
michael@0:     nsCOMPtr<nsIInterfaceRequestor> ifReq = do_QueryReferent(mWeakPtr);
michael@0:     if (ifReq) {
michael@0:         return ifReq->GetInterface(aIID, aSink);
michael@0:     }
michael@0:     *aSink = nullptr;
michael@0:     return NS_NOINTERFACE;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::SetBaseUrlForWyciwyg(nsIContentViewer * aContentViewer)
michael@0: {
michael@0:     if (!aContentViewer)
michael@0:         return NS_ERROR_FAILURE;
michael@0: 
michael@0:     nsCOMPtr<nsIURI> baseURI;
michael@0:     nsresult rv = NS_ERROR_NOT_AVAILABLE;
michael@0: 
michael@0:     if (sURIFixup)
michael@0:         rv = sURIFixup->CreateExposableURI(mCurrentURI,
michael@0:                                            getter_AddRefs(baseURI));
michael@0: 
michael@0:     // Get the current document and set the base uri
michael@0:     if (baseURI) {
michael@0:         nsIDocument* document = aContentViewer->GetDocument();
michael@0:         if (document) {
michael@0:             rv = document->SetBaseURI(baseURI);
michael@0:         }
michael@0:     }
michael@0:     return rv;
michael@0: }
michael@0: 
michael@0: //*****************************************************************************
michael@0: // nsDocShell::nsIAuthPromptProvider
michael@0: //*****************************************************************************
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetAuthPrompt(uint32_t aPromptReason, const nsIID& iid,
michael@0:                           void** aResult)
michael@0: {
michael@0:     // a priority prompt request will override a false mAllowAuth setting
michael@0:     bool priorityPrompt = (aPromptReason == PROMPT_PROXY);
michael@0: 
michael@0:     if (!mAllowAuth && !priorityPrompt)
michael@0:         return NS_ERROR_NOT_AVAILABLE;
michael@0: 
michael@0:     // we're either allowing auth, or it's a proxy request
michael@0:     nsresult rv;
michael@0:     nsCOMPtr<nsIPromptFactory> wwatch =
michael@0:       do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     rv = EnsureScriptEnvironment();
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:     // Get the an auth prompter for our window so that the parenting
michael@0:     // of the dialogs works as it should when using tabs.
michael@0: 
michael@0:     return wwatch->GetPrompt(mScriptGlobal, iid,
michael@0:                              reinterpret_cast<void**>(aResult));
michael@0: }
michael@0: 
michael@0: //*****************************************************************************
michael@0: // nsDocShell::nsILoadContext
michael@0: //*****************************************************************************
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetAssociatedWindow(nsIDOMWindow** aWindow)
michael@0: {
michael@0:     CallGetInterface(this, aWindow);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetTopWindow(nsIDOMWindow** aWindow)
michael@0: {
michael@0:     nsCOMPtr<nsIDOMWindow> win = do_GetInterface(GetAsSupports(this));
michael@0:     if (win) {
michael@0:         win->GetTop(aWindow);
michael@0:     }
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetTopFrameElement(nsIDOMElement** aElement)
michael@0: {
michael@0:     *aElement = nullptr;
michael@0:     nsCOMPtr<nsIDOMWindow> win = do_GetInterface(GetAsSupports(this));
michael@0:     if (!win) {
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIDOMWindow> top;
michael@0:     win->GetScriptableTop(getter_AddRefs(top));
michael@0:     NS_ENSURE_TRUE(top, NS_ERROR_FAILURE);
michael@0: 
michael@0:     // GetFrameElement, /not/ GetScriptableFrameElement -- if |top| is inside
michael@0:     // <iframe mozbrowser>, we want to return the iframe, not null.
michael@0:     return top->GetFrameElement(aElement);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::IsAppOfType(uint32_t aAppType, bool *aIsOfType)
michael@0: {
michael@0:     nsCOMPtr<nsIDocShell> shell = this;
michael@0:     while (shell) {
michael@0:         uint32_t type;
michael@0:         shell->GetAppType(&type);
michael@0:         if (type == aAppType) {
michael@0:             *aIsOfType = true;
michael@0:             return NS_OK;
michael@0:         }
michael@0:         nsCOMPtr<nsIDocShellTreeItem> item = do_QueryInterface(shell);
michael@0:         nsCOMPtr<nsIDocShellTreeItem> parent;
michael@0:         item->GetParent(getter_AddRefs(parent));
michael@0:         shell = do_QueryInterface(parent);
michael@0:     }
michael@0: 
michael@0:     *aIsOfType = false;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetIsContent(bool *aIsContent)
michael@0: {
michael@0:     *aIsContent = (mItemType == typeContent);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsDocShell::IsOKToLoadURI(nsIURI* aURI)
michael@0: {
michael@0:     NS_PRECONDITION(aURI, "Must have a URI!");
michael@0:     
michael@0:     if (!mFiredUnloadEvent) {
michael@0:         return true;
michael@0:     }
michael@0: 
michael@0:     if (!mLoadingURI) {
michael@0:         return false;
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIScriptSecurityManager> secMan =
michael@0:         do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID);
michael@0:     return
michael@0:         secMan &&
michael@0:         NS_SUCCEEDED(secMan->CheckSameOriginURI(aURI, mLoadingURI, false));
michael@0: }
michael@0: 
michael@0: //
michael@0: // Routines for selection and clipboard
michael@0: //
michael@0: nsresult
michael@0: nsDocShell::GetControllerForCommand(const char * inCommand,
michael@0:                                     nsIController** outController)
michael@0: {
michael@0:     NS_ENSURE_ARG_POINTER(outController);
michael@0:     *outController = nullptr;
michael@0: 
michael@0:     NS_ENSURE_TRUE(mScriptGlobal, NS_ERROR_FAILURE);
michael@0: 
michael@0:     nsCOMPtr<nsPIWindowRoot> root = mScriptGlobal->GetTopWindowRoot();
michael@0:     NS_ENSURE_TRUE(root, NS_ERROR_FAILURE);
michael@0: 
michael@0:     return root->GetControllerForCommand(inCommand, outController);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::IsCommandEnabled(const char * inCommand, bool* outEnabled)
michael@0: {
michael@0:   NS_ENSURE_ARG_POINTER(outEnabled);
michael@0:   *outEnabled = false;
michael@0: 
michael@0:   nsresult rv = NS_ERROR_FAILURE;
michael@0:   
michael@0:   nsCOMPtr<nsIController> controller;
michael@0:   rv = GetControllerForCommand (inCommand, getter_AddRefs(controller));
michael@0:   if (controller)
michael@0:     rv = controller->IsCommandEnabled(inCommand, outEnabled);
michael@0:   
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::DoCommand(const char * inCommand)
michael@0: {
michael@0:   nsresult rv = NS_ERROR_FAILURE;
michael@0:   
michael@0:   nsCOMPtr<nsIController> controller;
michael@0:   rv = GetControllerForCommand(inCommand, getter_AddRefs(controller));
michael@0:   if (controller)
michael@0:     rv = controller->DoCommand(inCommand);
michael@0:   
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsDocShell::EnsureCommandHandler()
michael@0: {
michael@0:   if (!mCommandManager)
michael@0:   {
michael@0:     nsCOMPtr<nsPICommandUpdater> commandUpdater =
michael@0:       do_CreateInstance("@mozilla.org/embedcomp/command-manager;1");
michael@0:     if (!commandUpdater) return NS_ERROR_OUT_OF_MEMORY;
michael@0:     
michael@0:     nsCOMPtr<nsIDOMWindow> domWindow =
michael@0:       do_GetInterface(static_cast<nsIInterfaceRequestor *>(this));
michael@0: 
michael@0:     nsresult rv = commandUpdater->Init(domWindow);
michael@0:     if (NS_SUCCEEDED(rv))
michael@0:       mCommandManager = do_QueryInterface(commandUpdater);
michael@0:   }
michael@0:   
michael@0:   return mCommandManager ? NS_OK : NS_ERROR_FAILURE;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::CanCutSelection(bool* aResult)
michael@0: {
michael@0:   return IsCommandEnabled("cmd_cut", aResult);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::CanCopySelection(bool* aResult)
michael@0: {
michael@0:   return IsCommandEnabled("cmd_copy", aResult);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::CanCopyLinkLocation(bool* aResult)
michael@0: {
michael@0:   return IsCommandEnabled("cmd_copyLink", aResult);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::CanCopyImageLocation(bool* aResult)
michael@0: {
michael@0:   return IsCommandEnabled("cmd_copyImageLocation",
michael@0:                           aResult);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::CanCopyImageContents(bool* aResult)
michael@0: {
michael@0:   return IsCommandEnabled("cmd_copyImageContents",
michael@0:                           aResult);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::CanPaste(bool* aResult)
michael@0: {
michael@0:   return IsCommandEnabled("cmd_paste", aResult);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::CutSelection(void)
michael@0: {
michael@0:   return DoCommand ( "cmd_cut" );
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::CopySelection(void)
michael@0: {
michael@0:   return DoCommand ( "cmd_copy" );
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::CopyLinkLocation(void)
michael@0: {
michael@0:   return DoCommand ( "cmd_copyLink" );
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::CopyImageLocation(void)
michael@0: {
michael@0:   return DoCommand ( "cmd_copyImageLocation" );
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::CopyImageContents(void)
michael@0: {
michael@0:   return DoCommand ( "cmd_copyImageContents" );
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::Paste(void)
michael@0: {
michael@0:   return DoCommand ( "cmd_paste" );
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SelectAll(void)
michael@0: {
michael@0:   return DoCommand ( "cmd_selectAll" );
michael@0: }
michael@0: 
michael@0: //
michael@0: // SelectNone
michael@0: //
michael@0: // Collapses the current selection, insertion point ends up at beginning
michael@0: // of previous selection.
michael@0: //
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SelectNone(void)
michael@0: {
michael@0:   return DoCommand ( "cmd_selectNone" );
michael@0: }
michael@0: 
michael@0: //----------------------------------------------------------------------
michael@0: 
michael@0: // link handling
michael@0: 
michael@0: class OnLinkClickEvent : public nsRunnable {
michael@0: public:
michael@0:   OnLinkClickEvent(nsDocShell* aHandler, nsIContent* aContent,
michael@0:                    nsIURI* aURI,
michael@0:                    const char16_t* aTargetSpec,
michael@0:                    const nsAString& aFileName,
michael@0:                    nsIInputStream* aPostDataStream,
michael@0:                    nsIInputStream* aHeadersDataStream,
michael@0:                    bool aIsTrusted);
michael@0: 
michael@0:   NS_IMETHOD Run() {
michael@0:     nsAutoPopupStatePusher popupStatePusher(mPopupState);
michael@0: 
michael@0:     nsCxPusher pusher;
michael@0:     if (mIsTrusted || pusher.Push(mContent)) {
michael@0:       mHandler->OnLinkClickSync(mContent, mURI,
michael@0:                                 mTargetSpec.get(), mFileName,
michael@0:                                 mPostDataStream, mHeadersDataStream,
michael@0:                                 nullptr, nullptr);
michael@0:     }
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0: private:
michael@0:   nsRefPtr<nsDocShell>     mHandler;
michael@0:   nsCOMPtr<nsIURI>         mURI;
michael@0:   nsString                 mTargetSpec;
michael@0:   nsString                mFileName;
michael@0:   nsCOMPtr<nsIInputStream> mPostDataStream;
michael@0:   nsCOMPtr<nsIInputStream> mHeadersDataStream;
michael@0:   nsCOMPtr<nsIContent>     mContent;
michael@0:   PopupControlState        mPopupState;
michael@0:   bool                     mIsTrusted;
michael@0: };
michael@0: 
michael@0: OnLinkClickEvent::OnLinkClickEvent(nsDocShell* aHandler,
michael@0:                                    nsIContent *aContent,
michael@0:                                    nsIURI* aURI,
michael@0:                                    const char16_t* aTargetSpec,
michael@0:                                    const nsAString& aFileName,
michael@0:                                    nsIInputStream* aPostDataStream,
michael@0:                                    nsIInputStream* aHeadersDataStream,
michael@0:                                    bool aIsTrusted)
michael@0:   : mHandler(aHandler)
michael@0:   , mURI(aURI)
michael@0:   , mTargetSpec(aTargetSpec)
michael@0:   , mFileName(aFileName)
michael@0:   , mPostDataStream(aPostDataStream)
michael@0:   , mHeadersDataStream(aHeadersDataStream)
michael@0:   , mContent(aContent)
michael@0:   , mPopupState(mHandler->mScriptGlobal->GetPopupControlState())
michael@0:   , mIsTrusted(aIsTrusted)
michael@0: {
michael@0: }
michael@0: 
michael@0: //----------------------------------------
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::OnLinkClick(nsIContent* aContent,
michael@0:                         nsIURI* aURI,
michael@0:                         const char16_t* aTargetSpec,
michael@0:                         const nsAString& aFileName,
michael@0:                         nsIInputStream* aPostDataStream,
michael@0:                         nsIInputStream* aHeadersDataStream,
michael@0:                         bool aIsTrusted)
michael@0: {
michael@0:   NS_ASSERTION(NS_IsMainThread(), "wrong thread");
michael@0: 
michael@0:   if (!IsOKToLoadURI(aURI)) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   // On history navigation through Back/Forward buttons, don't execute
michael@0:   // automatic JavaScript redirection such as |anchorElement.click()| or
michael@0:   // |formElement.submit()|.
michael@0:   //
michael@0:   // XXX |formElement.submit()| bypasses this checkpoint because it calls
michael@0:   //     nsDocShell::OnLinkClickSync(...) instead.
michael@0:   if (ShouldBlockLoadingForBackButton()) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   if (aContent->IsEditable()) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   nsresult rv = NS_ERROR_FAILURE;
michael@0:   nsAutoString target;
michael@0: 
michael@0:   nsCOMPtr<nsIWebBrowserChrome3> browserChrome3 = do_GetInterface(mTreeOwner);
michael@0:   if (browserChrome3) {
michael@0:     nsCOMPtr<nsIDOMNode> linkNode = do_QueryInterface(aContent);
michael@0:     nsAutoString oldTarget(aTargetSpec);
michael@0:     rv = browserChrome3->OnBeforeLinkTraversal(oldTarget, aURI,
michael@0:                                                linkNode, mIsAppTab, target);
michael@0:   }
michael@0:   
michael@0:   if (NS_FAILED(rv))
michael@0:     target = aTargetSpec;  
michael@0: 
michael@0:   nsCOMPtr<nsIRunnable> ev =
michael@0:       new OnLinkClickEvent(this, aContent, aURI, target.get(), aFileName, 
michael@0:                            aPostDataStream, aHeadersDataStream, aIsTrusted);
michael@0:   return NS_DispatchToCurrentThread(ev);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::OnLinkClickSync(nsIContent *aContent,
michael@0:                             nsIURI* aURI,
michael@0:                             const char16_t* aTargetSpec,
michael@0:                             const nsAString& aFileName,
michael@0:                             nsIInputStream* aPostDataStream,
michael@0:                             nsIInputStream* aHeadersDataStream,
michael@0:                             nsIDocShell** aDocShell,
michael@0:                             nsIRequest** aRequest)
michael@0: {
michael@0:   // Initialize the DocShell / Request
michael@0:   if (aDocShell) {
michael@0:     *aDocShell = nullptr;
michael@0:   }
michael@0:   if (aRequest) {
michael@0:     *aRequest = nullptr;
michael@0:   }
michael@0: 
michael@0:   if (!IsOKToLoadURI(aURI)) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   // XXX When the linking node was HTMLFormElement, it is synchronous event.
michael@0:   //     That is, the caller of this method is not |OnLinkClickEvent::Run()|
michael@0:   //     but |HTMLFormElement::SubmitSubmission(...)|.
michael@0:   if (nsGkAtoms::form == aContent->Tag() && ShouldBlockLoadingForBackButton()) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   if (aContent->IsEditable()) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   {
michael@0:     // defer to an external protocol handler if necessary...
michael@0:     nsCOMPtr<nsIExternalProtocolService> extProtService =
michael@0:         do_GetService(NS_EXTERNALPROTOCOLSERVICE_CONTRACTID);
michael@0:     if (extProtService) {
michael@0:       nsAutoCString scheme;
michael@0:       aURI->GetScheme(scheme);
michael@0:       if (!scheme.IsEmpty()) {
michael@0:         // if the URL scheme does not correspond to an exposed protocol, then we
michael@0:         // need to hand this link click over to the external protocol handler.
michael@0:         bool isExposed;
michael@0:         nsresult rv = extProtService->IsExposedProtocol(scheme.get(), &isExposed);
michael@0:         if (NS_SUCCEEDED(rv) && !isExposed) {
michael@0:           return extProtService->LoadURI(aURI, this); 
michael@0:         }
michael@0:       }
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // Get the owner document of the link that was clicked, this will be
michael@0:   // the document that the link is in, or the last document that the
michael@0:   // link was in. From that document, we'll get the URI to use as the
michael@0:   // referer, since the current URI in this docshell may be a
michael@0:   // new document that we're in the process of loading.
michael@0:   nsCOMPtr<nsIDocument> refererDoc = aContent->OwnerDoc();
michael@0:   NS_ENSURE_TRUE(refererDoc, NS_ERROR_UNEXPECTED);
michael@0: 
michael@0:   // Now check that the refererDoc's inner window is the current inner
michael@0:   // window for mScriptGlobal.  If it's not, then we don't want to
michael@0:   // follow this link.
michael@0:   nsPIDOMWindow* refererInner = refererDoc->GetInnerWindow();
michael@0:   NS_ENSURE_TRUE(refererInner, NS_ERROR_UNEXPECTED);
michael@0:   if (!mScriptGlobal ||
michael@0:       mScriptGlobal->GetCurrentInnerWindow() != refererInner) {
michael@0:       // We're no longer the current inner window
michael@0:       return NS_OK;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIURI> referer = refererDoc->GetDocumentURI();
michael@0: 
michael@0:   // referer could be null here in some odd cases, but that's ok,
michael@0:   // we'll just load the link w/o sending a referer in those cases.
michael@0: 
michael@0:   nsAutoString target(aTargetSpec);
michael@0: 
michael@0:   // If this is an anchor element, grab its type property to use as a hint
michael@0:   nsAutoString typeHint;
michael@0:   nsCOMPtr<nsIDOMHTMLAnchorElement> anchor(do_QueryInterface(aContent));
michael@0:   if (anchor) {
michael@0:     anchor->GetType(typeHint);
michael@0:     NS_ConvertUTF16toUTF8 utf8Hint(typeHint);
michael@0:     nsAutoCString type, dummy;
michael@0:     NS_ParseContentType(utf8Hint, type, dummy);
michael@0:     CopyUTF8toUTF16(type, typeHint);
michael@0:   }
michael@0: 
michael@0:   // Clone the URI now, in case a content policy or something messes
michael@0:   // with it under InternalLoad; we do _not_ want to change the URI
michael@0:   // our caller passed in.
michael@0:   nsCOMPtr<nsIURI> clonedURI;
michael@0:   aURI->Clone(getter_AddRefs(clonedURI));
michael@0:   if (!clonedURI) {
michael@0:     return NS_ERROR_OUT_OF_MEMORY;
michael@0:   }
michael@0: 
michael@0:   nsresult rv = InternalLoad(clonedURI,                 // New URI
michael@0:                              referer,                   // Referer URI
michael@0:                              aContent->NodePrincipal(), // Owner is our node's
michael@0:                                                         // principal
michael@0:                              INTERNAL_LOAD_FLAGS_NONE,
michael@0:                              target.get(),              // Window target
michael@0:                              NS_LossyConvertUTF16toASCII(typeHint).get(),
michael@0:                              aFileName,                 // Download as file
michael@0:                              aPostDataStream,           // Post data stream
michael@0:                              aHeadersDataStream,        // Headers stream
michael@0:                              LOAD_LINK,                 // Load type
michael@0:                              nullptr,                   // No SHEntry
michael@0:                              true,                      // first party site
michael@0:                              NullString(),              // No srcdoc
michael@0:                              this,                      // We are the source
michael@0:                              nullptr,                   // baseURI not needed
michael@0:                              aDocShell,                 // DocShell out-param
michael@0:                              aRequest);                 // Request out-param
michael@0:   if (NS_SUCCEEDED(rv)) {
michael@0:     DispatchPings(aContent, aURI, referer);
michael@0:   }
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::OnOverLink(nsIContent* aContent,
michael@0:                        nsIURI* aURI,
michael@0:                        const char16_t* aTargetSpec)
michael@0: {
michael@0:   if (aContent->IsEditable()) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsIWebBrowserChrome2> browserChrome2 = do_GetInterface(mTreeOwner);
michael@0:   nsresult rv = NS_ERROR_FAILURE;
michael@0: 
michael@0:   nsCOMPtr<nsIWebBrowserChrome> browserChrome;
michael@0:   if (!browserChrome2) {
michael@0:     browserChrome = do_GetInterface(mTreeOwner);
michael@0:     if (!browserChrome)
michael@0:       return rv;
michael@0:   }
michael@0: 
michael@0:   nsCOMPtr<nsITextToSubURI> textToSubURI =
michael@0:       do_GetService(NS_ITEXTTOSUBURI_CONTRACTID, &rv);
michael@0:   if (NS_FAILED(rv))
michael@0:     return rv;
michael@0: 
michael@0:   // use url origin charset to unescape the URL
michael@0:   nsAutoCString charset;
michael@0:   rv = aURI->GetOriginCharset(charset);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   nsAutoCString spec;
michael@0:   rv = aURI->GetSpec(spec);
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   nsAutoString uStr;
michael@0:   rv = textToSubURI->UnEscapeURIForUI(charset, spec, uStr);    
michael@0:   NS_ENSURE_SUCCESS(rv, rv);
michael@0: 
michael@0:   mozilla::net::SeerPredict(aURI, mCurrentURI, nsINetworkSeer::PREDICT_LINK,
michael@0:                             this, nullptr);
michael@0: 
michael@0:   if (browserChrome2) {
michael@0:     nsCOMPtr<nsIDOMElement> element = do_QueryInterface(aContent);
michael@0:     rv = browserChrome2->SetStatusWithContext(nsIWebBrowserChrome::STATUS_LINK,
michael@0:                                               uStr, element);
michael@0:   } else {
michael@0:     rv = browserChrome->SetStatus(nsIWebBrowserChrome::STATUS_LINK, uStr.get());
michael@0:   }
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::OnLeaveLink()
michael@0: {
michael@0:   nsCOMPtr<nsIWebBrowserChrome> browserChrome(do_GetInterface(mTreeOwner));
michael@0:   nsresult rv = NS_ERROR_FAILURE;
michael@0: 
michael@0:   if (browserChrome)  {
michael@0:       rv = browserChrome->SetStatus(nsIWebBrowserChrome::STATUS_LINK,
michael@0:                                     EmptyString().get());
michael@0:   }
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsDocShell::ShouldBlockLoadingForBackButton()
michael@0: {
michael@0:   if (!(mLoadType & LOAD_CMD_HISTORY) ||
michael@0:       EventStateManager::IsHandlingUserInput() ||
michael@0:       !Preferences::GetBool("accessibility.blockjsredirection")) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   bool canGoForward = false;
michael@0:   GetCanGoForward(&canGoForward);
michael@0:   return canGoForward;
michael@0: }
michael@0: 
michael@0: bool 
michael@0: nsDocShell::PluginsAllowedInCurrentDoc()
michael@0: {
michael@0:   bool pluginsAllowed = false;
michael@0: 
michael@0:   if (!mContentViewer) {
michael@0:     return false;
michael@0:   }
michael@0:   
michael@0:   nsIDocument* doc = mContentViewer->GetDocument();
michael@0:   if (!doc) {
michael@0:     return false;
michael@0:   }
michael@0:   
michael@0:   doc->GetAllowPlugins(&pluginsAllowed);
michael@0:   return pluginsAllowed;
michael@0: }
michael@0: 
michael@0: //----------------------------------------------------------------------
michael@0: // Web Shell Services API
michael@0: 
michael@0: //This functions is only called when a new charset is detected in loading a document. 
michael@0: //Its name should be changed to "CharsetReloadDocument"
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::ReloadDocument(const char* aCharset,
michael@0:                            int32_t aSource)
michael@0: {
michael@0: 
michael@0:   // XXX hack. keep the aCharset and aSource wait to pick it up
michael@0:   nsCOMPtr<nsIContentViewer> cv;
michael@0:   NS_ENSURE_SUCCESS(GetContentViewer(getter_AddRefs(cv)), NS_ERROR_FAILURE);
michael@0:   if (cv)
michael@0:   {
michael@0:     nsCOMPtr<nsIMarkupDocumentViewer> muDV = do_QueryInterface(cv);  
michael@0:     if (muDV)
michael@0:     {
michael@0:       int32_t hint;
michael@0:       muDV->GetHintCharacterSetSource(&hint);
michael@0:       if (aSource > hint)
michael@0:       {
michael@0:         nsCString charset(aCharset);
michael@0:         muDV->SetHintCharacterSet(charset);
michael@0:         muDV->SetHintCharacterSetSource(aSource);
michael@0:         if(eCharsetReloadRequested != mCharsetReloadState) 
michael@0:         {
michael@0:           mCharsetReloadState = eCharsetReloadRequested;
michael@0:           return Reload(LOAD_FLAGS_CHARSET_CHANGE);
michael@0:         }
michael@0:       }
michael@0:     }
michael@0:   }
michael@0:   //return failure if this request is not accepted due to mCharsetReloadState
michael@0:   return NS_ERROR_DOCSHELL_REQUEST_REJECTED;
michael@0: }
michael@0: 
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::StopDocumentLoad(void)
michael@0: {
michael@0:   if(eCharsetReloadRequested != mCharsetReloadState) 
michael@0:   {
michael@0:     Stop(nsIWebNavigation::STOP_ALL);
michael@0:     return NS_OK;
michael@0:   }
michael@0:   //return failer if this request is not accepted due to mCharsetReloadState
michael@0:   return NS_ERROR_DOCSHELL_REQUEST_REJECTED;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetPrintPreview(nsIWebBrowserPrint** aPrintPreview)
michael@0: {
michael@0:   *aPrintPreview = nullptr;
michael@0: #if NS_PRINT_PREVIEW
michael@0:   nsCOMPtr<nsIDocumentViewerPrint> print = do_QueryInterface(mContentViewer);
michael@0:   if (!print || !print->IsInitializedForPrintPreview()) {
michael@0:     Stop(nsIWebNavigation::STOP_ALL);
michael@0:     nsCOMPtr<nsIPrincipal> principal =
michael@0:       do_CreateInstance("@mozilla.org/nullprincipal;1");
michael@0:     NS_ENSURE_STATE(principal);
michael@0:     nsresult rv = CreateAboutBlankContentViewer(principal, nullptr);
michael@0:     NS_ENSURE_SUCCESS(rv, rv);
michael@0:     print = do_QueryInterface(mContentViewer);
michael@0:     NS_ENSURE_STATE(print);
michael@0:     print->InitializeForPrintPreview();
michael@0:   }
michael@0:   nsCOMPtr<nsIWebBrowserPrint> result = do_QueryInterface(print);
michael@0:   result.forget(aPrintPreview);
michael@0:   return NS_OK;
michael@0: #else
michael@0:   return NS_ERROR_NOT_IMPLEMENTED;
michael@0: #endif
michael@0: }
michael@0: 
michael@0: 
michael@0: #ifdef DEBUG
michael@0: unsigned long nsDocShell::gNumberOfDocShells = 0;
michael@0: #endif
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetCanExecuteScripts(bool *aResult)
michael@0: {
michael@0:   *aResult = mCanExecuteScripts;
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetIsApp(uint32_t aOwnAppId)
michael@0: {
michael@0:     mOwnOrContainingAppId = aOwnAppId;
michael@0:     if (aOwnAppId != nsIScriptSecurityManager::NO_APP_ID &&
michael@0:         aOwnAppId != nsIScriptSecurityManager::UNKNOWN_APP_ID) {
michael@0:         mFrameType = eFrameTypeApp;
michael@0:     } else {
michael@0:         mFrameType = eFrameTypeRegular;
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::SetIsBrowserInsideApp(uint32_t aContainingAppId)
michael@0: {
michael@0:     mOwnOrContainingAppId = aContainingAppId;
michael@0:     mFrameType = eFrameTypeBrowser;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: /* [infallible] */ NS_IMETHODIMP
michael@0: nsDocShell::GetIsBrowserElement(bool* aIsBrowser)
michael@0: {
michael@0:     *aIsBrowser = (mFrameType == eFrameTypeBrowser);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: /* [infallible] */ NS_IMETHODIMP
michael@0: nsDocShell::GetIsApp(bool* aIsApp)
michael@0: {
michael@0:     *aIsApp = (mFrameType == eFrameTypeApp);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: /* [infallible] */ NS_IMETHODIMP
michael@0: nsDocShell::GetIsBrowserOrApp(bool* aIsBrowserOrApp)
michael@0: {
michael@0:     switch (mFrameType) {
michael@0:         case eFrameTypeRegular:
michael@0:             *aIsBrowserOrApp = false;
michael@0:             break;
michael@0:         case eFrameTypeBrowser:
michael@0:         case eFrameTypeApp:
michael@0:             *aIsBrowserOrApp = true;
michael@0:             break;
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: nsDocShell::FrameType
michael@0: nsDocShell::GetInheritedFrameType()
michael@0: {
michael@0:     if (mFrameType != eFrameTypeRegular) {
michael@0:         return mFrameType;
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIDocShellTreeItem> parentAsItem;
michael@0:     GetSameTypeParent(getter_AddRefs(parentAsItem));
michael@0: 
michael@0:     nsCOMPtr<nsIDocShell> parent = do_QueryInterface(parentAsItem);
michael@0:     if (!parent) {
michael@0:         return eFrameTypeRegular;
michael@0:     }
michael@0: 
michael@0:     return static_cast<nsDocShell*>(parent.get())->GetInheritedFrameType();
michael@0: }
michael@0: 
michael@0: /* [infallible] */ NS_IMETHODIMP
michael@0: nsDocShell::GetIsInBrowserElement(bool* aIsInBrowserElement)
michael@0: {
michael@0:     *aIsInBrowserElement = (GetInheritedFrameType() == eFrameTypeBrowser);
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: /* [infallible] */ NS_IMETHODIMP
michael@0: nsDocShell::GetIsInBrowserOrApp(bool* aIsInBrowserOrApp)
michael@0: {
michael@0:     switch (GetInheritedFrameType()) {
michael@0:         case eFrameTypeRegular:
michael@0:             *aIsInBrowserOrApp = false;
michael@0:             break;
michael@0:         case eFrameTypeBrowser:
michael@0:         case eFrameTypeApp:
michael@0:             *aIsInBrowserOrApp = true;
michael@0:             break;
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: /* [infallible] */ NS_IMETHODIMP
michael@0: nsDocShell::GetAppId(uint32_t* aAppId)
michael@0: {
michael@0:     if (mOwnOrContainingAppId != nsIScriptSecurityManager::UNKNOWN_APP_ID) {
michael@0:         *aAppId = mOwnOrContainingAppId;
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     nsCOMPtr<nsIDocShell> parent;
michael@0:     GetSameTypeParentIgnoreBrowserAndAppBoundaries(getter_AddRefs(parent));
michael@0: 
michael@0:     if (!parent) {
michael@0:         *aAppId = nsIScriptSecurityManager::NO_APP_ID;
michael@0:         return NS_OK;
michael@0:     }
michael@0: 
michael@0:     return parent->GetAppId(aAppId);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetAppManifestURL(nsAString& aAppManifestURL)
michael@0: {
michael@0:   uint32_t appId;
michael@0:   GetAppId(&appId);
michael@0: 
michael@0:   if (appId != nsIScriptSecurityManager::NO_APP_ID &&
michael@0:       appId != nsIScriptSecurityManager::UNKNOWN_APP_ID) {
michael@0:     nsCOMPtr<nsIAppsService> appsService =
michael@0:       do_GetService(APPS_SERVICE_CONTRACTID);
michael@0:     NS_ASSERTION(appsService, "No AppsService available");
michael@0:     appsService->GetManifestURLByLocalId(appId, aAppManifestURL);
michael@0:   } else {
michael@0:     aAppManifestURL.SetLength(0);
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsDocShell::GetAsyncPanZoomEnabled(bool* aOut)
michael@0: {
michael@0:     if (TabChild* tabChild = TabChild::GetFrom(this)) {
michael@0:         *aOut = tabChild->IsAsyncPanZoomEnabled();
michael@0:         return NS_OK;
michael@0:     }
michael@0:     *aOut = false;
michael@0:     return NS_OK;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsDocShell::HasUnloadedParent()
michael@0: {
michael@0:     nsCOMPtr<nsIDocShellTreeItem> currentTreeItem = this;
michael@0:     while (currentTreeItem) {
michael@0:         nsCOMPtr<nsIDocShellTreeItem> parentTreeItem;
michael@0:         currentTreeItem->GetParent(getter_AddRefs(parentTreeItem));
michael@0:         nsCOMPtr<nsIDocShell> parent = do_QueryInterface(parentTreeItem);
michael@0:         if (parent) {
michael@0:             bool inUnload = false;
michael@0:             parent->GetIsInUnload(&inUnload);
michael@0:             if (inUnload) {
michael@0:                 return true;
michael@0:             }
michael@0:         }
michael@0:         currentTreeItem.swap(parentTreeItem);
michael@0:     }
michael@0:     return false;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsDocShell::IsInvisible()
michael@0: {
michael@0:     return mInvisible;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsDocShell::SetInvisible(bool aInvisible)
michael@0: {
michael@0:     mInvisible = aInvisible;
michael@0: }