Backed out changeset f95c19e45ab2 (bug 1652270) for reftest failures on test-text.html . CLOSED TREE

browser/components/extensions/parent/ext-tabs.js

@@ -1426,11 +1426,45 @@ this.tabs = class extends ExtensionAPI {
                   printSettings.footerStrRight = pageSettings.footerRight;
                 }
 
-                activeTab.linkedBrowser
+                let printProgressListener = {
-                  .print(activeTab.linkedBrowser.outerWindowID, printSettings)
+                  onLocationChange(webProgress, request, location, flags) {},
-                  .then(() => resolve(retval == 0 ? "saved" : "replaced"))
+                  onProgressChange(
-                  .catch(() =>
+                    webProgress,
-                    resolve(retval == 0 ? "not_saved" : "not_replaced")
+                    request,
+                    curSelfProgress,
+                    maxSelfProgress,
+                    curTotalProgress,
+                    maxTotalProgress
+                  ) {},
+                  onSecurityChange(webProgress, request, state) {},
+                  onContentBlockingEvent(webProgress, request, event) {},
+                  onStateChange(webProgress, request, flags, status) {
+                    if (
+                      flags & Ci.nsIWebProgressListener.STATE_STOP &&
+                      flags & Ci.nsIWebProgressListener.STATE_IS_DOCUMENT
+                    ) {
+                      resolve(retval == 0 ? "saved" : "replaced");
+                    }
+                  },
+                  onStatusChange: function(
+                    webProgress,
+                    request,
+                    status,
+                    message
+                  ) {
+                    if (status != 0) {
+                      resolve(retval == 0 ? "not_saved" : "not_replaced");
+                    }
+                  },
+                  QueryInterface: ChromeUtils.generateQI([
+                    "nsIWebProgressListener",
+                  ]),
+                };
+
+                activeTab.linkedBrowser.print(
+                  activeTab.linkedBrowser.outerWindowID,
+                  printSettings,
+                  printProgressListener
                 );
               } else {
                 // Cancel clicked (retval == 1)

dom/base/nsFrameLoader.cpp

@@ -3118,117 +3118,49 @@ void nsFrameLoader::RequestSHistoryUpdate(bool aImmediately) {
   }
 }
 
-#ifdef NS_PRINTING
+void nsFrameLoader::Print(uint64_t aOuterWindowID,
-class WebProgressListenerToPromise final : public nsIWebProgressListener {
- public:
-  explicit WebProgressListenerToPromise(Promise* aPromise)
-      : mPromise(aPromise) {}
-
-  NS_DECL_ISUPPORTS
-
-  // NS_DECL_NSIWEBPROGRESSLISTENER
-  NS_IMETHOD OnStateChange(nsIWebProgress* aWebProgress, nsIRequest* aRequest,
-                           uint32_t aStateFlags, nsresult aStatus) override {
-    if (aStateFlags & nsIWebProgressListener::STATE_STOP &&
-        aStateFlags & nsIWebProgressListener::STATE_IS_DOCUMENT) {
-      mPromise->MaybeResolveWithUndefined();
-      mPromise = nullptr;
-    }
-    return NS_OK;
-  }
-  NS_IMETHOD OnStatusChange(nsIWebProgress* aWebProgress, nsIRequest* aRequest,
-                            nsresult aStatus,
-                            const char16_t* aMessage) override {
-    if (aStatus != NS_OK) {
-      mPromise->MaybeReject(ErrorResult(aStatus));
-      mPromise = nullptr;
-    }
-    return NS_OK;
-  }
-  NS_IMETHOD OnProgressChange(nsIWebProgress* aWebProgress,
-                              nsIRequest* aRequest, int32_t aCurSelfProgress,
-                              int32_t aMaxSelfProgress,
-                              int32_t aCurTotalProgress,
-                              int32_t aMaxTotalProgress) override {
-    return NS_OK;
-  }
-  NS_IMETHOD OnLocationChange(nsIWebProgress* aWebProgress,
-                              nsIRequest* aRequest, nsIURI* aLocation,
-                              uint32_t aFlags) override {
-    return NS_OK;
-  }
-  NS_IMETHOD OnSecurityChange(nsIWebProgress* aWebProgress,
-                              nsIRequest* aRequest, uint32_t aState) override {
-    return NS_OK;
-  }
-  NS_IMETHOD OnContentBlockingEvent(nsIWebProgress* aWebProgress,
-                                    nsIRequest* aRequest,
-                                    uint32_t aEvent) override {
-    return NS_OK;
-  }
-
- private:
-  ~WebProgressListenerToPromise() = default;
-
-  RefPtr<Promise> mPromise;
-};
-
-NS_IMPL_ISUPPORTS(WebProgressListenerToPromise, nsIWebProgressListener)
-#endif
-
-already_AddRefed<Promise> nsFrameLoader::Print(uint64_t aOuterWindowID,
                           nsIPrintSettings* aPrintSettings,
+                          nsIWebProgressListener* aProgressListener,
                           ErrorResult& aRv) {
-  RefPtr<Promise> promise =
+#if defined(NS_PRINTING)
-      Promise::Create(GetOwnerDoc()->GetOwnerGlobal(), aRv);
-
-#ifndef NS_PRINTING
-  promise->MaybeReject(ErrorResult(NS_ERROR_NOT_AVAILABLE));
-  return promise.forget();
-#else
-
-  RefPtr<WebProgressListenerToPromise> listener(
-      new WebProgressListenerToPromise(promise));
-
   if (auto* browserParent = GetBrowserParent()) {
     RefPtr<embedding::PrintingParent> printingParent =
         browserParent->Manager()->GetPrintingParent();
 
     embedding::PrintData printData;
     nsresult rv = printingParent->SerializeAndEnsureRemotePrintJob(
-        aPrintSettings, listener, nullptr, &printData);
+        aPrintSettings, aProgressListener, nullptr, &printData);
     if (NS_WARN_IF(NS_FAILED(rv))) {
-      promise->MaybeReject(ErrorResult(rv));
+      aRv.Throw(rv);
-      return promise.forget();
+      return;
     }
 
     bool success = browserParent->SendPrint(aOuterWindowID, printData);
     if (!success) {
-      promise->MaybeReject(ErrorResult(NS_ERROR_FAILURE));
+      aRv.Throw(NS_ERROR_FAILURE);
     }
-    return promise.forget();
+    return;
   }
 
   nsGlobalWindowOuter* outerWindow =
       nsGlobalWindowOuter::GetOuterWindowWithId(aOuterWindowID);
   if (NS_WARN_IF(!outerWindow)) {
-    promise->MaybeReject(ErrorResult(NS_ERROR_FAILURE));
+    aRv.Throw(NS_ERROR_FAILURE);
-    return promise.forget();
+    return;
   }
 
   nsCOMPtr<nsIWebBrowserPrint> webBrowserPrint =
       do_GetInterface(ToSupports(outerWindow));
   if (NS_WARN_IF(!webBrowserPrint)) {
-    promise->MaybeReject(ErrorResult(NS_ERROR_FAILURE));
+    aRv.Throw(NS_ERROR_FAILURE);
-    return promise.forget();
+    return;
   }
 
-  nsresult rv = webBrowserPrint->Print(aPrintSettings, listener);
+  nsresult rv = webBrowserPrint->Print(aPrintSettings, aProgressListener);
   if (NS_FAILED(rv)) {
-    promise->MaybeReject(ErrorResult(rv));
+    aRv.Throw(rv);
+    return;
   }
-
-  return promise.forget();
 #endif
 }
 

dom/base/nsFrameLoader.h

@@ -24,7 +24,6 @@
 #include "mozilla/dom/Document.h"
 #include "mozilla/dom/Element.h"
 #include "mozilla/dom/Nullable.h"
-#include "mozilla/dom/Promise.h"
 #include "mozilla/dom/WindowProxyHolder.h"
 #include "mozilla/layers/LayersTypes.h"
 #include "nsCOMPtr.h"
@@ -106,7 +105,6 @@ class nsFrameLoader final : public nsStubMutationObserver,
   typedef mozilla::dom::BrowserBridgeChild BrowserBridgeChild;
   typedef mozilla::dom::BrowsingContext BrowsingContext;
   typedef mozilla::dom::BrowsingContextGroup BrowsingContextGroup;
-  typedef mozilla::dom::Promise Promise;
 
  public:
   // Called by Frame Elements to create a new FrameLoader.
@@ -225,8 +223,8 @@ class nsFrameLoader final : public nsStubMutationObserver,
 
   void RequestSHistoryUpdate(bool aImmediately = false);
 
-  already_AddRefed<Promise> Print(uint64_t aOuterWindowID,
+  void Print(uint64_t aOuterWindowID, nsIPrintSettings* aPrintSettings,
-                                  nsIPrintSettings* aPrintSettings,
+             nsIWebProgressListener* aProgressListener,
              mozilla::ErrorResult& aRv);
 
   void StartPersistence(BrowsingContext* aContext,

dom/chrome-webidl/FrameLoader.webidl

@@ -122,11 +122,12 @@ interface FrameLoader {
    * @param aOuterWindowID the ID of the outer window to print
    * @param aPrintSettings optional print settings to use; printSilent can be
    *                       set to prevent prompting.
-   * @return A Promise that resolves once printing is finished.
+   * @param aProgressListener optional print progress listener.
    */
   [Throws]
-  Promise<void> print(unsigned long long aOuterWindowID,
+  void print(unsigned long long aOuterWindowID,
-                      nsIPrintSettings aPrintSettings);
+             nsIPrintSettings aPrintSettings,
+             optional nsIWebProgressListener? aProgressListener = null);
 
   /**
    * The element which owns this frame loader.

remote/domains/parent/Page.jsm

@@ -617,13 +617,10 @@ class Page extends Domain {
       printSettings.orientation = Ci.nsIPrintSettings.kLandscapeOrientation;
     }
 
-    const { linkedBrowser } = this.session.target.tab;
-
-    await linkedBrowser.print(linkedBrowser.outerWindowID, printSettings);
-
-    // Bug 1603739 - With e10s enabled the promise returned by print() resolves
-    // too early, which means the file hasn't been completely written.
     await new Promise(resolve => {
+      // Bug 1603739 - With e10s enabled the WebProgressListener states
+      // STOP too early, which means the file hasn't been completely written.
+      const waitForFileWritten = () => {
         const DELAY_CHECK_FILE_COMPLETELY_WRITTEN = 100;
 
         let lastSize = 0;
@@ -635,6 +632,26 @@ class Page extends Domain {
           }
           lastSize = fileInfo.size;
         }, DELAY_CHECK_FILE_COMPLETELY_WRITTEN);
+      };
+
+      const printProgressListener = {
+        onStateChange(webProgress, request, flags, status) {
+          if (
+            flags & Ci.nsIWebProgressListener.STATE_STOP &&
+            flags & Ci.nsIWebProgressListener.STATE_IS_NETWORK
+          ) {
+            waitForFileWritten();
+          }
+        },
+        QueryInterface: ChromeUtils.generateQI(["nsIWebProgressListener"]),
+      };
+
+      const { tab } = this.session.target;
+      tab.linkedBrowser.print(
+        tab.linkedBrowser.outerWindowID,
+        printSettings,
+        printProgressListener
+      );
     });
 
     const fp = await OS.File.open(filePath);

testing/marionette/print.js

@@ -104,11 +104,10 @@ print.printToFile = async function(browser, outerWindowID, settings) {
 
   let printSettings = getPrintSettings(settings, filePath);
 
-  await browser.print(outerWindowID, printSettings);
-
-  // Bug 1603739 - With e10s enabled the promise returned by print() resolves
-  // too early, which means the file hasn't been completely written.
   await new Promise(resolve => {
+    // Bug 1603739 - With e10s enabled the WebProgressListener states
+    // STOP too early, which means the file hasn't been completely written.
+    const waitForFileWritten = () => {
       const DELAY_CHECK_FILE_COMPLETELY_WRITTEN = 100;
 
       let lastSize = 0;
@@ -120,6 +119,21 @@ print.printToFile = async function(browser, outerWindowID, settings) {
         }
         lastSize = fileInfo.size;
       }, DELAY_CHECK_FILE_COMPLETELY_WRITTEN);
+    };
+
+    const printProgressListener = {
+      onStateChange(webProgress, request, flags, status) {
+        if (
+          flags & Ci.nsIWebProgressListener.STATE_STOP &&
+          flags & Ci.nsIWebProgressListener.STATE_IS_NETWORK
+        ) {
+          waitForFileWritten();
+        }
+      },
+      QueryInterface: ChromeUtils.generateQI(["nsIWebProgressListener"]),
+    };
+
+    browser.print(outerWindowID, printSettings, printProgressListener);
   });
 
   logger.debug(`PDF output written to ${filePath}`);

toolkit/components/printing/content/printUtils.js

@@ -182,8 +182,6 @@ var PrintUtils = {
       printSettings.docURL = this._originalURL;
     }
 
-    // At some point we should handle the Promise that this returns (report
-    // rejection to telemetry?)
     topBrowser.print(windowID, printSettings);
 
     if (printPreviewIsOpen) {

toolkit/content/widgets/browser-custom-element.js

@@ -1710,12 +1710,16 @@
       };
     }
 
-    print(aOuterWindowID, aPrintSettings) {
+    print(aOuterWindowID, aPrintSettings, aPrintProgressListener) {
       if (!this.frameLoader) {
         throw Components.Exception("No frame loader.", Cr.NS_ERROR_FAILURE);
       }
 
-      return this.frameLoader.print(aOuterWindowID, aPrintSettings);
+      this.frameLoader.print(
+        aOuterWindowID,
+        aPrintSettings,
+        aPrintProgressListener
+      );
     }
 
     async drawSnapshot(x, y, w, h, scale, backgroundColor) {