The Tor Browser: comparison layout/printing/nsPrintEngine.cpp

--1:000000000000
+:11a3e07faedb
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include "nsPrintEngine.h"
+#include "nsIStringBundle.h"
+#include "nsReadableUtils.h"
+#include "nsCRT.h"
+#include "mozilla/AsyncEventDispatcher.h"
+#include "mozilla/dom/Selection.h"
+#include "nsIScriptGlobalObject.h"
+#include "nsPIDOMWindow.h"
+#include "nsIDocShell.h"
+#include "nsIFrame.h"
+#include "nsIURI.h"
+#include "nsITextToSubURI.h"
+#include "nsError.h"
+#include "nsView.h"
+#include <algorithm>
+// Print Options
+#include "nsIPrintSettings.h"
+#include "nsIPrintSettingsService.h"
+#include "nsIPrintOptions.h"
+#include "nsIPrintSession.h"
+#include "nsGfxCIID.h"
+#include "nsIServiceManager.h"
+#include "nsGkAtoms.h"
+#include "nsXPCOM.h"
+#include "nsISupportsPrimitives.h"
+static const char sPrintSettingsServiceContractID[] = "@mozilla.org/gfx/printsettings-service;1";
+// Printing Events
+#include "nsPrintPreviewListener.h"
+#include "nsThreadUtils.h"
+// Printing
+#include "nsIWebBrowserPrint.h"
+#include "nsIDOMHTMLFrameElement.h"
+#include "nsIDOMHTMLFrameSetElement.h"
+#include "nsIDOMHTMLIFrameElement.h"
+#include "nsIDOMHTMLObjectElement.h"
+#include "nsIDOMHTMLEmbedElement.h"
+// Print Preview
+#include "imgIContainer.h" // image animation mode constants
+#include "nsIWebBrowserPrint.h" // needed for PrintPreview Navigation constants
+// Print Progress
+#include "nsIPrintProgress.h"
+#include "nsIPrintProgressParams.h"
+#include "nsIObserver.h"
+// Print error dialog
+#include "nsIPrompt.h"
+#include "nsIWindowWatcher.h"
+// Printing Prompts
+#include "nsIPrintingPromptService.h"
+static const char kPrintingPromptService[] = "@mozilla.org/embedcomp/printingprompt-service;1";
+// Printing Timer
+#include "nsPagePrintTimer.h"
+// FrameSet
+#include "nsIDocument.h"
+// Focus
+#include "nsISelectionController.h"
+// Misc
+#include "nsISupportsUtils.h"
+#include "nsIScriptContext.h"
+#include "nsIDOMDocument.h"
+#include "nsISelectionListener.h"
+#include "nsISelectionPrivate.h"
+#include "nsIDOMRange.h"
+#include "nsContentCID.h"
+#include "nsLayoutCID.h"
+#include "nsContentUtils.h"
+#include "nsIPresShell.h"
+#include "nsLayoutUtils.h"
+#include "mozilla/Preferences.h"
+#include "nsWidgetsCID.h"
+#include "nsIDeviceContextSpec.h"
+#include "nsViewManager.h"
+#include "nsView.h"
+#include "nsRenderingContext.h"
+#include "nsIPageSequenceFrame.h"
+#include "nsIURL.h"
+#include "nsIContentViewerEdit.h"
+#include "nsIContentViewerFile.h"
+#include "nsIMarkupDocumentViewer.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsIDocShellTreeOwner.h"
+#include "nsIWebBrowserChrome.h"
+#include "nsIBaseWindow.h"
+#include "nsILayoutHistoryState.h"
+#include "nsFrameManager.h"
+#include "nsHTMLReflowState.h"
+#include "nsIDOMHTMLAnchorElement.h"
+#include "nsIDOMHTMLAreaElement.h"
+#include "nsIDOMHTMLLinkElement.h"
+#include "nsIDOMHTMLImageElement.h"
+#include "nsIContentViewerContainer.h"
+#include "nsIContentViewer.h"
+#include "nsIDocumentViewerPrint.h"
+#include "nsFocusManager.h"
+#include "nsRange.h"
+#include "nsCDefaultURIFixup.h"
+#include "nsIURIFixup.h"
+#include "mozilla/dom/Element.h"
+#include "nsContentList.h"
+#include "nsIChannel.h"
+#include "xpcpublic.h"
+using namespace mozilla;
+using namespace mozilla::dom;
+//-----------------------------------------------------
+// PR LOGGING
+#ifdef MOZ_LOGGING
+#define FORCE_PR_LOG /* Allow logging in the release build */
+#endif
+#include "prlog.h"
+#ifdef PR_LOGGING
+#ifdef DEBUG
+// PR_LOGGING is force to always be on (even in release builds)
+// but we only want some of it on,
+//#define EXTENDED_DEBUG_PRINTING
+#endif
+#define DUMP_LAYOUT_LEVEL 9 // this turns on the dumping of each doucment's layout info
+#ifndef PR_PL
+static PRLogModuleInfo *
+GetPrintingLog()
+{
+static PRLogModuleInfo *sLog;
+if (!sLog)
+sLog = PR_NewLogModule("printing");
+return sLog;
+}
+#define PR_PL(_p1)  PR_LOG(GetPrintingLog(), PR_LOG_DEBUG, _p1);
+#endif
+#ifdef EXTENDED_DEBUG_PRINTING
+static uint32_t gDumpFileNameCnt   = 0;
+static uint32_t gDumpLOFileNameCnt = 0;
+#endif
+#define PRT_YESNO(_p) ((_p)?"YES":"NO")
+static const char * gFrameTypesStr[]       = {"eDoc", "eFrame", "eIFrame", "eFrameSet"};
+static const char * gPrintFrameTypeStr[]   = {"kNoFrames", "kFramesAsIs", "kSelectedFrame", "kEachFrameSep"};
+static const char * gFrameHowToEnableStr[] = {"kFrameEnableNone", "kFrameEnableAll", "kFrameEnableAsIsAndEach"};
+static const char * gPrintRangeStr[]       = {"kRangeAllPages", "kRangeSpecifiedPageRange", "kRangeSelection", "kRangeFocusFrame"};
+#else
+#define PRT_YESNO(_p)
+#define PR_PL(_p1)
+#endif
+#ifdef EXTENDED_DEBUG_PRINTING
+// Forward Declarations
+static void DumpPrintObjectsListStart(const char * aStr, nsTArray<nsPrintObject*> * aDocList);
+static void DumpPrintObjectsTree(nsPrintObject * aPO, int aLevel= 0, FILE* aFD = nullptr);
+static void DumpPrintObjectsTreeLayout(nsPrintObject * aPO,nsDeviceContext * aDC, int aLevel= 0, FILE * aFD = nullptr);
+#define DUMP_DOC_LIST(_title) DumpPrintObjectsListStart((_title), mPrt->mPrintDocList);
+#define DUMP_DOC_TREE DumpPrintObjectsTree(mPrt->mPrintObject);
+#define DUMP_DOC_TREELAYOUT DumpPrintObjectsTreeLayout(mPrt->mPrintObject, mPrt->mPrintDC);
+#else
+#define DUMP_DOC_LIST(_title)
+#define DUMP_DOC_TREE
+#define DUMP_DOC_TREELAYOUT
+#endif
+class nsScriptSuppressor
+{
+public:
+nsScriptSuppressor(nsPrintEngine* aPrintEngine)
+: mPrintEngine(aPrintEngine), mSuppressed(false) {}
+~nsScriptSuppressor() { Unsuppress(); }
+void Suppress()
+{
+if (mPrintEngine) {
+mSuppressed = true;
+mPrintEngine->TurnScriptingOn(false);
+}
+}
+void Unsuppress()
+{
+if (mPrintEngine && mSuppressed) {
+mPrintEngine->TurnScriptingOn(true);
+}
+mSuppressed = false;
+}
+void Disconnect() { mPrintEngine = nullptr; }
+protected:
+nsRefPtr<nsPrintEngine> mPrintEngine;
+bool                    mSuppressed;
+};
+NS_IMPL_ISUPPORTS(nsPrintEngine, nsIWebProgressListener,
+nsISupportsWeakReference, nsIObserver)
+//---------------------------------------------------
+//-- nsPrintEngine Class Impl
+//---------------------------------------------------
+nsPrintEngine::nsPrintEngine() :
+mIsCreatingPrintPreview(false),
+mIsDoingPrinting(false),
+mIsDoingPrintPreview(false),
+mProgressDialogIsShown(false),
+mScreenDPI(115.0f),
+mPrt(nullptr),
+mPagePrintTimer(nullptr),
+mPageSeqFrame(nullptr),
+mPrtPreview(nullptr),
+mOldPrtPreview(nullptr),
+mDebugFile(nullptr),
+mLoadCounter(0),
+mDidLoadDataForPrinting(false),
+mIsDestroying(false),
+mDisallowSelectionPrint(false),
+mNoMarginBoxes(false)
+{
+}
+//-------------------------------------------------------
+nsPrintEngine::~nsPrintEngine()
+{
+Destroy(); // for insurance
+}
+//-------------------------------------------------------
+void nsPrintEngine::Destroy()
+{
+if (mIsDestroying) {
+return;
+}
+mIsDestroying = true;
+if (mPrt) {
+delete mPrt;
+mPrt = nullptr;
+}
+#ifdef NS_PRINT_PREVIEW
+if (mPrtPreview) {
+delete mPrtPreview;
+mPrtPreview = nullptr;
+}
+// This is insruance
+if (mOldPrtPreview) {
+delete mOldPrtPreview;
+mOldPrtPreview = nullptr;
+}
+#endif
+mDocViewerPrint = nullptr;
+}
+//-------------------------------------------------------
+void nsPrintEngine::DestroyPrintingData()
+{
+if (mPrt) {
+nsPrintData* data = mPrt;
+mPrt = nullptr;
+delete data;
+}
+}
+//---------------------------------------------------------------------------------
+//-- Section: Methods needed by the DocViewer
+//---------------------------------------------------------------------------------
+//--------------------------------------------------------
+nsresult nsPrintEngine::Initialize(nsIDocumentViewerPrint* aDocViewerPrint,
+nsIDocShell*            aContainer,
+nsIDocument*            aDocument,
+float                   aScreenDPI,
+FILE*                   aDebugFile)
+{
+NS_ENSURE_ARG_POINTER(aDocViewerPrint);
+NS_ENSURE_ARG_POINTER(aContainer);
+NS_ENSURE_ARG_POINTER(aDocument);
+mDocViewerPrint = aDocViewerPrint;
+mContainer      = do_GetWeakReference(aContainer);
+mDocument       = aDocument;
+mScreenDPI      = aScreenDPI;
+mDebugFile      = aDebugFile;      // ok to be nullptr
+return NS_OK;
+}
+//-------------------------------------------------------
+bool
+nsPrintEngine::CheckBeforeDestroy()
+{
+if (mPrt && mPrt->mPreparingForPrint) {
+mPrt->mDocWasToBeDestroyed = true;
+return true;
+}
+return false;
+}
+//-------------------------------------------------------
+nsresult
+nsPrintEngine::Cancelled()
+{
+if (mPrt && mPrt->mPrintSettings) {
+return mPrt->mPrintSettings->SetIsCancelled(true);
+}
+return NS_ERROR_FAILURE;
+}
+//-------------------------------------------------------
+// Install our event listeners on the document to prevent
+// some events from being processed while in PrintPreview
+//
+// No return code - if this fails, there isn't much we can do
+void
+nsPrintEngine::InstallPrintPreviewListener()
+{
+if (!mPrt->mPPEventListeners) {
+nsCOMPtr<nsIDocShell> docShell = do_QueryReferent(mContainer);
+nsCOMPtr<nsPIDOMWindow> win(do_GetInterface(docShell));
+if (win) {
+nsCOMPtr<EventTarget> target = do_QueryInterface(win->GetFrameElementInternal());
+mPrt->mPPEventListeners = new nsPrintPreviewListener(target);
+mPrt->mPPEventListeners->AddListeners();
+}
+}
+}
+//----------------------------------------------------------------------
+nsresult
+nsPrintEngine::GetSeqFrameAndCountPagesInternal(nsPrintObject*  aPO,
+nsIFrame*&    aSeqFrame,
+int32_t&      aCount)
+{
+NS_ENSURE_ARG_POINTER(aPO);
+// Finds the SimplePageSequencer frame
+nsIPageSequenceFrame* seqFrame = aPO->mPresShell->GetPageSequenceFrame();
+aSeqFrame = do_QueryFrame(seqFrame);
+if (!aSeqFrame) {
+return NS_ERROR_FAILURE;
+}
+// first count the total number of pages
+aCount = 0;
+nsIFrame* pageFrame = aSeqFrame->GetFirstPrincipalChild();
+while (pageFrame != nullptr) {
+aCount++;
+pageFrame = pageFrame->GetNextSibling();
+}
+return NS_OK;
+}
+//-----------------------------------------------------------------
+nsresult nsPrintEngine::GetSeqFrameAndCountPages(nsIFrame*& aSeqFrame, int32_t& aCount)
+{
+NS_ASSERTION(mPrtPreview, "mPrtPreview can't be null!");
+return GetSeqFrameAndCountPagesInternal(mPrtPreview->mPrintObject, aSeqFrame, aCount);
+}
+//---------------------------------------------------------------------------------
+//-- Done: Methods needed by the DocViewer
+//---------------------------------------------------------------------------------
+//---------------------------------------------------------------------------------
+//-- Section: nsIWebBrowserPrint
+//---------------------------------------------------------------------------------
+// Foward decl for Debug Helper Functions
+#ifdef EXTENDED_DEBUG_PRINTING
+static int RemoveFilesInDir(const char * aDir);
+static void GetDocTitleAndURL(nsPrintObject* aPO, char *& aDocStr, char *& aURLStr);
+static void DumpPrintObjectsTree(nsPrintObject * aPO, int aLevel, FILE* aFD);
+static void DumpPrintObjectsList(nsTArray<nsPrintObject*> * aDocList);
+static void RootFrameList(nsPresContext* aPresContext, FILE* out, int32_t aIndent);
+static void DumpViews(nsIDocShell* aDocShell, FILE* out);
+static void DumpLayoutData(char* aTitleStr, char* aURLStr,
+nsPresContext* aPresContext,
+nsDeviceContext * aDC, nsIFrame * aRootFrame,
+nsIDocShell * aDocShell, FILE* aFD);
+#endif
+//--------------------------------------------------------------------------------
+nsresult
+nsPrintEngine::CommonPrint(bool                    aIsPrintPreview,
+nsIPrintSettings*       aPrintSettings,
+nsIWebProgressListener* aWebProgressListener,
+nsIDOMDocument* aDoc) {
+nsRefPtr<nsPrintEngine> kungfuDeathGrip = this;
+nsresult rv = DoCommonPrint(aIsPrintPreview, aPrintSettings,
+aWebProgressListener, aDoc);
+if (NS_FAILED(rv)) {
+if (aIsPrintPreview) {
+SetIsCreatingPrintPreview(false);
+SetIsPrintPreview(false);
+} else {
+SetIsPrinting(false);
+}
+if (mProgressDialogIsShown)
+CloseProgressDialog(aWebProgressListener);
+if (rv != NS_ERROR_ABORT && rv != NS_ERROR_OUT_OF_MEMORY)
+ShowPrintErrorDialog(rv, !aIsPrintPreview);
+delete mPrt;
+mPrt = nullptr;
+}
+return rv;
+}
+nsresult
+nsPrintEngine::DoCommonPrint(bool                    aIsPrintPreview,
+nsIPrintSettings*       aPrintSettings,
+nsIWebProgressListener* aWebProgressListener,
+nsIDOMDocument*         aDoc)
+{
+nsresult rv;
+if (aIsPrintPreview) {
+// The WebProgressListener can be QI'ed to nsIPrintingPromptService
+// then that means the progress dialog is already being shown.
+nsCOMPtr<nsIPrintingPromptService> pps(do_QueryInterface(aWebProgressListener));
+mProgressDialogIsShown = pps != nullptr;
+if (mIsDoingPrintPreview) {
+mOldPrtPreview = mPrtPreview;
+mPrtPreview = nullptr;
+}
+} else {
+mProgressDialogIsShown = false;
+}
+mPrt = new nsPrintData(aIsPrintPreview ? nsPrintData::eIsPrintPreview :
+nsPrintData::eIsPrinting);
+NS_ENSURE_TRUE(mPrt, NS_ERROR_OUT_OF_MEMORY);
+// if they don't pass in a PrintSettings, then get the Global PS
+mPrt->mPrintSettings = aPrintSettings;
+if (!mPrt->mPrintSettings) {
+rv = GetGlobalPrintSettings(getter_AddRefs(mPrt->mPrintSettings));
+NS_ENSURE_SUCCESS(rv, rv);
+}
+rv = CheckForPrinters(mPrt->mPrintSettings);
+NS_ENSURE_SUCCESS(rv, rv);
+mPrt->mPrintSettings->SetIsCancelled(false);
+mPrt->mPrintSettings->GetShrinkToFit(&mPrt->mShrinkToFit);
+// In the case the margin boxes are not printed store the print settings for
+// the footer/header to be used as default print setting for follow up prints.
+mPrt->mPrintSettings->SetPersistMarginBoxSettings(!mNoMarginBoxes);
+if (mNoMarginBoxes) {
+// Set the footer/header to blank.
+const char16_t* emptyString = EmptyString().get();
+mPrt->mPrintSettings->SetHeaderStrLeft(emptyString);
+mPrt->mPrintSettings->SetHeaderStrCenter(emptyString);
+mPrt->mPrintSettings->SetHeaderStrRight(emptyString);
+mPrt->mPrintSettings->SetFooterStrLeft(emptyString);
+mPrt->mPrintSettings->SetFooterStrCenter(emptyString);
+mPrt->mPrintSettings->SetFooterStrRight(emptyString);
+}
+if (aIsPrintPreview) {
+SetIsCreatingPrintPreview(true);
+SetIsPrintPreview(true);
+nsCOMPtr<nsIMarkupDocumentViewer> viewer =
+do_QueryInterface(mDocViewerPrint);
+if (viewer) {
+viewer->SetTextZoom(1.0f);
+viewer->SetFullZoom(1.0f);
+viewer->SetMinFontSize(0);
+}
+}
+// Create a print session and let the print settings know about it.
+// The print settings hold an nsWeakPtr to the session so it does not
+// need to be cleared from the settings at the end of the job.
+// XXX What lifetime does the printSession need to have?
+nsCOMPtr<nsIPrintSession> printSession;
+if (!aIsPrintPreview) {
+printSession = do_CreateInstance("@mozilla.org/gfx/printsession;1", &rv);
+NS_ENSURE_SUCCESS(rv, rv);
+mPrt->mPrintSettings->SetPrintSession(printSession);
+}
+if (aWebProgressListener != nullptr) {
+mPrt->mPrintProgressListeners.AppendObject(aWebProgressListener);
+}
+// Get the currently focused window and cache it
+// because the Print Dialog will "steal" focus and later when you try
+// to get the currently focused windows it will be nullptr
+mPrt->mCurrentFocusWin = FindFocusedDOMWindow();
+// Check to see if there is a "regular" selection
+bool isSelection = IsThereARangeSelection(mPrt->mCurrentFocusWin);
+// Get the docshell for this documentviewer
+nsCOMPtr<nsIDocShell> webContainer(do_QueryReferent(mContainer, &rv));
+NS_ENSURE_SUCCESS(rv, rv);
+{
+if (aIsPrintPreview) {
+nsCOMPtr<nsIContentViewer> viewer;
+webContainer->GetContentViewer(getter_AddRefs(viewer));
+if (viewer && viewer->GetDocument() && viewer->GetDocument()->IsShowing()) {
+viewer->GetDocument()->OnPageHide(false, nullptr);
+}
+}
+nsAutoScriptBlocker scriptBlocker;
+mPrt->mPrintObject = new nsPrintObject();
+NS_ENSURE_TRUE(mPrt->mPrintObject, NS_ERROR_OUT_OF_MEMORY);
+rv = mPrt->mPrintObject->Init(webContainer, aDoc, aIsPrintPreview);
+NS_ENSURE_SUCCESS(rv, rv);
+NS_ENSURE_TRUE(mPrt->mPrintDocList.AppendElement(mPrt->mPrintObject),
+NS_ERROR_OUT_OF_MEMORY);
+mPrt->mIsParentAFrameSet = IsParentAFrameSet(webContainer);
+mPrt->mPrintObject->mFrameType = mPrt->mIsParentAFrameSet ? eFrameSet : eDoc;
+// Build the "tree" of PrintObjects
+BuildDocTree(mPrt->mPrintObject->mDocShell, &mPrt->mPrintDocList,
+mPrt->mPrintObject);
+}
+if (!aIsPrintPreview) {
+SetIsPrinting(true);
+}
+// XXX This isn't really correct...
+if (!mPrt->mPrintObject->mDocument ||
+!mPrt->mPrintObject->mDocument->GetRootElement())
+return NS_ERROR_GFX_PRINTER_STARTDOC;
+// Create the linkage from the sub-docs back to the content element
+// in the parent document
+MapContentToWebShells(mPrt->mPrintObject, mPrt->mPrintObject);
+mPrt->mIsIFrameSelected = IsThereAnIFrameSelected(webContainer, mPrt->mCurrentFocusWin, mPrt->mIsParentAFrameSet);
+// Setup print options for UI
+if (mPrt->mIsParentAFrameSet) {
+if (mPrt->mCurrentFocusWin) {
+mPrt->mPrintSettings->SetHowToEnableFrameUI(nsIPrintSettings::kFrameEnableAll);
+} else {
+mPrt->mPrintSettings->SetHowToEnableFrameUI(nsIPrintSettings::kFrameEnableAsIsAndEach);
+}
+} else {
+mPrt->mPrintSettings->SetHowToEnableFrameUI(nsIPrintSettings::kFrameEnableNone);
+}
+// Now determine how to set up the Frame print UI
+mPrt->mPrintSettings->SetPrintOptions(nsIPrintSettings::kEnableSelectionRB,
+isSelection || mPrt->mIsIFrameSelected);
+nsCOMPtr<nsIDeviceContextSpec> devspec
+(do_CreateInstance("@mozilla.org/gfx/devicecontextspec;1", &rv));
+NS_ENSURE_SUCCESS(rv, rv);
+nsScriptSuppressor scriptSuppressor(this);
+if (!aIsPrintPreview) {
+#ifdef DEBUG
+mPrt->mDebugFilePtr = mDebugFile;
+#endif
+scriptSuppressor.Suppress();
+bool printSilently;
+mPrt->mPrintSettings->GetPrintSilent(&printSilently);
+// Check prefs for a default setting as to whether we should print silently
+printSilently =
+Preferences::GetBool("print.always_print_silent", printSilently);
+// Ask dialog to be Print Shown via the Plugable Printing Dialog Service
+// This service is for the Print Dialog and the Print Progress Dialog
+// If printing silently or you can't get the service continue on
+if (!printSilently) {
+nsCOMPtr<nsIPrintingPromptService> printPromptService(do_GetService(kPrintingPromptService));
+if (printPromptService) {
+nsIDOMWindow *domWin = mDocument->GetWindow();
+NS_ENSURE_TRUE(domWin, NS_ERROR_FAILURE);
+// Platforms not implementing a given dialog for the service may
+// return NS_ERROR_NOT_IMPLEMENTED or an error code.
+//
+// NS_ERROR_NOT_IMPLEMENTED indicates they want default behavior
+// Any other error code means we must bail out
+//
+nsCOMPtr<nsIWebBrowserPrint> wbp(do_QueryInterface(mDocViewerPrint));
+rv = printPromptService->ShowPrintDialog(domWin, wbp,
+mPrt->mPrintSettings);
+//
+// ShowPrintDialog triggers an event loop which means we can't assume
+// that the state of this->{anything} matches the state we've checked
+// above. Including that a given {thing} is non null.
+if (!mPrt) {
+return NS_ERROR_FAILURE;
+}
+if (NS_SUCCEEDED(rv)) {
+// since we got the dialog and it worked then make sure we
+// are telling GFX we want to print silent
+printSilently = true;
+if (mPrt->mPrintSettings) {
+// The user might have changed shrink-to-fit in the print dialog, so update our copy of its state
+mPrt->mPrintSettings->GetShrinkToFit(&mPrt->mShrinkToFit);
+}
+} else if (rv == NS_ERROR_NOT_IMPLEMENTED) {
+// This means the Dialog service was there,
+// but they choose not to implement this dialog and
+// are looking for default behavior from the toolkit
+rv = NS_OK;
+}
+} else {
+// No dialog service available
+rv = NS_ERROR_NOT_IMPLEMENTED;
+}
+} else {
+// Call any code that requires a run of the event loop.
+rv = mPrt->mPrintSettings->SetupSilentPrinting();
+}
+// Check explicitly for abort because it's expected
+if (rv == NS_ERROR_ABORT)
+return rv;
+NS_ENSURE_SUCCESS(rv, rv);
+}
+rv = devspec->Init(nullptr, mPrt->mPrintSettings, aIsPrintPreview);
+NS_ENSURE_SUCCESS(rv, rv);
+mPrt->mPrintDC = new nsDeviceContext();
+rv = mPrt->mPrintDC->InitForPrinting(devspec);
+NS_ENSURE_SUCCESS(rv, rv);
+if (aIsPrintPreview) {
+mPrt->mPrintSettings->SetPrintFrameType(nsIPrintSettings::kFramesAsIs);
+// override any UI that wants to PrintPreview any selection or page range
+// we want to view every page in PrintPreview each time
+mPrt->mPrintSettings->SetPrintRange(nsIPrintSettings::kRangeAllPages);
+} else {
+// Always check and set the print settings first and then fall back
+// onto the PrintService if there isn't a PrintSettings
+//
+// Posiible Usage values:
+//   nsIPrintSettings::kUseInternalDefault
+//   nsIPrintSettings::kUseSettingWhenPossible
+//
+// NOTE: The consts are the same for PrintSettings and PrintSettings
+int16_t printFrameTypeUsage = nsIPrintSettings::kUseSettingWhenPossible;
+mPrt->mPrintSettings->GetPrintFrameTypeUsage(&printFrameTypeUsage);
+// Ok, see if we are going to use our value and override the default
+if (printFrameTypeUsage == nsIPrintSettings::kUseSettingWhenPossible) {
+// Get the Print Options/Settings PrintFrameType to see what is preferred
+int16_t printFrameType = nsIPrintSettings::kEachFrameSep;
+mPrt->mPrintSettings->GetPrintFrameType(&printFrameType);
+// Don't let anybody do something stupid like try to set it to
+// kNoFrames when we are printing a FrameSet
+if (printFrameType == nsIPrintSettings::kNoFrames) {
+mPrt->mPrintFrameType = nsIPrintSettings::kEachFrameSep;
+mPrt->mPrintSettings->SetPrintFrameType(mPrt->mPrintFrameType);
+} else {
+// First find out from the PrinService what options are available
+// to us for Printing FrameSets
+int16_t howToEnableFrameUI;
+mPrt->mPrintSettings->GetHowToEnableFrameUI(&howToEnableFrameUI);
+if (howToEnableFrameUI != nsIPrintSettings::kFrameEnableNone) {
+switch (howToEnableFrameUI) {
+case nsIPrintSettings::kFrameEnableAll:
+mPrt->mPrintFrameType = printFrameType;
+break;
+case nsIPrintSettings::kFrameEnableAsIsAndEach:
+if (printFrameType != nsIPrintSettings::kSelectedFrame) {
+mPrt->mPrintFrameType = printFrameType;
+} else { // revert back to a good value
+mPrt->mPrintFrameType = nsIPrintSettings::kEachFrameSep;
+}
+break;
+} // switch
+mPrt->mPrintSettings->SetPrintFrameType(mPrt->mPrintFrameType);
+}
+}
+} else {
+mPrt->mPrintSettings->GetPrintFrameType(&mPrt->mPrintFrameType);
+}
+}
+if (mPrt->mPrintFrameType == nsIPrintSettings::kEachFrameSep) {
+CheckForChildFrameSets(mPrt->mPrintObject);
+}
+if (NS_FAILED(EnablePOsForPrinting())) {
+return NS_ERROR_FAILURE;
+}
+// Attach progressListener to catch network requests.
+nsCOMPtr<nsIWebProgress> webProgress = do_QueryInterface(mPrt->mPrintObject->mDocShell);
+webProgress->AddProgressListener(
+static_cast<nsIWebProgressListener*>(this),
+nsIWebProgress::NOTIFY_STATE_REQUEST);
+mLoadCounter = 0;
+mDidLoadDataForPrinting = false;
+if (aIsPrintPreview) {
+bool notifyOnInit = false;
+ShowPrintProgress(false, notifyOnInit);
+// Very important! Turn Off scripting
+TurnScriptingOn(false);
+if (!notifyOnInit) {
+InstallPrintPreviewListener();
+rv = InitPrintDocConstruction(false);
+} else {
+rv = NS_OK;
+}
+} else {
+bool doNotify;
+ShowPrintProgress(true, doNotify);
+if (!doNotify) {
+// Print listener setup...
+mPrt->OnStartPrinting();
+rv = InitPrintDocConstruction(false);
+}
+}
+// We will enable scripting later after printing has finished.
+scriptSuppressor.Disconnect();
+return NS_OK;
+}
+//---------------------------------------------------------------------------------
+NS_IMETHODIMP
+nsPrintEngine::Print(nsIPrintSettings*       aPrintSettings,
+nsIWebProgressListener* aWebProgressListener)
+{
+// If we have a print preview document, use that instead of the original
+// mDocument. That way animated images etc. get printed using the same state
+// as in print preview.
+nsCOMPtr<nsIDOMDocument> doc =
+do_QueryInterface(mPrtPreview && mPrtPreview->mPrintObject ?
+mPrtPreview->mPrintObject->mDocument : mDocument);
+return CommonPrint(false, aPrintSettings, aWebProgressListener, doc);
+}
+NS_IMETHODIMP
+nsPrintEngine::PrintPreview(nsIPrintSettings* aPrintSettings,
+nsIDOMWindow *aChildDOMWin,
+nsIWebProgressListener* aWebProgressListener)
+{
+// Get the DocShell and see if it is busy
+// (We can't Print Preview this document if it is still busy)
+nsCOMPtr<nsIDocShell> docShell(do_QueryReferent(mContainer));
+NS_ENSURE_STATE(docShell);
+uint32_t busyFlags = nsIDocShell::BUSY_FLAGS_NONE;
+if (NS_FAILED(docShell->GetBusyFlags(&busyFlags)) ||
+busyFlags != nsIDocShell::BUSY_FLAGS_NONE) {
+CloseProgressDialog(aWebProgressListener);
+ShowPrintErrorDialog(NS_ERROR_GFX_PRINTER_DOC_IS_BUSY, false);
+return NS_ERROR_FAILURE;
+}
+NS_ENSURE_STATE(aChildDOMWin);
+nsCOMPtr<nsIDOMDocument> doc;
+aChildDOMWin->GetDocument(getter_AddRefs(doc));
+NS_ENSURE_STATE(doc);
+// Document is not busy -- go ahead with the Print Preview
+return CommonPrint(true, aPrintSettings, aWebProgressListener, doc);
+}
+//----------------------------------------------------------------------------------
+/* readonly attribute boolean isFramesetDocument; */
+NS_IMETHODIMP
+nsPrintEngine::GetIsFramesetDocument(bool *aIsFramesetDocument)
+{
+nsCOMPtr<nsIDocShell> webContainer(do_QueryReferent(mContainer));
+*aIsFramesetDocument = IsParentAFrameSet(webContainer);
+return NS_OK;
+}
+//----------------------------------------------------------------------------------
+/* readonly attribute boolean isIFrameSelected; */
+NS_IMETHODIMP
+nsPrintEngine::GetIsIFrameSelected(bool *aIsIFrameSelected)
+{
+*aIsIFrameSelected = false;
+// Get the docshell for this documentviewer
+nsCOMPtr<nsIDocShell> webContainer(do_QueryReferent(mContainer));
+// Get the currently focused window
+nsCOMPtr<nsIDOMWindow> currentFocusWin = FindFocusedDOMWindow();
+if (currentFocusWin && webContainer) {
+// Get whether the doc contains a frameset
+// Also, check to see if the currently focus docshell
+// is a child of this docshell
+bool isParentFrameSet;
+*aIsIFrameSelected = IsThereAnIFrameSelected(webContainer, currentFocusWin, isParentFrameSet);
+}
+return NS_OK;
+}
+//----------------------------------------------------------------------------------
+/* readonly attribute boolean isRangeSelection; */
+NS_IMETHODIMP
+nsPrintEngine::GetIsRangeSelection(bool *aIsRangeSelection)
+{
+// Get the currently focused window
+nsCOMPtr<nsIDOMWindow> currentFocusWin = FindFocusedDOMWindow();
+*aIsRangeSelection = IsThereARangeSelection(currentFocusWin);
+return NS_OK;
+}
+//----------------------------------------------------------------------------------
+/* readonly attribute boolean isFramesetFrameSelected; */
+NS_IMETHODIMP
+nsPrintEngine::GetIsFramesetFrameSelected(bool *aIsFramesetFrameSelected)
+{
+// Get the currently focused window
+nsCOMPtr<nsIDOMWindow> currentFocusWin = FindFocusedDOMWindow();
+*aIsFramesetFrameSelected = currentFocusWin != nullptr;
+return NS_OK;
+}
+//----------------------------------------------------------------------------------
+/* readonly attribute long printPreviewNumPages; */
+NS_IMETHODIMP
+nsPrintEngine::GetPrintPreviewNumPages(int32_t *aPrintPreviewNumPages)
+{
+NS_ENSURE_ARG_POINTER(aPrintPreviewNumPages);
+nsPrintData* prt = nullptr;
+nsIFrame* seqFrame  = nullptr;
+*aPrintPreviewNumPages = 0;
+// When calling this function, the FinishPrintPreview() function might not
+// been called as there are still some
+if (mPrtPreview) {
+prt = mPrtPreview;
+} else {
+prt = mPrt;
+}
+if ((!prt) ||
+NS_FAILED(GetSeqFrameAndCountPagesInternal(prt->mPrintObject, seqFrame, *aPrintPreviewNumPages))) {
+return NS_ERROR_FAILURE;
+}
+return NS_OK;
+}
+//----------------------------------------------------------------------------------
+// Enumerate all the documents for their titles
+NS_IMETHODIMP
+nsPrintEngine::EnumerateDocumentNames(uint32_t* aCount,
+char16_t*** aResult)
+{
+NS_ENSURE_ARG(aCount);
+NS_ENSURE_ARG_POINTER(aResult);
+*aCount = 0;
+*aResult = nullptr;
+int32_t     numDocs = mPrt->mPrintDocList.Length();
+char16_t** array   = (char16_t**) nsMemory::Alloc(numDocs * sizeof(char16_t*));
+if (!array)
+return NS_ERROR_OUT_OF_MEMORY;
+for (int32_t i=0;i<numDocs;i++) {
+nsPrintObject* po = mPrt->mPrintDocList.ElementAt(i);
+NS_ASSERTION(po, "nsPrintObject can't be null!");
+nsAutoString docTitleStr;
+nsAutoString docURLStr;
+GetDocumentTitleAndURL(po->mDocument, docTitleStr, docURLStr);
+// Use the URL if the doc is empty
+if (docTitleStr.IsEmpty() && !docURLStr.IsEmpty()) {
+docTitleStr = docURLStr;
+}
+array[i] = ToNewUnicode(docTitleStr);
+}
+*aCount  = numDocs;
+*aResult = array;
+return NS_OK;
+}
+//----------------------------------------------------------------------------------
+/* readonly attribute nsIPrintSettings globalPrintSettings; */
+nsresult
+nsPrintEngine::GetGlobalPrintSettings(nsIPrintSettings **aGlobalPrintSettings)
+{
+NS_ENSURE_ARG_POINTER(aGlobalPrintSettings);
+nsresult rv = NS_ERROR_FAILURE;
+nsCOMPtr<nsIPrintSettingsService> printSettingsService =
+do_GetService(sPrintSettingsServiceContractID, &rv);
+if (NS_SUCCEEDED(rv)) {
+rv = printSettingsService->GetGlobalPrintSettings(aGlobalPrintSettings);
+}
+return rv;
+}
+//----------------------------------------------------------------------------------
+/* readonly attribute boolean doingPrint; */
+NS_IMETHODIMP
+nsPrintEngine::GetDoingPrint(bool *aDoingPrint)
+{
+NS_ENSURE_ARG_POINTER(aDoingPrint);
+*aDoingPrint = mIsDoingPrinting;
+return NS_OK;
+}
+//----------------------------------------------------------------------------------
+/* readonly attribute boolean doingPrintPreview; */
+NS_IMETHODIMP
+nsPrintEngine::GetDoingPrintPreview(bool *aDoingPrintPreview)
+{
+NS_ENSURE_ARG_POINTER(aDoingPrintPreview);
+*aDoingPrintPreview = mIsDoingPrintPreview;
+return NS_OK;
+}
+//----------------------------------------------------------------------------------
+/* readonly attribute nsIPrintSettings currentPrintSettings; */
+NS_IMETHODIMP
+nsPrintEngine::GetCurrentPrintSettings(nsIPrintSettings * *aCurrentPrintSettings)
+{
+NS_ENSURE_ARG_POINTER(aCurrentPrintSettings);
+if (mPrt) {
+*aCurrentPrintSettings = mPrt->mPrintSettings;
+} else if (mPrtPreview) {
+*aCurrentPrintSettings = mPrtPreview->mPrintSettings;
+} else {
+*aCurrentPrintSettings = nullptr;
+}
+NS_IF_ADDREF(*aCurrentPrintSettings);
+return NS_OK;
+}
+//-----------------------------------------------------------------
+//-- Section: Pre-Reflow Methods
+//-----------------------------------------------------------------
+//---------------------------------------------------------------------
+// This method checks to see if there is at least one printer defined
+// and if so, it sets the first printer in the list as the default name
+// in the PrintSettings which is then used for Printer Preview
+nsresult
+nsPrintEngine::CheckForPrinters(nsIPrintSettings* aPrintSettings)
+{
+#if defined(XP_MACOSX) || defined(ANDROID)
+// Mac doesn't support retrieving a printer list.
+return NS_OK;
+#else
+NS_ENSURE_ARG_POINTER(aPrintSettings);
+// See if aPrintSettings already has a printer
+nsXPIDLString printerName;
+nsresult rv = aPrintSettings->GetPrinterName(getter_Copies(printerName));
+if (NS_SUCCEEDED(rv) && !printerName.IsEmpty()) {
+return NS_OK;
+}
+// aPrintSettings doesn't have a printer set. Try to fetch the default.
+nsCOMPtr<nsIPrintSettingsService> printSettingsService =
+do_GetService(sPrintSettingsServiceContractID, &rv);
+NS_ENSURE_SUCCESS(rv, rv);
+rv = printSettingsService->GetDefaultPrinterName(getter_Copies(printerName));
+if (NS_SUCCEEDED(rv) && !printerName.IsEmpty()) {
+rv = aPrintSettings->SetPrinterName(printerName.get());
+}
+return rv;
+#endif
+}
+//----------------------------------------------------------------------
+// Set up to use the "pluggable" Print Progress Dialog
+void
+nsPrintEngine::ShowPrintProgress(bool aIsForPrinting, bool& aDoNotify)
+{
+// default to not notifying, that if something here goes wrong
+// or we aren't going to show the progress dialog we can straight into
+// reflowing the doc for printing.
+aDoNotify = false;
+// Assume we can't do progress and then see if we can
+bool showProgresssDialog = false;
+// if it is already being shown then don't bother to find out if it should be
+// so skip this and leave mShowProgressDialog set to FALSE
+if (!mProgressDialogIsShown) {
+showProgresssDialog = Preferences::GetBool("print.show_print_progress");
+}
+// Turning off the showing of Print Progress in Prefs overrides
+// whether the calling PS desire to have it on or off, so only check PS if
+// prefs says it's ok to be on.
+if (showProgresssDialog) {
+mPrt->mPrintSettings->GetShowPrintProgress(&showProgresssDialog);
+}
+// Now open the service to get the progress dialog
+// If we don't get a service, that's ok, then just don't show progress
+if (showProgresssDialog) {
+nsCOMPtr<nsIPrintingPromptService> printPromptService(do_GetService(kPrintingPromptService));
+if (printPromptService) {
+nsPIDOMWindow *domWin = mDocument->GetWindow();
+if (!domWin) return;
+nsCOMPtr<nsIDocShell> docShell = domWin->GetDocShell();
+if (!docShell) return;
+nsCOMPtr<nsIDocShellTreeOwner> owner;
+docShell->GetTreeOwner(getter_AddRefs(owner));
+nsCOMPtr<nsIWebBrowserChrome> browserChrome = do_GetInterface(owner);
+if (!browserChrome) return;
+bool isModal = true;
+browserChrome->IsWindowModal(&isModal);
+if (isModal) {
+// Showing a print progress dialog when printing a modal window
+// isn't supported. See bug 301560.
+return;
+}
+nsCOMPtr<nsIWebProgressListener> printProgressListener;
+nsCOMPtr<nsIWebBrowserPrint> wbp(do_QueryInterface(mDocViewerPrint));
+nsresult rv = printPromptService->ShowProgress(domWin, wbp, mPrt->mPrintSettings, this, aIsForPrinting,
+getter_AddRefs(printProgressListener),
+getter_AddRefs(mPrt->mPrintProgressParams),
+&aDoNotify);
+if (NS_SUCCEEDED(rv)) {
+if (printProgressListener && mPrt->mPrintProgressParams) {
+mPrt->mPrintProgressListeners.AppendObject(printProgressListener);
+SetDocAndURLIntoProgress(mPrt->mPrintObject, mPrt->mPrintProgressParams);
+}
+}
+}
+}
+}
+//---------------------------------------------------------------------
+bool
+nsPrintEngine::IsThereARangeSelection(nsIDOMWindow* aDOMWin)
+{
+if (mDisallowSelectionPrint)
+return false;
+nsCOMPtr<nsIPresShell> presShell;
+if (aDOMWin) {
+nsCOMPtr<nsPIDOMWindow> window(do_QueryInterface(aDOMWin));
+presShell = window->GetDocShell()->GetPresShell();
+}
+if (!presShell)
+return false;
+// check here to see if there is a range selection
+// so we know whether to turn on the "Selection" radio button
+Selection* selection =
+presShell->GetCurrentSelection(nsISelectionController::SELECTION_NORMAL);
+if (!selection) {
+return false;
+}
+int32_t rangeCount = selection->GetRangeCount();
+if (!rangeCount) {
+return false;
+}
+if (rangeCount > 1) {
+return true;
+}
+// check to make sure it isn't an insertion selection
+return selection->GetRangeAt(0) && !selection->IsCollapsed();
+}
+//---------------------------------------------------------------------
+bool
+nsPrintEngine::IsParentAFrameSet(nsIDocShell * aParent)
+{
+// See if the incoming doc is the root document
+if (!aParent) return false;
+// When it is the top level document we need to check
+// to see if it contains a frameset. If it does, then
+// we only want to print the doc's children and not the document itself
+// For anything else we always print all the children and the document
+// for example, if the doc contains an IFRAME we eant to print the child
+// document (the IFRAME) and then the rest of the document.
+//
+// XXX we really need to search the frame tree, and not the content
+// but there is no way to distinguish between IFRAMEs and FRAMEs
+// with the GetFrameType call.
+// Bug 53459 has been files so we can eventually distinguish
+// between IFRAME frames and FRAME frames
+bool isFrameSet = false;
+// only check to see if there is a frameset if there is
+// NO parent doc for this doc. meaning this parent is the root doc
+nsCOMPtr<nsIDOMDocument> domDoc = do_GetInterface(aParent);
+nsCOMPtr<nsIDocument> doc = do_QueryInterface(domDoc);
+if (doc) {
+nsIContent *rootElement = doc->GetRootElement();
+if (rootElement) {
+isFrameSet = HasFramesetChild(rootElement);
+}
+}
+return isFrameSet;
+}
+//---------------------------------------------------------------------
+// Recursively build a list of sub documents to be printed
+// that mirrors the document tree
+void
+nsPrintEngine::BuildDocTree(nsIDocShell *      aParentNode,
+nsTArray<nsPrintObject*> * aDocList,
+nsPrintObject *            aPO)
+{
+NS_ASSERTION(aParentNode, "Pointer is null!");
+NS_ASSERTION(aDocList, "Pointer is null!");
+NS_ASSERTION(aPO, "Pointer is null!");
+int32_t childWebshellCount;
+aParentNode->GetChildCount(&childWebshellCount);
+if (childWebshellCount > 0) {
+for (int32_t i=0;i<childWebshellCount;i++) {
+nsCOMPtr<nsIDocShellTreeItem> child;
+aParentNode->GetChildAt(i, getter_AddRefs(child));
+nsCOMPtr<nsIDocShell> childAsShell(do_QueryInterface(child));
+nsCOMPtr<nsIContentViewer>  viewer;
+childAsShell->GetContentViewer(getter_AddRefs(viewer));
+if (viewer) {
+nsCOMPtr<nsIContentViewerFile> viewerFile(do_QueryInterface(viewer));
+if (viewerFile) {
+nsCOMPtr<nsIDOMDocument> doc = do_GetInterface(childAsShell);
+nsPrintObject * po = new nsPrintObject();
+po->mParent = aPO;
+nsresult rv = po->Init(childAsShell, doc, aPO->mPrintPreview);
+if (NS_FAILED(rv))
+NS_NOTREACHED("Init failed?");
+aPO->mKids.AppendElement(po);
+aDocList->AppendElement(po);
+BuildDocTree(childAsShell, aDocList, po);
+}
+}
+}
+}
+}
+//---------------------------------------------------------------------
+void
+nsPrintEngine::GetDocumentTitleAndURL(nsIDocument* aDoc,
+nsAString&   aTitle,
+nsAString&   aURLStr)
+{
+NS_ASSERTION(aDoc, "Pointer is null!");
+aTitle.Truncate();
+aURLStr.Truncate();
+nsCOMPtr<nsIDOMDocument> doc = do_QueryInterface(aDoc);
+doc->GetTitle(aTitle);
+nsIURI* url = aDoc->GetDocumentURI();
+if (!url) return;
+nsCOMPtr<nsIURIFixup> urifixup(do_GetService(NS_URIFIXUP_CONTRACTID));
+if (!urifixup) return;
+nsCOMPtr<nsIURI> exposableURI;
+urifixup->CreateExposableURI(url, getter_AddRefs(exposableURI));
+if (!exposableURI) return;
+nsAutoCString urlCStr;
+exposableURI->GetSpec(urlCStr);
+nsresult rv;
+nsCOMPtr<nsITextToSubURI> textToSubURI =
+do_GetService(NS_ITEXTTOSUBURI_CONTRACTID, &rv);
+if (NS_FAILED(rv)) return;
+textToSubURI->UnEscapeURIForUI(NS_LITERAL_CSTRING("UTF-8"),
+urlCStr, aURLStr);
+}
+//---------------------------------------------------------------------
+// The walks the PO tree and for each document it walks the content
+// tree looking for any content that are sub-shells
+//
+// It then sets the mContent pointer in the "found" PO object back to the
+// the document that contained it.
+void
+nsPrintEngine::MapContentToWebShells(nsPrintObject* aRootPO,
+nsPrintObject* aPO)
+{
+NS_ASSERTION(aRootPO, "Pointer is null!");
+NS_ASSERTION(aPO, "Pointer is null!");
+// Recursively walk the content from the root item
+// XXX Would be faster to enumerate the subdocuments, although right now
+//     nsIDocument doesn't expose quite what would be needed.
+nsCOMPtr<nsIContentViewer> viewer;
+aPO->mDocShell->GetContentViewer(getter_AddRefs(viewer));
+if (!viewer) return;
+nsCOMPtr<nsIDOMDocument> domDoc;
+viewer->GetDOMDocument(getter_AddRefs(domDoc));
+nsCOMPtr<nsIDocument> doc = do_QueryInterface(domDoc);
+if (!doc) return;
+Element* rootElement = doc->GetRootElement();
+if (rootElement) {
+MapContentForPO(aPO, rootElement);
+} else {
+NS_WARNING("Null root content on (sub)document.");
+}
+// Continue recursively walking the chilren of this PO
+for (uint32_t i=0;i<aPO->mKids.Length();i++) {
+MapContentToWebShells(aRootPO, aPO->mKids[i]);
+}
+}
+//-------------------------------------------------------
+// A Frame's sub-doc may contain content or a FrameSet
+// When it contains a FrameSet the mFrameType for the PrintObject
+// is always set to an eFrame. Which is fine when printing "AsIs"
+// but is incorrect when when printing "Each Frame Separately".
+// When printing "Each Frame Separately" the Frame really acts like
+// a frameset.
+//
+// This method walks the PO tree and checks to see if the PrintObject is
+// an eFrame and has children that are eFrames (meaning it's a Frame containing a FrameSet)
+// If so, then the mFrameType need to be changed to eFrameSet
+//
+// Also note: We only want to call this we are printing "Each Frame Separately"
+//            when printing "As Is" leave it as an eFrame
+void
+nsPrintEngine::CheckForChildFrameSets(nsPrintObject* aPO)
+{
+NS_ASSERTION(aPO, "Pointer is null!");
+// Continue recursively walking the chilren of this PO
+bool hasChildFrames = false;
+for (uint32_t i=0;i<aPO->mKids.Length();i++) {
+nsPrintObject* po = aPO->mKids[i];
+if (po->mFrameType == eFrame) {
+hasChildFrames = true;
+CheckForChildFrameSets(po);
+}
+}
+if (hasChildFrames && aPO->mFrameType == eFrame) {
+aPO->mFrameType = eFrameSet;
+}
+}
+//---------------------------------------------------------------------
+// This method is key to the entire print mechanism.
+//
+// This "maps" or figures out which sub-doc represents a
+// given Frame or IFrame in its parent sub-doc.
+//
+// So the Mcontent pointer in the child sub-doc points to the
+// content in the its parent document, that caused it to be printed.
+// This is used later to (after reflow) to find the absolute location
+// of the sub-doc on its parent's page frame so it can be
+// printed in the correct location.
+//
+// This method recursvely "walks" the content for a document finding
+// all the Frames and IFrames, then sets the "mFrameType" data member
+// which tells us what type of PO we have
+void
+nsPrintEngine::MapContentForPO(nsPrintObject*   aPO,
+nsIContent*      aContent)
+{
+NS_PRECONDITION(aPO && aContent, "Null argument");
+nsIDocument* doc = aContent->GetDocument();
+NS_ASSERTION(doc, "Content without a document from a document tree?");
+nsIDocument* subDoc = doc->GetSubDocumentFor(aContent);
+if (subDoc) {
+nsCOMPtr<nsIDocShell> docShell(subDoc->GetDocShell());
+if (docShell) {
+nsPrintObject * po = nullptr;
+int32_t cnt = aPO->mKids.Length();
+for (int32_t i=0;i<cnt;i++) {
+nsPrintObject* kid = aPO->mKids.ElementAt(i);
+if (kid->mDocument == subDoc) {
+po = kid;
+break;
+}
+}
+// XXX If a subdocument has no onscreen presentation, there will be no PO
+//     This is even if there should be a print presentation
+if (po) {
+nsCOMPtr<nsIDOMHTMLFrameElement> frame(do_QueryInterface(aContent));
+// "frame" elements not in a frameset context should be treated
+// as iframes
+if (frame && po->mParent->mFrameType == eFrameSet) {
+po->mFrameType = eFrame;
+} else {
+// Assume something iframe-like, i.e. iframe, object, or embed
+po->mFrameType = eIFrame;
+SetPrintAsIs(po, true);
+NS_ASSERTION(po->mParent, "The root must be a parent");
+po->mParent->mPrintAsIs = true;
+}
+}
+}
+}
+// walk children content
+for (nsIContent* child = aContent->GetFirstChild();
+child;
+child = child->GetNextSibling()) {
+MapContentForPO(aPO, child);
+}
+}
+//---------------------------------------------------------------------
+bool
+nsPrintEngine::IsThereAnIFrameSelected(nsIDocShell* aDocShell,
+nsIDOMWindow* aDOMWin,
+bool& aIsParentFrameSet)
+{
+aIsParentFrameSet = IsParentAFrameSet(aDocShell);
+bool iFrameIsSelected = false;
+if (mPrt && mPrt->mPrintObject) {
+nsPrintObject* po = FindPrintObjectByDOMWin(mPrt->mPrintObject, aDOMWin);
+iFrameIsSelected = po && po->mFrameType == eIFrame;
+} else {
+// First, check to see if we are a frameset
+if (!aIsParentFrameSet) {
+// Check to see if there is a currenlt focused frame
+// if so, it means the selected frame is either the main docshell
+// or an IFRAME
+if (aDOMWin) {
+// Get the main docshell's DOMWin to see if it matches
+// the frame that is selected
+nsCOMPtr<nsIDOMWindow> domWin = do_GetInterface(aDocShell);
+if (domWin != aDOMWin) {
+iFrameIsSelected = true; // we have a selected IFRAME
+}
+}
+}
+}
+return iFrameIsSelected;
+}
+//---------------------------------------------------------------------
+// Recursively sets all the PO items to be printed
+// from the given item down into the tree
+void
+nsPrintEngine::SetPrintPO(nsPrintObject* aPO, bool aPrint)
+{
+NS_ASSERTION(aPO, "Pointer is null!");
+// Set whether to print flag
+aPO->mDontPrint = !aPrint;
+for (uint32_t i=0;i<aPO->mKids.Length();i++) {
+SetPrintPO(aPO->mKids[i], aPrint);
+}
+}
+//---------------------------------------------------------------------
+// This will first use a Title and/or URL from the PrintSettings
+// if one isn't set then it uses the one from the document
+// then if not title is there we will make sure we send something back
+// depending on the situation.
+void
+nsPrintEngine::GetDisplayTitleAndURL(nsPrintObject*   aPO,
+nsAString&       aTitle,
+nsAString&       aURLStr,
+eDocTitleDefault aDefType)
+{
+NS_ASSERTION(aPO, "Pointer is null!");
+if (!mPrt)
+return;
+aTitle.Truncate();
+aURLStr.Truncate();
+// First check to see if the PrintSettings has defined an alternate title
+// and use that if it did
+if (mPrt->mPrintSettings) {
+char16_t * docTitleStrPS = nullptr;
+char16_t * docURLStrPS   = nullptr;
+mPrt->mPrintSettings->GetTitle(&docTitleStrPS);
+mPrt->mPrintSettings->GetDocURL(&docURLStrPS);
+if (docTitleStrPS) {
+aTitle = docTitleStrPS;
+}
+if (docURLStrPS) {
+aURLStr = docURLStrPS;
+}
+nsMemory::Free(docTitleStrPS);
+nsMemory::Free(docURLStrPS);
+}
+nsAutoString docTitle;
+nsAutoString docUrl;
+GetDocumentTitleAndURL(aPO->mDocument, docTitle, docUrl);
+if (aURLStr.IsEmpty() && !docUrl.IsEmpty()) {
+aURLStr = docUrl;
+}
+if (aTitle.IsEmpty()) {
+if (!docTitle.IsEmpty()) {
+aTitle = docTitle;
+} else {
+if (aDefType == eDocTitleDefURLDoc) {
+if (!aURLStr.IsEmpty()) {
+aTitle = aURLStr;
+} else if (mPrt->mBrandName) {
+aTitle = mPrt->mBrandName;
+}
+}
+}
+}
+}
+//---------------------------------------------------------------------
+nsresult nsPrintEngine::DocumentReadyForPrinting()
+{
+if (mPrt->mPrintFrameType == nsIPrintSettings::kEachFrameSep) {
+CheckForChildFrameSets(mPrt->mPrintObject);
+}
+//
+// Send the document to the printer...
+//
+nsresult rv = SetupToPrintContent();
+if (NS_FAILED(rv)) {
+// The print job was canceled or there was a problem
+// So remove all other documents from the print list
+DonePrintingPages(nullptr, rv);
+}
+return rv;
+}
+/** ---------------------------------------------------
+*  Cleans up when an error occurred
+*/
+nsresult nsPrintEngine::CleanupOnFailure(nsresult aResult, bool aIsPrinting)
+{
+PR_PL(("****  Failed %s - rv 0x%X", aIsPrinting?"Printing":"Print Preview", aResult));
+/* cleanup... */
+if (mPagePrintTimer) {
+mPagePrintTimer->Stop();
+NS_RELEASE(mPagePrintTimer);
+}
+if (aIsPrinting) {
+SetIsPrinting(false);
+} else {
+SetIsPrintPreview(false);
+SetIsCreatingPrintPreview(false);
+}
+/* cleanup done, let's fire-up an error dialog to notify the user
+* what went wrong...
+*
+* When rv == NS_ERROR_ABORT, it means we want out of the
+* print job without displaying any error messages
+*/
+if (aResult != NS_ERROR_ABORT) {
+ShowPrintErrorDialog(aResult, aIsPrinting);
+}
+FirePrintCompletionEvent();
+return aResult;
+}
+//---------------------------------------------------------------------
+void
+nsPrintEngine::ShowPrintErrorDialog(nsresult aPrintError, bool aIsPrinting)
+{
+nsAutoCString stringName;
+nsXPIDLString msg, title;
+nsresult rv = NS_OK;
+switch(aPrintError)
+{
+#define ENTITY_FOR_ERROR(label) \
+case NS_ERROR_##label: stringName.AssignLiteral("PERR_" #label); break
+ENTITY_FOR_ERROR(GFX_PRINTER_NO_PRINTER_AVAILABLE);
+ENTITY_FOR_ERROR(GFX_PRINTER_NAME_NOT_FOUND);
+ENTITY_FOR_ERROR(GFX_PRINTER_COULD_NOT_OPEN_FILE);
+ENTITY_FOR_ERROR(GFX_PRINTER_STARTDOC);
+ENTITY_FOR_ERROR(GFX_PRINTER_ENDDOC);
+ENTITY_FOR_ERROR(GFX_PRINTER_STARTPAGE);
+ENTITY_FOR_ERROR(GFX_PRINTER_DOC_IS_BUSY);
+ENTITY_FOR_ERROR(ABORT);
+ENTITY_FOR_ERROR(NOT_AVAILABLE);
+ENTITY_FOR_ERROR(NOT_IMPLEMENTED);
+ENTITY_FOR_ERROR(OUT_OF_MEMORY);
+ENTITY_FOR_ERROR(UNEXPECTED);
+default:
+ENTITY_FOR_ERROR(FAILURE);
+#undef ENTITY_FOR_ERROR
+}
+if (!aIsPrinting) {
+// Try first with _PP suffix.
+stringName.AppendLiteral("_PP");
+rv = nsContentUtils::GetLocalizedString(
+nsContentUtils::ePRINTING_PROPERTIES, stringName.get(), msg);
+if (NS_FAILED(rv)) {
+stringName.Truncate(stringName.Length() - 3);
+}
+}
+if (aIsPrinting || NS_FAILED(rv)) {
+rv = nsContentUtils::GetLocalizedString(
+nsContentUtils::ePRINTING_PROPERTIES, stringName.get(), msg);
+}
+if (NS_FAILED(rv)) {
+return;
+}
+rv = nsContentUtils::GetLocalizedString(
+nsContentUtils::ePRINTING_PROPERTIES,
+aIsPrinting ? "print_error_dialog_title"
+: "printpreview_error_dialog_title",
+title);
+if (NS_FAILED(rv)) {
+return;
+}
+nsCOMPtr<nsIWindowWatcher> wwatch =
+do_GetService(NS_WINDOWWATCHER_CONTRACTID, &rv);
+if (NS_FAILED(rv)) {
+return;
+}
+nsCOMPtr<nsIDOMWindow> active;
+wwatch->GetActiveWindow(getter_AddRefs(active));
+nsCOMPtr<nsIPrompt> dialog;
+/* |GetNewPrompter| allows that |active| is |nullptr|
+* (see bug 234982 ("nsPrintEngine::ShowPrintErrorDialog() fails in many cases")) */
+wwatch->GetNewPrompter(active, getter_AddRefs(dialog));
+if (!dialog) {
+return;
+}
+dialog->Alert(title.get(), msg.get());
+}
+//-----------------------------------------------------------------
+//-- Section: Reflow Methods
+//-----------------------------------------------------------------
+nsresult
+nsPrintEngine::ReconstructAndReflow(bool doSetPixelScale)
+{
+#if defined(XP_WIN) && defined(EXTENDED_DEBUG_PRINTING)
+// We need to clear all the output files here
+// because they will be re-created with second reflow of the docs
+if (kPrintingLogMod && kPrintingLogMod->level == DUMP_LAYOUT_LEVEL) {
+RemoveFilesInDir(".\\");
+gDumpFileNameCnt   = 0;
+gDumpLOFileNameCnt = 0;
+}
+#endif
+for (uint32_t i = 0; i < mPrt->mPrintDocList.Length(); ++i) {
+nsPrintObject* po = mPrt->mPrintDocList.ElementAt(i);
+NS_ASSERTION(po, "nsPrintObject can't be null!");
+if (po->mDontPrint || po->mInvisible) {
+continue;
+}
+UpdateZoomRatio(po, doSetPixelScale);
+po->mPresContext->SetPageScale(po->mZoomRatio);
+// Calculate scale factor from printer to screen
+float printDPI = float(mPrt->mPrintDC->AppUnitsPerCSSInch()) /
+float(mPrt->mPrintDC->AppUnitsPerDevPixel());
+po->mPresContext->SetPrintPreviewScale(mScreenDPI / printDPI);
+po->mPresShell->ReconstructFrames();
+// For all views except the first one, setup the root view.
+// ??? Can there be multiple po for the top-level-document?
+bool documentIsTopLevel = true;
+if (i != 0) {
+nsSize adjSize;
+bool doReturn;
+nsresult rv = SetRootView(po, doReturn, documentIsTopLevel, adjSize);
+MOZ_ASSERT(!documentIsTopLevel, "How could this happen?");
+if (NS_FAILED(rv) || doReturn) {
+return rv;
+}
+}
+po->mPresShell->FlushPendingNotifications(Flush_Layout);
+nsresult rv = UpdateSelectionAndShrinkPrintObject(po, documentIsTopLevel);
+NS_ENSURE_SUCCESS(rv, rv);
+}
+return NS_OK;
+}
+//-------------------------------------------------------
+nsresult
+nsPrintEngine::SetupToPrintContent()
+{
+nsresult rv;
+bool didReconstruction = false;
+// If some new content got loaded since the initial reflow rebuild
+// everything.
+if (mDidLoadDataForPrinting) {
+rv = ReconstructAndReflow(DoSetPixelScale());
+didReconstruction = true;
+NS_ENSURE_SUCCESS(rv, rv);
+}
+// Here is where we figure out if extra reflow for shrinking the content
+// is required.
+// But skip this step if we are in PrintPreview
+bool ppIsShrinkToFit = mPrtPreview && mPrtPreview->mShrinkToFit;
+if (mPrt->mShrinkToFit && !ppIsShrinkToFit) {
+// Now look for the PO that has the smallest percent for shrink to fit
+if (mPrt->mPrintDocList.Length() > 1 && mPrt->mPrintObject->mFrameType == eFrameSet) {
+nsPrintObject* smallestPO = FindSmallestSTF();
+NS_ASSERTION(smallestPO, "There must always be an XMost PO!");
+if (smallestPO) {
+// Calc the shrinkage based on the entire content area
+mPrt->mShrinkRatio = smallestPO->mShrinkRatio;
+}
+} else {
+// Single document so use the Shrink as calculated for the PO
+mPrt->mShrinkRatio = mPrt->mPrintObject->mShrinkRatio;
+}
+if (mPrt->mShrinkRatio < 0.998f) {
+rv = ReconstructAndReflow(true);
+didReconstruction = true;
+NS_ENSURE_SUCCESS(rv, rv);
+}
+#ifdef PR_LOGGING
+float calcRatio = 0.0f;
+if (mPrt->mPrintDocList.Length() > 1 && mPrt->mPrintObject->mFrameType == eFrameSet) {
+nsPrintObject* smallestPO = FindSmallestSTF();
+NS_ASSERTION(smallestPO, "There must always be an XMost PO!");
+if (smallestPO) {
+// Calc the shrinkage based on the entire content area
+calcRatio = smallestPO->mShrinkRatio;
+}
+} else {
+// Single document so use the Shrink as calculated for the PO
+calcRatio = mPrt->mPrintObject->mShrinkRatio;
+}
+PR_PL(("**************************************************************************\n"));
+PR_PL(("STF Ratio is: %8.5f Effective Ratio: %8.5f Diff: %8.5f\n", mPrt->mShrinkRatio, calcRatio,  mPrt->mShrinkRatio-calcRatio));
+PR_PL(("**************************************************************************\n"));
+#endif
+}
+// If the frames got reconstructed and reflowed the number of pages might
+// has changed.
+if (didReconstruction) {
+FirePrintPreviewUpdateEvent();
+}
+DUMP_DOC_LIST(("\nAfter Reflow------------------------------------------"));
+PR_PL(("\n"));
+PR_PL(("-------------------------------------------------------\n"));
+PR_PL(("\n"));
+CalcNumPrintablePages(mPrt->mNumPrintablePages);
+PR_PL(("--- Printing %d pages\n", mPrt->mNumPrintablePages));
+DUMP_DOC_TREELAYOUT;
+// Print listener setup...
+if (mPrt != nullptr) {
+mPrt->OnStartPrinting();
+}
+char16_t* fileName = nullptr;
+// check to see if we are printing to a file
+bool isPrintToFile = false;
+mPrt->mPrintSettings->GetPrintToFile(&isPrintToFile);
+if (isPrintToFile) {
+// On some platforms The BeginDocument needs to know the name of the file
+// and it uses the PrintService to get it, so we need to set it into the PrintService here
+mPrt->mPrintSettings->GetToFileName(&fileName);
+}
+nsAutoString docTitleStr;
+nsAutoString docURLStr;
+GetDisplayTitleAndURL(mPrt->mPrintObject, docTitleStr, docURLStr, eDocTitleDefURLDoc);
+int32_t startPage = 1;
+int32_t endPage   = mPrt->mNumPrintablePages;
+int16_t printRangeType = nsIPrintSettings::kRangeAllPages;
+mPrt->mPrintSettings->GetPrintRange(&printRangeType);
+if (printRangeType == nsIPrintSettings::kRangeSpecifiedPageRange) {
+mPrt->mPrintSettings->GetStartPageRange(&startPage);
+mPrt->mPrintSettings->GetEndPageRange(&endPage);
+if (endPage > mPrt->mNumPrintablePages) {
+endPage = mPrt->mNumPrintablePages;
+}
+}
+rv = NS_OK;
+// BeginDocument may pass back a FAILURE code
+// i.e. On Windows, if you are printing to a file and hit "Cancel"
+//      to the "File Name" dialog, this comes back as an error
+// Don't start printing when regression test are executed
+if (!mPrt->mDebugFilePtr && mIsDoingPrinting) {
+rv = mPrt->mPrintDC->BeginDocument(docTitleStr, fileName, startPage, endPage);
+}
+if (mIsCreatingPrintPreview) {
+// Copy docTitleStr and docURLStr to the pageSequenceFrame, to be displayed
+// in the header
+nsIPageSequenceFrame *seqFrame = mPrt->mPrintObject->mPresShell->GetPageSequenceFrame();
+if (seqFrame) {
+seqFrame->StartPrint(mPrt->mPrintObject->mPresContext,
+mPrt->mPrintSettings, docTitleStr, docURLStr);
+}
+}
+PR_PL(("****************** Begin Document ************************\n"));
+NS_ENSURE_SUCCESS(rv, rv);
+// This will print the docshell document
+// when it completes asynchronously in the DonePrintingPages method
+// it will check to see if there are more docshells to be printed and
+// then PrintDocContent will be called again.
+if (mIsDoingPrinting) {
+PrintDocContent(mPrt->mPrintObject, rv); // ignore return value
+}
+return rv;
+}
+//-------------------------------------------------------
+// Recursively reflow each sub-doc and then calc
+// all the frame locations of the sub-docs
+nsresult
+nsPrintEngine::ReflowDocList(nsPrintObject* aPO, bool aSetPixelScale)
+{
+NS_ENSURE_ARG_POINTER(aPO);
+// Check to see if the subdocument's element has been hidden by the parent document
+if (aPO->mParent && aPO->mParent->mPresShell) {
+nsIFrame* frame = aPO->mContent ? aPO->mContent->GetPrimaryFrame() : nullptr;
+if (!frame || !frame->StyleVisibility()->IsVisible()) {
+SetPrintPO(aPO, false);
+aPO->mInvisible = true;
+return NS_OK;
+}
+}
+UpdateZoomRatio(aPO, aSetPixelScale);
+nsresult rv;
+// Reflow the PO
+rv = ReflowPrintObject(aPO);
+NS_ENSURE_SUCCESS(rv, rv);
+int32_t cnt = aPO->mKids.Length();
+for (int32_t i=0;i<cnt;i++) {
+rv = ReflowDocList(aPO->mKids[i], aSetPixelScale);
+NS_ENSURE_SUCCESS(rv, rv);
+}
+return NS_OK;
+}
+void
+nsPrintEngine::FirePrintPreviewUpdateEvent()
+{
+// Dispatch the event only while in PrintPreview. When printing, there is no
+// listener bound to this event and therefore no need to dispatch it.
+if (mIsDoingPrintPreview && !mIsDoingPrinting) {
+nsCOMPtr<nsIContentViewer> cv = do_QueryInterface(mDocViewerPrint);
+(new AsyncEventDispatcher(
+cv->GetDocument(), NS_LITERAL_STRING("printPreviewUpdate"), true, true)
+)->RunDOMEventWhenSafe();
+}
+}
+nsresult
+nsPrintEngine::InitPrintDocConstruction(bool aHandleError)
+{
+nsresult rv;
+rv = ReflowDocList(mPrt->mPrintObject, DoSetPixelScale());
+NS_ENSURE_SUCCESS(rv, rv);
+FirePrintPreviewUpdateEvent();
+if (mLoadCounter == 0) {
+AfterNetworkPrint(aHandleError);
+}
+return rv;
+}
+nsresult
+nsPrintEngine::AfterNetworkPrint(bool aHandleError)
+{
+nsCOMPtr<nsIWebProgress> webProgress = do_QueryInterface(mPrt->mPrintObject->mDocShell);
+webProgress->RemoveProgressListener(
+static_cast<nsIWebProgressListener*>(this));
+nsresult rv;
+if (mIsDoingPrinting) {
+rv = DocumentReadyForPrinting();
+} else {
+rv = FinishPrintPreview();
+}
+/* cleaup on failure + notify user */
+if (aHandleError && NS_FAILED(rv)) {
+CleanupOnFailure(rv, !mIsDoingPrinting);
+}
+return rv;
+}
+////////////////////////////////////////////////////////////////////////////////
+// nsIWebProgressListener
+NS_IMETHODIMP
+nsPrintEngine::OnStateChange(nsIWebProgress* aWebProgress,
+nsIRequest* aRequest,
+uint32_t aStateFlags,
+nsresult aStatus)
+{
+nsAutoCString name;
+aRequest->GetName(name);
+if (name.Equals("about:document-onload-blocker")) {
+return NS_OK;
+}
+if (aStateFlags & STATE_START) {
+nsCOMPtr<nsIChannel> channel = do_QueryInterface(aRequest);
+++mLoadCounter;
+} else if (aStateFlags & STATE_STOP) {
+mDidLoadDataForPrinting = true;
+--mLoadCounter;
+// If all resources are loaded, then do a small timeout and if there
+// are still no new requests, then another reflow.
+if (mLoadCounter == 0) {
+AfterNetworkPrint(true);
+}
+}
+return NS_OK;
+}
+NS_IMETHODIMP
+nsPrintEngine::OnProgressChange(nsIWebProgress* aWebProgress,
+nsIRequest* aRequest,
+int32_t aCurSelfProgress,
+int32_t aMaxSelfProgress,
+int32_t aCurTotalProgress,
+int32_t aMaxTotalProgress)
+{
+NS_NOTREACHED("notification excluded in AddProgressListener(...)");
+return NS_OK;
+}
+NS_IMETHODIMP
+nsPrintEngine::OnLocationChange(nsIWebProgress* aWebProgress,
+nsIRequest* aRequest,
+nsIURI* aLocation,
+uint32_t aFlags)
+{
+NS_NOTREACHED("notification excluded in AddProgressListener(...)");
+return NS_OK;
+}
+NS_IMETHODIMP
+nsPrintEngine::OnStatusChange(nsIWebProgress *aWebProgress,
+nsIRequest *aRequest,
+nsresult aStatus,
+const char16_t *aMessage)
+{
+NS_NOTREACHED("notification excluded in AddProgressListener(...)");
+return NS_OK;
+}
+NS_IMETHODIMP
+nsPrintEngine::OnSecurityChange(nsIWebProgress *aWebProgress,
+nsIRequest *aRequest,
+uint32_t aState)
+{
+NS_NOTREACHED("notification excluded in AddProgressListener(...)");
+return NS_OK;
+}
+//-------------------------------------------------------
+void
+nsPrintEngine::UpdateZoomRatio(nsPrintObject* aPO, bool aSetPixelScale)
+{
+// Here is where we set the shrinkage value into the DC
+// and this is what actually makes it shrink
+if (aSetPixelScale && aPO->mFrameType != eIFrame) {
+float ratio;
+if (mPrt->mPrintFrameType == nsIPrintSettings::kFramesAsIs || mPrt->mPrintFrameType == nsIPrintSettings::kNoFrames) {
+ratio = mPrt->mShrinkRatio - 0.005f; // round down
+} else {
+ratio = aPO->mShrinkRatio - 0.005f; // round down
+}
+aPO->mZoomRatio = ratio;
+} else if (!mPrt->mShrinkToFit) {
+double scaling;
+mPrt->mPrintSettings->GetScaling(&scaling);
+aPO->mZoomRatio = float(scaling);
+}
+}
+nsresult
+nsPrintEngine::UpdateSelectionAndShrinkPrintObject(nsPrintObject* aPO,
+bool aDocumentIsTopLevel)
+{
+nsCOMPtr<nsIPresShell> displayShell = aPO->mDocShell->GetPresShell();
+// Transfer Selection Ranges to the new Print PresShell
+nsRefPtr<Selection> selection, selectionPS;
+// It's okay if there is no display shell, just skip copying the selection
+if (displayShell) {
+selection = displayShell->GetCurrentSelection(nsISelectionController::SELECTION_NORMAL);
+}
+selectionPS = aPO->mPresShell->GetCurrentSelection(nsISelectionController::SELECTION_NORMAL);
+// Reset all existing selection ranges that might have been added by calling
+// this function before.
+if (selectionPS) {
+selectionPS->RemoveAllRanges();
+}
+if (selection && selectionPS) {
+int32_t cnt = selection->GetRangeCount();
+int32_t inx;
+for (inx = 0; inx < cnt; ++inx) {
+selectionPS->AddRange(selection->GetRangeAt(inx));
+}
+}
+// If we are trying to shrink the contents to fit on the page
+// we must first locate the "pageContent" frame
+// Then we walk the frame tree and look for the "xmost" frame
+// this is the frame where the right-hand side of the frame extends
+// the furthest
+if (mPrt->mShrinkToFit && aDocumentIsTopLevel) {
+nsIPageSequenceFrame* pageSequence = aPO->mPresShell->GetPageSequenceFrame();
+NS_ENSURE_STATE(pageSequence);
+pageSequence->GetSTFPercent(aPO->mShrinkRatio);
+// Limit the shrink-to-fit scaling for some text-ish type of documents.
+nsAutoString contentType;
+aPO->mPresShell->GetDocument()->GetContentType(contentType);
+if (contentType.EqualsLiteral("application/xhtml+xml") ||
+StringBeginsWith(contentType, NS_LITERAL_STRING("text/"))) {
+int32_t limitPercent =
+Preferences::GetInt("print.shrink-to-fit.scale-limit-percent", 20);
+limitPercent = std::max(0, limitPercent);
+limitPercent = std::min(100, limitPercent);
+float minShrinkRatio = float(limitPercent) / 100;
+aPO->mShrinkRatio = std::max(aPO->mShrinkRatio, minShrinkRatio);
+}
+}
+return NS_OK;
+}
+bool
+nsPrintEngine::DoSetPixelScale()
+{
+// This is an Optimization
+// If we are in PP then we already know all the shrinkage information
+// so just transfer it to the PrintData and we will skip the extra shrinkage reflow
+//
+// doSetPixelScale tells Reflow whether to set the shrinkage value into the DC
+// The first time we do not want to do this, the second time through we do
+bool doSetPixelScale = false;
+bool ppIsShrinkToFit = mPrtPreview && mPrtPreview->mShrinkToFit;
+if (ppIsShrinkToFit) {
+mPrt->mShrinkRatio = mPrtPreview->mShrinkRatio;
+doSetPixelScale = true;
+}
+return doSetPixelScale;
+}
+nsView*
+nsPrintEngine::GetParentViewForRoot()
+{
+if (mIsCreatingPrintPreview) {
+nsCOMPtr<nsIContentViewer> cv = do_QueryInterface(mDocViewerPrint);
+if (cv) {
+return cv->FindContainerView();
+}
+}
+return nullptr;
+}
+nsresult
+nsPrintEngine::SetRootView(
+nsPrintObject* aPO,
+bool& doReturn,
+bool& documentIsTopLevel,
+nsSize& adjSize
+)
+{
+bool canCreateScrollbars = true;
+nsView* rootView;
+nsView* parentView = nullptr;
+doReturn = false;
+if (aPO->mParent && aPO->mParent->IsPrintable()) {
+nsIFrame* frame = aPO->mContent ? aPO->mContent->GetPrimaryFrame() : nullptr;
+// Without a frame, this document can't be displayed; therefore, there is no
+// point to reflowing it
+if (!frame) {
+SetPrintPO(aPO, false);
+doReturn = true;
+return NS_OK;
+}
+//XXX If printing supported printing document hierarchies with non-constant
+// zoom this would be wrong as we use the same mPrt->mPrintDC for all
+// subdocuments.
+adjSize = frame->GetContentRect().Size();
+documentIsTopLevel = false;
+// presshell exists because parent is printable
+// the top nsPrintObject's widget will always have scrollbars
+if (frame && frame->GetType() == nsGkAtoms::subDocumentFrame) {
+nsView* view = frame->GetView();
+NS_ENSURE_TRUE(view, NS_ERROR_FAILURE);
+view = view->GetFirstChild();
+NS_ENSURE_TRUE(view, NS_ERROR_FAILURE);
+parentView = view;
+canCreateScrollbars = false;
+}
+} else {
+nscoord pageWidth, pageHeight;
+mPrt->mPrintDC->GetDeviceSurfaceDimensions(pageWidth, pageHeight);
+adjSize = nsSize(pageWidth, pageHeight);
+documentIsTopLevel = true;
+parentView = GetParentViewForRoot();
+}
+if (aPO->mViewManager->GetRootView()) {
+// Reuse the root view that is already on the root frame.
+rootView = aPO->mViewManager->GetRootView();
+// Remove it from its existing parent if necessary
+aPO->mViewManager->RemoveChild(rootView);
+rootView->SetParent(parentView);
+} else {
+// Create a child window of the parent that is our "root view/window"
+nsRect tbounds = nsRect(nsPoint(0, 0), adjSize);
+rootView = aPO->mViewManager->CreateView(tbounds, parentView);
+NS_ENSURE_TRUE(rootView, NS_ERROR_OUT_OF_MEMORY);
+}
+if (mIsCreatingPrintPreview && documentIsTopLevel) {
+aPO->mPresContext->SetPaginatedScrolling(canCreateScrollbars);
+}
+// Setup hierarchical relationship in view manager
+aPO->mViewManager->SetRootView(rootView);
+return NS_OK;
+}
+// Reflow a nsPrintObject
+nsresult
+nsPrintEngine::ReflowPrintObject(nsPrintObject * aPO)
+{
+NS_ENSURE_STATE(aPO);
+if (!aPO->IsPrintable()) {
+return NS_OK;
+}
+NS_ASSERTION(!aPO->mPresContext, "Recreating prescontext");
+// create the PresContext
+nsPresContext::nsPresContextType type =
+mIsCreatingPrintPreview ? nsPresContext::eContext_PrintPreview:
+nsPresContext::eContext_Print;
+nsView* parentView =
+aPO->mParent && aPO->mParent->IsPrintable() ? nullptr : GetParentViewForRoot();
+aPO->mPresContext = parentView ?
+new nsPresContext(aPO->mDocument, type) :
+new nsRootPresContext(aPO->mDocument, type);
+NS_ENSURE_TRUE(aPO->mPresContext, NS_ERROR_OUT_OF_MEMORY);
+aPO->mPresContext->SetPrintSettings(mPrt->mPrintSettings);
+// set the presentation context to the value in the print settings
+bool printBGColors;
+mPrt->mPrintSettings->GetPrintBGColors(&printBGColors);
+aPO->mPresContext->SetBackgroundColorDraw(printBGColors);
+mPrt->mPrintSettings->GetPrintBGImages(&printBGColors);
+aPO->mPresContext->SetBackgroundImageDraw(printBGColors);
+// init it with the DC
+nsresult rv = aPO->mPresContext->Init(mPrt->mPrintDC);
+NS_ENSURE_SUCCESS(rv, rv);
+aPO->mViewManager = new nsViewManager();
+rv = aPO->mViewManager->Init(mPrt->mPrintDC);
+NS_ENSURE_SUCCESS(rv,rv);
+nsStyleSet* styleSet;
+rv = mDocViewerPrint->CreateStyleSet(aPO->mDocument, &styleSet);
+NS_ENSURE_SUCCESS(rv, rv);
+aPO->mPresShell = aPO->mDocument->CreateShell(aPO->mPresContext,
+aPO->mViewManager, styleSet);
+if (!aPO->mPresShell) {
+delete styleSet;
+return NS_ERROR_FAILURE;
+}
+styleSet->EndUpdate();
+// The pres shell now owns the style set object.
+bool doReturn = false;;
+bool documentIsTopLevel = false;
+nsSize adjSize;
+rv = SetRootView(aPO, doReturn, documentIsTopLevel, adjSize);
+if (NS_FAILED(rv) || doReturn) {
+return rv;
+}
+PR_PL(("In DV::ReflowPrintObject PO: %p pS: %p (%9s) Setting w,h to %d,%d\n", aPO, aPO->mPresShell.get(),
+gFrameTypesStr[aPO->mFrameType], adjSize.width, adjSize.height));
+// This docshell stuff is weird; will go away when we stop having multiple
+// presentations per document
+aPO->mPresContext->SetContainer(aPO->mDocShell);
+aPO->mPresShell->BeginObservingDocument();
+aPO->mPresContext->SetPageSize(adjSize);
+aPO->mPresContext->SetIsRootPaginatedDocument(documentIsTopLevel);
+aPO->mPresContext->SetPageScale(aPO->mZoomRatio);
+// Calculate scale factor from printer to screen
+float printDPI = float(mPrt->mPrintDC->AppUnitsPerCSSInch()) /
+float(mPrt->mPrintDC->AppUnitsPerDevPixel());
+aPO->mPresContext->SetPrintPreviewScale(mScreenDPI / printDPI);
+if (mIsCreatingPrintPreview && documentIsTopLevel) {
+mDocViewerPrint->SetPrintPreviewPresentation(aPO->mViewManager,
+aPO->mPresContext,
+aPO->mPresShell);
+}
+rv = aPO->mPresShell->Initialize(adjSize.width, adjSize.height);
+NS_ENSURE_SUCCESS(rv, rv);
+NS_ASSERTION(aPO->mPresShell, "Presshell should still be here");
+// Process the reflow event Initialize posted
+aPO->mPresShell->FlushPendingNotifications(Flush_Layout);
+rv = UpdateSelectionAndShrinkPrintObject(aPO, documentIsTopLevel);
+NS_ENSURE_SUCCESS(rv, rv);
+#ifdef EXTENDED_DEBUG_PRINTING
+if (kPrintingLogMod && kPrintingLogMod->level == DUMP_LAYOUT_LEVEL) {
+nsAutoCString docStr;
+nsAutoCString urlStr;
+GetDocTitleAndURL(aPO, docStr, urlStr);
+char filename[256];
+sprintf(filename, "print_dump_%d.txt", gDumpFileNameCnt++);
+// Dump all the frames and view to a a file
+FILE * fd = fopen(filename, "w");
+if (fd) {
+nsIFrame *theRootFrame =
+aPO->mPresShell->FrameManager()->GetRootFrame();
+fprintf(fd, "Title: %s\n", docStr.get());
+fprintf(fd, "URL:   %s\n", urlStr.get());
+fprintf(fd, "--------------- Frames ----------------\n");
+nsRefPtr<nsRenderingContext> renderingContext =
+mPrt->mPrintDocDC->CreateRenderingContext();
+RootFrameList(aPO->mPresContext, fd, 0);
+//DumpFrames(fd, aPO->mPresContext, renderingContext, theRootFrame, 0);
+fprintf(fd, "---------------------------------------\n\n");
+fprintf(fd, "--------------- Views From Root Frame----------------\n");
+nsView* v = theRootFrame->GetView();
+if (v) {
+v->List(fd);
+} else {
+printf("View is null!\n");
+}
+if (docShell) {
+fprintf(fd, "--------------- All Views ----------------\n");
+DumpViews(docShell, fd);
+fprintf(fd, "---------------------------------------\n\n");
+}
+fclose(fd);
+}
+}
+#endif
+return NS_OK;
+}
+//-------------------------------------------------------
+// Figure out how many documents and how many total pages we are printing
+void
+nsPrintEngine::CalcNumPrintablePages(int32_t& aNumPages)
+{
+aNumPages = 0;
+// Count the number of printable documents
+// and printable pages
+for (uint32_t i=0; i<mPrt->mPrintDocList.Length(); i++) {
+nsPrintObject* po = mPrt->mPrintDocList.ElementAt(i);
+NS_ASSERTION(po, "nsPrintObject can't be null!");
+if (po->mPresContext && po->mPresContext->IsRootPaginatedDocument()) {
+nsIPageSequenceFrame* pageSequence = po->mPresShell->GetPageSequenceFrame();
+nsIFrame * seqFrame = do_QueryFrame(pageSequence);
+if (seqFrame) {
+nsIFrame* frame = seqFrame->GetFirstPrincipalChild();
+while (frame) {
+aNumPages++;
+frame = frame->GetNextSibling();
+}
+}
+}
+}
+}
+//-----------------------------------------------------------------
+//-- Done: Reflow Methods
+//-----------------------------------------------------------------
+//-----------------------------------------------------------------
+//-- Section: Printing Methods
+//-----------------------------------------------------------------
+//-------------------------------------------------------
+// Called for each DocShell that needs to be printed
+bool
+nsPrintEngine::PrintDocContent(nsPrintObject* aPO, nsresult& aStatus)
+{
+NS_ASSERTION(aPO, "Pointer is null!");
+aStatus = NS_OK;
+if (!aPO->mHasBeenPrinted && aPO->IsPrintable()) {
+aStatus = DoPrint(aPO);
+return true;
+}
+// If |aPO->mPrintAsIs| and |aPO->mHasBeenPrinted| are true,
+// the kids frames are already processed in |PrintPage|.
+if (!aPO->mInvisible && !(aPO->mPrintAsIs && aPO->mHasBeenPrinted)) {
+for (uint32_t i=0;i<aPO->mKids.Length();i++) {
+nsPrintObject* po = aPO->mKids[i];
+bool printed = PrintDocContent(po, aStatus);
+if (printed || NS_FAILED(aStatus)) {
+return true;
+}
+}
+}
+return false;
+}
+static already_AddRefed<nsIDOMNode>
+GetEqualNodeInCloneTree(nsIDOMNode* aNode, nsIDocument* aDoc)
+{
+nsCOMPtr<nsIContent> content = do_QueryInterface(aNode);
+// Selections in anonymous subtrees aren't supported.
+if (content && content->IsInAnonymousSubtree()) {
+return nullptr;
+}
+nsCOMPtr<nsINode> node = do_QueryInterface(aNode);
+NS_ENSURE_TRUE(node, nullptr);
+nsTArray<int32_t> indexArray;
+nsINode* current = node;
+NS_ENSURE_TRUE(current, nullptr);
+while (current) {
+nsINode* parent = current->GetParentNode();
+if (!parent) {
+break;
+}
+int32_t index = parent->IndexOf(current);
+NS_ENSURE_TRUE(index >= 0, nullptr);
+indexArray.AppendElement(index);
+current = parent;
+}
+NS_ENSURE_TRUE(current->IsNodeOfType(nsINode::eDOCUMENT), nullptr);
+current = aDoc;
+for (int32_t i = indexArray.Length() - 1; i >= 0; --i) {
+current = current->GetChildAt(indexArray[i]);
+NS_ENSURE_TRUE(current, nullptr);
+}
+nsCOMPtr<nsIDOMNode> result = do_QueryInterface(current);
+return result.forget();
+}
+static void
+CloneRangeToSelection(nsRange* aRange, nsIDocument* aDoc,
+Selection* aSelection)
+{
+if (aRange->Collapsed()) {
+return;
+}
+nsCOMPtr<nsIDOMNode> startContainer, endContainer;
+aRange->GetStartContainer(getter_AddRefs(startContainer));
+int32_t startOffset = aRange->StartOffset();
+aRange->GetEndContainer(getter_AddRefs(endContainer));
+int32_t endOffset = aRange->EndOffset();
+NS_ENSURE_TRUE_VOID(startContainer && endContainer);
+nsCOMPtr<nsIDOMNode> newStart = GetEqualNodeInCloneTree(startContainer, aDoc);
+nsCOMPtr<nsIDOMNode> newEnd = GetEqualNodeInCloneTree(endContainer, aDoc);
+NS_ENSURE_TRUE_VOID(newStart && newEnd);
+nsCOMPtr<nsINode> newStartNode = do_QueryInterface(newStart);
+NS_ENSURE_TRUE_VOID(newStartNode);
+nsRefPtr<nsRange> range = new nsRange(newStartNode);
+nsresult rv = range->SetStart(newStartNode, startOffset);
+NS_ENSURE_SUCCESS_VOID(rv);
+rv = range->SetEnd(newEnd, endOffset);
+NS_ENSURE_SUCCESS_VOID(rv);
+aSelection->AddRange(range);
+}
+static nsresult CloneSelection(nsIDocument* aOrigDoc, nsIDocument* aDoc)
+{
+nsIPresShell* origShell = aOrigDoc->GetShell();
+nsIPresShell* shell = aDoc->GetShell();
+NS_ENSURE_STATE(origShell && shell);
+nsRefPtr<Selection> origSelection =
+origShell->GetCurrentSelection(nsISelectionController::SELECTION_NORMAL);
+nsRefPtr<Selection> selection =
+shell->GetCurrentSelection(nsISelectionController::SELECTION_NORMAL);
+NS_ENSURE_STATE(origSelection && selection);
+int32_t rangeCount = origSelection->GetRangeCount();
+for (int32_t i = 0; i < rangeCount; ++i) {
+CloneRangeToSelection(origSelection->GetRangeAt(i), aDoc, selection);
+}
+return NS_OK;
+}
+//-------------------------------------------------------
+nsresult
+nsPrintEngine::DoPrint(nsPrintObject * aPO)
+{
+PR_PL(("\n"));
+PR_PL(("**************************** %s ****************************\n", gFrameTypesStr[aPO->mFrameType]));
+PR_PL(("****** In DV::DoPrint   PO: %p \n", aPO));
+nsIPresShell*   poPresShell   = aPO->mPresShell;
+nsPresContext*  poPresContext = aPO->mPresContext;
+NS_ASSERTION(poPresContext, "PrintObject has not been reflowed");
+NS_ASSERTION(poPresContext->Type() != nsPresContext::eContext_PrintPreview,
+"How did this context end up here?");
+if (mPrt->mPrintProgressParams) {
+SetDocAndURLIntoProgress(aPO, mPrt->mPrintProgressParams);
+}
+{
+int16_t printRangeType = nsIPrintSettings::kRangeAllPages;
+nsresult rv;
+if (mPrt->mPrintSettings != nullptr) {
+mPrt->mPrintSettings->GetPrintRange(&printRangeType);
+}
+// Ask the page sequence frame to print all the pages
+nsIPageSequenceFrame* pageSequence = poPresShell->GetPageSequenceFrame();
+NS_ASSERTION(nullptr != pageSequence, "no page sequence frame");
+// We are done preparing for printing, so we can turn this off
+mPrt->mPreparingForPrint = false;
+// mPrt->mDebugFilePtr this is onlu non-null when compiled for debugging
+if (nullptr != mPrt->mDebugFilePtr) {
+#ifdef DEBUG
+// output the regression test
+nsIFrame* root = poPresShell->FrameManager()->GetRootFrame();
+root->DumpRegressionData(poPresContext, mPrt->mDebugFilePtr, 0);
+fclose(mPrt->mDebugFilePtr);
+SetIsPrinting(false);
+#endif
+} else {
+#ifdef EXTENDED_DEBUG_PRINTING
+nsIFrame* rootFrame = poPresShell->FrameManager()->GetRootFrame();
+if (aPO->IsPrintable()) {
+nsAutoCString docStr;
+nsAutoCString urlStr;
+GetDocTitleAndURL(aPO, docStr, urlStr);
+DumpLayoutData(docStr.get(), urlStr.get(), poPresContext, mPrt->mPrintDocDC, rootFrame, docShell, nullptr);
+}
+#endif
+if (!mPrt->mPrintSettings) {
+// not sure what to do here!
+SetIsPrinting(false);
+return NS_ERROR_FAILURE;
+}
+nsAutoString docTitleStr;
+nsAutoString docURLStr;
+GetDisplayTitleAndURL(aPO, docTitleStr, docURLStr, eDocTitleDefBlank);
+if (nsIPrintSettings::kRangeSelection == printRangeType) {
+CloneSelection(aPO->mDocument->GetOriginalDocument(), aPO->mDocument);
+poPresContext->SetIsRenderingOnlySelection(true);
+// temporarily creating rendering context
+// which is needed to find the selection frames
+nsRefPtr<nsRenderingContext> rc =
+mPrt->mPrintDC->CreateRenderingContext();
+// find the starting and ending page numbers
+// via the selection
+nsIFrame* startFrame;
+nsIFrame* endFrame;
+int32_t   startPageNum;
+int32_t   endPageNum;
+nsRect    startRect;
+nsRect    endRect;
+nsRefPtr<Selection> selectionPS =
+poPresShell->GetCurrentSelection(nsISelectionController::SELECTION_NORMAL);
+rv = GetPageRangeForSelection(poPresShell, poPresContext, *rc, selectionPS, pageSequence,
+&startFrame, startPageNum, startRect,
+&endFrame, endPageNum, endRect);
+if (NS_SUCCEEDED(rv)) {
+mPrt->mPrintSettings->SetStartPageRange(startPageNum);
+mPrt->mPrintSettings->SetEndPageRange(endPageNum);
+nsIntMargin marginTwips(0,0,0,0);
+nsIntMargin unwrtMarginTwips(0,0,0,0);
+mPrt->mPrintSettings->GetMarginInTwips(marginTwips);
+mPrt->mPrintSettings->GetUnwriteableMarginInTwips(unwrtMarginTwips);
+nsMargin totalMargin = poPresContext->CSSTwipsToAppUnits(marginTwips +
+unwrtMarginTwips);
+if (startPageNum == endPageNum) {
+startRect.y -= totalMargin.top;
+endRect.y   -= totalMargin.top;
+// Clip out selection regions above the top of the first page
+if (startRect.y < 0) {
+// Reduce height to be the height of the positive-territory
+// region of original rect
+startRect.height = std::max(0, startRect.YMost());
+startRect.y = 0;
+}
+if (endRect.y < 0) {
+// Reduce height to be the height of the positive-territory
+// region of original rect
+endRect.height = std::max(0, endRect.YMost());
+endRect.y = 0;
+}
+NS_ASSERTION(endRect.y >= startRect.y,
+"Selection end point should be after start point");
+NS_ASSERTION(startRect.height >= 0,
+"rect should have non-negative height.");
+NS_ASSERTION(endRect.height >= 0,
+"rect should have non-negative height.");
+nscoord selectionHgt = endRect.y + endRect.height - startRect.y;
+// XXX This is temporary fix for printing more than one page of a selection
+pageSequence->SetSelectionHeight(startRect.y * aPO->mZoomRatio,
+selectionHgt * aPO->mZoomRatio);
+// calc total pages by getting calculating the selection's height
+// and then dividing it by how page content frames will fit.
+nscoord pageWidth, pageHeight;
+mPrt->mPrintDC->GetDeviceSurfaceDimensions(pageWidth, pageHeight);
+pageHeight -= totalMargin.top + totalMargin.bottom;
+int32_t totalPages = NSToIntCeil(float(selectionHgt) * aPO->mZoomRatio / float(pageHeight));
+pageSequence->SetTotalNumPages(totalPages);
+}
+}
+}
+nsIFrame * seqFrame = do_QueryFrame(pageSequence);
+if (!seqFrame) {
+SetIsPrinting(false);
+return NS_ERROR_FAILURE;
+}
+mPageSeqFrame = pageSequence;
+mPageSeqFrame->StartPrint(poPresContext, mPrt->mPrintSettings, docTitleStr, docURLStr);
+// Schedule Page to Print
+PR_PL(("Scheduling Print of PO: %p (%s) \n", aPO, gFrameTypesStr[aPO->mFrameType]));
+StartPagePrintTimer(aPO);
+}
+}
+return NS_OK;
+}
+//---------------------------------------------------------------------
+void
+nsPrintEngine::SetDocAndURLIntoProgress(nsPrintObject* aPO,
+nsIPrintProgressParams* aParams)
+{
+NS_ASSERTION(aPO, "Must have valid nsPrintObject");
+NS_ASSERTION(aParams, "Must have valid nsIPrintProgressParams");
+if (!aPO || !aPO->mDocShell || !aParams) {
+return;
+}
+const uint32_t kTitleLength = 64;
+nsAutoString docTitleStr;
+nsAutoString docURLStr;
+GetDisplayTitleAndURL(aPO, docTitleStr, docURLStr, eDocTitleDefURLDoc);
+// Make sure the Titles & URLS don't get too long for the progress dialog
+EllipseLongString(docTitleStr, kTitleLength, false);
+EllipseLongString(docURLStr, kTitleLength, true);
+aParams->SetDocTitle(docTitleStr.get());
+aParams->SetDocURL(docURLStr.get());
+}
+//---------------------------------------------------------------------
+void
+nsPrintEngine::EllipseLongString(nsAString& aStr, const uint32_t aLen, bool aDoFront)
+{
+// Make sure the URLS don't get too long for the progress dialog
+if (aLen >= 3 && aStr.Length() > aLen) {
+if (aDoFront) {
+nsAutoString newStr;
+newStr.AppendLiteral("...");
+newStr += Substring(aStr, aStr.Length() - (aLen - 3), aLen - 3);
+aStr = newStr;
+} else {
+aStr.SetLength(aLen - 3);
+aStr.AppendLiteral("...");
+}
+}
+}
+static bool
+DocHasPrintCallbackCanvas(nsIDocument* aDoc, void* aData)
+{
+if (!aDoc) {
+return true;
+}
+Element* root = aDoc->GetRootElement();
+if (!root) {
+return true;
+}
+nsRefPtr<nsContentList> canvases = NS_GetContentList(root,
+kNameSpaceID_XHTML,
+NS_LITERAL_STRING("canvas"));
+uint32_t canvasCount = canvases->Length(true);
+for (uint32_t i = 0; i < canvasCount; ++i) {
+HTMLCanvasElement* canvas = HTMLCanvasElement::FromContentOrNull(canvases->Item(i, false));
+if (canvas && canvas->GetMozPrintCallback()) {
+// This subdocument has a print callback. Set result and return false to
+// stop iteration.
+*static_cast<bool*>(aData) = true;
+return false;
+}
+}
+return true;
+}
+static bool
+DocHasPrintCallbackCanvas(nsIDocument* aDoc)
+{
+bool result = false;
+aDoc->EnumerateSubDocuments(&DocHasPrintCallbackCanvas, static_cast<void*>(&result));
+return result;
+}
+/**
+* Checks to see if the document this print engine is associated with has any
+* canvases that have a mozPrintCallback.
+*/
+bool
+nsPrintEngine::HasPrintCallbackCanvas()
+{
+if (!mDocument) {
+return false;
+}
+// First check this mDocument.
+bool result = false;
+DocHasPrintCallbackCanvas(mDocument, static_cast<void*>(&result));
+// Also check the sub documents.
+return result || DocHasPrintCallbackCanvas(mDocument);
+}
+//-------------------------------------------------------
+bool
+nsPrintEngine::PrePrintPage()
+{
+NS_ASSERTION(mPageSeqFrame,  "mPageSeqFrame is null!");
+NS_ASSERTION(mPrt,           "mPrt is null!");
+// Although these should NEVER be nullptr
+// This is added insurance, to make sure we don't crash in optimized builds
+if (!mPrt || !mPageSeqFrame) {
+return true; // means we are done preparing the page.
+}
+// Check setting to see if someone request it be cancelled
+bool isCancelled = false;
+mPrt->mPrintSettings->GetIsCancelled(&isCancelled);
+if (isCancelled)
+return true;
+// Ask mPageSeqFrame if the page is ready to be printed.
+// If the page doesn't get printed at all, the |done| will be |true|.
+bool done = false;
+nsresult rv = mPageSeqFrame->PrePrintNextPage(mPagePrintTimer, &done);
+if (NS_FAILED(rv)) {
+// ??? ::PrintPage doesn't set |mPrt->mIsAborted = true| if rv != NS_ERROR_ABORT,
+// but I don't really understand why this should be the right thing to do?
+// Shouldn't |mPrt->mIsAborted| set to true all the time if something
+// wents wrong?
+if (rv != NS_ERROR_ABORT) {
+ShowPrintErrorDialog(rv);
+mPrt->mIsAborted = true;
+}
+done = true;
+}
+return done;
+}
+bool
+nsPrintEngine::PrintPage(nsPrintObject*    aPO,
+bool&           aInRange)
+{
+NS_ASSERTION(aPO,            "aPO is null!");
+NS_ASSERTION(mPageSeqFrame,  "mPageSeqFrame is null!");
+NS_ASSERTION(mPrt,           "mPrt is null!");
+// Although these should NEVER be nullptr
+// This is added insurance, to make sure we don't crash in optimized builds
+if (!mPrt || !aPO || !mPageSeqFrame) {
+ShowPrintErrorDialog(NS_ERROR_FAILURE);
+return true; // means we are done printing
+}
+PR_PL(("-----------------------------------\n"));
+PR_PL(("------ In DV::PrintPage PO: %p (%s)\n", aPO, gFrameTypesStr[aPO->mFrameType]));
+// Check setting to see if someone request it be cancelled
+bool isCancelled = false;
+mPrt->mPrintSettings->GetIsCancelled(&isCancelled);
+if (isCancelled || mPrt->mIsAborted)
+return true;
+int32_t pageNum, numPages, endPage;
+mPageSeqFrame->GetCurrentPageNum(&pageNum);
+mPageSeqFrame->GetNumPages(&numPages);
+bool donePrinting;
+bool isDoingPrintRange;
+mPageSeqFrame->IsDoingPrintRange(&isDoingPrintRange);
+if (isDoingPrintRange) {
+int32_t fromPage;
+int32_t toPage;
+mPageSeqFrame->GetPrintRange(&fromPage, &toPage);
+if (fromPage > numPages) {
+return true;
+}
+if (toPage > numPages) {
+toPage = numPages;
+}
+PR_PL(("****** Printing Page %d printing from %d to page %d\n", pageNum, fromPage, toPage));
+donePrinting = pageNum >= toPage;
+aInRange = pageNum >= fromPage && pageNum <= toPage;
+endPage = (toPage - fromPage)+1;
+} else {
+PR_PL(("****** Printing Page %d of %d page(s)\n", pageNum, numPages));
+donePrinting = pageNum >= numPages;
+endPage = numPages;
+aInRange = true;
+}
+// XXX This is wrong, but the actual behavior in the presence of a print
+// range sucks.
+if (mPrt->mPrintFrameType == nsIPrintSettings::kEachFrameSep)
+endPage = mPrt->mNumPrintablePages;
+mPrt->DoOnProgressChange(++mPrt->mNumPagesPrinted, endPage, false, 0);
+// Print the Page
+// if a print job was cancelled externally, an EndPage or BeginPage may
+// fail and the failure is passed back here.
+// Returning true means we are done printing.
+//
+// When rv == NS_ERROR_ABORT, it means we want out of the
+// print job without displaying any error messages
+nsresult rv = mPageSeqFrame->PrintNextPage();
+if (NS_FAILED(rv)) {
+if (rv != NS_ERROR_ABORT) {
+ShowPrintErrorDialog(rv);
+mPrt->mIsAborted = true;
+}
+return true;
+}
+mPageSeqFrame->DoPageEnd();
+return donePrinting;
+}
+/** ---------------------------------------------------
+*  Find by checking frames type
+*/
+nsresult
+nsPrintEngine::FindSelectionBoundsWithList(nsPresContext* aPresContext,
+nsRenderingContext& aRC,
+nsFrameList::Enumerator& aChildFrames,
+nsIFrame *      aParentFrame,
+nsRect&         aRect,
+nsIFrame *&     aStartFrame,
+nsRect&         aStartRect,
+nsIFrame *&     aEndFrame,
+nsRect&         aEndRect)
+{
+NS_ASSERTION(aPresContext, "Pointer is null!");
+NS_ASSERTION(aParentFrame, "Pointer is null!");
+aRect += aParentFrame->GetPosition();
+for (; !aChildFrames.AtEnd(); aChildFrames.Next()) {
+nsIFrame* child = aChildFrames.get();
+if (child->IsSelected() && child->IsVisibleForPainting()) {
+nsRect r = child->GetRect();
+if (aStartFrame == nullptr) {
+aStartFrame = child;
+aStartRect.SetRect(aRect.x + r.x, aRect.y + r.y, r.width, r.height);
+} else {
+aEndFrame = child;
+aEndRect.SetRect(aRect.x + r.x, aRect.y + r.y, r.width, r.height);
+}
+}
+FindSelectionBounds(aPresContext, aRC, child, aRect, aStartFrame, aStartRect, aEndFrame, aEndRect);
+child = child->GetNextSibling();
+}
+aRect -= aParentFrame->GetPosition();
+return NS_OK;
+}
+//-------------------------------------------------------
+// Find the Frame that is XMost
+nsresult
+nsPrintEngine::FindSelectionBounds(nsPresContext* aPresContext,
+nsRenderingContext& aRC,
+nsIFrame *      aParentFrame,
+nsRect&         aRect,
+nsIFrame *&     aStartFrame,
+nsRect&         aStartRect,
+nsIFrame *&     aEndFrame,
+nsRect&         aEndRect)
+{
+NS_ASSERTION(aPresContext, "Pointer is null!");
+NS_ASSERTION(aParentFrame, "Pointer is null!");
+// loop through named child lists
+nsIFrame::ChildListIterator lists(aParentFrame);
+for (; !lists.IsDone(); lists.Next()) {
+nsFrameList::Enumerator childFrames(lists.CurrentList());
+nsresult rv = FindSelectionBoundsWithList(aPresContext, aRC, childFrames, aParentFrame, aRect, aStartFrame, aStartRect, aEndFrame, aEndRect);
+NS_ENSURE_SUCCESS(rv, rv);
+}
+return NS_OK;
+}
+/** ---------------------------------------------------
+*  This method finds the starting and ending page numbers
+*  of the selection and also returns rect for each where
+*  the x,y of the rect is relative to the very top of the
+*  frame tree (absolutely positioned)
+*/
+nsresult
+nsPrintEngine::GetPageRangeForSelection(nsIPresShell *        aPresShell,
+nsPresContext*       aPresContext,
+nsRenderingContext&  aRC,
+nsISelection*         aSelection,
+nsIPageSequenceFrame* aPageSeqFrame,
+nsIFrame**            aStartFrame,
+int32_t&              aStartPageNum,
+nsRect&               aStartRect,
+nsIFrame**            aEndFrame,
+int32_t&              aEndPageNum,
+nsRect&               aEndRect)
+{
+NS_ASSERTION(aPresShell, "Pointer is null!");
+NS_ASSERTION(aPresContext, "Pointer is null!");
+NS_ASSERTION(aSelection, "Pointer is null!");
+NS_ASSERTION(aPageSeqFrame, "Pointer is null!");
+NS_ASSERTION(aStartFrame, "Pointer is null!");
+NS_ASSERTION(aEndFrame, "Pointer is null!");
+nsIFrame * seqFrame = do_QueryFrame(aPageSeqFrame);
+if (!seqFrame) {
+return NS_ERROR_FAILURE;
+}
+nsIFrame * startFrame = nullptr;
+nsIFrame * endFrame   = nullptr;
+// start out with the sequence frame and search the entire frame tree
+// capturing the starting and ending child frames of the selection
+// and their rects
+nsRect r = seqFrame->GetRect();
+FindSelectionBounds(aPresContext, aRC, seqFrame, r,
+startFrame, aStartRect, endFrame, aEndRect);
+#ifdef DEBUG_rodsX
+printf("Start Frame: %p\n", startFrame);
+printf("End Frame:   %p\n", endFrame);
+#endif
+// initial the page numbers here
+// in case we don't find and frames
+aStartPageNum = -1;
+aEndPageNum   = -1;
+nsIFrame * startPageFrame;
+nsIFrame * endPageFrame;
+// check to make sure we found a starting frame
+if (startFrame != nullptr) {
+// Now search up the tree to find what page the
+// start/ending selections frames are on
+//
+// Check to see if start should be same as end if
+// the end frame comes back null
+if (endFrame == nullptr) {
+// XXX the "GetPageFrame" step could be integrated into
+// the FindSelectionBounds step, but walking up to find
+// the parent of a child frame isn't expensive and it makes
+// FindSelectionBounds a little easier to understand
+startPageFrame = nsLayoutUtils::GetPageFrame(startFrame);
+endPageFrame   = startPageFrame;
+aEndRect       = aStartRect;
+} else {
+startPageFrame = nsLayoutUtils::GetPageFrame(startFrame);
+endPageFrame   = nsLayoutUtils::GetPageFrame(endFrame);
+}
+} else {
+return NS_ERROR_FAILURE;
+}
+#ifdef DEBUG_rodsX
+printf("Start Page: %p\n", startPageFrame);
+printf("End Page:   %p\n", endPageFrame);
+// dump all the pages and their pointers
+{
+int32_t pageNum = 1;
+nsIFrame* child = seqFrame->GetFirstPrincipalChild();
+while (child != nullptr) {
+printf("Page: %d - %p\n", pageNum, child);
+pageNum++;
+child = child->GetNextSibling();
+}
+}
+#endif
+// Now that we have the page frames
+// find out what the page numbers are for each frame
+int32_t pageNum = 1;
+nsIFrame* page = seqFrame->GetFirstPrincipalChild();
+while (page != nullptr) {
+if (page == startPageFrame) {
+aStartPageNum = pageNum;
+}
+if (page == endPageFrame) {
+aEndPageNum = pageNum;
+}
+pageNum++;
+page = page->GetNextSibling();
+}
+#ifdef DEBUG_rodsX
+printf("Start Page No: %d\n", aStartPageNum);
+printf("End Page No:   %d\n", aEndPageNum);
+#endif
+*aStartFrame = startPageFrame;
+*aEndFrame   = endPageFrame;
+return NS_OK;
+}
+//-----------------------------------------------------------------
+//-- Done: Printing Methods
+//-----------------------------------------------------------------
+//-----------------------------------------------------------------
+//-- Section: Misc Support Methods
+//-----------------------------------------------------------------
+//---------------------------------------------------------------------
+void nsPrintEngine::SetIsPrinting(bool aIsPrinting)
+{
+mIsDoingPrinting = aIsPrinting;
+// Calling SetIsPrinting while in print preview confuses the document viewer
+// This is safe because we prevent exiting print preview while printing
+if (!mIsDoingPrintPreview && mDocViewerPrint) {
+mDocViewerPrint->SetIsPrinting(aIsPrinting);
+}
+if (mPrt && aIsPrinting) {
+mPrt->mPreparingForPrint = true;
+}
+}
+//---------------------------------------------------------------------
+void nsPrintEngine::SetIsPrintPreview(bool aIsPrintPreview)
+{
+mIsDoingPrintPreview = aIsPrintPreview;
+if (mDocViewerPrint) {
+mDocViewerPrint->SetIsPrintPreview(aIsPrintPreview);
+}
+}
+//---------------------------------------------------------------------
+void
+nsPrintEngine::CleanupDocTitleArray(char16_t**& aArray, int32_t& aCount)
+{
+for (int32_t i = aCount - 1; i >= 0; i--) {
+nsMemory::Free(aArray[i]);
+}
+nsMemory::Free(aArray);
+aArray = nullptr;
+aCount = 0;
+}
+//---------------------------------------------------------------------
+// static
+bool nsPrintEngine::HasFramesetChild(nsIContent* aContent)
+{
+if (!aContent) {
+return false;
+}
+// do a breadth search across all siblings
+for (nsIContent* child = aContent->GetFirstChild();
+child;
+child = child->GetNextSibling()) {
+if (child->IsHTML(nsGkAtoms::frameset)) {
+return true;
+}
+}
+return false;
+}
+/** ---------------------------------------------------
+*  Get the Focused Frame for a documentviewer
+*/
+already_AddRefed<nsIDOMWindow>
+nsPrintEngine::FindFocusedDOMWindow()
+{
+nsIFocusManager* fm = nsFocusManager::GetFocusManager();
+NS_ENSURE_TRUE(fm, nullptr);
+nsCOMPtr<nsPIDOMWindow> window(mDocument->GetWindow());
+NS_ENSURE_TRUE(window, nullptr);
+nsCOMPtr<nsPIDOMWindow> rootWindow = window->GetPrivateRoot();
+NS_ENSURE_TRUE(rootWindow, nullptr);
+nsCOMPtr<nsPIDOMWindow> focusedWindow;
+nsFocusManager::GetFocusedDescendant(rootWindow, true,
+getter_AddRefs(focusedWindow));
+NS_ENSURE_TRUE(focusedWindow, nullptr);
+if (IsWindowsInOurSubTree(focusedWindow)) {
+return focusedWindow.forget();
+}
+return nullptr;
+}
+//---------------------------------------------------------------------
+bool
+nsPrintEngine::IsWindowsInOurSubTree(nsPIDOMWindow * window)
+{
+bool found = false;
+// now check to make sure it is in "our" tree of docshells
+if (window) {
+nsCOMPtr<nsIDocShell> docShell = window->GetDocShell();
+if (docShell) {
+// get this DocViewer docshell
+nsCOMPtr<nsIDocShell> thisDVDocShell(do_QueryReferent(mContainer));
+while (!found) {
+if (docShell) {
+if (docShell == thisDVDocShell) {
+found = true;
+break;
+}
+} else {
+break; // at top of tree
+}
+nsCOMPtr<nsIDocShellTreeItem> docShellItemParent;
+docShell->GetSameTypeParent(getter_AddRefs(docShellItemParent));
+docShell = do_QueryInterface(docShellItemParent);
+} // while
+}
+} // scriptobj
+return found;
+}
+//-------------------------------------------------------
+bool
+nsPrintEngine::DonePrintingPages(nsPrintObject* aPO, nsresult aResult)
+{
+//NS_ASSERTION(aPO, "Pointer is null!");
+PR_PL(("****** In DV::DonePrintingPages PO: %p (%s)\n", aPO, aPO?gFrameTypesStr[aPO->mFrameType]:""));
+// If there is a pageSeqFrame, make sure there are no more printCanvas active
+// that might call |Notify| on the pagePrintTimer after things are cleaned up
+// and printing was marked as being done.
+if (mPageSeqFrame) {
+mPageSeqFrame->ResetPrintCanvasList();
+}
+if (aPO && !mPrt->mIsAborted) {
+aPO->mHasBeenPrinted = true;
+nsresult rv;
+bool didPrint = PrintDocContent(mPrt->mPrintObject, rv);
+if (NS_SUCCEEDED(rv) && didPrint) {
+PR_PL(("****** In DV::DonePrintingPages PO: %p (%s) didPrint:%s (Not Done Printing)\n", aPO, gFrameTypesStr[aPO->mFrameType], PRT_YESNO(didPrint)));
+return false;
+}
+}
+if (NS_SUCCEEDED(aResult)) {
+FirePrintCompletionEvent();
+}
+TurnScriptingOn(true);
+SetIsPrinting(false);
+// Release reference to mPagePrintTimer; the timer object destroys itself
+// after this returns true
+NS_IF_RELEASE(mPagePrintTimer);
+return true;
+}
+//-------------------------------------------------------
+// Recursively sets the PO items to be printed "As Is"
+// from the given item down into the tree
+void
+nsPrintEngine::SetPrintAsIs(nsPrintObject* aPO, bool aAsIs)
+{
+NS_ASSERTION(aPO, "Pointer is null!");
+aPO->mPrintAsIs = aAsIs;
+for (uint32_t i=0;i<aPO->mKids.Length();i++) {
+SetPrintAsIs(aPO->mKids[i], aAsIs);
+}
+}
+//-------------------------------------------------------
+// Given a DOMWindow it recursively finds the PO object that matches
+nsPrintObject*
+nsPrintEngine::FindPrintObjectByDOMWin(nsPrintObject* aPO,
+nsIDOMWindow* aDOMWin)
+{
+NS_ASSERTION(aPO, "Pointer is null!");
+// Often the CurFocused DOMWindow is passed in
+// andit is valid for it to be null, so short circut
+if (!aDOMWin) {
+return nullptr;
+}
+nsCOMPtr<nsIDOMDocument> domDoc;
+aDOMWin->GetDocument(getter_AddRefs(domDoc));
+nsCOMPtr<nsIDocument> doc = do_QueryInterface(domDoc);
+if (aPO->mDocument && aPO->mDocument->GetOriginalDocument() == doc) {
+return aPO;
+}
+int32_t cnt = aPO->mKids.Length();
+for (int32_t i = 0; i < cnt; ++i) {
+nsPrintObject* po = FindPrintObjectByDOMWin(aPO->mKids[i], aDOMWin);
+if (po) {
+return po;
+}
+}
+return nullptr;
+}
+//-------------------------------------------------------
+nsresult
+nsPrintEngine::EnablePOsForPrinting()
+{
+// NOTE: All POs have been "turned off" for printing
+// this is where we decided which POs get printed.
+mPrt->mSelectedPO = nullptr;
+if (mPrt->mPrintSettings == nullptr) {
+return NS_ERROR_FAILURE;
+}
+mPrt->mPrintFrameType = nsIPrintSettings::kNoFrames;
+mPrt->mPrintSettings->GetPrintFrameType(&mPrt->mPrintFrameType);
+int16_t printHowEnable = nsIPrintSettings::kFrameEnableNone;
+mPrt->mPrintSettings->GetHowToEnableFrameUI(&printHowEnable);
+int16_t printRangeType = nsIPrintSettings::kRangeAllPages;
+mPrt->mPrintSettings->GetPrintRange(&printRangeType);
+PR_PL(("\n"));
+PR_PL(("********* nsPrintEngine::EnablePOsForPrinting *********\n"));
+PR_PL(("PrintFrameType:     %s \n", gPrintFrameTypeStr[mPrt->mPrintFrameType]));
+PR_PL(("HowToEnableFrameUI: %s \n", gFrameHowToEnableStr[printHowEnable]));
+PR_PL(("PrintRange:         %s \n", gPrintRangeStr[printRangeType]));
+PR_PL(("----\n"));
+// ***** This is the ultimate override *****
+// if we are printing the selection (either an IFrame or selection range)
+// then set the mPrintFrameType as if it were the selected frame
+if (printRangeType == nsIPrintSettings::kRangeSelection) {
+mPrt->mPrintFrameType = nsIPrintSettings::kSelectedFrame;
+printHowEnable        = nsIPrintSettings::kFrameEnableNone;
+}
+// This tells us that the "Frame" UI has turned off,
+// so therefore there are no FrameSets/Frames/IFrames to be printed
+//
+// This means there are not FrameSets,
+// but the document could contain an IFrame
+if (printHowEnable == nsIPrintSettings::kFrameEnableNone) {
+// Print all the pages or a sub range of pages
+if (printRangeType == nsIPrintSettings::kRangeAllPages ||
+printRangeType == nsIPrintSettings::kRangeSpecifiedPageRange) {
+SetPrintPO(mPrt->mPrintObject, true);
+// Set the children so they are PrinAsIs
+// In this case, the children are probably IFrames
+if (mPrt->mPrintObject->mKids.Length() > 0) {
+for (uint32_t i=0;i<mPrt->mPrintObject->mKids.Length();i++) {
+nsPrintObject* po = mPrt->mPrintObject->mKids[i];
+NS_ASSERTION(po, "nsPrintObject can't be null!");
+SetPrintAsIs(po);
+}
+// ***** Another override *****
+mPrt->mPrintFrameType = nsIPrintSettings::kFramesAsIs;
+}
+PR_PL(("PrintFrameType:     %s \n", gPrintFrameTypeStr[mPrt->mPrintFrameType]));
+PR_PL(("HowToEnableFrameUI: %s \n", gFrameHowToEnableStr[printHowEnable]));
+PR_PL(("PrintRange:         %s \n", gPrintRangeStr[printRangeType]));
+return NS_OK;
+}
+// This means we are either printed a selected IFrame or
+// we are printing the current selection
+if (printRangeType == nsIPrintSettings::kRangeSelection) {
+// If the currentFocusDOMWin can'r be null if something is selected
+if (mPrt->mCurrentFocusWin) {
+// Find the selected IFrame
+nsPrintObject * po = FindPrintObjectByDOMWin(mPrt->mPrintObject, mPrt->mCurrentFocusWin);
+if (po != nullptr) {
+mPrt->mSelectedPO = po;
+// Makes sure all of its children are be printed "AsIs"
+SetPrintAsIs(po);
+// Now, only enable this POs (the selected PO) and all of its children
+SetPrintPO(po, true);
+// check to see if we have a range selection,
+// as oppose to a insert selection
+// this means if the user just clicked on the IFrame then
+// there will not be a selection so we want the entire page to print
+//
+// XXX this is sort of a hack right here to make the page
+// not try to reposition itself when printing selection
+nsCOMPtr<nsIDOMWindow> domWin =
+do_QueryInterface(po->mDocument->GetOriginalDocument()->GetWindow());
+if (!IsThereARangeSelection(domWin)) {
+printRangeType = nsIPrintSettings::kRangeAllPages;
+mPrt->mPrintSettings->SetPrintRange(printRangeType);
+}
+PR_PL(("PrintFrameType:     %s \n", gPrintFrameTypeStr[mPrt->mPrintFrameType]));
+PR_PL(("HowToEnableFrameUI: %s \n", gFrameHowToEnableStr[printHowEnable]));
+PR_PL(("PrintRange:         %s \n", gPrintRangeStr[printRangeType]));
+return NS_OK;
+}
+} else {
+for (uint32_t i=0;i<mPrt->mPrintDocList.Length();i++) {
+nsPrintObject* po = mPrt->mPrintDocList.ElementAt(i);
+NS_ASSERTION(po, "nsPrintObject can't be null!");
+nsCOMPtr<nsIDOMWindow> domWin = do_GetInterface(po->mDocShell);
+if (IsThereARangeSelection(domWin)) {
+mPrt->mCurrentFocusWin = domWin;
+SetPrintPO(po, true);
+break;
+}
+}
+return NS_OK;
+}
+}
+}
+// check to see if there is a selection when a FrameSet is present
+if (printRangeType == nsIPrintSettings::kRangeSelection) {
+// If the currentFocusDOMWin can'r be null if something is selected
+if (mPrt->mCurrentFocusWin) {
+// Find the selected IFrame
+nsPrintObject * po = FindPrintObjectByDOMWin(mPrt->mPrintObject, mPrt->mCurrentFocusWin);
+if (po != nullptr) {
+mPrt->mSelectedPO = po;
+// Makes sure all of its children are be printed "AsIs"
+SetPrintAsIs(po);
+// Now, only enable this POs (the selected PO) and all of its children
+SetPrintPO(po, true);
+// check to see if we have a range selection,
+// as oppose to a insert selection
+// this means if the user just clicked on the IFrame then
+// there will not be a selection so we want the entire page to print
+//
+// XXX this is sort of a hack right here to make the page
+// not try to reposition itself when printing selection
+nsCOMPtr<nsIDOMWindow> domWin =
+do_QueryInterface(po->mDocument->GetOriginalDocument()->GetWindow());
+if (!IsThereARangeSelection(domWin)) {
+printRangeType = nsIPrintSettings::kRangeAllPages;
+mPrt->mPrintSettings->SetPrintRange(printRangeType);
+}
+PR_PL(("PrintFrameType:     %s \n", gPrintFrameTypeStr[mPrt->mPrintFrameType]));
+PR_PL(("HowToEnableFrameUI: %s \n", gFrameHowToEnableStr[printHowEnable]));
+PR_PL(("PrintRange:         %s \n", gPrintRangeStr[printRangeType]));
+return NS_OK;
+}
+}
+}
+// If we are printing "AsIs" then sets all the POs to be printed as is
+if (mPrt->mPrintFrameType == nsIPrintSettings::kFramesAsIs) {
+SetPrintAsIs(mPrt->mPrintObject);
+SetPrintPO(mPrt->mPrintObject, true);
+return NS_OK;
+}
+// If we are printing the selected Frame then
+// find that PO for that selected DOMWin and set it all of its
+// children to be printed
+if (mPrt->mPrintFrameType == nsIPrintSettings::kSelectedFrame) {
+if ((mPrt->mIsParentAFrameSet && mPrt->mCurrentFocusWin) || mPrt->mIsIFrameSelected) {
+nsPrintObject * po = FindPrintObjectByDOMWin(mPrt->mPrintObject, mPrt->mCurrentFocusWin);
+if (po != nullptr) {
+mPrt->mSelectedPO = po;
+// NOTE: Calling this sets the "po" and
+// we don't want to do this for documents that have no children,
+// because then the "DoEndPage" gets called and it shouldn't
+if (po->mKids.Length() > 0) {
+// Makes sure that itself, and all of its children are printed "AsIs"
+SetPrintAsIs(po);
+}
+// Now, only enable this POs (the selected PO) and all of its children
+SetPrintPO(po, true);
+}
+}
+return NS_OK;
+}
+// If we are print each subdoc separately,
+// then don't print any of the FraneSet Docs
+if (mPrt->mPrintFrameType == nsIPrintSettings::kEachFrameSep) {
+SetPrintPO(mPrt->mPrintObject, true);
+int32_t cnt = mPrt->mPrintDocList.Length();
+for (int32_t i=0;i<cnt;i++) {
+nsPrintObject* po = mPrt->mPrintDocList.ElementAt(i);
+NS_ASSERTION(po, "nsPrintObject can't be null!");
+if (po->mFrameType == eFrameSet) {
+po->mDontPrint = true;
+}
+}
+}
+return NS_OK;
+}
+//-------------------------------------------------------
+// Return the nsPrintObject with that is XMost (The widest frameset frame) AND
+// contains the XMost (widest) layout frame
+nsPrintObject*
+nsPrintEngine::FindSmallestSTF()
+{
+float smallestRatio = 1.0f;
+nsPrintObject* smallestPO = nullptr;
+for (uint32_t i=0;i<mPrt->mPrintDocList.Length();i++) {
+nsPrintObject* po = mPrt->mPrintDocList.ElementAt(i);
+NS_ASSERTION(po, "nsPrintObject can't be null!");
+if (po->mFrameType != eFrameSet && po->mFrameType != eIFrame) {
+if (po->mShrinkRatio < smallestRatio) {
+smallestRatio = po->mShrinkRatio;
+smallestPO    = po;
+}
+}
+}
+#ifdef EXTENDED_DEBUG_PRINTING
+if (smallestPO) printf("*PO: %p  Type: %d  %10.3f\n", smallestPO, smallestPO->mFrameType, smallestPO->mShrinkRatio);
+#endif
+return smallestPO;
+}
+//-------------------------------------------------------
+void
+nsPrintEngine::TurnScriptingOn(bool aDoTurnOn)
+{
+if (mIsDoingPrinting && aDoTurnOn && mDocViewerPrint &&
+mDocViewerPrint->GetIsPrintPreview()) {
+// We don't want to turn scripting on if print preview is shown still after
+// printing.
+return;
+}
+nsPrintData* prt = mPrt;
+#ifdef NS_PRINT_PREVIEW
+if (!prt) {
+prt = mPrtPreview;
+}
+#endif
+if (!prt) {
+return;
+}
+NS_ASSERTION(mDocument, "We MUST have a document.");
+// First, get the script global object from the document...
+for (uint32_t i=0;i<prt->mPrintDocList.Length();i++) {
+nsPrintObject* po = prt->mPrintDocList.ElementAt(i);
+NS_ASSERTION(po, "nsPrintObject can't be null!");
+nsIDocument* doc = po->mDocument;
+if (!doc) {
+continue;
+}
+if (nsCOMPtr<nsPIDOMWindow> window = doc->GetInnerWindow()) {
+nsCOMPtr<nsIGlobalObject> go = do_QueryInterface(window);
+NS_WARN_IF_FALSE(go && go->GetGlobalJSObject(), "Can't get global");
+nsresult propThere = NS_PROPTABLE_PROP_NOT_THERE;
+doc->GetProperty(nsGkAtoms::scriptEnabledBeforePrintOrPreview,
+&propThere);
+if (aDoTurnOn) {
+if (propThere != NS_PROPTABLE_PROP_NOT_THERE) {
+doc->DeleteProperty(nsGkAtoms::scriptEnabledBeforePrintOrPreview);
+if (go && go->GetGlobalJSObject()) {
+xpc::Scriptability::Get(go->GetGlobalJSObject()).Unblock();
+}
+window->ResumeTimeouts(false);
+}
+} else {
+// Have to be careful, because people call us over and over again with
+// aDoTurnOn == false.  So don't set the property if it's already
+// set, since in that case we'd set it to the wrong value.
+if (propThere == NS_PROPTABLE_PROP_NOT_THERE) {
+// Stash the current value of IsScriptEnabled on the document, so
+// that layout code running in print preview doesn't get confused.
+doc->SetProperty(nsGkAtoms::scriptEnabledBeforePrintOrPreview,
+NS_INT32_TO_PTR(doc->IsScriptEnabled()));
+if (go && go->GetGlobalJSObject()) {
+xpc::Scriptability::Get(go->GetGlobalJSObject()).Block();
+}
+window->SuspendTimeouts(1, false);
+}
+}
+}
+}
+}
+//-----------------------------------------------------------------
+//-- Done: Misc Support Methods
+//-----------------------------------------------------------------
+//-----------------------------------------------------------------
+//-- Section: Finishing up or Cleaning up
+//-----------------------------------------------------------------
+//-----------------------------------------------------------------
+void
+nsPrintEngine::CloseProgressDialog(nsIWebProgressListener* aWebProgressListener)
+{
+if (aWebProgressListener) {
+aWebProgressListener->OnStateChange(nullptr, nullptr, nsIWebProgressListener::STATE_STOP|nsIWebProgressListener::STATE_IS_DOCUMENT, NS_OK);
+}
+}
+//-----------------------------------------------------------------
+nsresult
+nsPrintEngine::FinishPrintPreview()
+{
+nsresult rv = NS_OK;
+#ifdef NS_PRINT_PREVIEW
+if (!mPrt) {
+/* we're already finished with print preview */
+return rv;
+}
+rv = DocumentReadyForPrinting();
+SetIsCreatingPrintPreview(false);
+/* cleaup on failure + notify user */
+if (NS_FAILED(rv)) {
+/* cleanup done, let's fire-up an error dialog to notify the user
+* what went wrong...
+*/
+mPrt->OnEndPrinting();
+TurnScriptingOn(true);
+return rv;
+}
+// At this point we are done preparing everything
+// before it is to be created
+if (mIsDoingPrintPreview && mOldPrtPreview) {
+delete mOldPrtPreview;
+mOldPrtPreview = nullptr;
+}
+mPrt->OnEndPrinting();
+// PrintPreview was built using the mPrt (code reuse)
+// then we assign it over
+mPrtPreview = mPrt;
+mPrt        = nullptr;
+#endif // NS_PRINT_PREVIEW
+return NS_OK;
+}
+//-----------------------------------------------------------------
+//-- Done: Finishing up or Cleaning up
+//-----------------------------------------------------------------
+/*=============== Timer Related Code ======================*/
+nsresult
+nsPrintEngine::StartPagePrintTimer(nsPrintObject* aPO)
+{
+if (!mPagePrintTimer) {
+// Get the delay time in between the printing of each page
+// this gives the user more time to press cancel
+int32_t printPageDelay = 50;
+mPrt->mPrintSettings->GetPrintPageDelay(&printPageDelay);
+nsRefPtr<nsPagePrintTimer> timer =
+new nsPagePrintTimer(this, mDocViewerPrint, printPageDelay);
+timer.forget(&mPagePrintTimer);
+}
+return mPagePrintTimer->Start(aPO);
+}
+/*=============== nsIObserver Interface ======================*/
+NS_IMETHODIMP
+nsPrintEngine::Observe(nsISupports *aSubject, const char *aTopic, const char16_t *aData)
+{
+nsresult rv = NS_ERROR_FAILURE;
+rv = InitPrintDocConstruction(true);
+if (!mIsDoingPrinting && mPrtPreview) {
+mPrtPreview->OnEndPrinting();
+}
+return rv;
+}
+//---------------------------------------------------------------
+//-- PLEvent Notification
+//---------------------------------------------------------------
+class nsPrintCompletionEvent : public nsRunnable {
+public:
+nsPrintCompletionEvent(nsIDocumentViewerPrint *docViewerPrint)
+: mDocViewerPrint(docViewerPrint) {
+NS_ASSERTION(mDocViewerPrint, "mDocViewerPrint is null.");
+}
+NS_IMETHOD Run() MOZ_OVERRIDE {
+if (mDocViewerPrint)
+mDocViewerPrint->OnDonePrinting();
+return NS_OK;
+}
+private:
+nsCOMPtr<nsIDocumentViewerPrint> mDocViewerPrint;
+};
+//-----------------------------------------------------------
+void
+nsPrintEngine::FirePrintCompletionEvent()
+{
+nsCOMPtr<nsIRunnable> event = new nsPrintCompletionEvent(mDocViewerPrint);
+if (NS_FAILED(NS_DispatchToCurrentThread(event)))
+NS_WARNING("failed to dispatch print completion event");
+}
+//---------------------------------------------------------------
+//---------------------------------------------------------------
+//-- Debug helper routines
+//---------------------------------------------------------------
+//---------------------------------------------------------------
+#if defined(XP_WIN) && defined(EXTENDED_DEBUG_PRINTING)
+#include "windows.h"
+#include "process.h"
+#include "direct.h"
+#define MY_FINDFIRST(a,b) FindFirstFile(a,b)
+#define MY_FINDNEXT(a,b) FindNextFile(a,b)
+#define ISDIR(a) (a.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+#define MY_FINDCLOSE(a) FindClose(a)
+#define MY_FILENAME(a) a.cFileName
+#define MY_FILESIZE(a) (a.nFileSizeHigh * MAXDWORD) + a.nFileSizeLow
+int RemoveFilesInDir(const char * aDir)
+{
+	WIN32_FIND_DATA data_ptr;
+	HANDLE find_handle;
+char path[MAX_PATH];
+strcpy(path, aDir);
+	// Append slash to the end of the directory names if not there
+	if (path[strlen(path)-1] != '\\')
+strcat(path, "\\");
+char findPath[MAX_PATH];
+strcpy(findPath, path);
+strcat(findPath, "*.*");
+	find_handle = MY_FINDFIRST(findPath, &data_ptr);
+	if (find_handle != INVALID_HANDLE_VALUE) {
+		do  {
+			if (ISDIR(data_ptr)
+				&& (stricmp(MY_FILENAME(data_ptr),"."))
+				&& (stricmp(MY_FILENAME(data_ptr),".."))) {
+					// skip
+			}
+			else if (!ISDIR(data_ptr)) {
+if (!strncmp(MY_FILENAME(data_ptr), "print_dump", 10)) {
+char fileName[MAX_PATH];
+strcpy(fileName, aDir);
+strcat(fileName, "\\");
+strcat(fileName, MY_FILENAME(data_ptr));
+				  printf("Removing %s\n", fileName);
+remove(fileName);
+}
+			}
+		} while(MY_FINDNEXT(find_handle,&data_ptr));
+		MY_FINDCLOSE(find_handle);
+	}
+	return TRUE;
+}
+#endif
+#ifdef EXTENDED_DEBUG_PRINTING
+/** ---------------------------------------------------
+*  Dumps Frames for Printing
+*/
+static void RootFrameList(nsPresContext* aPresContext, FILE* out, int32_t aIndent)
+{
+if (!aPresContext || !out)
+return;
+nsIPresShell *shell = aPresContext->GetPresShell();
+if (shell) {
+nsIFrame* frame = shell->FrameManager()->GetRootFrame();
+if (frame) {
+frame->List(aPresContext, out, aIndent);
+}
+}
+}
+/** ---------------------------------------------------
+*  Dumps Frames for Printing
+*/
+static void DumpFrames(FILE*                 out,
+nsPresContext*       aPresContext,
+nsRenderingContext * aRendContext,
+nsIFrame *            aFrame,
+int32_t               aLevel)
+{
+NS_ASSERTION(out, "Pointer is null!");
+NS_ASSERTION(aPresContext, "Pointer is null!");
+NS_ASSERTION(aRendContext, "Pointer is null!");
+NS_ASSERTION(aFrame, "Pointer is null!");
+nsIFrame* child = aFrame->GetFirstPrincipalChild();
+while (child != nullptr) {
+for (int32_t i=0;i<aLevel;i++) {
+fprintf(out, "  ");
+}
+nsAutoString tmp;
+child->GetFrameName(tmp);
+fputs(NS_LossyConvertUTF16toASCII(tmp).get(), out);
+bool isSelected;
+if (NS_SUCCEEDED(child->IsVisibleForPainting(aPresContext, *aRendContext, true, &isSelected))) {
+fprintf(out, " %p %s", child, isSelected?"VIS":"UVS");
+nsRect rect = child->GetRect();
+fprintf(out, "[%d,%d,%d,%d] ", rect.x, rect.y, rect.width, rect.height);
+fprintf(out, "v: %p ", (void*)child->GetView());
+fprintf(out, "\n");
+DumpFrames(out, aPresContext, aRendContext, child, aLevel+1);
+child = child->GetNextSibling();
+}
+}
+}
+/** ---------------------------------------------------
+*  Dumps the Views from the DocShell
+*/
+static void
+DumpViews(nsIDocShell* aDocShell, FILE* out)
+{
+NS_ASSERTION(aDocShell, "Pointer is null!");
+NS_ASSERTION(out, "Pointer is null!");
+if (nullptr != aDocShell) {
+fprintf(out, "docshell=%p \n", aDocShell);
+nsIPresShell* shell = nsPrintEngine::GetPresShellFor(aDocShell);
+if (shell) {
+nsViewManager* vm = shell->GetViewManager();
+if (vm) {
+nsView* root = vm->GetRootView();
+if (root) {
+root->List(out);
+}
+}
+}
+else {
+fputs("null pres shell\n", out);
+}
+// dump the views of the sub documents
+int32_t i, n;
+aDocShell->GetChildCount(&n);
+for (i = 0; i < n; i++) {
+nsCOMPtr<nsIDocShellTreeItem> child;
+aDocShell->GetChildAt(i, getter_AddRefs(child));
+nsCOMPtr<nsIDocShell> childAsShell(do_QueryInterface(child));
+if (childAsShell) {
+DumpViews(childAsShell, out);
+}
+}
+}
+}
+/** ---------------------------------------------------
+*  Dumps the Views and Frames
+*/
+void DumpLayoutData(char*              aTitleStr,
+char*              aURLStr,
+nsPresContext*    aPresContext,
+nsDeviceContext * aDC,
+nsIFrame *         aRootFrame,
+nsIDocShekk *      aDocShell,
+FILE*              aFD = nullptr)
+{
+if (!kPrintingLogMod || kPrintingLogMod->level != DUMP_LAYOUT_LEVEL) return;
+if (aPresContext == nullptr || aDC == nullptr) {
+return;
+}
+#ifdef NS_PRINT_PREVIEW
+if (aPresContext->Type() == nsPresContext::eContext_PrintPreview) {
+return;
+}
+#endif
+NS_ASSERTION(aRootFrame, "Pointer is null!");
+NS_ASSERTION(aDocShell, "Pointer is null!");
+// Dump all the frames and view to a a file
+char filename[256];
+sprintf(filename, "print_dump_layout_%d.txt", gDumpLOFileNameCnt++);
+FILE * fd = aFD?aFD:fopen(filename, "w");
+if (fd) {
+fprintf(fd, "Title: %s\n", aTitleStr?aTitleStr:"");
+fprintf(fd, "URL:   %s\n", aURLStr?aURLStr:"");
+fprintf(fd, "--------------- Frames ----------------\n");
+fprintf(fd, "--------------- Frames ----------------\n");
+nsRefPtr<nsRenderingContext> renderingContext =
+aDC->CreateRenderingContext();
+RootFrameList(aPresContext, fd, 0);
+//DumpFrames(fd, aPresContext, renderingContext, aRootFrame, 0);
+fprintf(fd, "---------------------------------------\n\n");
+fprintf(fd, "--------------- Views From Root Frame----------------\n");
+nsView* v = aRootFrame->GetView();
+if (v) {
+v->List(fd);
+} else {
+printf("View is null!\n");
+}
+if (aDocShell) {
+fprintf(fd, "--------------- All Views ----------------\n");
+DumpViews(aDocShell, fd);
+fprintf(fd, "---------------------------------------\n\n");
+}
+if (aFD == nullptr) {
+fclose(fd);
+}
+}
+}
+//-------------------------------------------------------------
+static void DumpPrintObjectsList(nsTArray<nsPrintObject*> * aDocList)
+{
+if (!kPrintingLogMod || kPrintingLogMod->level != DUMP_LAYOUT_LEVEL) return;
+NS_ASSERTION(aDocList, "Pointer is null!");
+const char types[][3] = {"DC", "FR", "IF", "FS"};
+PR_PL(("Doc List\n***************************************************\n"));
+PR_PL(("T  P A H    PO    DocShell   Seq     Page      Root     Page#    Rect\n"));
+int32_t cnt = aDocList->Length();
+for (int32_t i=0;i<cnt;i++) {
+nsPrintObject* po = aDocList->ElementAt(i);
+NS_ASSERTION(po, "nsPrintObject can't be null!");
+nsIFrame* rootFrame = nullptr;
+if (po->mPresShell) {
+rootFrame = po->mPresShell->FrameManager()->GetRootFrame();
+while (rootFrame != nullptr) {
+nsIPageSequenceFrame * sqf = do_QueryFrame(rootFrame);
+if (sqf) {
+break;
+}
+rootFrame = rootFrame->GetFirstPrincipalChild();
+}
+}
+PR_PL(("%s %d %d %d %p %p %p %p %p   %d   %d,%d,%d,%d\n", types[po->mFrameType],
+po->IsPrintable(), po->mPrintAsIs, po->mHasBeenPrinted, po, po->mDocShell.get(), po->mSeqFrame,
+po->mPageFrame, rootFrame, po->mPageNum, po->mRect.x, po->mRect.y, po->mRect.width, po->mRect.height));
+}
+}
+//-------------------------------------------------------------
+static void DumpPrintObjectsTree(nsPrintObject * aPO, int aLevel, FILE* aFD)
+{
+if (!kPrintingLogMod || kPrintingLogMod->level != DUMP_LAYOUT_LEVEL) return;
+NS_ASSERTION(aPO, "Pointer is null!");
+FILE * fd = aFD?aFD:stdout;
+const char types[][3] = {"DC", "FR", "IF", "FS"};
+if (aLevel == 0) {
+fprintf(fd, "DocTree\n***************************************************\n");
+fprintf(fd, "T     PO    DocShell   Seq      Page     Page#    Rect\n");
+}
+int32_t cnt = aPO->mKids.Length();
+for (int32_t i=0;i<cnt;i++) {
+nsPrintObject* po = aPO->mKids.ElementAt(i);
+NS_ASSERTION(po, "nsPrintObject can't be null!");
+for (int32_t k=0;k<aLevel;k++) fprintf(fd, "  ");
+fprintf(fd, "%s %p %p %p %p %d %d,%d,%d,%d\n", types[po->mFrameType], po, po->mDocShell.get(), po->mSeqFrame,
+po->mPageFrame, po->mPageNum, po->mRect.x, po->mRect.y, po->mRect.width, po->mRect.height);
+}
+}
+//-------------------------------------------------------------
+static void GetDocTitleAndURL(nsPrintObject* aPO, nsACString& aDocStr, nsACString& aURLStr)
+{
+nsAutoString docTitleStr;
+nsAutoString docURLStr;
+nsPrintEngine::GetDisplayTitleAndURL(aPO,
+docTitleStr, docURLStr,
+nsPrintEngine::eDocTitleDefURLDoc);
+aDocStr = NS_ConvertUTF16toUTF8(docTitleStr);
+aURLStr = NS_ConvertUTF16toUTF8(docURLStr);
+}
+//-------------------------------------------------------------
+static void DumpPrintObjectsTreeLayout(nsPrintObject * aPO,
+nsDeviceContext * aDC,
+int aLevel, FILE * aFD)
+{
+if (!kPrintingLogMod || kPrintingLogMod->level != DUMP_LAYOUT_LEVEL) return;
+NS_ASSERTION(aPO, "Pointer is null!");
+NS_ASSERTION(aDC, "Pointer is null!");
+const char types[][3] = {"DC", "FR", "IF", "FS"};
+FILE * fd = nullptr;
+if (aLevel == 0) {
+fd = fopen("tree_layout.txt", "w");
+fprintf(fd, "DocTree\n***************************************************\n");
+fprintf(fd, "***************************************************\n");
+fprintf(fd, "T     PO    DocShell   Seq      Page     Page#    Rect\n");
+} else {
+fd = aFD;
+}
+if (fd) {
+nsIFrame* rootFrame = nullptr;
+if (aPO->mPresShell) {
+rootFrame = aPO->mPresShell->FrameManager()->GetRootFrame();
+}
+for (int32_t k=0;k<aLevel;k++) fprintf(fd, "  ");
+fprintf(fd, "%s %p %p %p %p %d %d,%d,%d,%d\n", types[aPO->mFrameType], aPO, aPO->mDocShell.get(), aPO->mSeqFrame,
+aPO->mPageFrame, aPO->mPageNum, aPO->mRect.x, aPO->mRect.y, aPO->mRect.width, aPO->mRect.height);
+if (aPO->IsPrintable()) {
+nsAutoCString docStr;
+nsAutoCString urlStr;
+GetDocTitleAndURL(aPO, docStr, urlStr);
+DumpLayoutData(docStr.get(), urlStr.get(), aPO->mPresContext, aDC, rootFrame, aPO->mDocShell, fd);
+}
+fprintf(fd, "<***************************************************>\n");
+int32_t cnt = aPO->mKids.Length();
+for (int32_t i=0;i<cnt;i++) {
+nsPrintObject* po = aPO->mKids.ElementAt(i);
+NS_ASSERTION(po, "nsPrintObject can't be null!");
+DumpPrintObjectsTreeLayout(po, aDC, aLevel+1, fd);
+}
+}
+if (aLevel == 0 && fd) {
+fclose(fd);
+}
+}
+//-------------------------------------------------------------
+static void DumpPrintObjectsListStart(const char * aStr, nsTArray<nsPrintObject*> * aDocList)
+{
+if (!kPrintingLogMod || kPrintingLogMod->level != DUMP_LAYOUT_LEVEL) return;
+NS_ASSERTION(aStr, "Pointer is null!");
+NS_ASSERTION(aDocList, "Pointer is null!");
+PR_PL(("%s\n", aStr));
+DumpPrintObjectsList(aDocList);
+}
+#define DUMP_DOC_LIST(_title) DumpPrintObjectsListStart((_title), mPrt->mPrintDocList);
+#define DUMP_DOC_TREE DumpPrintObjectsTree(mPrt->mPrintObject);
+#define DUMP_DOC_TREELAYOUT DumpPrintObjectsTreeLayout(mPrt->mPrintObject, mPrt->mPrintDC);
+#else
+#define DUMP_DOC_LIST(_title)
+#define DUMP_DOC_TREE
+#define DUMP_DOC_TREELAYOUT
+#endif
+//---------------------------------------------------------------
+//---------------------------------------------------------------
+//-- End of debug helper routines
+//---------------------------------------------------------------

The Tor Browser / file comparison

comparison: layout/printing/nsPrintEngine.cpp

layout/printing/nsPrintEngine.cpp