Add m-esr52 at 52.6.0

1 files changed, 4668 insertions, 0 deletions

diff --git a/layout/base/nsDocumentViewer.cpp b/layout/base/nsDocumentViewer.cpp
new file mode 100644
index 000000000..a1105ae52
--- /dev/null
+++ b/layout/base/nsDocumentViewer.cpp
@@ -0,0 +1,4668 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 sw=2 et tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* container for a document and its presentation */
+
+#include "mozilla/ServoStyleSet.h"
+#include "nsAutoPtr.h"
+#include "nscore.h"
+#include "nsCOMPtr.h"
+#include "nsCRT.h"
+#include "nsString.h"
+#include "nsReadableUtils.h"
+#include "nsIContent.h"
+#include "nsIContentViewerContainer.h"
+#include "nsIContentViewer.h"
+#include "nsIDocumentViewerPrint.h"
+#include "nsIDOMBeforeUnloadEvent.h"
+#include "nsIDocument.h"
+#include "nsPresContext.h"
+#include "nsIPresShell.h"
+#include "mozilla/StyleSetHandle.h"
+#include "mozilla/StyleSetHandleInlines.h"
+#include "nsIFrame.h"
+#include "nsIWritablePropertyBag2.h"
+#include "nsSubDocumentFrame.h"
+
+#include "nsILinkHandler.h"
+#include "nsIDOMDocument.h"
+#include "nsISelectionListener.h"
+#include "mozilla/dom/Selection.h"
+#include "nsIDOMHTMLDocument.h"
+#include "nsIDOMHTMLElement.h"
+#include "nsContentUtils.h"
+#include "nsLayoutStylesheetCache.h"
+#ifdef ACCESSIBILITY
+#include "mozilla/a11y/DocAccessible.h"
+#endif
+#include "mozilla/BasicEvents.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/dom/EncodingUtils.h"
+#include "mozilla/WeakPtr.h"
+#include "mozilla/StyleSheet.h"
+#include "mozilla/StyleSheetInlines.h"
+
+#include "nsViewManager.h"
+#include "nsView.h"
+
+#include "nsIPageSequenceFrame.h"
+#include "nsNetUtil.h"
+#include "nsIContentViewerEdit.h"
+#include "nsIContentViewerFile.h"
+#include "mozilla/StyleSheetInlines.h"
+#include "mozilla/css/Loader.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsDocShell.h"
+#include "nsIBaseWindow.h"
+#include "nsILayoutHistoryState.h"
+#include "nsCharsetSource.h"
+#include "mozilla/ReflowInput.h"
+#include "nsIImageLoadingContent.h"
+#include "nsCopySupport.h"
+#include "nsIDOMHTMLFrameSetElement.h"
+#include "nsIDOMHTMLImageElement.h"
+#ifdef MOZ_XUL
+#include "nsIXULDocument.h"
+#include "nsXULPopupManager.h"
+#endif
+
+#include "nsIClipboardHelper.h"
+
+#include "nsPIDOMWindow.h"
+#include "nsGlobalWindow.h"
+#include "nsDOMNavigationTiming.h"
+#include "nsPIWindowRoot.h"
+#include "nsJSEnvironment.h"
+#include "nsFocusManager.h"
+
+#include "nsIScrollableFrame.h"
+#include "nsStyleSheetService.h"
+#include "nsRenderingContext.h"
+#include "nsILoadContext.h"
+
+#include "nsIPrompt.h"
+#include "imgIContainer.h" // image animation mode constants
+
+#include "nsSandboxFlags.h"
+
+#include "mozilla/DocLoadingTimelineMarker.h"
+
+//--------------------------
+// Printing Include
+//---------------------------
+#ifdef NS_PRINTING
+
+#include "nsIWebBrowserPrint.h"
+
+#include "nsPrintEngine.h"
+
+// Print Options
+#include "nsIPrintSettings.h"
+#include "nsIPrintSettingsService.h"
+#include "nsISimpleEnumerator.h"
+
+#include "nsIPluginDocument.h"
+
+#endif // NS_PRINTING
+
+//focus
+#include "nsIDOMEventTarget.h"
+#include "nsIDOMEventListener.h"
+#include "nsISelectionController.h"
+
+#include "mozilla/EventDispatcher.h"
+#include "nsISHEntry.h"
+#include "nsISHistory.h"
+#include "nsISHistoryInternal.h"
+#include "nsIWebNavigation.h"
+#include "mozilla/dom/XMLHttpRequestMainThread.h"
+
+//paint forcing
+#include <stdio.h>
+
+#include "mozilla/dom/Element.h"
+#include "mozilla/Telemetry.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+
+#define BEFOREUNLOAD_DISABLED_PREFNAME "dom.disable_beforeunload"
+#define BEFOREUNLOAD_REQUIRES_INTERACTION_PREFNAME "dom.require_user_interaction_for_beforeunload"
+
+//-----------------------------------------------------
+// LOGGING
+#include "LayoutLogging.h"
+#include "mozilla/Logging.h"
+
+#ifdef NS_PRINTING
+static mozilla::LazyLogModule gPrintingLog("printing");
+
+#define PR_PL(_p1)  MOZ_LOG(gPrintingLog, mozilla::LogLevel::Debug, _p1);
+#endif // NS_PRINTING
+
+#define PRT_YESNO(_p) ((_p)?"YES":"NO")
+//-----------------------------------------------------
+
+class nsDocumentViewer;
+namespace mozilla {
+class AutoPrintEventDispatcher;
+}
+
+// a small delegate class used to avoid circular references
+
+class nsDocViewerSelectionListener : public nsISelectionListener
+{
+public:
+
+  // nsISupports interface...
+  NS_DECL_ISUPPORTS
+
+  // nsISelectionListerner interface
+  NS_DECL_NSISELECTIONLISTENER
+
+                       nsDocViewerSelectionListener()
+                       : mDocViewer(nullptr)
+                       , mSelectionWasCollapsed(true)
+                       {
+                       }
+
+  nsresult             Init(nsDocumentViewer *aDocViewer);
+
+  void                 Disconnect() { mDocViewer = nullptr; }
+
+protected:
+
+  virtual              ~nsDocViewerSelectionListener() {}
+
+  nsDocumentViewer*    mDocViewer;
+  bool                 mSelectionWasCollapsed;
+
+};
+
+
+/** editor Implementation of the FocusListener interface
+ */
+class nsDocViewerFocusListener : public nsIDOMEventListener
+{
+public:
+  /** default constructor
+   */
+  nsDocViewerFocusListener();
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIDOMEVENTLISTENER
+
+  nsresult             Init(nsDocumentViewer *aDocViewer);
+
+  void                 Disconnect() { mDocViewer = nullptr; }
+
+protected:
+  /** default destructor
+   */
+  virtual ~nsDocViewerFocusListener();
+
+private:
+    nsDocumentViewer*  mDocViewer;
+};
+
+
+//-------------------------------------------------------------
+class nsDocumentViewer final : public nsIContentViewer,
+                               public nsIContentViewerEdit,
+                               public nsIContentViewerFile,
+                               public nsIDocumentViewerPrint
+
+#ifdef NS_PRINTING
+                             , public nsIWebBrowserPrint
+#endif
+
+{
+  friend class nsDocViewerSelectionListener;
+  friend class nsPagePrintTimer;
+  friend class nsPrintEngine;
+
+public:
+  nsDocumentViewer();
+
+  NS_DECL_AND_IMPL_ZEROING_OPERATOR_NEW
+
+  // nsISupports interface...
+  NS_DECL_ISUPPORTS
+
+  // nsIContentViewer interface...
+  NS_DECL_NSICONTENTVIEWER
+
+  // nsIContentViewerEdit
+  NS_DECL_NSICONTENTVIEWEREDIT
+
+  // nsIContentViewerFile
+  NS_DECL_NSICONTENTVIEWERFILE
+
+#ifdef NS_PRINTING
+  // nsIWebBrowserPrint
+  NS_DECL_NSIWEBBROWSERPRINT
+#endif
+
+  typedef void (*CallChildFunc)(nsIContentViewer* aViewer, void* aClosure);
+  void CallChildren(CallChildFunc aFunc, void* aClosure);
+
+  // nsIDocumentViewerPrint Printing Methods
+  NS_DECL_NSIDOCUMENTVIEWERPRINT
+
+protected:
+  virtual ~nsDocumentViewer();
+
+private:
+  /**
+   * Creates a view manager, root view, and widget for the root view, setting
+   * mViewManager and mWindow.
+   * @param aSize the initial size in appunits
+   * @param aContainerView the container view to hook our root view up
+   * to as a child, or null if this will be the root view manager
+   */
+  nsresult MakeWindow(const nsSize& aSize, nsView* aContainerView);
+
+  /**
+   * Create our device context
+   */
+  nsresult CreateDeviceContext(nsView* aContainerView);
+
+  /**
+   * If aDoCreation is true, this creates the device context, creates a
+   * prescontext if necessary, and calls MakeWindow.
+   *
+   * If aForceSetNewDocument is false, then SetNewDocument won't be
+   * called if the window's current document is already mDocument.
+   */
+  nsresult InitInternal(nsIWidget* aParentWidget,
+                        nsISupports *aState,
+                        const nsIntRect& aBounds,
+                        bool aDoCreation,
+                        bool aNeedMakeCX = true,
+                        bool aForceSetNewDocument = true);
+  /**
+   * @param aDoInitialReflow set to true if you want to kick off the initial
+   * reflow
+   */
+  nsresult InitPresentationStuff(bool aDoInitialReflow);
+
+  nsresult GetPopupNode(nsIDOMNode** aNode);
+  nsresult GetPopupLinkNode(nsIDOMNode** aNode);
+  nsresult GetPopupImageNode(nsIImageLoadingContent** aNode);
+
+  nsresult GetContentSizeInternal(int32_t* aWidth, int32_t* aHeight,
+                                  nscoord aMaxWidth, nscoord aMaxHeight);
+
+  void PrepareToStartLoad(void);
+
+  nsresult SyncParentSubDocMap();
+
+  mozilla::dom::Selection* GetDocumentSelection();
+
+  void DestroyPresShell();
+  void DestroyPresContext();
+
+#ifdef NS_PRINTING
+  // Called when the DocViewer is notified that the state
+  // of Printing or PP has changed
+  void SetIsPrintingInDocShellTree(nsIDocShellTreeItem* aParentNode, 
+                                   bool                 aIsPrintingOrPP, 
+                                   bool                 aStartAtTop);
+#endif // NS_PRINTING
+
+  // Whether we should attach to the top level widget. This is true if we
+  // are sharing/recycling a single base widget and not creating multiple
+  // child widgets.
+  bool ShouldAttachToTopLevel();
+
+protected:
+  // These return the current shell/prescontext etc.
+  nsIPresShell* GetPresShell();
+  nsPresContext* GetPresContext();
+  nsViewManager* GetViewManager();
+
+  void DetachFromTopLevelWidget();
+
+  // IMPORTANT: The ownership implicit in the following member
+  // variables has been explicitly checked and set using nsCOMPtr
+  // for owning pointers and raw COM interface pointers for weak
+  // (ie, non owning) references. If you add any members to this
+  // class, please make the ownership explicit (pinkerton, scc).
+
+  WeakPtr<nsDocShell> mContainer; // it owns me!
+  nsWeakPtr mTopContainerWhilePrinting;
+  RefPtr<nsDeviceContext> mDeviceContext;  // We create and own this baby
+
+  // the following six items are explicitly in this order
+  // so they will be destroyed in the reverse order (pinkerton, scc)
+  nsCOMPtr<nsIDocument>    mDocument;
+  nsCOMPtr<nsIWidget>      mWindow;      // may be null
+  RefPtr<nsViewManager> mViewManager;
+  RefPtr<nsPresContext>  mPresContext;
+  nsCOMPtr<nsIPresShell>   mPresShell;
+
+  RefPtr<nsDocViewerSelectionListener> mSelectionListener;
+  RefPtr<nsDocViewerFocusListener> mFocusListener;
+
+  nsCOMPtr<nsIContentViewer> mPreviousViewer;
+  nsCOMPtr<nsISHEntry> mSHEntry;
+
+  nsIWidget* mParentWidget; // purposely won't be ref counted.  May be null
+  bool mAttachedToParent; // view is attached to the parent widget
+
+  nsIntRect mBounds;
+
+  // mTextZoom/mPageZoom record the textzoom/pagezoom of the first (galley)
+  // presshell only.
+  float mTextZoom;      // Text zoom, defaults to 1.0
+  float mPageZoom;
+  float mOverrideDPPX;  // DPPX overrided, defaults to 0.0
+  int mMinFontSize;
+
+  int16_t mNumURLStarts;
+  int16_t mDestroyRefCount;    // a second "refcount" for the document viewer's "destroy"
+
+  unsigned      mStopped : 1;
+  unsigned      mLoaded : 1;
+  unsigned      mDeferredWindowClose : 1;
+  // document management data
+  //   these items are specific to markup documents (html and xml)
+  //   may consider splitting these out into a subclass
+  unsigned      mIsSticky : 1;
+  unsigned      mInPermitUnload : 1;
+  unsigned      mInPermitUnloadPrompt: 1;
+
+#ifdef NS_PRINTING
+  unsigned      mClosingWhilePrinting : 1;
+
+#if NS_PRINT_PREVIEW
+  unsigned                         mPrintPreviewZoomed : 1;
+
+  // These data members support delayed printing when the document is loading
+  unsigned                         mPrintIsPending : 1;
+  unsigned                         mPrintDocIsFullyLoaded : 1;
+  nsCOMPtr<nsIPrintSettings>       mCachedPrintSettings;
+  nsCOMPtr<nsIWebProgressListener> mCachedPrintWebProgressListner;
+
+  RefPtr<nsPrintEngine>          mPrintEngine;
+  float                            mOriginalPrintPreviewScale;
+  float                            mPrintPreviewZoom;
+  nsAutoPtr<AutoPrintEventDispatcher> mAutoBeforeAndAfterPrint;
+#endif // NS_PRINT_PREVIEW
+
+#ifdef DEBUG
+  FILE* mDebugFile;
+#endif // DEBUG
+#endif // NS_PRINTING
+
+  /* character set member data */
+  int32_t mHintCharsetSource;
+  nsCString mHintCharset;
+  nsCString mForceCharacterSet;
+  
+  bool mIsPageMode;
+  bool mInitializedForPrintPreview;
+  bool mHidden;
+};
+
+namespace mozilla {
+
+/**
+ * A RAII class for automatic dispatch of the 'beforeprint' and 'afterprint'
+ * events ('beforeprint' on construction, 'afterprint' on destruction).
+ *
+ * https://developer.mozilla.org/en-US/docs/Web/Events/beforeprint
+ * https://developer.mozilla.org/en-US/docs/Web/Events/afterprint
+ */
+class AutoPrintEventDispatcher
+{
+public:
+  explicit AutoPrintEventDispatcher(nsIDocument* aTop) : mTop(aTop)
+  {
+    DispatchEventToWindowTree(NS_LITERAL_STRING("beforeprint"));
+  }
+  ~AutoPrintEventDispatcher()
+  {
+    DispatchEventToWindowTree(NS_LITERAL_STRING("afterprint"));
+  }
+
+private:
+  void DispatchEventToWindowTree(const nsAString& aEvent)
+  {
+    nsCOMArray<nsIDocument> targets;
+    CollectDocuments(mTop, &targets);
+    for (int32_t i = 0; i < targets.Count(); ++i) {
+      nsIDocument* d = targets[i];
+      nsContentUtils::DispatchTrustedEvent(d, d->GetWindow(),
+                                           aEvent, false, false, nullptr);
+    }
+  }
+
+  static bool CollectDocuments(nsIDocument* aDocument, void* aData)
+  {
+    if (aDocument) {
+      static_cast<nsCOMArray<nsIDocument>*>(aData)->AppendObject(aDocument);
+      aDocument->EnumerateSubDocuments(CollectDocuments, aData);
+    }
+    return true;
+  }
+
+  nsCOMPtr<nsIDocument> mTop;
+};
+
+}
+
+class nsDocumentShownDispatcher : public Runnable
+{
+public:
+  explicit nsDocumentShownDispatcher(nsCOMPtr<nsIDocument> aDocument)
+  : mDocument(aDocument) {}
+
+  NS_IMETHOD Run() override;
+
+private:
+  nsCOMPtr<nsIDocument> mDocument;
+};
+
+
+//------------------------------------------------------------------
+// nsDocumentViewer
+//------------------------------------------------------------------
+
+//------------------------------------------------------------------
+already_AddRefed<nsIContentViewer>
+NS_NewContentViewer()
+{
+  RefPtr<nsDocumentViewer> viewer = new nsDocumentViewer();
+  return viewer.forget();
+}
+
+void nsDocumentViewer::PrepareToStartLoad()
+{
+  mStopped          = false;
+  mLoaded           = false;
+  mAttachedToParent = false;
+  mDeferredWindowClose = false;
+
+#ifdef NS_PRINTING
+  mPrintIsPending        = false;
+  mPrintDocIsFullyLoaded = false;
+  mClosingWhilePrinting  = false;
+
+  // Make sure we have destroyed it and cleared the data member
+  if (mPrintEngine) {
+    mPrintEngine->Destroy();
+    mPrintEngine = nullptr;
+#ifdef NS_PRINT_PREVIEW
+    SetIsPrintPreview(false);
+#endif
+  }
+
+#ifdef DEBUG
+  mDebugFile = nullptr;
+#endif
+
+#endif // NS_PRINTING
+}
+
+// Note: operator new zeros our memory, so no need to init things to null.
+nsDocumentViewer::nsDocumentViewer()
+  : mTextZoom(1.0), mPageZoom(1.0), mOverrideDPPX(0.0), mMinFontSize(0),
+    mIsSticky(true),
+#ifdef NS_PRINT_PREVIEW
+    mPrintPreviewZoom(1.0),
+#endif
+    mHintCharsetSource(kCharsetUninitialized),
+    mInitializedForPrintPreview(false),
+    mHidden(false)
+{
+  PrepareToStartLoad();
+}
+
+NS_IMPL_ADDREF(nsDocumentViewer)
+NS_IMPL_RELEASE(nsDocumentViewer)
+
+NS_INTERFACE_MAP_BEGIN(nsDocumentViewer)
+    NS_INTERFACE_MAP_ENTRY(nsIContentViewer)
+    NS_INTERFACE_MAP_ENTRY(nsIContentViewerFile)
+    NS_INTERFACE_MAP_ENTRY(nsIContentViewerEdit)
+    NS_INTERFACE_MAP_ENTRY(nsIDocumentViewerPrint)
+    NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIContentViewer)
+#ifdef NS_PRINTING
+    NS_INTERFACE_MAP_ENTRY(nsIWebBrowserPrint)
+#endif
+NS_INTERFACE_MAP_END
+
+nsDocumentViewer::~nsDocumentViewer()
+{
+  if (mDocument) {
+    Close(nullptr);
+    mDocument->Destroy();
+  }
+
+  NS_ASSERTION(!mPresShell && !mPresContext,
+               "User did not call nsIContentViewer::Destroy");
+  if (mPresShell || mPresContext) {
+    // Make sure we don't hand out a reference to the content viewer to
+    // the SHEntry!
+    mSHEntry = nullptr;
+
+    Destroy();
+  }
+
+  if (mSelectionListener) {
+    mSelectionListener->Disconnect();
+  }
+
+  if (mFocusListener) {
+    mFocusListener->Disconnect();
+  }
+
+  // XXX(?) Revoke pending invalidate events
+}
+
+/*
+ * This method is called by the Document Loader once a document has
+ * been created for a particular data stream...  The content viewer
+ * must cache this document for later use when Init(...) is called.
+ *
+ * This method is also called when an out of band document.write() happens.
+ * In that case, the document passed in is the same as the previous document.
+ */
+/* virtual */ void
+nsDocumentViewer::LoadStart(nsIDocument* aDocument)
+{
+  MOZ_ASSERT(aDocument);
+
+  if (!mDocument) {
+    mDocument = aDocument;
+  }
+}
+
+nsresult
+nsDocumentViewer::SyncParentSubDocMap()
+{
+  nsCOMPtr<nsIDocShell> docShell(mContainer);
+  if (!docShell) {
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsPIDOMWindowOuter> pwin(docShell->GetWindow());
+  if (!mDocument || !pwin) {
+    return NS_OK;
+  }
+
+  nsCOMPtr<Element> element = pwin->GetFrameElementInternal();
+  if (!element) {
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsIDocShellTreeItem> parent;
+  docShell->GetParent(getter_AddRefs(parent));
+
+  nsCOMPtr<nsPIDOMWindowOuter> parent_win = parent ? parent->GetWindow() : nullptr;
+  if (!parent_win) {
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsIDocument> parent_doc = parent_win->GetDoc();
+  if (!parent_doc) {
+    return NS_OK;
+  }
+
+  if (mDocument &&
+      parent_doc->GetSubDocumentFor(element) != mDocument &&
+      parent_doc->EventHandlingSuppressed()) {
+    mDocument->SuppressEventHandling(nsIDocument::eEvents,
+                                     parent_doc->EventHandlingSuppressed());
+  }
+  return parent_doc->SetSubDocumentFor(element, mDocument);
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::SetContainer(nsIDocShell* aContainer)
+{
+  mContainer = static_cast<nsDocShell*>(aContainer);
+  if (mPresContext) {
+    mPresContext->SetContainer(mContainer);
+  }
+
+  // We're loading a new document into the window where this document
+  // viewer lives, sync the parent document's frame element -> sub
+  // document map
+
+  return SyncParentSubDocMap();
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::GetContainer(nsIDocShell** aResult)
+{
+   NS_ENSURE_ARG_POINTER(aResult);
+
+   nsCOMPtr<nsIDocShell> container(mContainer);
+   container.swap(*aResult);
+   return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::Init(nsIWidget* aParentWidget,
+                         const nsIntRect& aBounds)
+{
+  return InitInternal(aParentWidget, nullptr, aBounds, true);
+}
+
+nsresult
+nsDocumentViewer::InitPresentationStuff(bool aDoInitialReflow)
+{
+  // We assert this because initializing the pres shell could otherwise cause
+  // re-entrancy into nsDocumentViewer methods, which might cause a different
+  // pres shell to be created.  Callers of InitPresentationStuff should ensure
+  // the call is appropriately bounded by an nsAutoScriptBlocker to decide
+  // when it is safe for these re-entrant calls to be made.
+  MOZ_ASSERT(!nsContentUtils::IsSafeToRunScript(),
+             "InitPresentationStuff must only be called when scripts are "
+             "blocked");
+
+  if (GetIsPrintPreview())
+    return NS_OK;
+
+  NS_ASSERTION(!mPresShell,
+               "Someone should have destroyed the presshell!");
+
+  // Create the style set...
+  StyleSetHandle styleSet = CreateStyleSet(mDocument);
+
+  // Now make the shell for the document
+  mPresShell = mDocument->CreateShell(mPresContext, mViewManager, styleSet);
+  if (!mPresShell) {
+    styleSet->Delete();
+    return NS_ERROR_FAILURE;
+  }
+
+  // We're done creating the style set
+  styleSet->EndUpdate();
+
+  if (aDoInitialReflow) {
+    // Since Initialize() will create frames for *all* items
+    // that are currently in the document tree, we need to flush
+    // any pending notifications to prevent the content sink from
+    // duplicating layout frames for content it has added to the tree
+    // but hasn't notified the document about. (Bug 154018)
+    //
+    // Note that we are flushing before we add mPresShell as an observer
+    // to avoid bogus notifications.
+
+    mDocument->FlushPendingNotifications(Flush_ContentAndNotify);
+  }
+
+  mPresShell->BeginObservingDocument();
+
+  // Initialize our view manager
+  int32_t p2a = mPresContext->AppUnitsPerDevPixel();
+  MOZ_ASSERT(p2a ==
+             mPresContext->DeviceContext()->AppUnitsPerDevPixelAtUnitFullZoom());
+  nscoord width = p2a * mBounds.width;
+  nscoord height = p2a * mBounds.height;
+
+  mViewManager->SetWindowDimensions(width, height);
+  mPresContext->SetTextZoom(mTextZoom);
+  mPresContext->SetFullZoom(mPageZoom);
+  mPresContext->SetOverrideDPPX(mOverrideDPPX);
+  mPresContext->SetBaseMinFontSize(mMinFontSize);
+
+  p2a = mPresContext->AppUnitsPerDevPixel();  // zoom may have changed it
+  width = p2a * mBounds.width;
+  height = p2a * mBounds.height;
+  if (aDoInitialReflow) {
+    nsCOMPtr<nsIPresShell> shell = mPresShell;
+    // Initial reflow
+    shell->Initialize(width, height);
+  } else {
+    // Store the visible area so it's available for other callers of
+    // Initialize, like nsContentSink::StartLayout.
+    mPresContext->SetVisibleArea(nsRect(0, 0, width, height));
+  }
+
+  // now register ourselves as a selection listener, so that we get
+  // called when the selection changes in the window
+  if (!mSelectionListener) {
+    nsDocViewerSelectionListener *selectionListener =
+      new nsDocViewerSelectionListener();
+
+    selectionListener->Init(this);
+
+    // mSelectionListener is a owning reference
+    mSelectionListener = selectionListener;
+  }
+
+  RefPtr<mozilla::dom::Selection> selection = GetDocumentSelection();
+  if (!selection) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsresult rv = selection->AddSelectionListener(mSelectionListener);
+  if (NS_FAILED(rv))
+    return rv;
+
+  // Save old listener so we can unregister it
+  RefPtr<nsDocViewerFocusListener> oldFocusListener = mFocusListener;
+  if (oldFocusListener) {
+    oldFocusListener->Disconnect();
+  }
+
+  // focus listener
+  //
+  // now register ourselves as a focus listener, so that we get called
+  // when the focus changes in the window
+  nsDocViewerFocusListener *focusListener = new nsDocViewerFocusListener();
+
+  focusListener->Init(this);
+
+  // mFocusListener is a strong reference
+  mFocusListener = focusListener;
+
+  if (mDocument) {
+    mDocument->AddEventListener(NS_LITERAL_STRING("focus"),
+                                mFocusListener,
+                                false, false);
+    mDocument->AddEventListener(NS_LITERAL_STRING("blur"),
+                                mFocusListener,
+                                false, false);
+
+    if (oldFocusListener) {
+      mDocument->RemoveEventListener(NS_LITERAL_STRING("focus"),
+                                     oldFocusListener, false);
+      mDocument->RemoveEventListener(NS_LITERAL_STRING("blur"),
+                                     oldFocusListener, false);
+    }
+  }
+
+  if (aDoInitialReflow && mDocument) {
+    mDocument->ScrollToRef();
+  }
+
+  return NS_OK;
+}
+
+static nsPresContext*
+CreatePresContext(nsIDocument* aDocument,
+                  nsPresContext::nsPresContextType aType,
+                  nsView* aContainerView)
+{
+  if (aContainerView)
+    return new nsPresContext(aDocument, aType);
+  return new nsRootPresContext(aDocument, aType);
+}
+
+//-----------------------------------------------
+// This method can be used to initial the "presentation"
+// The aDoCreation indicates whether it should create
+// all the new objects or just initialize the existing ones
+nsresult
+nsDocumentViewer::InitInternal(nsIWidget* aParentWidget,
+                                 nsISupports *aState,
+                                 const nsIntRect& aBounds,
+                                 bool aDoCreation,
+                                 bool aNeedMakeCX /*= true*/,
+                                 bool aForceSetNewDocument /* = true*/)
+{
+  if (mIsPageMode) {
+    // XXXbz should the InitInternal in SetPageMode just pass false
+    // here itself?
+    aForceSetNewDocument = false;
+  }
+
+  // We don't want any scripts to run here. That can cause flushing,
+  // which can cause reentry into initialization of this document viewer,
+  // which would be disastrous.
+  nsAutoScriptBlocker blockScripts;
+
+  mParentWidget = aParentWidget; // not ref counted
+  mBounds = aBounds;
+
+  nsresult rv = NS_OK;
+  NS_ENSURE_TRUE(mDocument, NS_ERROR_NULL_POINTER);
+
+  nsView* containerView = FindContainerView();
+
+  bool makeCX = false;
+  if (aDoCreation) {
+    nsresult rv = CreateDeviceContext(containerView);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // XXXbz this is a nasty hack to do with the fact that we create
+    // presentations both in Init() and in Show()...  Ideally we would only do
+    // it in one place (Show()) and require that callers call init(), open(),
+    // show() in that order or something.
+    if (!mPresContext &&
+        (aParentWidget || containerView || mDocument->IsBeingUsedAsImage() ||
+         (mDocument->GetDisplayDocument() &&
+          mDocument->GetDisplayDocument()->GetShell()))) {
+      // Create presentation context
+      if (mIsPageMode) {
+        //Presentation context already created in SetPageMode which is calling this method
+      } else {
+        mPresContext = CreatePresContext(mDocument,
+            nsPresContext::eContext_Galley, containerView);
+      }
+      NS_ENSURE_TRUE(mPresContext, NS_ERROR_OUT_OF_MEMORY);
+
+      nsresult rv = mPresContext->Init(mDeviceContext); 
+      if (NS_FAILED(rv)) {
+        mPresContext = nullptr;
+        return rv;
+      }
+
+#if defined(NS_PRINTING) && defined(NS_PRINT_PREVIEW)
+      makeCX = !GetIsPrintPreview() && aNeedMakeCX; // needs to be true except when we are already in PP or we are enabling/disabling paginated mode.
+#else
+      makeCX = true;
+#endif
+    }
+
+    if (mPresContext) {
+      // Create the ViewManager and Root View...
+
+      // We must do this before we tell the script global object about
+      // this new document since doing that will cause us to re-enter
+      // into nsSubDocumentFrame code through reflows caused by
+      // FlushPendingNotifications() calls down the road...
+
+      rv = MakeWindow(nsSize(mPresContext->DevPixelsToAppUnits(aBounds.width),
+                             mPresContext->DevPixelsToAppUnits(aBounds.height)),
+                      containerView);
+      NS_ENSURE_SUCCESS(rv, rv);
+      Hide();
+
+#ifdef NS_PRINT_PREVIEW
+      if (mIsPageMode) {
+        // I'm leaving this in a broken state for the moment; we should
+        // be measuring/scaling with the print device context, not the
+        // screen device context, but this is good enough to allow
+        // printing reftests to work.
+        double pageWidth = 0, pageHeight = 0;
+        mPresContext->GetPrintSettings()->GetEffectivePageSize(&pageWidth,
+                                                               &pageHeight);
+        mPresContext->SetPageSize(
+          nsSize(mPresContext->CSSTwipsToAppUnits(NSToIntFloor(pageWidth)),
+                 mPresContext->CSSTwipsToAppUnits(NSToIntFloor(pageHeight))));
+        mPresContext->SetIsRootPaginatedDocument(true);
+        mPresContext->SetPageScale(1.0f);
+      }
+#endif
+    } else {
+      // Avoid leaking the old viewer.
+      if (mPreviousViewer) {
+        mPreviousViewer->Destroy();
+        mPreviousViewer = nullptr;
+      }
+    }
+  }
+
+  nsCOMPtr<nsIInterfaceRequestor> requestor(mContainer);
+  if (requestor) {
+    if (mPresContext) {
+      nsCOMPtr<nsILinkHandler> linkHandler;
+      requestor->GetInterface(NS_GET_IID(nsILinkHandler),
+                              getter_AddRefs(linkHandler));
+
+      mPresContext->SetContainer(mContainer);
+      mPresContext->SetLinkHandler(linkHandler);
+    }
+
+    // Set script-context-owner in the document
+
+    nsCOMPtr<nsPIDOMWindowOuter> window = do_GetInterface(requestor);
+
+    if (window) {
+      nsCOMPtr<nsIDocument> curDoc = window->GetExtantDoc();
+      if (aForceSetNewDocument || curDoc != mDocument) {
+        rv = window->SetNewDocument(mDocument, aState, false);
+        if (NS_FAILED(rv)) {
+          Destroy();
+          return rv;
+        }
+        nsJSContext::LoadStart();
+      }
+    }
+  }
+
+  if (aDoCreation && mPresContext) {
+    // The ViewManager and Root View was created above (in
+    // MakeWindow())...
+
+    rv = InitPresentationStuff(!makeCX);
+  }
+
+  return rv;
+}
+
+void nsDocumentViewer::SetNavigationTiming(nsDOMNavigationTiming* timing)
+{
+  NS_ASSERTION(mDocument, "Must have a document to set navigation timing.");
+  if (mDocument) {
+    mDocument->SetNavigationTiming(timing);
+  }
+}
+
+//
+// LoadComplete(aStatus)
+//
+//   aStatus - The status returned from loading the document.
+//
+// This method is called by the container when the document has been
+// completely loaded.
+//
+NS_IMETHODIMP
+nsDocumentViewer::LoadComplete(nsresult aStatus)
+{
+  /* We need to protect ourself against auto-destruction in case the
+     window is closed while processing the OnLoad event.  See bug
+     http://bugzilla.mozilla.org/show_bug.cgi?id=78445 for more
+     explanation.
+  */
+  RefPtr<nsDocumentViewer> kungFuDeathGrip(this);
+
+  // Flush out layout so it's up-to-date by the time onload is called.
+  // Note that this could destroy the window, so do this before
+  // checking for our mDocument and its window.
+  if (mPresShell && !mStopped) {
+    // Hold strong ref because this could conceivably run script
+    nsCOMPtr<nsIPresShell> shell = mPresShell;
+    shell->FlushPendingNotifications(Flush_Layout);
+  }
+
+  nsresult rv = NS_OK;
+  NS_ENSURE_TRUE(mDocument, NS_ERROR_NOT_AVAILABLE);
+
+  // First, get the window from the document...
+  nsCOMPtr<nsPIDOMWindowOuter> window = mDocument->GetWindow();
+
+  mLoaded = true;
+
+  // Now, fire either an OnLoad or OnError event to the document...
+  bool restoring = false;
+  // XXXbz imagelib kills off the document load for a full-page image with
+  // NS_ERROR_PARSED_DATA_CACHED if it's in the cache.  So we want to treat
+  // that one as a success code; otherwise whether we fire onload for the image
+  // will depend on whether it's cached!
+  if(window &&
+     (NS_SUCCEEDED(aStatus) || aStatus == NS_ERROR_PARSED_DATA_CACHED)) {
+    nsEventStatus status = nsEventStatus_eIgnore;
+    WidgetEvent event(true, eLoad);
+    event.mFlags.mBubbles = false;
+    event.mFlags.mCancelable = false;
+     // XXX Dispatching to |window|, but using |document| as the target.
+    event.mTarget = mDocument;
+
+    // If the document presentation is being restored, we don't want to fire
+    // onload to the document content since that would likely confuse scripts
+    // on the page.
+
+    nsIDocShell *docShell = window->GetDocShell();
+    NS_ENSURE_TRUE(docShell, NS_ERROR_UNEXPECTED);
+
+    docShell->GetRestoringDocument(&restoring);
+    if (!restoring) {
+      NS_ASSERTION(mDocument->IsXULDocument() || // readyState for XUL is bogus
+                   mDocument->GetReadyStateEnum() ==
+                     nsIDocument::READYSTATE_INTERACTIVE ||
+                   // test_stricttransportsecurity.html has old-style
+                   // docshell-generated about:blank docs reach this code!
+                   (mDocument->GetReadyStateEnum() ==
+                      nsIDocument::READYSTATE_UNINITIALIZED &&
+                    NS_IsAboutBlank(mDocument->GetDocumentURI())),
+                   "Bad readystate");
+      nsCOMPtr<nsIDocument> d = mDocument;
+      mDocument->SetReadyStateInternal(nsIDocument::READYSTATE_COMPLETE);
+
+      RefPtr<nsDOMNavigationTiming> timing(d->GetNavigationTiming());
+      if (timing) {
+        timing->NotifyLoadEventStart();
+      }
+
+      // Dispatch observer notification to notify observers document load is complete.
+      nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
+      if (os) {
+        nsIPrincipal *principal = d->NodePrincipal();
+        os->NotifyObservers(d,
+                            nsContentUtils::IsSystemPrincipal(principal) ?
+                            "chrome-document-loaded" :
+                            "content-document-loaded",
+                            nullptr);
+      }
+
+      // Notify any devtools about the load.
+      RefPtr<TimelineConsumers> timelines = TimelineConsumers::Get();
+
+      if (timelines && timelines->HasConsumer(docShell)) {
+        timelines->AddMarkerForDocShell(docShell,
+          MakeUnique<DocLoadingTimelineMarker>("document::Load"));
+      }
+
+      EventDispatcher::Dispatch(window, mPresContext, &event, nullptr, &status);
+      if (timing) {
+        timing->NotifyLoadEventEnd();
+      }
+    }
+  } else {
+    // XXX: Should fire error event to the document...
+  }
+
+  // Notify the document that it has been shown (regardless of whether
+  // it was just loaded). Note: mDocument may be null now if the above
+  // firing of onload caused the document to unload.
+  if (mDocument) {
+    // Re-get window, since it might have changed during above firing of onload
+    window = mDocument->GetWindow();
+    if (window) {
+      nsIDocShell *docShell = window->GetDocShell();
+      bool isInUnload;
+      if (docShell && NS_SUCCEEDED(docShell->GetIsInUnload(&isInUnload)) &&
+          !isInUnload) {
+        mDocument->OnPageShow(restoring, nullptr);
+      }
+    }
+  }
+
+  if (!mStopped) {
+    if (mDocument) {
+      mDocument->ScrollToRef();
+    }
+
+    // Now that the document has loaded, we can tell the presshell
+    // to unsuppress painting.
+    if (mPresShell) {
+      nsCOMPtr<nsIPresShell> shell(mPresShell);
+      shell->UnsuppressPainting();
+      // mPresShell could have been removed now, see bug 378682/421432
+      if (mPresShell) {
+        mPresShell->LoadComplete();
+      }
+    }
+  }
+
+  nsJSContext::LoadEnd();
+
+#ifdef NS_PRINTING
+  // Check to see if someone tried to print during the load
+  if (mPrintIsPending) {
+    mPrintIsPending        = false;
+    mPrintDocIsFullyLoaded = true;
+    Print(mCachedPrintSettings, mCachedPrintWebProgressListner);
+    mCachedPrintSettings           = nullptr;
+    mCachedPrintWebProgressListner = nullptr;
+  }
+#endif
+
+  return rv;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::GetLoadCompleted(bool *aOutLoadCompleted)
+{
+  *aOutLoadCompleted = mLoaded;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::PermitUnload(bool *aPermitUnload)
+{
+  bool shouldPrompt = true;
+  return PermitUnloadInternal(&shouldPrompt, aPermitUnload);
+}
+
+
+nsresult
+nsDocumentViewer::PermitUnloadInternal(bool *aShouldPrompt,
+                                       bool *aPermitUnload)
+{
+  AutoDontWarnAboutSyncXHR disableSyncXHRWarning;
+
+  nsresult rv = NS_OK;
+  *aPermitUnload = true;
+
+  if (!mDocument
+   || mInPermitUnload
+   || mInPermitUnloadPrompt) {
+    return NS_OK;
+  }
+
+  static bool sIsBeforeUnloadDisabled;
+  static bool sBeforeUnloadRequiresInteraction;
+  static bool sBeforeUnloadPrefsCached = false;
+
+  if (!sBeforeUnloadPrefsCached) {
+    sBeforeUnloadPrefsCached = true;
+    Preferences::AddBoolVarCache(&sIsBeforeUnloadDisabled,
+                                 BEFOREUNLOAD_DISABLED_PREFNAME);
+    Preferences::AddBoolVarCache(&sBeforeUnloadRequiresInteraction,
+                                 BEFOREUNLOAD_REQUIRES_INTERACTION_PREFNAME);
+  }
+
+  // First, get the script global object from the document...
+  nsPIDOMWindowOuter* window = mDocument->GetWindow();
+
+  if (!window) {
+    // This is odd, but not fatal
+    NS_WARNING("window not set for document!");
+    return NS_OK;
+  }
+
+  NS_ASSERTION(nsContentUtils::IsSafeToRunScript(), "This is unsafe");
+
+  // Now, fire an BeforeUnload event to the document and see if it's ok
+  // to unload...
+  nsCOMPtr<nsIDOMDocument> domDoc = do_QueryInterface(mDocument);
+  nsCOMPtr<nsIDOMEvent> event;
+  domDoc->CreateEvent(NS_LITERAL_STRING("beforeunloadevent"),
+                      getter_AddRefs(event));
+  nsCOMPtr<nsIDOMBeforeUnloadEvent> beforeUnload = do_QueryInterface(event);
+  NS_ENSURE_STATE(beforeUnload);
+  event->InitEvent(NS_LITERAL_STRING("beforeunload"), false, true);
+
+  // Dispatching to |window|, but using |document| as the target.
+  event->SetTarget(mDocument);
+  event->SetTrusted(true);
+
+  // In evil cases we might be destroyed while handling the
+  // onbeforeunload event, don't let that happen. (see also bug#331040)
+  RefPtr<nsDocumentViewer> kungFuDeathGrip(this);
+
+  bool dialogsAreEnabled = false;
+  {
+    // Never permit popups from the beforeunload handler, no matter
+    // how we get here.
+    nsAutoPopupStatePusher popupStatePusher(openAbused, true);
+
+    // Never permit dialogs from the beforeunload handler
+    nsGlobalWindow* globalWindow = nsGlobalWindow::Cast(window);
+    dialogsAreEnabled = globalWindow->AreDialogsEnabled();
+    nsGlobalWindow::TemporarilyDisableDialogs disableDialogs(globalWindow);
+
+    nsIDocument::PageUnloadingEventTimeStamp timestamp(mDocument);
+
+    mInPermitUnload = true;
+    {
+      Telemetry::AutoTimer<Telemetry::HANDLE_BEFOREUNLOAD_MS> telemetryTimer;
+      EventDispatcher::DispatchDOMEvent(window, nullptr, event, mPresContext,
+                                        nullptr);
+    }
+    mInPermitUnload = false;
+  }
+
+  nsCOMPtr<nsIDocShell> docShell(mContainer);
+  nsAutoString text;
+  beforeUnload->GetReturnValue(text);
+
+  // NB: we nullcheck mDocument because it might now be dead as a result of
+  // the event being dispatched.
+  if (!sIsBeforeUnloadDisabled && *aShouldPrompt && dialogsAreEnabled &&
+      mDocument && !(mDocument->GetSandboxFlags() & SANDBOXED_MODALS) &&
+      (!sBeforeUnloadRequiresInteraction || mDocument->UserHasInteracted()) &&
+      (event->WidgetEventPtr()->DefaultPrevented() || !text.IsEmpty())) {
+    // Ask the user if it's ok to unload the current page
+
+    nsCOMPtr<nsIPrompt> prompt = do_GetInterface(docShell);
+
+    if (prompt) {
+      nsCOMPtr<nsIWritablePropertyBag2> promptBag = do_QueryInterface(prompt);
+      if (promptBag) {
+        bool isTabModalPromptAllowed;
+        GetIsTabModalPromptAllowed(&isTabModalPromptAllowed);
+        promptBag->SetPropertyAsBool(NS_LITERAL_STRING("allowTabModal"),
+                                     isTabModalPromptAllowed);
+      }
+
+      nsXPIDLString title, message, stayLabel, leaveLabel;
+      rv  = nsContentUtils::GetLocalizedString(nsContentUtils::eDOM_PROPERTIES,
+                                               "OnBeforeUnloadTitle",
+                                               title);
+      nsresult tmp = nsContentUtils::GetLocalizedString(nsContentUtils::eDOM_PROPERTIES,
+                                               "OnBeforeUnloadMessage",
+                                               message);
+      if (NS_FAILED(tmp)) {
+        rv = tmp;
+      }
+      tmp = nsContentUtils::GetLocalizedString(nsContentUtils::eDOM_PROPERTIES,
+                                               "OnBeforeUnloadLeaveButton",
+                                               leaveLabel);
+      if (NS_FAILED(tmp)) {
+        rv = tmp;
+      }
+      tmp = nsContentUtils::GetLocalizedString(nsContentUtils::eDOM_PROPERTIES,
+                                               "OnBeforeUnloadStayButton",
+                                               stayLabel);
+      if (NS_FAILED(tmp)) {
+        rv = tmp;
+      }
+
+      if (NS_FAILED(rv) || !title || !message || !stayLabel || !leaveLabel) {
+        NS_ERROR("Failed to get strings from dom.properties!");
+        return NS_OK;
+      }
+
+      // Although the exact value is ignored, we must not pass invalid
+      // bool values through XPConnect.
+      bool dummy = false;
+      int32_t buttonPressed = 0;
+      uint32_t buttonFlags = (nsIPrompt::BUTTON_POS_0_DEFAULT |
+                             (nsIPrompt::BUTTON_TITLE_IS_STRING * nsIPrompt::BUTTON_POS_0) |
+                             (nsIPrompt::BUTTON_TITLE_IS_STRING * nsIPrompt::BUTTON_POS_1));
+
+      nsAutoSyncOperation sync(mDocument);
+      mInPermitUnloadPrompt = true;
+      mozilla::Telemetry::Accumulate(mozilla::Telemetry::ONBEFOREUNLOAD_PROMPT_COUNT, 1);
+      rv = prompt->ConfirmEx(title, message, buttonFlags,
+                             leaveLabel, stayLabel, nullptr, nullptr,
+                             &dummy, &buttonPressed);
+      mInPermitUnloadPrompt = false;
+
+      // If the prompt aborted, we tell our consumer that it is not allowed
+      // to unload the page. One reason that prompts abort is that the user
+      // performed some action that caused the page to unload while our prompt
+      // was active. In those cases we don't want our consumer to also unload
+      // the page.
+      //
+      // XXX: Are there other cases where prompts can abort? Is it ok to
+      //      prevent unloading the page in those cases?
+      if (NS_FAILED(rv)) {
+        mozilla::Telemetry::Accumulate(mozilla::Telemetry::ONBEFOREUNLOAD_PROMPT_ACTION, 2);
+        *aPermitUnload = false;
+        return NS_OK;
+      }
+
+      // Button 0 == leave, button 1 == stay
+      *aPermitUnload = (buttonPressed == 0);
+      mozilla::Telemetry::Accumulate(mozilla::Telemetry::ONBEFOREUNLOAD_PROMPT_ACTION,
+        (*aPermitUnload ? 1 : 0));
+      // If the user decided to go ahead, make sure not to prompt the user again
+      // by toggling the internal prompting bool to false:
+      if (*aPermitUnload) {
+        *aShouldPrompt = false;
+      }
+    }
+  }
+
+  if (docShell) {
+    int32_t childCount;
+    docShell->GetChildCount(&childCount);
+
+    for (int32_t i = 0; i < childCount && *aPermitUnload; ++i) {
+      nsCOMPtr<nsIDocShellTreeItem> item;
+      docShell->GetChildAt(i, getter_AddRefs(item));
+
+      nsCOMPtr<nsIDocShell> docShell(do_QueryInterface(item));
+
+      if (docShell) {
+        nsCOMPtr<nsIContentViewer> cv;
+        docShell->GetContentViewer(getter_AddRefs(cv));
+
+        if (cv) {
+          cv->PermitUnloadInternal(aShouldPrompt, aPermitUnload);
+        }
+      }
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::GetBeforeUnloadFiring(bool* aInEvent)
+{
+  *aInEvent = mInPermitUnload;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::GetInPermitUnload(bool* aInEvent)
+{
+  *aInEvent = mInPermitUnloadPrompt;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::PageHide(bool aIsUnload)
+{
+  AutoDontWarnAboutSyncXHR disableSyncXHRWarning;
+
+  mHidden = true;
+
+  if (!mDocument) {
+    return NS_ERROR_NULL_POINTER;
+  }
+
+  mDocument->OnPageHide(!aIsUnload, nullptr);
+
+  // inform the window so that the focus state is reset.
+  NS_ENSURE_STATE(mDocument);
+  nsPIDOMWindowOuter* window = mDocument->GetWindow();
+  if (window)
+    window->PageHidden();
+
+  if (aIsUnload) {
+    // Poke the GC. The window might be collectable garbage now.
+    nsJSContext::PokeGC(JS::gcreason::PAGE_HIDE, NS_GC_DELAY * 2);
+
+    // if Destroy() was called during OnPageHide(), mDocument is nullptr.
+    NS_ENSURE_STATE(mDocument);
+
+    // First, get the window from the document...
+    nsPIDOMWindowOuter* window = mDocument->GetWindow();
+
+    if (!window) {
+      // Fail if no window is available...
+      NS_WARNING("window not set for document!");
+      return NS_ERROR_NULL_POINTER;
+    }
+
+    // Now, fire an Unload event to the document...
+    nsEventStatus status = nsEventStatus_eIgnore;
+    WidgetEvent event(true, eUnload);
+    event.mFlags.mBubbles = false;
+    // XXX Dispatching to |window|, but using |document| as the target.
+    event.mTarget = mDocument;
+
+    // Never permit popups from the unload handler, no matter how we get
+    // here.
+    nsAutoPopupStatePusher popupStatePusher(openAbused, true);
+
+    nsIDocument::PageUnloadingEventTimeStamp timestamp(mDocument);
+
+    {
+      Telemetry::AutoTimer<Telemetry::HANDLE_UNLOAD_MS> telemetryTimer;
+      EventDispatcher::Dispatch(window, mPresContext, &event, nullptr, &status);
+    }
+  }
+
+#ifdef MOZ_XUL
+  // look for open menupopups and close them after the unload event, in case
+  // the unload event listeners open any new popups
+  nsContentUtils::HidePopupsInDocument(mDocument);
+#endif
+
+  return NS_OK;
+}
+
+static void
+AttachContainerRecurse(nsIDocShell* aShell)
+{
+  nsCOMPtr<nsIContentViewer> viewer;
+  aShell->GetContentViewer(getter_AddRefs(viewer));
+  if (viewer) {
+    viewer->SetIsHidden(false);
+    nsIDocument* doc = viewer->GetDocument();
+    if (doc) {
+      doc->SetContainer(static_cast<nsDocShell*>(aShell));
+    }
+    RefPtr<nsPresContext> pc;
+    viewer->GetPresContext(getter_AddRefs(pc));
+    if (pc) {
+      pc->SetContainer(static_cast<nsDocShell*>(aShell));
+      nsCOMPtr<nsILinkHandler> handler = do_QueryInterface(aShell);
+      pc->SetLinkHandler(handler);
+    }
+    nsCOMPtr<nsIPresShell> presShell;
+    viewer->GetPresShell(getter_AddRefs(presShell));
+    if (presShell) {
+      presShell->SetForwardingContainer(WeakPtr<nsDocShell>());
+    }
+  }
+
+  // Now recurse through the children
+  int32_t childCount;
+  aShell->GetChildCount(&childCount);
+  for (int32_t i = 0; i < childCount; ++i) {
+    nsCOMPtr<nsIDocShellTreeItem> childItem;
+    aShell->GetChildAt(i, getter_AddRefs(childItem));
+    nsCOMPtr<nsIDocShell> shell = do_QueryInterface(childItem);
+    AttachContainerRecurse(shell);
+  }
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::Open(nsISupports *aState, nsISHEntry *aSHEntry)
+{
+  NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_INITIALIZED);
+
+  if (mDocument)
+    mDocument->SetContainer(mContainer);
+
+  nsresult rv = InitInternal(mParentWidget, aState, mBounds, false);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  mHidden = false;
+
+  if (mPresShell)
+    mPresShell->SetForwardingContainer(WeakPtr<nsDocShell>());
+
+  // Rehook the child presentations.  The child shells are still in
+  // session history, so get them from there.
+
+  if (aSHEntry) {
+    nsCOMPtr<nsIDocShellTreeItem> item;
+    int32_t itemIndex = 0;
+    while (NS_SUCCEEDED(aSHEntry->ChildShellAt(itemIndex++,
+                                               getter_AddRefs(item))) && item) {
+      nsCOMPtr<nsIDocShell> shell = do_QueryInterface(item);
+      AttachContainerRecurse(shell);
+    }
+  }
+  
+  SyncParentSubDocMap();
+
+  if (mFocusListener && mDocument) {
+    mDocument->AddEventListener(NS_LITERAL_STRING("focus"), mFocusListener,
+                                false, false);
+    mDocument->AddEventListener(NS_LITERAL_STRING("blur"), mFocusListener,
+                                false, false);
+  }
+
+  // XXX re-enable image animations once that works correctly
+
+  PrepareToStartLoad();
+
+  // When loading a page from the bfcache with puppet widgets, we do the
+  // widget attachment here (it is otherwise done in MakeWindow, which is
+  // called for non-bfcache pages in the history, but not bfcache pages).
+  // Attachment is necessary, since we get detached when another page
+  // is browsed to. That is, if we are one page A, then when we go to
+  // page B, we detach. So page A's view has no widget. If we then go
+  // back to it, and it is in the bfcache, we will use that view, which
+  // doesn't have a widget. The attach call here will properly attach us.
+  if (nsIWidget::UsePuppetWidgets() && mPresContext &&
+      ShouldAttachToTopLevel()) {
+    // If the old view is already attached to our parent, detach
+    DetachFromTopLevelWidget();
+
+    nsViewManager *vm = GetViewManager();
+    MOZ_ASSERT(vm, "no view manager");
+    nsView* v = vm->GetRootView();
+    MOZ_ASSERT(v, "no root view");
+    MOZ_ASSERT(mParentWidget, "no mParentWidget to set");
+    v->AttachToTopLevelWidget(mParentWidget);
+
+    mAttachedToParent = true;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::Close(nsISHEntry *aSHEntry)
+{
+  // All callers are supposed to call close to break circular
+  // references.  If we do this stuff in the destructor, the
+  // destructor might never be called (especially if we're being
+  // used from JS.
+
+  mSHEntry = aSHEntry;
+
+  // Close is also needed to disable scripts during paint suppression,
+  // since we transfer the existing global object to the new document
+  // that is loaded.  In the future, the global object may become a proxy
+  // for an object that can be switched in and out so that we don't need
+  // to disable scripts during paint suppression.
+
+  if (!mDocument)
+    return NS_OK;
+
+#if defined(NS_PRINTING) && defined(NS_PRINT_PREVIEW)
+  // Turn scripting back on
+  // after PrintPreview had turned it off
+  if (GetIsPrintPreview() && mPrintEngine) {
+    mPrintEngine->TurnScriptingOn(true);
+  }
+#endif
+
+#ifdef NS_PRINTING
+  // A Close was called while we were printing
+  // so don't clear the ScriptGlobalObject
+  // or clear the mDocument below
+  if (mPrintEngine && !mClosingWhilePrinting) {
+    mClosingWhilePrinting = true;
+  } else
+#endif
+    {
+      // out of band cleanup of docshell
+      mDocument->SetScriptGlobalObject(nullptr);
+
+      if (!mSHEntry && mDocument)
+        mDocument->RemovedFromDocShell();
+    }
+
+  if (mFocusListener) {
+    mFocusListener->Disconnect();
+    if (mDocument) {
+      mDocument->RemoveEventListener(NS_LITERAL_STRING("focus"), mFocusListener,
+                                     false);
+      mDocument->RemoveEventListener(NS_LITERAL_STRING("blur"), mFocusListener,
+                                     false);
+    }
+  }
+
+  return NS_OK;
+}
+
+static void
+DetachContainerRecurse(nsIDocShell *aShell)
+{
+  // Unhook this docshell's presentation
+  nsCOMPtr<nsIContentViewer> viewer;
+  aShell->GetContentViewer(getter_AddRefs(viewer));
+  if (viewer) {
+    nsIDocument* doc = viewer->GetDocument();
+    if (doc) {
+      doc->SetContainer(nullptr);
+    }
+    RefPtr<nsPresContext> pc;
+    viewer->GetPresContext(getter_AddRefs(pc));
+    if (pc) {
+      pc->Detach();
+    }
+    nsCOMPtr<nsIPresShell> presShell;
+    viewer->GetPresShell(getter_AddRefs(presShell));
+    if (presShell) {
+      auto weakShell = static_cast<nsDocShell*>(aShell);
+      presShell->SetForwardingContainer(weakShell);
+    }
+  }
+
+  // Now recurse through the children
+  int32_t childCount;
+  aShell->GetChildCount(&childCount);
+  for (int32_t i = 0; i < childCount; ++i) {
+    nsCOMPtr<nsIDocShellTreeItem> childItem;
+    aShell->GetChildAt(i, getter_AddRefs(childItem));
+    nsCOMPtr<nsIDocShell> shell = do_QueryInterface(childItem);
+    DetachContainerRecurse(shell);
+  }
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::Destroy()
+{
+  NS_ASSERTION(mDocument, "No document in Destroy()!");
+
+#ifdef NS_PRINTING
+  // Here is where we check to see if the document was still being prepared 
+  // for printing when it was asked to be destroy from someone externally
+  // This usually happens if the document is unloaded while the user is in the
+  // Print Dialog
+  //
+  // So we flip the bool to remember that the document is going away
+  // and we can clean up and abort later after returning from the Print Dialog
+  if (mPrintEngine) {
+    if (mPrintEngine->CheckBeforeDestroy()) {
+      return NS_OK;
+    }
+  }
+  // Dispatch the 'afterprint' event now, if pending:
+  mAutoBeforeAndAfterPrint = nullptr;
+#endif
+
+  // Don't let the document get unloaded while we are printing.
+  // this could happen if we hit the back button during printing.
+  // We also keep the viewer from being cached in session history, since
+  // we require all documents there to be sanitized.
+  if (mDestroyRefCount != 0) {
+    --mDestroyRefCount;
+    return NS_OK;
+  }
+
+  // If we were told to put ourselves into session history instead of destroy
+  // the presentation, do that now.
+  if (mSHEntry) {
+    if (mPresShell)
+      mPresShell->Freeze();
+
+    // Make sure the presentation isn't torn down by Hide().
+    mSHEntry->SetSticky(mIsSticky);
+    mIsSticky = true;
+
+    bool savePresentation = mDocument ? mDocument->IsBFCachingAllowed() : true;
+
+    // Remove our root view from the view hierarchy.
+    if (mPresShell) {
+      nsViewManager *vm = mPresShell->GetViewManager();
+      if (vm) {
+        nsView *rootView = vm->GetRootView();
+
+        if (rootView) {
+          nsView *rootViewParent = rootView->GetParent();
+          if (rootViewParent) {
+            nsViewManager *parentVM = rootViewParent->GetViewManager();
+            if (parentVM) {
+              parentVM->RemoveChild(rootView);
+            }
+          }
+        }
+      }
+    }
+
+    Hide();
+
+    // This is after Hide() so that the user doesn't see the inputs clear.
+    if (mDocument) {
+      mDocument->Sanitize();
+    }
+
+    // Reverse ownership. Do this *after* calling sanitize so that sanitize
+    // doesn't cause mutations that make the SHEntry drop the presentation
+
+    // Grab a reference to mSHEntry before calling into things like
+    // SyncPresentationState that might mess with our members.
+    nsCOMPtr<nsISHEntry> shEntry = mSHEntry; // we'll need this below
+    mSHEntry = nullptr;
+
+    if (savePresentation) {
+      shEntry->SetContentViewer(this);
+    }
+
+    // Always sync the presentation state.  That way even if someone screws up
+    // and shEntry has no window state at this point we'll be ok; we just won't
+    // cache ourselves.
+    shEntry->SyncPresentationState();
+
+    // Shut down accessibility for the document before we start to tear it down.
+#ifdef ACCESSIBILITY
+    if (mPresShell) {
+      a11y::DocAccessible* docAcc = mPresShell->GetDocAccessible();
+      if (docAcc) {
+        docAcc->Shutdown();
+      }
+    }
+#endif
+
+    // Break the link from the document/presentation to the docshell, so that
+    // link traversals cannot affect the currently-loaded document.
+    // When the presentation is restored, Open() and InitInternal() will reset
+    // these pointers to their original values.
+
+    if (mDocument) {
+      mDocument->SetContainer(nullptr);
+    }
+    if (mPresContext) {
+      mPresContext->Detach();
+    }
+    if (mPresShell) {
+      mPresShell->SetForwardingContainer(mContainer);
+    }
+
+    // Do the same for our children.  Note that we need to get the child
+    // docshells from the SHEntry now; the docshell will have cleared them.
+    nsCOMPtr<nsIDocShellTreeItem> item;
+    int32_t itemIndex = 0;
+    while (NS_SUCCEEDED(shEntry->ChildShellAt(itemIndex++,
+                                              getter_AddRefs(item))) && item) {
+      nsCOMPtr<nsIDocShell> shell = do_QueryInterface(item);
+      DetachContainerRecurse(shell);
+    }
+
+    return NS_OK;
+  }
+
+  // The document was not put in the bfcache
+
+  // Protect against pres shell destruction running scripts and re-entrantly
+  // creating a new presentation.
+  nsAutoScriptBlocker scriptBlocker;
+
+  if (mPresShell) {
+    DestroyPresShell();
+  }
+  if (mDocument) {
+    mDocument->Destroy();
+    mDocument = nullptr;
+  }
+
+  // All callers are supposed to call destroy to break circular
+  // references.  If we do this stuff in the destructor, the
+  // destructor might never be called (especially if we're being
+  // used from JS.
+
+#ifdef NS_PRINTING
+  if (mPrintEngine) {
+    RefPtr<nsPrintEngine> printEngine = mozilla::Move(mPrintEngine);
+#ifdef NS_PRINT_PREVIEW
+    bool doingPrintPreview;
+    printEngine->GetDoingPrintPreview(&doingPrintPreview);
+    if (doingPrintPreview) {
+      printEngine->FinishPrintPreview();
+    }
+#endif
+    printEngine->Destroy();
+    MOZ_ASSERT(!mPrintEngine,
+               "mPrintEngine shouldn't be recreated while destroying it");
+  }
+#endif
+
+  // Avoid leaking the old viewer.
+  if (mPreviousViewer) {
+    mPreviousViewer->Destroy();
+    mPreviousViewer = nullptr;
+  }
+
+  mDeviceContext = nullptr;
+
+  if (mPresContext) {
+    DestroyPresContext();
+  }
+
+  mWindow = nullptr;
+  mViewManager = nullptr;
+  mContainer = WeakPtr<nsDocShell>();
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::Stop(void)
+{
+  NS_ASSERTION(mDocument, "Stop called too early or too late");
+  if (mDocument) {
+    mDocument->StopDocumentLoad();
+  }
+
+  if (!mHidden && (mLoaded || mStopped) && mPresContext && !mSHEntry)
+    mPresContext->SetImageAnimationMode(imgIContainer::kDontAnimMode);
+
+  mStopped = true;
+
+  if (!mLoaded && mPresShell) {
+    // Well, we might as well paint what we have so far.
+    nsCOMPtr<nsIPresShell> shell(mPresShell); // bug 378682
+    shell->UnsuppressPainting();
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::GetDOMDocument(nsIDOMDocument **aResult)
+{
+  NS_ENSURE_TRUE(mDocument, NS_ERROR_NOT_AVAILABLE);
+  return CallQueryInterface(mDocument, aResult);
+}
+
+NS_IMETHODIMP_(nsIDocument *)
+nsDocumentViewer::GetDocument()
+{
+  return mDocument;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::SetDOMDocument(nsIDOMDocument *aDocument)
+{
+  // Assumptions:
+  //
+  // 1) this document viewer has been initialized with a call to Init().
+  // 2) the stylesheets associated with the document have been added
+  // to the document.
+
+  // XXX Right now, this method assumes that the layout of the current
+  // document hasn't started yet.  More cleanup will probably be
+  // necessary to make this method work for the case when layout *has*
+  // occurred for the current document.
+  // That work can happen when and if it is needed.
+
+  if (!aDocument)
+    return NS_ERROR_NULL_POINTER;
+
+  nsCOMPtr<nsIDocument> newDoc = do_QueryInterface(aDocument);
+  NS_ENSURE_TRUE(newDoc, NS_ERROR_UNEXPECTED);
+
+  return SetDocumentInternal(newDoc, false);
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::SetDocumentInternal(nsIDocument* aDocument,
+                                        bool aForceReuseInnerWindow)
+{
+  MOZ_ASSERT(aDocument);
+
+  // Set new container
+  aDocument->SetContainer(mContainer);
+
+  if (mDocument != aDocument) {
+    if (aForceReuseInnerWindow) {
+      // Transfer the navigation timing information to the new document, since
+      // we're keeping the same inner and hence should really have the same
+      // timing information.
+      aDocument->SetNavigationTiming(mDocument->GetNavigationTiming());
+    }
+
+    if (mDocument->IsStaticDocument()) {
+      mDocument->Destroy();
+    }
+
+    // Clear the list of old child docshells. Child docshells for the new
+    // document will be constructed as frames are created.
+    if (!aDocument->IsStaticDocument()) {
+      nsCOMPtr<nsIDocShell> node(mContainer);
+      if (node) {
+        int32_t count;
+        node->GetChildCount(&count);
+        for (int32_t i = 0; i < count; ++i) {
+          nsCOMPtr<nsIDocShellTreeItem> child;
+          node->GetChildAt(0, getter_AddRefs(child));
+          node->RemoveChild(child);
+        }
+      }
+    }
+
+    // Replace the old document with the new one. Do this only when
+    // the new document really is a new document.
+    mDocument = aDocument;
+
+    // Set the script global object on the new document
+    nsCOMPtr<nsPIDOMWindowOuter> window =
+      mContainer ? mContainer->GetWindow() : nullptr;
+    if (window) {
+      nsresult rv = window->SetNewDocument(aDocument, nullptr,
+                                           aForceReuseInnerWindow);
+      if (NS_FAILED(rv)) {
+        Destroy();
+        return rv;
+      }
+    }
+  }
+
+  nsresult rv = SyncParentSubDocMap();
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Replace the current pres shell with a new shell for the new document
+
+  // Protect against pres shell destruction running scripts and re-entrantly
+  // creating a new presentation.
+  nsAutoScriptBlocker scriptBlocker;
+
+  if (mPresShell) {
+    DestroyPresShell();
+  }
+
+  if (mPresContext) {
+    DestroyPresContext();
+
+    mWindow = nullptr;
+    rv = InitInternal(mParentWidget, nullptr, mBounds, true, true, false);
+  }
+
+  return rv;
+}
+
+nsIPresShell*
+nsDocumentViewer::GetPresShell()
+{
+  return mPresShell;
+}
+
+nsPresContext*
+nsDocumentViewer::GetPresContext()
+{
+  return mPresContext;
+}
+
+nsViewManager*
+nsDocumentViewer::GetViewManager()
+{
+  return mViewManager;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::GetPresShell(nsIPresShell** aResult)
+{
+  nsIPresShell* shell = GetPresShell();
+  NS_IF_ADDREF(*aResult = shell);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::GetPresContext(nsPresContext** aResult)
+{
+  nsPresContext* pc = GetPresContext();
+  NS_IF_ADDREF(*aResult = pc);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::GetBounds(nsIntRect& aResult)
+{
+  NS_ENSURE_TRUE(mDocument, NS_ERROR_NOT_AVAILABLE);
+  aResult = mBounds;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::GetPreviousViewer(nsIContentViewer** aViewer)
+{
+  *aViewer = mPreviousViewer;
+  NS_IF_ADDREF(*aViewer);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::SetPreviousViewer(nsIContentViewer* aViewer)
+{
+  // NOTE:  |Show| sets |mPreviousViewer| to null without calling this
+  // function.
+
+  if (aViewer) {
+    NS_ASSERTION(!mPreviousViewer,
+                 "can't set previous viewer when there already is one");
+
+    // In a multiple chaining situation (which occurs when running a thrashing
+    // test like i-bench or jrgm's tests with no delay), we can build up a
+    // whole chain of viewers.  In order to avoid this, we always set our previous
+    // viewer to the MOST previous viewer in the chain, and then dump the intermediate
+    // link from the chain.  This ensures that at most only 2 documents are alive
+    // and undestroyed at any given time (the one that is showing and the one that
+    // is loading with painting suppressed).
+    // It's very important that if this ever gets changed the code
+    // before the RestorePresentation call in nsDocShell::InternalLoad
+    // be changed accordingly.
+    nsCOMPtr<nsIContentViewer> prevViewer;
+    aViewer->GetPreviousViewer(getter_AddRefs(prevViewer));
+    if (prevViewer) {
+      aViewer->SetPreviousViewer(nullptr);
+      aViewer->Destroy();
+      return SetPreviousViewer(prevViewer);
+    }
+  }
+
+  mPreviousViewer = aViewer;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::SetBoundsWithFlags(const nsIntRect& aBounds, uint32_t aFlags)
+{
+  NS_ENSURE_TRUE(mDocument, NS_ERROR_NOT_AVAILABLE);
+
+  mBounds = aBounds;
+
+  if (mWindow && !mAttachedToParent) {
+    // Resize the widget, but don't trigger repaint. Layout will generate
+    // repaint requests during reflow.
+    mWindow->Resize(aBounds.x, aBounds.y,
+                    aBounds.width, aBounds.height,
+                    false);
+  } else if (mPresContext && mViewManager) {
+    // Ensure presContext's deviceContext is up to date, as we sometimes get
+    // here before a resolution-change notification has been fully handled
+    // during display configuration changes, especially when there are lots
+    // of windows/widgets competing to handle the notifications.
+    // (See bug 1154125.)
+    if (mPresContext->DeviceContext()->CheckDPIChange()) {
+      mPresContext->UIResolutionChanged();
+    }
+    int32_t p2a = mPresContext->AppUnitsPerDevPixel();
+    mViewManager->SetWindowDimensions(NSIntPixelsToAppUnits(mBounds.width, p2a),
+                                      NSIntPixelsToAppUnits(mBounds.height, p2a),
+                                      !!(aFlags & nsIContentViewer::eDelayResize));
+  }
+
+  // If there's a previous viewer, it's the one that's actually showing,
+  // so be sure to resize it as well so it paints over the right area.
+  // This may slow down the performance of the new page load, but resize
+  // during load is also probably a relatively unusual condition
+  // relating to things being hidden while something is loaded.  It so
+  // happens that Firefox does this a good bit with its infobar, and it
+  // looks ugly if we don't do this.
+  if (mPreviousViewer) {
+    nsCOMPtr<nsIContentViewer> previousViewer = mPreviousViewer;
+    previousViewer->SetBounds(aBounds);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::SetBounds(const nsIntRect& aBounds)
+{
+  return SetBoundsWithFlags(aBounds, 0);
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::Move(int32_t aX, int32_t aY)
+{
+  NS_ENSURE_TRUE(mDocument, NS_ERROR_NOT_AVAILABLE);
+  mBounds.MoveTo(aX, aY);
+  if (mWindow) {
+    mWindow->Move(aX, aY);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::Show(void)
+{
+  NS_ENSURE_TRUE(mDocument, NS_ERROR_NOT_AVAILABLE);
+
+  // We don't need the previous viewer anymore since we're not
+  // displaying it.
+  if (mPreviousViewer) {
+    // This little dance *may* only be to keep
+    // PresShell::EndObservingDocument happy, but I'm not sure.
+    nsCOMPtr<nsIContentViewer> prevViewer(mPreviousViewer);
+    mPreviousViewer = nullptr;
+    prevViewer->Destroy();
+
+    // Make sure we don't have too many cached ContentViewers
+    nsCOMPtr<nsIDocShellTreeItem> treeItem(mContainer);
+    if (treeItem) {
+      // We need to find the root DocShell since only that object has an
+      // SHistory and we need the SHistory to evict content viewers
+      nsCOMPtr<nsIDocShellTreeItem> root;
+      treeItem->GetSameTypeRootTreeItem(getter_AddRefs(root));
+      nsCOMPtr<nsIWebNavigation> webNav = do_QueryInterface(root);
+      nsCOMPtr<nsISHistory> history;
+      webNav->GetSessionHistory(getter_AddRefs(history));
+      nsCOMPtr<nsISHistoryInternal> historyInt = do_QueryInterface(history);
+      if (historyInt) {
+        int32_t prevIndex,loadedIndex;
+        nsCOMPtr<nsIDocShell> docShell = do_QueryInterface(treeItem);
+        docShell->GetPreviousTransIndex(&prevIndex);
+        docShell->GetLoadedTransIndex(&loadedIndex);
+#ifdef DEBUG_PAGE_CACHE
+        printf("About to evict content viewers: prev=%d, loaded=%d\n",
+               prevIndex, loadedIndex);
+#endif
+        historyInt->EvictOutOfRangeContentViewers(loadedIndex);
+      }
+    }
+  }
+
+  if (mWindow) {
+    // When attached to a top level xul window, we do not need to call
+    // Show on the widget. Underlying window management code handles
+    // this when the window is initialized.
+    if (!mAttachedToParent) {
+      mWindow->Show(true);
+    }
+  }
+
+  // Hold on to the document so we can use it after the script blocker below
+  // has been released (which might re-entrantly call into other
+  // nsDocumentViewer methods).
+  nsCOMPtr<nsIDocument> document = mDocument;
+
+  if (mDocument && !mPresShell) {
+    // The InitPresentationStuff call below requires a script blocker, because
+    // its PresShell::Initialize call can cause scripts to run and therefore
+    // re-entrant calls to nsDocumentViewer methods to be made.
+    nsAutoScriptBlocker scriptBlocker;
+
+    NS_ASSERTION(!mWindow, "Window already created but no presshell?");
+
+    nsCOMPtr<nsIBaseWindow> base_win(mContainer);
+    if (base_win) {
+      base_win->GetParentWidget(&mParentWidget);
+      if (mParentWidget) {
+        mParentWidget->Release(); // GetParentWidget AddRefs, but mParentWidget is weak
+      }
+    }
+
+    nsView* containerView = FindContainerView();
+
+    nsresult rv = CreateDeviceContext(containerView);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    // Create presentation context
+    NS_ASSERTION(!mPresContext, "Shouldn't have a prescontext if we have no shell!");
+    mPresContext = CreatePresContext(mDocument,
+        nsPresContext::eContext_Galley, containerView);
+    NS_ENSURE_TRUE(mPresContext, NS_ERROR_OUT_OF_MEMORY);
+
+    rv = mPresContext->Init(mDeviceContext);
+    if (NS_FAILED(rv)) {
+      mPresContext = nullptr;
+      return rv;
+    }
+
+    rv = MakeWindow(nsSize(mPresContext->DevPixelsToAppUnits(mBounds.width),
+                           mPresContext->DevPixelsToAppUnits(mBounds.height)),
+                           containerView);
+    if (NS_FAILED(rv))
+      return rv;
+
+    if (mPresContext && base_win) {
+      nsCOMPtr<nsILinkHandler> linkHandler(do_GetInterface(base_win));
+
+      if (linkHandler) {
+        mPresContext->SetLinkHandler(linkHandler);
+      }
+
+      mPresContext->SetContainer(mContainer);
+    }
+
+    if (mPresContext) {
+      Hide();
+
+      rv = InitPresentationStuff(mDocument->MayStartLayout());
+    }
+
+    // If we get here the document load has already started and the
+    // window is shown because some JS on the page caused it to be
+    // shown...
+
+    if (mPresShell) {
+      nsCOMPtr<nsIPresShell> shell(mPresShell); // bug 378682
+      shell->UnsuppressPainting();
+    }
+  }
+
+  // Notify observers that a new page has been shown. This will get run
+  // from the event loop after we actually draw the page.
+  NS_DispatchToMainThread(new nsDocumentShownDispatcher(document));
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::Hide(void)
+{
+  if (!mAttachedToParent && mWindow) {
+    mWindow->Show(false);
+  }
+
+  if (!mPresShell)
+    return NS_OK;
+
+  NS_ASSERTION(mPresContext, "Can't have a presshell and no prescontext!");
+
+  // Avoid leaking the old viewer.
+  if (mPreviousViewer) {
+    mPreviousViewer->Destroy();
+    mPreviousViewer = nullptr;
+  }
+
+  if (mIsSticky) {
+    // This window is sticky, that means that it might be shown again
+    // and we don't want the presshell n' all that to be thrown away
+    // just because the window is hidden.
+
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsIDocShell> docShell(mContainer);
+  if (docShell) {
+#ifdef DEBUG
+    nsCOMPtr<nsIContentViewer> currentViewer;
+    docShell->GetContentViewer(getter_AddRefs(currentViewer));
+    MOZ_ASSERT(currentViewer == this);
+#endif
+    nsCOMPtr<nsILayoutHistoryState> layoutState;
+    mPresShell->CaptureHistoryState(getter_AddRefs(layoutState));
+  }
+
+  // Do not run ScriptRunners queued by DestroyPresShell() in the intermediate
+  // state before we're done destroying PresShell, PresContext, ViewManager, etc.
+  nsAutoScriptBlocker scriptBlocker;
+
+  DestroyPresShell();
+
+  DestroyPresContext();
+
+  mViewManager   = nullptr;
+  mWindow        = nullptr;
+  mDeviceContext = nullptr;
+  mParentWidget  = nullptr;
+
+  nsCOMPtr<nsIBaseWindow> base_win(mContainer);
+
+  if (base_win && !mAttachedToParent) {
+    base_win->SetParentWidget(nullptr);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::GetSticky(bool *aSticky)
+{
+  *aSticky = mIsSticky;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::SetSticky(bool aSticky)
+{
+  mIsSticky = aSticky;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::RequestWindowClose(bool* aCanClose)
+{
+#ifdef NS_PRINTING
+  if (mPrintIsPending || (mPrintEngine && mPrintEngine->GetIsPrinting())) {
+    *aCanClose = false;
+    mDeferredWindowClose = true;
+  } else
+#endif
+    *aCanClose = true;
+
+  return NS_OK;
+}
+
+StyleSetHandle
+nsDocumentViewer::CreateStyleSet(nsIDocument* aDocument)
+{
+  // Make sure this does the same thing as PresShell::AddSheet wrt ordering.
+
+  // this should eventually get expanded to allow for creating
+  // different sets for different media
+
+  StyleBackendType backendType = aDocument->GetStyleBackendType();
+
+  StyleSetHandle styleSet;
+  if (backendType == StyleBackendType::Gecko) {
+    styleSet = new nsStyleSet();
+  } else {
+    styleSet = new ServoStyleSet();
+  }
+
+  styleSet->BeginUpdate();
+  
+  // The document will fill in the document sheets when we create the presshell
+
+  if (aDocument->IsBeingUsedAsImage()) {
+    MOZ_ASSERT(aDocument->IsSVGDocument(),
+               "Do we want to skip most sheets for this new image type?");
+
+    // SVG-as-an-image must be kept as light and small as possible. We
+    // deliberately skip loading everything and leave svg.css (and html.css and
+    // xul.css) to be loaded on-demand.
+    // XXXjwatt Nothing else is loaded on-demand, but I don't think that
+    // should matter for SVG-as-an-image. If it does, I want to know why!
+
+    // Caller will handle calling EndUpdate, per contract.
+    return styleSet;
+  }
+
+  auto cache = nsLayoutStylesheetCache::For(backendType);
+
+  // Handle the user sheets.
+  StyleSheet* sheet = nullptr;
+  if (nsContentUtils::IsInChromeDocshell(aDocument)) {
+    sheet = cache->UserChromeSheet();
+  } else {
+    sheet = cache->UserContentSheet();
+  }
+
+  if (sheet)
+    styleSet->AppendStyleSheet(SheetType::User, sheet);
+
+  // Append chrome sheets (scrollbars + forms).
+  bool shouldOverride = false;
+  // We don't want a docshell here for external resource docs, so just
+  // look at mContainer.
+  nsCOMPtr<nsIDocShell> ds(mContainer);
+  nsCOMPtr<nsIDOMEventTarget> chromeHandler;
+  nsCOMPtr<nsIURI> uri;
+  RefPtr<StyleSheet> chromeSheet;
+
+  if (ds) {
+    ds->GetChromeEventHandler(getter_AddRefs(chromeHandler));
+  }
+  if (chromeHandler) {
+    nsCOMPtr<nsIDOMElement> elt(do_QueryInterface(chromeHandler));
+    nsCOMPtr<nsIContent> content(do_QueryInterface(elt));
+    if (elt && content) {
+      nsCOMPtr<nsIURI> baseURI = content->GetBaseURI();
+
+      nsAutoString sheets;
+      elt->GetAttribute(NS_LITERAL_STRING("usechromesheets"), sheets);
+      if (!sheets.IsEmpty() && baseURI) {
+        RefPtr<mozilla::css::Loader> cssLoader =
+          new mozilla::css::Loader(backendType);
+
+        char *str = ToNewCString(sheets);
+        char *newStr = str;
+        char *token;
+        while ( (token = nsCRT::strtok(newStr, ", ", &newStr)) ) {
+          NS_NewURI(getter_AddRefs(uri), nsDependentCString(token), nullptr,
+                    baseURI);
+          if (!uri) continue;
+
+          cssLoader->LoadSheetSync(uri, &chromeSheet);
+          if (!chromeSheet) continue;
+
+          styleSet->PrependStyleSheet(SheetType::Agent, chromeSheet);
+          shouldOverride = true;
+        }
+        free(str);
+      }
+    }
+  }
+
+  if (!shouldOverride) {
+    sheet = cache->ScrollbarsSheet();
+    if (sheet) {
+      styleSet->PrependStyleSheet(SheetType::Agent, sheet);
+    }
+  }
+
+  if (!aDocument->IsSVGDocument()) {
+    // !!! IMPORTANT - KEEP THIS BLOCK IN SYNC WITH
+    // !!! SVGDocument::EnsureNonSVGUserAgentStyleSheetsLoaded.
+
+    // SVGForeignObjectElement::BindToTree calls SVGDocument::
+    // EnsureNonSVGUserAgentStyleSheetsLoaded to loads these UA sheet
+    // on-demand. (Excluding the quirks sheet, which should never be loaded for
+    // an SVG document, and excluding xul.css which will be loaded on demand by
+    // nsXULElement::BindToTree.)
+
+    sheet = cache->NumberControlSheet();
+    if (sheet) {
+      styleSet->PrependStyleSheet(SheetType::Agent, sheet);
+    }
+
+    sheet = cache->FormsSheet();
+    if (sheet) {
+      styleSet->PrependStyleSheet(SheetType::Agent, sheet);
+    }
+
+    if (aDocument->LoadsFullXULStyleSheetUpFront()) {
+      // nsXULElement::BindToTree loads xul.css on-demand if we don't load it
+      // up-front here.
+      sheet = cache->XULSheet();
+      if (sheet) {
+        styleSet->PrependStyleSheet(SheetType::Agent, sheet);
+      }
+    }
+
+    sheet = cache->MinimalXULSheet();
+    if (sheet) {
+      // Load the minimal XUL rules for scrollbars and a few other XUL things
+      // that non-XUL (typically HTML) documents commonly use.
+      styleSet->PrependStyleSheet(SheetType::Agent, sheet);
+    }
+
+    sheet = cache->CounterStylesSheet();
+    if (sheet) {
+      styleSet->PrependStyleSheet(SheetType::Agent, sheet);
+    }
+
+    if (nsLayoutUtils::ShouldUseNoScriptSheet(aDocument)) {
+      sheet = cache->NoScriptSheet();
+      if (sheet) {
+        styleSet->PrependStyleSheet(SheetType::Agent, sheet);
+      }
+    }
+
+    if (nsLayoutUtils::ShouldUseNoFramesSheet(aDocument)) {
+      sheet = cache->NoFramesSheet();
+      if (sheet) {
+        styleSet->PrependStyleSheet(SheetType::Agent, sheet);
+      }
+    }
+
+    // We don't add quirk.css here; nsPresContext::CompatibilityModeChanged will
+    // append it if needed.
+
+    sheet = cache->HTMLSheet();
+    if (sheet) {
+      styleSet->PrependStyleSheet(SheetType::Agent, sheet);
+    }
+
+    styleSet->PrependStyleSheet(SheetType::Agent,
+                                cache->UASheet());
+  } else {
+    // SVG documents may have scrollbars and need the scrollbar styling.
+    sheet = cache->MinimalXULSheet();
+    if (sheet) {
+      styleSet->PrependStyleSheet(SheetType::Agent, sheet);
+    }
+  }
+
+  if (styleSet->IsGecko()) {
+    nsStyleSheetService* sheetService = nsStyleSheetService::GetInstance();
+    if (sheetService) {
+      for (StyleSheet* sheet : *sheetService->AgentStyleSheets()) {
+        styleSet->AppendStyleSheet(SheetType::Agent, sheet);
+      }
+      for (StyleSheet* sheet : Reversed(*sheetService->UserStyleSheets())) {
+        styleSet->PrependStyleSheet(SheetType::User, sheet);
+      }
+    }
+  } else {
+    NS_WARNING("stylo: Not yet checking nsStyleSheetService for Servo-backed "
+               "documents. See bug 1290224");
+  }
+
+  // Caller will handle calling EndUpdate, per contract.
+  return styleSet;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::ClearHistoryEntry()
+{
+  mSHEntry = nullptr;
+  return NS_OK;
+}
+
+//-------------------------------------------------------
+
+nsresult
+nsDocumentViewer::MakeWindow(const nsSize& aSize, nsView* aContainerView)
+{
+  if (GetIsPrintPreview())
+    return NS_OK;
+
+  bool shouldAttach = ShouldAttachToTopLevel();
+
+  if (shouldAttach) {
+    // If the old view is already attached to our parent, detach
+    DetachFromTopLevelWidget();
+  }
+
+  mViewManager = new nsViewManager();
+
+  nsDeviceContext *dx = mPresContext->DeviceContext();
+
+  nsresult rv = mViewManager->Init(dx);
+  if (NS_FAILED(rv))
+    return rv;
+
+  // The root view is always at 0,0.
+  nsRect tbounds(nsPoint(0, 0), aSize);
+  // Create a view
+  nsView* view = mViewManager->CreateView(tbounds, aContainerView);
+  if (!view)
+    return NS_ERROR_OUT_OF_MEMORY;
+
+  // Create a widget if we were given a parent widget or don't have a
+  // container view that we can hook up to without a widget.
+  // Don't create widgets for ResourceDocs (external resources & svg images),
+  // because when they're displayed, they're painted into *another* document's
+  // widget.
+  if (!mDocument->IsResourceDoc() &&
+      (mParentWidget || !aContainerView)) {
+    // pass in a native widget to be the parent widget ONLY if the view hierarchy will stand alone.
+    // otherwise the view will find its own parent widget and "do the right thing" to
+    // establish a parent/child widget relationship
+    nsWidgetInitData initData;
+    nsWidgetInitData* initDataPtr;
+    if (!mParentWidget) {
+      initDataPtr = &initData;
+      initData.mWindowType = eWindowType_invisible;
+    } else {
+      initDataPtr = nullptr;
+    }
+
+    if (shouldAttach) {
+      // Reuse the top level parent widget.
+      rv = view->AttachToTopLevelWidget(mParentWidget);
+      mAttachedToParent = true;
+    }
+    else if (!aContainerView && mParentWidget) {
+      rv = view->CreateWidgetForParent(mParentWidget, initDataPtr,
+                                       true, false);
+    }
+    else {
+      rv = view->CreateWidget(initDataPtr, true, false);
+    }
+    if (NS_FAILED(rv))
+      return rv;
+  }
+
+  // Setup hierarchical relationship in view manager
+  mViewManager->SetRootView(view);
+
+  mWindow = view->GetWidget();
+
+  // This SetFocus is necessary so the Arrow Key and Page Key events
+  // go to the scrolled view as soon as the Window is created instead of going to
+  // the browser window (this enables keyboard scrolling of the document)
+  // mWindow->SetFocus();
+
+  return rv;
+}
+
+void
+nsDocumentViewer::DetachFromTopLevelWidget()
+{
+  if (mViewManager) {
+    nsView* oldView = mViewManager->GetRootView();
+    if (oldView && oldView->IsAttachedToTopLevel()) {
+      oldView->DetachFromTopLevelWidget();
+    }
+  }
+  mAttachedToParent = false;
+}
+
+nsView*
+nsDocumentViewer::FindContainerView()
+{
+  if (!mContainer) {
+    return nullptr;
+  }
+
+  nsCOMPtr<nsIDocShell> docShell(mContainer);
+  nsCOMPtr<nsPIDOMWindowOuter> pwin(docShell->GetWindow());
+  if (!pwin) {
+    return nullptr;
+  }
+
+  nsCOMPtr<Element> containerElement = pwin->GetFrameElementInternal();
+  if (!containerElement) {
+    return nullptr;
+  }
+
+  nsIFrame* subdocFrame = nsLayoutUtils::GetRealPrimaryFrameFor(containerElement);
+  if (!subdocFrame) {
+    // XXX Silenced by default in bug 1175289
+    LAYOUT_WARNING("Subdocument container has no frame");
+    return nullptr;
+  }
+
+  // subdocFrame might not be a subdocument frame; the frame
+  // constructor can treat a <frame> as an inline in some XBL
+  // cases. Treat that as display:none, the document is not
+  // displayed.
+  if (subdocFrame->GetType() != nsGkAtoms::subDocumentFrame) {
+    NS_WARNING_ASSERTION(!subdocFrame->GetType(),
+                         "Subdocument container has non-subdocument frame");
+    return nullptr;
+  }
+
+  NS_ASSERTION(subdocFrame->GetView(), "Subdoc frames must have views");
+  return static_cast<nsSubDocumentFrame*>(subdocFrame)->EnsureInnerView();
+}
+
+nsresult
+nsDocumentViewer::CreateDeviceContext(nsView* aContainerView)
+{
+  NS_PRECONDITION(!mPresShell && !mWindow,
+                  "This will screw up our existing presentation");
+  NS_PRECONDITION(mDocument, "Gotta have a document here");
+  
+  nsIDocument* doc = mDocument->GetDisplayDocument();
+  if (doc) {
+    NS_ASSERTION(!aContainerView, "External resource document embedded somewhere?");
+    // We want to use our display document's device context if possible
+    nsIPresShell* shell = doc->GetShell();
+    if (shell) {
+      nsPresContext* ctx = shell->GetPresContext();
+      if (ctx) {
+        mDeviceContext = ctx->DeviceContext();
+        return NS_OK;
+      }
+    }
+  }
+  
+  // Create a device context even if we already have one, since our widget
+  // might have changed.
+  nsIWidget* widget = nullptr;
+  if (aContainerView) {
+    widget = aContainerView->GetNearestWidget(nullptr);
+  }
+  if (!widget) {
+    widget = mParentWidget;
+  }
+  if (widget) {
+    widget = widget->GetTopLevelWidget();
+  }
+
+  mDeviceContext = new nsDeviceContext();
+  mDeviceContext->Init(widget);
+  return NS_OK;
+}
+
+// Return the selection for the document. Note that text fields have their
+// own selection, which cannot be accessed with this method.
+mozilla::dom::Selection*
+nsDocumentViewer::GetDocumentSelection()
+{
+  if (!mPresShell) {
+    return nullptr;
+  }
+
+  return mPresShell->GetCurrentSelection(SelectionType::eNormal);
+}
+
+/* ========================================================================================
+ * nsIContentViewerEdit
+ * ======================================================================================== */
+
+NS_IMETHODIMP nsDocumentViewer::ClearSelection()
+{
+  // use nsCopySupport::GetSelectionForCopy() ?
+  RefPtr<mozilla::dom::Selection> selection = GetDocumentSelection();
+  if (!selection) {
+    return NS_ERROR_FAILURE;
+  }
+
+  return selection->CollapseToStart();
+}
+
+NS_IMETHODIMP nsDocumentViewer::SelectAll()
+{
+  // XXX this is a temporary implementation copied from nsWebShell
+  // for now. I think nsDocument and friends should have some helper
+  // functions to make this easier.
+
+  // use nsCopySupport::GetSelectionForCopy() ?
+  RefPtr<mozilla::dom::Selection> selection = GetDocumentSelection();
+  if (!selection) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIDOMHTMLDocument> htmldoc = do_QueryInterface(mDocument);
+  nsCOMPtr<nsIDOMNode> bodyNode;
+
+  nsresult rv;
+  if (htmldoc)
+  {
+    nsCOMPtr<nsIDOMHTMLElement>bodyElement;
+    rv = htmldoc->GetBody(getter_AddRefs(bodyElement));
+    if (NS_FAILED(rv) || !bodyElement) return rv;
+
+    bodyNode = do_QueryInterface(bodyElement);
+  }
+  else if (mDocument)
+  {
+    bodyNode = do_QueryInterface(mDocument->GetRootElement());
+  }
+  if (!bodyNode) return NS_ERROR_FAILURE;
+
+  rv = selection->RemoveAllRanges();
+  if (NS_FAILED(rv)) return rv;
+
+  mozilla::dom::Selection::AutoUserInitiated userSelection(selection);
+  rv = selection->SelectAllChildren(bodyNode);
+  return rv;
+}
+
+NS_IMETHODIMP nsDocumentViewer::CopySelection()
+{
+  nsCopySupport::FireClipboardEvent(eCopy, nsIClipboard::kGlobalClipboard,
+                                    mPresShell, nullptr);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsDocumentViewer::CopyLinkLocation()
+{
+  NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_INITIALIZED);
+  nsCOMPtr<nsIDOMNode> node;
+  GetPopupLinkNode(getter_AddRefs(node));
+  // make noise if we're not in a link
+  NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
+
+  nsCOMPtr<dom::Element> elm(do_QueryInterface(node));
+  NS_ENSURE_TRUE(elm, NS_ERROR_FAILURE);
+
+  nsAutoString locationText;
+  nsContentUtils::GetLinkLocation(elm, locationText);
+  if (locationText.IsEmpty())
+    return NS_ERROR_FAILURE;
+
+  nsresult rv = NS_OK;
+  nsCOMPtr<nsIClipboardHelper> clipboard(do_GetService("@mozilla.org/widget/clipboardhelper;1", &rv));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // copy the href onto the clipboard
+  return clipboard->CopyString(locationText);
+}
+
+NS_IMETHODIMP nsDocumentViewer::CopyImage(int32_t aCopyFlags)
+{
+  NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_INITIALIZED);
+  nsCOMPtr<nsIImageLoadingContent> node;
+  GetPopupImageNode(getter_AddRefs(node));
+  // make noise if we're not in an image
+  NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
+
+  nsCOMPtr<nsILoadContext> loadContext(mContainer);
+  return nsCopySupport::ImageCopy(node, loadContext, aCopyFlags);
+}
+
+
+NS_IMETHODIMP nsDocumentViewer::GetCopyable(bool *aCopyable)
+{
+  NS_ENSURE_ARG_POINTER(aCopyable);
+  *aCopyable = nsCopySupport::CanCopy(mDocument);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsDocumentViewer::GetContents(const char *mimeType, bool selectionOnly, nsAString& aOutValue)
+{
+  aOutValue.Truncate();
+
+  NS_ENSURE_TRUE(mPresShell, NS_ERROR_NOT_INITIALIZED);
+  NS_ENSURE_TRUE(mDocument, NS_ERROR_NOT_INITIALIZED);
+
+  // Now we have the selection.  Make sure it's nonzero:
+  nsCOMPtr<nsISelection> sel;
+  if (selectionOnly) {
+    nsCopySupport::GetSelectionForCopy(mDocument, getter_AddRefs(sel));
+    NS_ENSURE_TRUE(sel, NS_ERROR_FAILURE);
+  
+    bool isCollapsed;
+    sel->GetIsCollapsed(&isCollapsed);
+    if (isCollapsed)
+      return NS_OK;
+  }
+
+  // call the copy code
+  return nsCopySupport::GetContents(nsDependentCString(mimeType), 0, sel,
+                                    mDocument, aOutValue);
+}
+
+NS_IMETHODIMP nsDocumentViewer::GetCanGetContents(bool *aCanGetContents)
+{
+  NS_ENSURE_ARG_POINTER(aCanGetContents);
+  *aCanGetContents = false;
+  NS_ENSURE_STATE(mDocument);
+  *aCanGetContents = nsCopySupport::CanCopy(mDocument);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsDocumentViewer::SetCommandNode(nsIDOMNode* aNode)
+{
+  nsIDocument* document = GetDocument();
+  NS_ENSURE_STATE(document);
+
+  nsCOMPtr<nsPIDOMWindowOuter> window(document->GetWindow());
+  NS_ENSURE_TRUE(window, NS_ERROR_NOT_AVAILABLE);
+
+  nsCOMPtr<nsPIWindowRoot> root = window->GetTopWindowRoot();
+  NS_ENSURE_STATE(root);
+
+  root->SetPopupNode(aNode);
+  return NS_OK;
+}
+
+/* ========================================================================================
+ * nsIContentViewerFile
+ * ======================================================================================== */
+/** ---------------------------------------------------
+ *  See documentation above in the nsIContentViewerfile class definition
+ *	@update 01/24/00 dwc
+ */
+NS_IMETHODIMP
+nsDocumentViewer::Print(bool              aSilent,
+                          FILE *            aDebugFile,
+                          nsIPrintSettings* aPrintSettings)
+{
+#ifdef NS_PRINTING
+  nsCOMPtr<nsIPrintSettings> printSettings;
+
+#ifdef DEBUG
+  nsresult rv = NS_ERROR_FAILURE;
+
+  mDebugFile = aDebugFile;
+  // if they don't pass in a PrintSettings, then make one
+  // it will have all the default values
+  printSettings = aPrintSettings;
+  nsCOMPtr<nsIPrintSettingsService> printSettingsSvc
+    = do_GetService("@mozilla.org/gfx/printsettings-service;1", &rv);
+  if (NS_SUCCEEDED(rv)) {
+    // if they don't pass in a PrintSettings, then make one
+    if (printSettings == nullptr) {
+      printSettingsSvc->GetNewPrintSettings(getter_AddRefs(printSettings));
+    }
+    NS_ASSERTION(printSettings, "You can't PrintPreview without a PrintSettings!");
+  }
+  if (printSettings) printSettings->SetPrintSilent(aSilent);
+  if (printSettings) printSettings->SetShowPrintProgress(false);
+#endif
+
+
+  return Print(printSettings, nullptr);
+#else
+  return NS_ERROR_FAILURE;
+#endif
+}
+
+// nsIContentViewerFile interface
+NS_IMETHODIMP
+nsDocumentViewer::GetPrintable(bool *aPrintable)
+{
+  NS_ENSURE_ARG_POINTER(aPrintable);
+
+  *aPrintable = !GetIsPrinting();
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsDocumentViewer::ScrollToNode(nsIDOMNode* aNode)
+{
+  NS_ENSURE_ARG(aNode);
+  NS_ENSURE_TRUE(mDocument, NS_ERROR_NOT_AVAILABLE);
+  nsCOMPtr<nsIPresShell> presShell;
+  NS_ENSURE_SUCCESS(GetPresShell(getter_AddRefs(presShell)), NS_ERROR_FAILURE);
+
+  // Get the nsIContent interface, because that's what we need to
+  // get the primary frame
+
+  nsCOMPtr<nsIContent> content(do_QueryInterface(aNode));
+  NS_ENSURE_TRUE(content, NS_ERROR_FAILURE);
+
+  // Tell the PresShell to scroll to the primary frame of the content.
+  NS_ENSURE_SUCCESS(
+    presShell->ScrollContentIntoView(content,
+                                     nsIPresShell::ScrollAxis(
+                                       nsIPresShell::SCROLL_TOP,
+                                       nsIPresShell::SCROLL_ALWAYS),
+                                     nsIPresShell::ScrollAxis(),
+                                     nsIPresShell::SCROLL_OVERFLOW_HIDDEN),
+    NS_ERROR_FAILURE);
+  return NS_OK;
+}
+
+void
+nsDocumentViewer::CallChildren(CallChildFunc aFunc, void* aClosure)
+{
+  nsCOMPtr<nsIDocShell> docShell(mContainer);
+  if (docShell)
+  {
+    int32_t i;
+    int32_t n;
+    docShell->GetChildCount(&n);
+    for (i=0; i < n; i++)
+    {
+      nsCOMPtr<nsIDocShellTreeItem> child;
+      docShell->GetChildAt(i, getter_AddRefs(child));
+      nsCOMPtr<nsIDocShell> childAsShell(do_QueryInterface(child));
+      NS_ASSERTION(childAsShell, "null child in docshell");
+      if (childAsShell)
+      {
+        nsCOMPtr<nsIContentViewer> childCV;
+        childAsShell->GetContentViewer(getter_AddRefs(childCV));
+        if (childCV)
+        {
+          (*aFunc)(childCV, aClosure);
+        }
+      }
+    }
+  }
+}
+
+static void
+ChangeChildPaintingEnabled(nsIContentViewer* aChild, void* aClosure)
+{
+  bool* enablePainting = (bool*) aClosure;
+  if (*enablePainting) {
+    aChild->ResumePainting();
+  } else {
+    aChild->PausePainting();
+  }
+}
+
+struct ZoomInfo
+{
+  float mZoom;
+};
+
+static void
+SetChildTextZoom(nsIContentViewer* aChild, void* aClosure)
+{
+  struct ZoomInfo* ZoomInfo = (struct ZoomInfo*) aClosure;
+  aChild->SetTextZoom(ZoomInfo->mZoom);
+}
+
+static void
+SetChildMinFontSize(nsIContentViewer* aChild, void* aClosure)
+{
+  aChild->SetMinFontSize(NS_PTR_TO_INT32(aClosure));
+}
+
+static void
+SetChildFullZoom(nsIContentViewer* aChild, void* aClosure)
+{
+  struct ZoomInfo* ZoomInfo = (struct ZoomInfo*) aClosure;
+  aChild->SetFullZoom(ZoomInfo->mZoom);
+}
+
+static void
+SetChildOverrideDPPX(nsIContentViewer* aChild, void* aClosure)
+{
+  struct ZoomInfo* ZoomInfo = (struct ZoomInfo*) aClosure;
+  aChild->SetOverrideDPPX(ZoomInfo->mZoom);
+}
+
+static bool
+SetExtResourceTextZoom(nsIDocument* aDocument, void* aClosure)
+{
+  // Would it be better to enumerate external resource viewers instead?
+  nsIPresShell* shell = aDocument->GetShell();
+  if (shell) {
+    nsPresContext* ctxt = shell->GetPresContext();
+    if (ctxt) {
+      struct ZoomInfo* ZoomInfo = static_cast<struct ZoomInfo*>(aClosure);
+      ctxt->SetTextZoom(ZoomInfo->mZoom);
+    }
+  }
+
+  return true;
+}
+
+static bool
+SetExtResourceMinFontSize(nsIDocument* aDocument, void* aClosure)
+{
+  nsIPresShell* shell = aDocument->GetShell();
+  if (shell) {
+    nsPresContext* ctxt = shell->GetPresContext();
+    if (ctxt) {
+      ctxt->SetBaseMinFontSize(NS_PTR_TO_INT32(aClosure));
+    }
+  }
+
+  return true;
+}
+
+static bool
+SetExtResourceFullZoom(nsIDocument* aDocument, void* aClosure)
+{
+  // Would it be better to enumerate external resource viewers instead?
+  nsIPresShell* shell = aDocument->GetShell();
+  if (shell) {
+    nsPresContext* ctxt = shell->GetPresContext();
+    if (ctxt) {
+      struct ZoomInfo* ZoomInfo = static_cast<struct ZoomInfo*>(aClosure);
+      ctxt->SetFullZoom(ZoomInfo->mZoom);
+    }
+  }
+
+  return true;
+}
+
+static bool
+SetExtResourceOverrideDPPX(nsIDocument* aDocument, void* aClosure)
+{
+  nsIPresShell* shell = aDocument->GetShell();
+  if (shell) {
+    nsPresContext* ctxt = shell->GetPresContext();
+    if (ctxt) {
+      struct ZoomInfo* ZoomInfo = static_cast<struct ZoomInfo*>(aClosure);
+      ctxt->SetOverrideDPPX(ZoomInfo->mZoom);
+    }
+  }
+
+  return true;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::SetTextZoom(float aTextZoom)
+{
+  // If we don't have a document, then we need to bail.
+  if (!mDocument) {
+    return NS_ERROR_FAILURE;
+  }
+
+  if (GetIsPrintPreview()) {
+    return NS_OK;
+  }
+
+  mTextZoom = aTextZoom;
+
+  // Set the text zoom on all children of mContainer (even if our zoom didn't
+  // change, our children's zoom may be different, though it would be unusual).
+  // Do this first, in case kids are auto-sizing and post reflow commands on
+  // our presshell (which should be subsumed into our own style change reflow).
+  struct ZoomInfo ZoomInfo = { aTextZoom };
+  CallChildren(SetChildTextZoom, &ZoomInfo);
+
+  // Now change our own zoom
+  nsPresContext* pc = GetPresContext();
+  if (pc && aTextZoom != mPresContext->TextZoom()) {
+      pc->SetTextZoom(aTextZoom);
+  }
+
+  // And do the external resources
+  mDocument->EnumerateExternalResources(SetExtResourceTextZoom, &ZoomInfo);
+
+  nsContentUtils::DispatchChromeEvent(mDocument, static_cast<nsIDocument*>(mDocument),
+                                      NS_LITERAL_STRING("TextZoomChange"),
+                                      true, true);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::GetTextZoom(float* aTextZoom)
+{
+  NS_ENSURE_ARG_POINTER(aTextZoom);
+  nsPresContext* pc = GetPresContext();
+  *aTextZoom = pc ? pc->TextZoom() : 1.0f;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::SetMinFontSize(int32_t aMinFontSize)
+{
+  // If we don't have a document, then we need to bail.
+  if (!mDocument) {
+    return NS_ERROR_FAILURE;
+  }
+
+  if (GetIsPrintPreview()) {
+    return NS_OK;
+  }
+
+  mMinFontSize = aMinFontSize;
+
+  // Set the min font on all children of mContainer (even if our min font didn't
+  // change, our children's min font may be different, though it would be unusual).
+  // Do this first, in case kids are auto-sizing and post reflow commands on
+  // our presshell (which should be subsumed into our own style change reflow).
+  CallChildren(SetChildMinFontSize, NS_INT32_TO_PTR(aMinFontSize));
+
+  // Now change our own min font
+  nsPresContext* pc = GetPresContext();
+  if (pc && aMinFontSize != mPresContext->MinFontSize(nullptr)) {
+    pc->SetBaseMinFontSize(aMinFontSize);
+  }
+
+  // And do the external resources
+  mDocument->EnumerateExternalResources(SetExtResourceMinFontSize,
+                                        NS_INT32_TO_PTR(aMinFontSize));
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::GetMinFontSize(int32_t* aMinFontSize)
+{
+  NS_ENSURE_ARG_POINTER(aMinFontSize);
+  nsPresContext* pc = GetPresContext();
+  *aMinFontSize = pc ? pc->BaseMinFontSize() : 0;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::SetFullZoom(float aFullZoom)
+{
+#ifdef NS_PRINT_PREVIEW
+  if (GetIsPrintPreview()) {
+    nsPresContext* pc = GetPresContext();
+    NS_ENSURE_TRUE(pc, NS_OK);
+    nsCOMPtr<nsIPresShell> shell = pc->GetPresShell();
+    NS_ENSURE_TRUE(shell, NS_OK);
+
+    if (!mPrintPreviewZoomed) {
+      mOriginalPrintPreviewScale = pc->GetPrintPreviewScale();
+      mPrintPreviewZoomed = true;
+    }
+
+    mPrintPreviewZoom = aFullZoom;
+    pc->SetPrintPreviewScale(aFullZoom * mOriginalPrintPreviewScale);
+    nsIPageSequenceFrame* pf = shell->GetPageSequenceFrame();
+    if (pf) {
+      nsIFrame* f = do_QueryFrame(pf);
+      shell->FrameNeedsReflow(f, nsIPresShell::eResize, NS_FRAME_IS_DIRTY);
+    }
+
+    nsIFrame* rootFrame = shell->GetRootFrame();
+    if (rootFrame) {
+      rootFrame->InvalidateFrame();
+    }
+    return NS_OK;
+  }
+#endif
+
+  // If we don't have a document, then we need to bail.
+  if (!mDocument) {
+    return NS_ERROR_FAILURE;
+  }
+
+  bool fullZoomChange = (mPageZoom != aFullZoom);
+  mPageZoom = aFullZoom;
+
+  struct ZoomInfo ZoomInfo = { aFullZoom };
+  CallChildren(SetChildFullZoom, &ZoomInfo);
+
+  nsPresContext* pc = GetPresContext();
+  if (pc) {
+    pc->SetFullZoom(aFullZoom);
+  }
+
+  // And do the external resources
+  mDocument->EnumerateExternalResources(SetExtResourceFullZoom, &ZoomInfo);
+
+  // Dispatch FullZoomChange event only if fullzoom value really was been changed
+  if (fullZoomChange) {
+    nsContentUtils::DispatchChromeEvent(mDocument, static_cast<nsIDocument*>(mDocument),
+                                        NS_LITERAL_STRING("FullZoomChange"),
+                                        true, true);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::GetFullZoom(float* aFullZoom)
+{
+  NS_ENSURE_ARG_POINTER(aFullZoom);
+#ifdef NS_PRINT_PREVIEW
+  if (GetIsPrintPreview()) {
+    *aFullZoom = mPrintPreviewZoom;
+    return NS_OK;
+  }
+#endif
+  // Check the prescontext first because it might have a temporary
+  // setting for print-preview
+  nsPresContext* pc = GetPresContext();
+  *aFullZoom = pc ? pc->GetFullZoom() : mPageZoom;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::SetOverrideDPPX(float aDPPX)
+{
+  // If we don't have a document, then we need to bail.
+  if (!mDocument) {
+    return NS_ERROR_FAILURE;
+  }
+
+  mOverrideDPPX = aDPPX;
+
+  struct ZoomInfo ZoomInfo = { aDPPX };
+  CallChildren(SetChildOverrideDPPX, &ZoomInfo);
+
+  nsPresContext* pc = GetPresContext();
+  if (pc) {
+    pc->SetOverrideDPPX(aDPPX);
+  }
+
+  // And do the external resources
+  mDocument->EnumerateExternalResources(SetExtResourceOverrideDPPX, &ZoomInfo);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::GetOverrideDPPX(float* aDPPX)
+{
+  NS_ENSURE_ARG_POINTER(aDPPX);
+
+  nsPresContext* pc = GetPresContext();
+  *aDPPX = pc ? pc->GetOverrideDPPX() : mOverrideDPPX;
+  return NS_OK;
+}
+
+static void
+SetChildAuthorStyleDisabled(nsIContentViewer* aChild, void* aClosure)
+{
+  bool styleDisabled  = *static_cast<bool*>(aClosure);
+  aChild->SetAuthorStyleDisabled(styleDisabled);
+}
+
+
+NS_IMETHODIMP
+nsDocumentViewer::SetAuthorStyleDisabled(bool aStyleDisabled)
+{
+  if (mPresShell) {
+    mPresShell->SetAuthorStyleDisabled(aStyleDisabled);
+  }
+  CallChildren(SetChildAuthorStyleDisabled, &aStyleDisabled);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::GetAuthorStyleDisabled(bool* aStyleDisabled)
+{
+  if (mPresShell) {
+    *aStyleDisabled = mPresShell->GetAuthorStyleDisabled();
+  } else {
+    *aStyleDisabled = false;
+  }
+  return NS_OK;
+}
+
+static bool
+ExtResourceEmulateMedium(nsIDocument* aDocument, void* aClosure)
+{
+  nsIPresShell* shell = aDocument->GetShell();
+  if (shell) {
+    nsPresContext* ctxt = shell->GetPresContext();
+    if (ctxt) {
+      const nsAString* mediaType = static_cast<nsAString*>(aClosure);
+      ctxt->EmulateMedium(*mediaType);
+    }
+  }
+
+  return true;
+}
+
+static void
+ChildEmulateMedium(nsIContentViewer* aChild, void* aClosure)
+{
+  const nsAString* mediaType = static_cast<nsAString*>(aClosure);
+  aChild->EmulateMedium(*mediaType);
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::EmulateMedium(const nsAString& aMediaType)
+{
+  if (mPresContext) {
+    mPresContext->EmulateMedium(aMediaType);
+  }
+  CallChildren(ChildEmulateMedium, const_cast<nsAString*>(&aMediaType));
+
+  if (mDocument) {
+    mDocument->EnumerateExternalResources(ExtResourceEmulateMedium,
+                                          const_cast<nsAString*>(&aMediaType));
+  }
+
+  return NS_OK;
+}
+
+static bool
+ExtResourceStopEmulatingMedium(nsIDocument* aDocument, void* aClosure)
+{
+  nsIPresShell* shell = aDocument->GetShell();
+  if (shell) {
+    nsPresContext* ctxt = shell->GetPresContext();
+    if (ctxt) {
+      ctxt->StopEmulatingMedium();
+    }
+  }
+
+  return true;
+}
+
+static void
+ChildStopEmulatingMedium(nsIContentViewer* aChild, void* aClosure)
+{
+  aChild->StopEmulatingMedium();
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::StopEmulatingMedium()
+{
+  if (mPresContext) {
+    mPresContext->StopEmulatingMedium();
+  }
+  CallChildren(ChildStopEmulatingMedium, nullptr);
+
+  if (mDocument) {
+    mDocument->EnumerateExternalResources(ExtResourceStopEmulatingMedium,
+                                          nullptr);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsDocumentViewer::GetForceCharacterSet(nsACString& aForceCharacterSet)
+{
+  aForceCharacterSet = mForceCharacterSet;
+  return NS_OK;
+}
+
+static void
+SetChildForceCharacterSet(nsIContentViewer* aChild, void* aClosure)
+{
+  const nsACString* charset = static_cast<nsACString*>(aClosure);
+  aChild->SetForceCharacterSet(*charset);
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::SetForceCharacterSet(const nsACString& aForceCharacterSet)
+{
+  // This method is scriptable, so add-ons could pass in something other
+  // than a canonical name. However, in case where the input is a canonical
+  // name, "replacement" doesn't survive label resolution. Additionally, the
+  // empty string means no hint.
+  nsAutoCString encoding;
+  if (!aForceCharacterSet.IsEmpty()) {
+    if (aForceCharacterSet.EqualsLiteral("replacement")) {
+      encoding.AssignLiteral("replacement");
+    } else if (!EncodingUtils::FindEncodingForLabel(aForceCharacterSet,
+                                                    encoding)) {
+      // Reject unknown labels
+      return NS_ERROR_INVALID_ARG;
+    }
+  }
+  mForceCharacterSet = encoding;
+  // now set the force char set on all children of mContainer
+  CallChildren(SetChildForceCharacterSet, (void*) &aForceCharacterSet);
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsDocumentViewer::GetHintCharacterSet(nsACString& aHintCharacterSet)
+{
+
+  if(kCharsetUninitialized == mHintCharsetSource) {
+    aHintCharacterSet.Truncate();
+  } else {
+    aHintCharacterSet = mHintCharset;
+    // this can't possibly be right.  we can't set a value just because somebody got a related value!
+    //mHintCharsetSource = kCharsetUninitialized;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsDocumentViewer::GetHintCharacterSetSource(int32_t *aHintCharacterSetSource)
+{
+  NS_ENSURE_ARG_POINTER(aHintCharacterSetSource);
+
+  *aHintCharacterSetSource = mHintCharsetSource;
+  return NS_OK;
+}
+
+static void
+SetChildHintCharacterSetSource(nsIContentViewer* aChild, void* aClosure)
+{
+  aChild->SetHintCharacterSetSource(NS_PTR_TO_INT32(aClosure));
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::SetHintCharacterSetSource(int32_t aHintCharacterSetSource)
+{
+  mHintCharsetSource = aHintCharacterSetSource;
+  // now set the hint char set source on all children of mContainer
+  CallChildren(SetChildHintCharacterSetSource,
+                      NS_INT32_TO_PTR(aHintCharacterSetSource));
+  return NS_OK;
+}
+
+static void
+SetChildHintCharacterSet(nsIContentViewer* aChild, void* aClosure)
+{
+  const nsACString* charset = static_cast<nsACString*>(aClosure);
+  aChild->SetHintCharacterSet(*charset);
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::SetHintCharacterSet(const nsACString& aHintCharacterSet)
+{
+  // This method is scriptable, so add-ons could pass in something other
+  // than a canonical name. However, in case where the input is a canonical
+  // name, "replacement" doesn't survive label resolution. Additionally, the
+  // empty string means no hint.
+  nsAutoCString encoding;
+  if (!aHintCharacterSet.IsEmpty()) {
+    if (aHintCharacterSet.EqualsLiteral("replacement")) {
+      encoding.AssignLiteral("replacement");
+    } else if (!EncodingUtils::FindEncodingForLabel(aHintCharacterSet,
+                                                    encoding)) {
+      // Reject unknown labels
+      return NS_ERROR_INVALID_ARG;
+    }
+  }
+  mHintCharset = encoding;
+  // now set the hint char set on all children of mContainer
+  CallChildren(SetChildHintCharacterSet, (void*) &aHintCharacterSet);
+  return NS_OK;
+}
+
+static void
+AppendChildSubtree(nsIContentViewer* aChild, void* aClosure)
+{
+  nsTArray<nsCOMPtr<nsIContentViewer> >& array =
+    *static_cast<nsTArray<nsCOMPtr<nsIContentViewer> >*>(aClosure);
+  aChild->AppendSubtree(array);
+}
+
+NS_IMETHODIMP nsDocumentViewer::AppendSubtree(nsTArray<nsCOMPtr<nsIContentViewer> >& aArray)
+{
+  aArray.AppendElement(this);
+  CallChildren(AppendChildSubtree, &aArray);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::PausePainting()
+{
+  bool enablePaint = false;
+  CallChildren(ChangeChildPaintingEnabled, &enablePaint);
+
+  nsIPresShell* presShell = GetPresShell();
+  if (presShell) {
+    presShell->PausePainting();
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::ResumePainting()
+{
+  bool enablePaint = true;
+  CallChildren(ChangeChildPaintingEnabled, &enablePaint);
+
+  nsIPresShell* presShell = GetPresShell();
+  if (presShell) {
+    presShell->ResumePainting();
+  }
+
+  return NS_OK;
+}
+
+nsresult
+nsDocumentViewer::GetContentSizeInternal(int32_t* aWidth, int32_t* aHeight,
+                                         nscoord aMaxWidth, nscoord aMaxHeight)
+{
+  NS_ENSURE_TRUE(mDocument, NS_ERROR_NOT_AVAILABLE);
+
+  nsCOMPtr<nsIPresShell> presShell;
+  GetPresShell(getter_AddRefs(presShell));
+  NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
+
+  // Flush out all content and style updates. We can't use a resize reflow
+  // because it won't change some sizes that a style change reflow will.
+  mDocument->FlushPendingNotifications(Flush_Layout);
+
+  nsIFrame *root = presShell->GetRootFrame();
+  NS_ENSURE_TRUE(root, NS_ERROR_FAILURE);
+
+  nscoord prefWidth;
+  {
+    nsRenderingContext rcx(presShell->CreateReferenceRenderingContext());
+    prefWidth = root->GetPrefISize(&rcx);
+  }
+  if (prefWidth > aMaxWidth) {
+    prefWidth = aMaxWidth;
+  }
+
+  nsresult rv = presShell->ResizeReflow(prefWidth, NS_UNCONSTRAINEDSIZE);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  RefPtr<nsPresContext> presContext;
+  GetPresContext(getter_AddRefs(presContext));
+  NS_ENSURE_TRUE(presContext, NS_ERROR_FAILURE);
+
+  // so how big is it?
+  nsRect shellArea = presContext->GetVisibleArea();
+  if (shellArea.height > aMaxHeight) {
+    // Reflow to max height if we would up too tall.
+    rv = presShell->ResizeReflow(prefWidth, aMaxHeight);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    shellArea = presContext->GetVisibleArea();
+  }
+
+  // Protect against bogus returns here
+  NS_ENSURE_TRUE(shellArea.width != NS_UNCONSTRAINEDSIZE &&
+                 shellArea.height != NS_UNCONSTRAINEDSIZE,
+                 NS_ERROR_FAILURE);
+
+  *aWidth = presContext->AppUnitsToDevPixels(shellArea.width);
+  *aHeight = presContext->AppUnitsToDevPixels(shellArea.height);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::GetContentSize(int32_t* aWidth, int32_t* aHeight)
+{
+  // Skip doing this on docshell-less documents for now
+  nsCOMPtr<nsIDocShellTreeItem> docShellAsItem(mContainer);
+  NS_ENSURE_TRUE(docShellAsItem, NS_ERROR_NOT_AVAILABLE);
+
+  nsCOMPtr<nsIDocShellTreeItem> docShellParent;
+  docShellAsItem->GetSameTypeParent(getter_AddRefs(docShellParent));
+
+  // It's only valid to access this from a top frame.  Doesn't work from
+  // sub-frames.
+  NS_ENSURE_TRUE(!docShellParent, NS_ERROR_FAILURE);
+
+  return GetContentSizeInternal(aWidth, aHeight, NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE);
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::GetContentSizeConstrained(int32_t aMaxWidth, int32_t aMaxHeight,
+                                            int32_t* aWidth, int32_t* aHeight)
+{
+  RefPtr<nsPresContext> presContext;
+  GetPresContext(getter_AddRefs(presContext));
+  NS_ENSURE_TRUE(presContext, NS_ERROR_FAILURE);
+
+  nscoord maxWidth = NS_UNCONSTRAINEDSIZE;
+  nscoord maxHeight = NS_UNCONSTRAINEDSIZE;
+  if (aMaxWidth > 0) {
+    maxWidth = presContext->DevPixelsToAppUnits(aMaxWidth);
+  }
+  if (aMaxHeight > 0) {
+    maxHeight = presContext->DevPixelsToAppUnits(aMaxHeight);
+  }
+
+  return GetContentSizeInternal(aWidth, aHeight, maxWidth, maxHeight);
+}
+
+
+NS_IMPL_ISUPPORTS(nsDocViewerSelectionListener, nsISelectionListener)
+
+nsresult nsDocViewerSelectionListener::Init(nsDocumentViewer *aDocViewer)
+{
+  mDocViewer = aDocViewer;
+  return NS_OK;
+}
+
+/*
+ * GetPopupNode, GetPopupLinkNode and GetPopupImageNode are helpers
+ * for the cmd_copyLink / cmd_copyImageLocation / cmd_copyImageContents family
+ * of commands. The focus controller stores the popup node, these retrieve
+ * them and munge appropriately. Note that we have to store the popup node
+ * rather than retrieving it from EventStateManager::GetFocusedContent because
+ * not all content (images included) can receive focus.
+ */
+
+nsresult
+nsDocumentViewer::GetPopupNode(nsIDOMNode** aNode)
+{
+  NS_ENSURE_ARG_POINTER(aNode);
+
+  *aNode = nullptr;
+
+  // get the document
+  nsIDocument* document = GetDocument();
+  NS_ENSURE_TRUE(document, NS_ERROR_FAILURE);
+
+  // get the private dom window
+  nsCOMPtr<nsPIDOMWindowOuter> window(document->GetWindow());
+  NS_ENSURE_TRUE(window, NS_ERROR_NOT_AVAILABLE);
+  if (window) {
+    nsCOMPtr<nsPIWindowRoot> root = window->GetTopWindowRoot();
+    NS_ENSURE_TRUE(root, NS_ERROR_FAILURE);
+
+    // get the popup node
+    nsCOMPtr<nsIDOMNode> node = root->GetPopupNode();
+#ifdef MOZ_XUL
+    if (!node) {
+      nsPIDOMWindowOuter* rootWindow = root->GetWindow();
+      if (rootWindow) {
+        nsCOMPtr<nsIDocument> rootDoc = rootWindow->GetExtantDoc();
+        if (rootDoc) {
+          nsXULPopupManager* pm = nsXULPopupManager::GetInstance();
+          if (pm) {
+            node = pm->GetLastTriggerPopupNode(rootDoc);
+          }
+        }
+      }
+    }
+#endif
+    node.swap(*aNode);
+  }
+
+  return NS_OK;
+}
+
+// GetPopupLinkNode: return popup link node or fail
+nsresult
+nsDocumentViewer::GetPopupLinkNode(nsIDOMNode** aNode)
+{
+  NS_ENSURE_ARG_POINTER(aNode);
+
+  // you get null unless i say so
+  *aNode = nullptr;
+
+  // find popup node
+  nsCOMPtr<nsIDOMNode> node;
+  nsresult rv = GetPopupNode(getter_AddRefs(node));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // find out if we have a link in our ancestry
+  while (node) {
+
+    nsCOMPtr<nsIContent> content(do_QueryInterface(node));
+    if (content) {
+      nsCOMPtr<nsIURI> hrefURI = content->GetHrefURI();
+      if (hrefURI) {
+        *aNode = node;
+        NS_IF_ADDREF(*aNode); // addref
+        return NS_OK;
+      }
+    }
+
+    // get our parent and keep trying...
+    nsCOMPtr<nsIDOMNode> parentNode;
+    node->GetParentNode(getter_AddRefs(parentNode));
+    node = parentNode;
+  }
+
+  // if we have no node, fail
+  return NS_ERROR_FAILURE;
+}
+
+// GetPopupLinkNode: return popup image node or fail
+nsresult
+nsDocumentViewer::GetPopupImageNode(nsIImageLoadingContent** aNode)
+{
+  NS_ENSURE_ARG_POINTER(aNode);
+
+  // you get null unless i say so
+  *aNode = nullptr;
+
+  // find popup node
+  nsCOMPtr<nsIDOMNode> node;
+  nsresult rv = GetPopupNode(getter_AddRefs(node));
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  if (node)
+    CallQueryInterface(node, aNode);
+
+  return NS_OK;
+}
+
+/*
+ * XXX dr
+ * ------
+ * These two functions -- GetInLink and GetInImage -- are kind of annoying
+ * in that they only get called from the controller (in
+ * nsDOMWindowController::IsCommandEnabled). The actual construction of the
+ * context menus in communicator (nsContextMenu.js) has its own, redundant
+ * tests. No big deal, but good to keep in mind if we ever clean context
+ * menus.
+ */
+
+NS_IMETHODIMP nsDocumentViewer::GetInLink(bool* aInLink)
+{
+#ifdef DEBUG_dr
+  printf("dr :: nsDocumentViewer::GetInLink\n");
+#endif
+
+  NS_ENSURE_ARG_POINTER(aInLink);
+
+  // we're not in a link unless i say so
+  *aInLink = false;
+
+  // get the popup link
+  nsCOMPtr<nsIDOMNode> node;
+  nsresult rv = GetPopupLinkNode(getter_AddRefs(node));
+  if (NS_FAILED(rv)) return rv;
+  NS_ENSURE_TRUE(node, NS_ERROR_FAILURE);
+
+  // if we made it here, we're in a link
+  *aInLink = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsDocumentViewer::GetInImage(bool* aInImage)
+{
+#ifdef DEBUG_dr
+  printf("dr :: nsDocumentViewer::GetInImage\n");
+#endif
+
+  NS_ENSURE_ARG_POINTER(aInImage);
+
+  // we're not in an image unless i say so
+  *aInImage = false;
+
+  // get the popup image
+  nsCOMPtr<nsIImageLoadingContent> node;
+  nsresult rv = GetPopupImageNode(getter_AddRefs(node));
+  if (NS_FAILED(rv)) return rv;
+  if (!node) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // Make sure there is a URI assigned. This allows <input type="image"> to
+  // be an image but rejects other <input> types. This matches what
+  // nsContextMenu.js does.
+  nsCOMPtr<nsIURI> uri;
+  node->GetCurrentURI(getter_AddRefs(uri));
+  if (uri) {
+    // if we made it here, we're in an image
+    *aInImage = true;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP nsDocViewerSelectionListener::NotifySelectionChanged(nsIDOMDocument *, nsISelection *, int16_t aReason)
+{
+  if (!mDocViewer) {
+    return NS_OK;
+  }
+
+  // get the selection state
+  RefPtr<mozilla::dom::Selection> selection = mDocViewer->GetDocumentSelection();
+  if (!selection) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsIDocument* theDoc = mDocViewer->GetDocument();
+  if (!theDoc) return NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsPIDOMWindowOuter> domWindow = theDoc->GetWindow();
+  if (!domWindow) return NS_ERROR_FAILURE;
+
+  bool selectionCollapsed;
+  selection->GetIsCollapsed(&selectionCollapsed);
+  // We only call UpdateCommands when the selection changes from collapsed to
+  // non-collapsed or vice versa, however we skip the initializing collapse. We
+  // might need another update string for simple selection changes, but that
+  // would be expenseive.
+  if (mSelectionWasCollapsed != selectionCollapsed)
+  {
+    domWindow->UpdateCommands(NS_LITERAL_STRING("select"), selection, aReason);
+    mSelectionWasCollapsed = selectionCollapsed;
+  }
+
+  return NS_OK;
+}
+
+//nsDocViewerFocusListener
+NS_IMPL_ISUPPORTS(nsDocViewerFocusListener,
+                  nsIDOMEventListener)
+
+nsDocViewerFocusListener::nsDocViewerFocusListener()
+:mDocViewer(nullptr)
+{
+}
+
+nsDocViewerFocusListener::~nsDocViewerFocusListener(){}
+
+nsresult
+nsDocViewerFocusListener::HandleEvent(nsIDOMEvent* aEvent)
+{
+  NS_ENSURE_STATE(mDocViewer);
+
+  nsCOMPtr<nsIPresShell> shell;
+  mDocViewer->GetPresShell(getter_AddRefs(shell));
+  NS_ENSURE_TRUE(shell, NS_ERROR_FAILURE);
+
+  nsCOMPtr<nsISelectionController> selCon = do_QueryInterface(shell);
+  int16_t selectionStatus;
+  selCon->GetDisplaySelection(&selectionStatus);
+
+  nsAutoString eventType;
+  aEvent->GetType(eventType);
+  if (eventType.EqualsLiteral("focus")) {
+    // If selection was disabled, re-enable it.
+    if(selectionStatus == nsISelectionController::SELECTION_DISABLED ||
+       selectionStatus == nsISelectionController::SELECTION_HIDDEN) {
+      selCon->SetDisplaySelection(nsISelectionController::SELECTION_ON);
+      selCon->RepaintSelection(nsISelectionController::SELECTION_NORMAL);
+    }
+  } else {
+    MOZ_ASSERT(eventType.EqualsLiteral("blur"), "Unexpected event type");
+    // If selection was on, disable it.
+    if(selectionStatus == nsISelectionController::SELECTION_ON ||
+       selectionStatus == nsISelectionController::SELECTION_ATTENTION) {
+      selCon->SetDisplaySelection(nsISelectionController::SELECTION_DISABLED);
+      selCon->RepaintSelection(nsISelectionController::SELECTION_NORMAL);
+    }
+  }
+
+  return NS_OK;
+}
+
+nsresult
+nsDocViewerFocusListener::Init(nsDocumentViewer *aDocViewer)
+{
+  mDocViewer = aDocViewer;
+  return NS_OK;
+}
+
+/** ---------------------------------------------------
+ *  From nsIWebBrowserPrint
+ */
+
+#ifdef NS_PRINTING
+
+NS_IMETHODIMP
+nsDocumentViewer::Print(nsIPrintSettings*       aPrintSettings,
+                          nsIWebProgressListener* aWebProgressListener)
+{
+  // Printing XUL documents is not supported.
+  nsCOMPtr<nsIXULDocument> xulDoc(do_QueryInterface(mDocument));
+  if (xulDoc) {
+    return NS_ERROR_FAILURE;
+  }
+
+  if (!mContainer) {
+    PR_PL(("Container was destroyed yet we are still trying to use it!"));
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIDocShell> docShell(mContainer);
+  NS_ENSURE_STATE(docShell);
+
+  // Check to see if this document is still busy
+  // If it is busy and we aren't already "queued" up to print then
+  // Indicate there is a print pending and cache the args for later
+  uint32_t busyFlags = nsIDocShell::BUSY_FLAGS_NONE;
+  if ((NS_FAILED(docShell->GetBusyFlags(&busyFlags)) ||
+       (busyFlags != nsIDocShell::BUSY_FLAGS_NONE && busyFlags & nsIDocShell::BUSY_FLAGS_PAGE_LOADING)) && 
+      !mPrintDocIsFullyLoaded) {
+    if (!mPrintIsPending) {
+      mCachedPrintSettings           = aPrintSettings;
+      mCachedPrintWebProgressListner = aWebProgressListener;
+      mPrintIsPending                = true;
+    }
+    PR_PL(("Printing Stopped - document is still busy!"));
+    return NS_ERROR_GFX_PRINTER_DOC_IS_BUSY;
+  }
+
+  if (!mDocument || !mDeviceContext) {
+    PR_PL(("Can't Print without a document and a device context"));
+    return NS_ERROR_FAILURE;
+  }
+
+  nsresult rv;
+
+  // if we are printing another URL, then exit
+  // the reason we check here is because this method can be called while
+  // another is still in here (the printing dialog is a good example).
+  // the only time we can print more than one job at a time is the regression tests
+  if (GetIsPrinting()) {
+    // Let the user know we are not ready to print.
+    rv = NS_ERROR_NOT_AVAILABLE;
+
+    if (mPrintEngine) {
+      mPrintEngine->FirePrintingErrorEvent(rv);
+    }
+
+    return rv;
+  }
+
+  // Dispatch 'beforeprint' event and ensure 'afterprint' will be dispatched:
+  MOZ_ASSERT(!mAutoBeforeAndAfterPrint,
+             "We don't want to dispatch nested beforeprint/afterprint");
+  nsAutoPtr<AutoPrintEventDispatcher> autoBeforeAndAfterPrint(
+    new AutoPrintEventDispatcher(mDocument));
+  NS_ENSURE_STATE(!GetIsPrinting());
+  // If we are hosting a full-page plugin, tell it to print
+  // first. It shows its own native print UI.
+  nsCOMPtr<nsIPluginDocument> pDoc(do_QueryInterface(mDocument));
+  if (pDoc)
+    return pDoc->Print();
+
+  if (!mPrintEngine) {
+    NS_ENSURE_STATE(mDeviceContext);
+    mPrintEngine = new nsPrintEngine();
+
+    rv = mPrintEngine->Initialize(this, mContainer, mDocument, 
+                                  float(mDeviceContext->AppUnitsPerCSSInch()) /
+                                  float(mDeviceContext->AppUnitsPerDevPixel()) /
+                                  mPageZoom,
+#ifdef DEBUG
+                                  mDebugFile
+#else
+                                  nullptr
+#endif
+                                  );
+    if (NS_FAILED(rv)) {
+      mPrintEngine->Destroy();
+      mPrintEngine = nullptr;
+      return rv;
+    }
+  }
+  if (mPrintEngine->HasPrintCallbackCanvas()) {
+    // Postpone the 'afterprint' event until after the mozPrintCallback
+    // callbacks have been called:
+    mAutoBeforeAndAfterPrint = autoBeforeAndAfterPrint;
+  }
+  dom::Element* root = mDocument->GetRootElement();
+  if (root && root->HasAttr(kNameSpaceID_None, nsGkAtoms::mozdisallowselectionprint)) {
+    mPrintEngine->SetDisallowSelectionPrint(true);
+  }
+  rv = mPrintEngine->Print(aPrintSettings, aWebProgressListener);
+  if (NS_FAILED(rv)) {
+    OnDonePrinting();
+  }
+  return rv;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::PrintPreview(nsIPrintSettings* aPrintSettings, 
+                               mozIDOMWindowProxy* aChildDOMWin, 
+                               nsIWebProgressListener* aWebProgressListener)
+{
+#if defined(NS_PRINTING) && defined(NS_PRINT_PREVIEW)
+  NS_WARNING_ASSERTION(
+    IsInitializedForPrintPreview(),
+    "Using docshell.printPreview is the preferred way for print previewing!");
+
+  NS_ENSURE_ARG_POINTER(aChildDOMWin);
+  nsresult rv = NS_OK;
+
+  if (GetIsPrinting()) {
+    nsPrintEngine::CloseProgressDialog(aWebProgressListener);
+    return NS_ERROR_FAILURE;
+  }
+
+  // Printing XUL documents is not supported.
+  nsCOMPtr<nsIXULDocument> xulDoc(do_QueryInterface(mDocument));
+  if (xulDoc) {
+    nsPrintEngine::CloseProgressDialog(aWebProgressListener);
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIDocShell> docShell(mContainer);
+  if (!docShell || !mDeviceContext) {
+    PR_PL(("Can't Print Preview without device context and docshell"));
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsPIDOMWindowOuter> window = do_QueryInterface(aChildDOMWin);
+  MOZ_ASSERT(window);
+  nsCOMPtr<nsIDocument> doc = window->GetDoc();
+  NS_ENSURE_STATE(doc);
+
+  // Dispatch 'beforeprint' event and ensure 'afterprint' will be dispatched:
+  // XXX Currently[1] when the user switches between portrait and landscape
+  // mode in print preview, we re-enter this function before
+  // mAutoBeforeAndAfterPrint (if set) is cleared to dispatch the 'afterprint'
+  // event.  To avoid sending multiple 'beforeprint'/'afterprint' events we
+  // must avoid creating a new AutoPrintEventDispatcher object here if we
+  // already have one saved in mAutoBeforeAndAfterPrint.
+  // [1] Until PDF.js is removed (though, maybe after that as well).
+  nsAutoPtr<AutoPrintEventDispatcher> autoBeforeAndAfterPrint;
+  if (!mAutoBeforeAndAfterPrint) {
+    autoBeforeAndAfterPrint = new AutoPrintEventDispatcher(doc);
+  }
+  NS_ENSURE_STATE(!GetIsPrinting());
+  // beforeprint event may have caused ContentViewer to be shutdown.
+  NS_ENSURE_STATE(mContainer);
+  NS_ENSURE_STATE(mDeviceContext);
+  if (!mPrintEngine) {
+    mPrintEngine = new nsPrintEngine();
+
+    rv = mPrintEngine->Initialize(this, mContainer, doc,
+                                  float(mDeviceContext->AppUnitsPerCSSInch()) /
+                                  float(mDeviceContext->AppUnitsPerDevPixel()) /
+                                  mPageZoom,
+#ifdef DEBUG
+                                  mDebugFile
+#else
+                                  nullptr
+#endif
+                                  );
+    if (NS_FAILED(rv)) {
+      mPrintEngine->Destroy();
+      mPrintEngine = nullptr;
+      return rv;
+    }
+  }
+  if (autoBeforeAndAfterPrint &&
+      mPrintEngine->HasPrintCallbackCanvas()) {
+    // Postpone the 'afterprint' event until after the mozPrintCallback
+    // callbacks have been called:
+    mAutoBeforeAndAfterPrint = autoBeforeAndAfterPrint;
+  }
+  dom::Element* root = doc->GetRootElement();
+  if (root && root->HasAttr(kNameSpaceID_None, nsGkAtoms::mozdisallowselectionprint)) {
+    PR_PL(("PrintPreview: found mozdisallowselectionprint"));
+    mPrintEngine->SetDisallowSelectionPrint(true);
+  }
+  rv = mPrintEngine->PrintPreview(aPrintSettings, aChildDOMWin, aWebProgressListener);
+  mPrintPreviewZoomed = false;
+  if (NS_FAILED(rv)) {
+    OnDonePrinting();
+  }
+  return rv;
+#else
+  return NS_ERROR_FAILURE;
+#endif
+}
+
+//----------------------------------------------------------------------
+NS_IMETHODIMP
+nsDocumentViewer::PrintPreviewNavigate(int16_t aType, int32_t aPageNum)
+{
+  if (!GetIsPrintPreview() ||
+      mPrintEngine->GetIsCreatingPrintPreview())
+    return NS_ERROR_FAILURE;
+
+  nsIScrollableFrame* sf =
+    mPrintEngine->GetPrintPreviewPresShell()->GetRootScrollFrameAsScrollable();
+  if (!sf)
+    return NS_OK;
+
+  // Check to see if we can short circut scrolling to the top
+  if (aType == nsIWebBrowserPrint::PRINTPREVIEW_HOME ||
+      (aType == nsIWebBrowserPrint::PRINTPREVIEW_GOTO_PAGENUM && aPageNum == 1)) {
+    sf->ScrollTo(nsPoint(0, 0), nsIScrollableFrame::INSTANT);
+    return NS_OK;
+  }
+
+  // Finds the SimplePageSequencer frame
+  // in PP mPrtPreview->mPrintObject->mSeqFrame is null
+  nsIFrame* seqFrame  = nullptr;
+  int32_t   pageCount = 0;
+  if (NS_FAILED(mPrintEngine->GetSeqFrameAndCountPages(seqFrame, pageCount))) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // Figure where we are currently scrolled to
+  nsPoint pt = sf->GetScrollPosition();
+
+  int32_t    pageNum = 1;
+  nsIFrame * fndPageFrame  = nullptr;
+  nsIFrame * currentPage   = nullptr;
+
+  // If it is "End" then just do a "goto" to the last page
+  if (aType == nsIWebBrowserPrint::PRINTPREVIEW_END) {
+    aType    = nsIWebBrowserPrint::PRINTPREVIEW_GOTO_PAGENUM;
+    aPageNum = pageCount;
+  }
+
+  // Now, locate the current page we are on and
+  // and the page of the page number
+  for (nsIFrame* pageFrame : seqFrame->PrincipalChildList()) {
+    nsRect pageRect = pageFrame->GetRect();
+    if (pageRect.Contains(pageRect.x, pt.y)) {
+      currentPage = pageFrame;
+    }
+    if (pageNum == aPageNum) {
+      fndPageFrame = pageFrame;
+      break;
+    }
+    pageNum++;
+  }
+
+  if (aType == nsIWebBrowserPrint::PRINTPREVIEW_PREV_PAGE) {
+    if (currentPage) {
+      fndPageFrame = currentPage->GetPrevInFlow();
+      if (!fndPageFrame) {
+        return NS_OK;
+      }
+    } else {
+      return NS_OK;
+    }
+  } else if (aType == nsIWebBrowserPrint::PRINTPREVIEW_NEXT_PAGE) {
+    if (currentPage) {
+      fndPageFrame = currentPage->GetNextInFlow();
+      if (!fndPageFrame) {
+        return NS_OK;
+      }
+    } else {
+      return NS_OK;
+    }
+  } else { // If we get here we are doing "GoTo"
+    if (aPageNum < 0 || aPageNum > pageCount) {
+      return NS_OK;
+    }
+  }
+
+  if (fndPageFrame) {
+    nscoord newYPosn =
+      nscoord(mPrintEngine->GetPrintPreviewScale() * fndPageFrame->GetPosition().y);
+    sf->ScrollTo(nsPoint(pt.x, newYPosn), nsIScrollableFrame::INSTANT);
+  }
+  return NS_OK;
+
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::GetGlobalPrintSettings(nsIPrintSettings * *aGlobalPrintSettings)
+{
+  return nsPrintEngine::GetGlobalPrintSettings(aGlobalPrintSettings);
+}
+
+// XXX This always returns false for subdocuments
+NS_IMETHODIMP
+nsDocumentViewer::GetDoingPrint(bool *aDoingPrint)
+{
+  NS_ENSURE_ARG_POINTER(aDoingPrint);
+  
+  *aDoingPrint = false;
+  if (mPrintEngine) {
+    // XXX shouldn't this be GetDoingPrint() ?
+    return mPrintEngine->GetDoingPrintPreview(aDoingPrint);
+  } 
+  return NS_OK;
+}
+
+// XXX This always returns false for subdocuments
+NS_IMETHODIMP
+nsDocumentViewer::GetDoingPrintPreview(bool *aDoingPrintPreview)
+{
+  NS_ENSURE_ARG_POINTER(aDoingPrintPreview);
+
+  *aDoingPrintPreview = false;
+  if (mPrintEngine) {
+    return mPrintEngine->GetDoingPrintPreview(aDoingPrintPreview);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::GetCurrentPrintSettings(nsIPrintSettings * *aCurrentPrintSettings)
+{
+  NS_ENSURE_ARG_POINTER(aCurrentPrintSettings);
+
+  *aCurrentPrintSettings = nullptr;
+  NS_ENSURE_TRUE(mPrintEngine, NS_ERROR_FAILURE);
+
+  return mPrintEngine->GetCurrentPrintSettings(aCurrentPrintSettings);
+}
+
+
+NS_IMETHODIMP 
+nsDocumentViewer::GetCurrentChildDOMWindow(mozIDOMWindowProxy** aCurrentChildDOMWindow)
+{
+  NS_ENSURE_ARG_POINTER(aCurrentChildDOMWindow);
+  *aCurrentChildDOMWindow = nullptr;
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::Cancel()
+{
+  NS_ENSURE_TRUE(mPrintEngine, NS_ERROR_FAILURE);
+  return mPrintEngine->Cancelled();
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::ExitPrintPreview()
+{
+  if (GetIsPrinting())
+    return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(mPrintEngine, NS_ERROR_FAILURE);
+
+  if (GetIsPrintPreview()) {
+    ReturnToGalleyPresentation();
+  }
+  return NS_OK;
+}
+
+//----------------------------------------------------------------------------------
+// Enumerate all the documents for their titles
+NS_IMETHODIMP
+nsDocumentViewer::EnumerateDocumentNames(uint32_t* aCount,
+                                           char16_t*** aResult)
+{
+#ifdef NS_PRINTING
+  NS_ENSURE_ARG(aCount);
+  NS_ENSURE_ARG_POINTER(aResult);
+  NS_ENSURE_TRUE(mPrintEngine, NS_ERROR_FAILURE);
+
+  return mPrintEngine->EnumerateDocumentNames(aCount, aResult);
+#else
+  return NS_ERROR_FAILURE;
+#endif
+}
+
+NS_IMETHODIMP 
+nsDocumentViewer::GetIsFramesetFrameSelected(bool *aIsFramesetFrameSelected)
+{
+#ifdef NS_PRINTING
+  *aIsFramesetFrameSelected = false;
+  NS_ENSURE_TRUE(mPrintEngine, NS_ERROR_FAILURE);
+
+  return mPrintEngine->GetIsFramesetFrameSelected(aIsFramesetFrameSelected);
+#else
+  return NS_ERROR_FAILURE;
+#endif
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::GetPrintPreviewNumPages(int32_t *aPrintPreviewNumPages)
+{
+#ifdef NS_PRINTING
+  NS_ENSURE_ARG_POINTER(aPrintPreviewNumPages);
+  NS_ENSURE_TRUE(mPrintEngine, NS_ERROR_FAILURE);
+
+  return mPrintEngine->GetPrintPreviewNumPages(aPrintPreviewNumPages);
+#else
+  return NS_ERROR_FAILURE;
+#endif
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::GetIsFramesetDocument(bool *aIsFramesetDocument)
+{
+#ifdef NS_PRINTING
+  *aIsFramesetDocument = false;
+  NS_ENSURE_TRUE(mPrintEngine, NS_ERROR_FAILURE);
+
+  return mPrintEngine->GetIsFramesetDocument(aIsFramesetDocument);
+#else
+  return NS_ERROR_FAILURE;
+#endif
+}
+
+NS_IMETHODIMP 
+nsDocumentViewer::GetIsIFrameSelected(bool *aIsIFrameSelected)
+{
+#ifdef NS_PRINTING
+  *aIsIFrameSelected = false;
+  NS_ENSURE_TRUE(mPrintEngine, NS_ERROR_FAILURE);
+
+  return mPrintEngine->GetIsIFrameSelected(aIsIFrameSelected);
+#else
+  return NS_ERROR_FAILURE;
+#endif
+}
+
+NS_IMETHODIMP 
+nsDocumentViewer::GetIsRangeSelection(bool *aIsRangeSelection)
+{
+#ifdef NS_PRINTING
+  *aIsRangeSelection = false;
+  NS_ENSURE_TRUE(mPrintEngine, NS_ERROR_FAILURE);
+
+  return mPrintEngine->GetIsRangeSelection(aIsRangeSelection);
+#else
+  return NS_ERROR_FAILURE;
+#endif
+}
+
+//----------------------------------------------------------------------------------
+// Printing/Print Preview Helpers
+//----------------------------------------------------------------------------------
+
+//----------------------------------------------------------------------------------
+// Walks the document tree and tells each DocShell whether Printing/PP is happening
+void 
+nsDocumentViewer::SetIsPrintingInDocShellTree(nsIDocShellTreeItem* aParentNode, 
+                                                bool                 aIsPrintingOrPP, 
+                                                bool                 aStartAtTop)
+{
+  nsCOMPtr<nsIDocShellTreeItem> parentItem(do_QueryInterface(aParentNode));
+
+  // find top of "same parent" tree
+  if (aStartAtTop) {
+    if (aIsPrintingOrPP) {
+      while (parentItem) {
+        nsCOMPtr<nsIDocShellTreeItem> parent;
+        parentItem->GetSameTypeParent(getter_AddRefs(parent));
+        if (!parent) {
+          break;
+        }
+        parentItem = do_QueryInterface(parent);
+      }
+      mTopContainerWhilePrinting = do_GetWeakReference(parentItem);
+    } else {
+      parentItem = do_QueryReferent(mTopContainerWhilePrinting);
+    }
+  }
+
+  // Check to see if the DocShell's ContentViewer is printing/PP
+  nsCOMPtr<nsIContentViewerContainer> viewerContainer(do_QueryInterface(parentItem));
+  if (viewerContainer) {
+    viewerContainer->SetIsPrinting(aIsPrintingOrPP);
+  }
+
+  if (!aParentNode) {
+    return;
+  }
+
+  // Traverse children to see if any of them are printing.
+  int32_t n;
+  aParentNode->GetChildCount(&n);
+  for (int32_t i=0; i < n; i++) {
+    nsCOMPtr<nsIDocShellTreeItem> child;
+    aParentNode->GetChildAt(i, getter_AddRefs(child));
+    NS_ASSERTION(child, "child isn't nsIDocShell");
+    if (child) {
+      SetIsPrintingInDocShellTree(child, aIsPrintingOrPP, false);
+    }
+  }
+
+}
+#endif // NS_PRINTING
+
+bool
+nsDocumentViewer::ShouldAttachToTopLevel()
+{
+  if (!mParentWidget)
+    return false;
+
+  nsCOMPtr<nsIDocShellTreeItem> containerItem(mContainer);
+  if (!containerItem)
+    return false;
+
+  // We always attach when using puppet widgets
+  if (nsIWidget::UsePuppetWidgets())
+    return true;
+
+#if defined(XP_WIN) || defined(MOZ_WIDGET_GTK) || defined(MOZ_WIDGET_ANDROID) || defined(MOZ_WIDGET_UIKIT)
+  // On windows, in the parent process we also attach, but just to
+  // chrome items
+  nsWindowType winType = mParentWidget->WindowType();
+  if ((winType == eWindowType_toplevel ||
+       winType == eWindowType_dialog ||
+       winType == eWindowType_invisible) &&
+      containerItem->ItemType() == nsIDocShellTreeItem::typeChrome) {
+    return true;
+  }
+#endif
+
+  return false;
+}
+
+//------------------------------------------------------------
+// XXX this always returns false for subdocuments
+bool
+nsDocumentViewer::GetIsPrinting()
+{
+#ifdef NS_PRINTING
+  if (mPrintEngine) {
+    return mPrintEngine->GetIsPrinting();
+  }
+#endif
+  return false; 
+}
+
+//------------------------------------------------------------
+// Notification from the PrintEngine of the current Printing status
+void
+nsDocumentViewer::SetIsPrinting(bool aIsPrinting)
+{
+#ifdef NS_PRINTING
+  // Set all the docShells in the docshell tree to be printing.
+  // that way if anyone of them tries to "navigate" it can't
+  nsCOMPtr<nsIDocShell> docShell(mContainer);
+  if (docShell || !aIsPrinting) {
+    SetIsPrintingInDocShellTree(docShell, aIsPrinting, true);
+  } else {
+    NS_WARNING("Did you close a window before printing?");
+  }
+
+  if (!aIsPrinting) {
+    // Dispatch the 'afterprint' event now, if pending:
+    mAutoBeforeAndAfterPrint = nullptr;
+  }
+#endif
+}
+
+//------------------------------------------------------------
+// The PrintEngine holds the current value
+// this called from inside the DocViewer.
+// XXX it always returns false for subdocuments
+bool
+nsDocumentViewer::GetIsPrintPreview()
+{
+#ifdef NS_PRINTING
+  if (mPrintEngine) {
+    return mPrintEngine->GetIsPrintPreview();
+  }
+#endif
+  return false; 
+}
+
+//------------------------------------------------------------
+// Notification from the PrintEngine of the current PP status
+void
+nsDocumentViewer::SetIsPrintPreview(bool aIsPrintPreview)
+{
+#ifdef NS_PRINTING
+  // Set all the docShells in the docshell tree to be printing.
+  // that way if anyone of them tries to "navigate" it can't
+  nsCOMPtr<nsIDocShell> docShell(mContainer);
+  if (docShell || !aIsPrintPreview) {
+    SetIsPrintingInDocShellTree(docShell, aIsPrintPreview, true);
+  }
+  if (!aIsPrintPreview) {
+    // Dispatch the 'afterprint' event now, if pending:
+    mAutoBeforeAndAfterPrint = nullptr;
+  }
+#endif
+
+  // Protect against pres shell destruction running scripts.
+  nsAutoScriptBlocker scriptBlocker;
+
+  if (!aIsPrintPreview) {
+    if (mPresShell) {
+      DestroyPresShell();
+    }
+    mWindow = nullptr;
+    mViewManager = nullptr;
+    mPresContext = nullptr;
+    mPresShell = nullptr;
+  }
+}
+
+//----------------------------------------------------------------------------------
+// nsIDocumentViewerPrint IFace
+//----------------------------------------------------------------------------------
+
+//------------------------------------------------------------
+void
+nsDocumentViewer::IncrementDestroyRefCount()
+{
+  ++mDestroyRefCount;
+}
+
+//------------------------------------------------------------
+
+#if defined(NS_PRINTING) && defined(NS_PRINT_PREVIEW)
+//------------------------------------------------------------
+// Reset ESM focus for all descendent doc shells.
+static void
+ResetFocusState(nsIDocShell* aDocShell)
+{
+  nsIFocusManager* fm = nsFocusManager::GetFocusManager();
+  if (!fm)
+    return;
+
+  nsCOMPtr<nsISimpleEnumerator> docShellEnumerator;
+  aDocShell->GetDocShellEnumerator(nsIDocShellTreeItem::typeContent,
+                                   nsIDocShell::ENUMERATE_FORWARDS,
+                                   getter_AddRefs(docShellEnumerator));
+  
+  nsCOMPtr<nsISupports> currentContainer;
+  bool hasMoreDocShells;
+  while (NS_SUCCEEDED(docShellEnumerator->HasMoreElements(&hasMoreDocShells))
+         && hasMoreDocShells) {
+    docShellEnumerator->GetNext(getter_AddRefs(currentContainer));
+    nsCOMPtr<nsPIDOMWindowOuter> win = do_GetInterface(currentContainer);
+    if (win)
+      fm->ClearFocus(win);
+  }
+}
+#endif // NS_PRINTING && NS_PRINT_PREVIEW
+
+void
+nsDocumentViewer::ReturnToGalleyPresentation()
+{
+#if defined(NS_PRINTING) && defined(NS_PRINT_PREVIEW)
+  if (!GetIsPrintPreview()) {
+    NS_ERROR("Wow, we should never get here!");
+    return;
+  }
+
+  SetIsPrintPreview(false);
+
+  mPrintEngine->TurnScriptingOn(true);
+  mPrintEngine->Destroy();
+  mPrintEngine = nullptr;
+
+  nsCOMPtr<nsIDocShell> docShell(mContainer);
+  ResetFocusState(docShell);
+
+  SetTextZoom(mTextZoom);
+  SetFullZoom(mPageZoom);
+  SetOverrideDPPX(mOverrideDPPX);
+  SetMinFontSize(mMinFontSize);
+  Show();
+
+#endif // NS_PRINTING && NS_PRINT_PREVIEW
+}
+
+//------------------------------------------------------------
+// This called ONLY when printing has completed and the DV
+// is being notified that it should get rid of the PrintEngine.
+//
+// BUT, if we are in Print Preview then we want to ignore the 
+// notification (we do not get rid of the PrintEngine)
+// 
+// One small caveat: 
+//   This IS called from two places in this module for cleaning
+//   up when an error occurred during the start up printing 
+//   and print preview
+//
+void
+nsDocumentViewer::OnDonePrinting() 
+{
+#if defined(NS_PRINTING) && defined(NS_PRINT_PREVIEW)
+  if (mPrintEngine) {
+    RefPtr<nsPrintEngine> pe = mPrintEngine;
+    if (GetIsPrintPreview()) {
+      pe->DestroyPrintingData();
+    } else {
+      mPrintEngine = nullptr;
+      pe->Destroy();
+    }
+
+    // We are done printing, now cleanup 
+    if (mDeferredWindowClose) {
+      mDeferredWindowClose = false;
+      if (mContainer) {
+        if (nsCOMPtr<nsPIDOMWindowOuter> win = do_QueryInterface(mContainer->GetWindow())) {
+          win->Close();
+        }
+      }
+    } else if (mClosingWhilePrinting) {
+      if (mDocument) {
+        mDocument->Destroy();
+        mDocument = nullptr;
+      }
+      mClosingWhilePrinting = false;
+    }
+  }
+#endif // NS_PRINTING && NS_PRINT_PREVIEW
+}
+
+NS_IMETHODIMP nsDocumentViewer::SetPageMode(bool aPageMode, nsIPrintSettings* aPrintSettings)
+{
+  // XXX Page mode is only partially working; it's currently used for
+  // reftests that require a paginated context
+  mIsPageMode = aPageMode;
+
+  // The DestroyPresShell call requires a script blocker, since the
+  // PresShell::Destroy call it does can cause scripts to run, which could
+  // re-entrantly call methods on the nsDocumentViewer.
+  nsAutoScriptBlocker scriptBlocker;
+
+  if (mPresShell) {
+    DestroyPresShell();
+  }
+
+  if (mPresContext) {
+    DestroyPresContext();
+  }
+
+  mViewManager  = nullptr;
+  mWindow       = nullptr;
+
+  NS_ENSURE_STATE(mDocument);
+  if (aPageMode)
+  {    
+    mPresContext = CreatePresContext(mDocument,
+        nsPresContext::eContext_PageLayout, FindContainerView());
+    NS_ENSURE_TRUE(mPresContext, NS_ERROR_OUT_OF_MEMORY);
+    mPresContext->SetPaginatedScrolling(true);
+    mPresContext->SetPrintSettings(aPrintSettings);
+    nsresult rv = mPresContext->Init(mDeviceContext);
+    NS_ENSURE_SUCCESS(rv, rv);
+  }
+  NS_ENSURE_SUCCESS(InitInternal(mParentWidget, nullptr, mBounds, true, false),
+                    NS_ERROR_FAILURE);
+
+  Show();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::GetHistoryEntry(nsISHEntry **aHistoryEntry)
+{
+  NS_IF_ADDREF(*aHistoryEntry = mSHEntry);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::GetIsTabModalPromptAllowed(bool *aAllowed)
+{
+  *aAllowed = !mHidden;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::GetIsHidden(bool *aHidden)
+{
+  *aHidden = mHidden;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsDocumentViewer::SetIsHidden(bool aHidden)
+{
+  mHidden = aHidden;
+  return NS_OK;
+}
+
+void
+nsDocumentViewer::DestroyPresShell()
+{
+  // We assert this because destroying the pres shell could otherwise cause
+  // re-entrancy into nsDocumentViewer methods, and all callers of
+  // DestroyPresShell need to do other cleanup work afterwards before it
+  // is safe for those re-entrant method calls to be made.
+  MOZ_ASSERT(!nsContentUtils::IsSafeToRunScript(),
+             "DestroyPresShell must only be called when scripts are blocked");
+
+  // Break circular reference (or something)
+  mPresShell->EndObservingDocument();
+
+  RefPtr<mozilla::dom::Selection> selection = GetDocumentSelection();
+  if (selection && mSelectionListener)
+    selection->RemoveSelectionListener(mSelectionListener);
+
+  mPresShell->Destroy();
+  mPresShell = nullptr;
+}
+
+void
+nsDocumentViewer::DestroyPresContext()
+{
+  mPresContext->Detach();
+  mPresContext = nullptr;
+}
+
+bool
+nsDocumentViewer::IsInitializedForPrintPreview()
+{
+  return mInitializedForPrintPreview;
+}
+
+void
+nsDocumentViewer::InitializeForPrintPreview()
+{
+  mInitializedForPrintPreview = true;
+}
+
+void
+nsDocumentViewer::SetPrintPreviewPresentation(nsViewManager* aViewManager,
+                                              nsPresContext* aPresContext,
+                                              nsIPresShell* aPresShell)
+{
+  // Protect against pres shell destruction running scripts and re-entrantly
+  // creating a new presentation.
+  nsAutoScriptBlocker scriptBlocker;
+
+  if (mPresShell) {
+    DestroyPresShell();
+  }
+
+  mWindow = nullptr;
+  mViewManager = aViewManager;
+  mPresContext = aPresContext;
+  mPresShell = aPresShell;
+
+  if (ShouldAttachToTopLevel()) {
+    DetachFromTopLevelWidget();
+    nsView* rootView = mViewManager->GetRootView();
+    rootView->AttachToTopLevelWidget(mParentWidget);
+    mAttachedToParent = true;
+  }
+}
+
+// Fires the "document-shown" event so that interested parties are aware of it.
+NS_IMETHODIMP
+nsDocumentShownDispatcher::Run()
+{
+  nsCOMPtr<nsIObserverService> observerService =
+    mozilla::services::GetObserverService();
+  if (observerService) {
+    observerService->NotifyObservers(mDocument, "document-shown", nullptr);
+  }
+  return NS_OK;
+}
+