electron/patches/chromium/printing.patch

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Shelley Vohr <shelley.vohr@gmail.com>
Date: Fri, 7 Jun 2019 13:59:37 -0700
Subject: printing.patch

Add changeset that was previously applied to sources in chromium_src. The
majority of changes originally come from these PRs:
  * https://github.com/electron/electron/pull/1835
  * https://github.com/electron/electron/pull/8596

This patch also fixes callback for manual user cancellation and success.

diff --git a/chrome/browser/printing/print_job.cc b/chrome/browser/printing/print_job.cc
index 0de0532d64897c91ce0f72d165976e12e1dec03e..13167ca3f9c0d4895fecd40ab1e2d397c6e85a0b 100644
--- a/chrome/browser/printing/print_job.cc
+++ b/chrome/browser/printing/print_job.cc
@@ -88,6 +88,7 @@ bool PrintWithReducedRasterization(PrefService* prefs) {
   return base::FeatureList::IsEnabled(features::kPrintWithReducedRasterization);
 }
 
+#if 0
 PrefService* GetPrefsForWebContents(content::WebContents* web_contents) {
   // TODO(thestig): Figure out why crbug.com/1083911 occurred, which is likely
   // because `web_contents` was null. As a result, this section has many more
@@ -96,6 +97,7 @@ PrefService* GetPrefsForWebContents(content::WebContents* web_contents) {
       web_contents ? web_contents->GetBrowserContext() : nullptr;
   return context ? Profile::FromBrowserContext(context)->GetPrefs() : nullptr;
 }
+#endif
 
 #endif  // defined(OS_WIN)
 
@@ -355,8 +357,10 @@ void PrintJob::StartPdfToEmfConversion(
 
   const PrintSettings& settings = document()->settings();
 
+#if 0
   PrefService* prefs = GetPrefsForWebContents(worker_->GetWebContents());
-  bool print_with_reduced_rasterization = PrintWithReducedRasterization(prefs);
+#endif
+  bool print_with_reduced_rasterization = PrintWithReducedRasterization(nullptr);
 
   using RenderMode = PdfRenderSettings::Mode;
   RenderMode mode = print_with_reduced_rasterization
@@ -446,8 +450,10 @@ void PrintJob::StartPdfToPostScriptConversion(
   if (ps_level2) {
     mode = PdfRenderSettings::Mode::POSTSCRIPT_LEVEL2;
   } else {
+#if 0
     PrefService* prefs = GetPrefsForWebContents(worker_->GetWebContents());
-    mode = PrintWithPostScriptType42Fonts(prefs)
+#endif
+    mode = PrintWithPostScriptType42Fonts(nullptr)
                ? PdfRenderSettings::Mode::POSTSCRIPT_LEVEL3_WITH_TYPE42_FONTS
                : PdfRenderSettings::Mode::POSTSCRIPT_LEVEL3;
   }
@@ -504,6 +510,20 @@ void PrintJob::OnPageDone(PrintedPage* page) {
 }
 #endif  // defined(OS_WIN)
 
+void PrintJob::OnUserInitCancelled() {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  // Make sure a `Cancel()` is broadcast.
+  auto details = base::MakeRefCounted<JobEventDetails>(JobEventDetails::USER_INIT_CANCELED,
+                                                       0, nullptr);
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_PRINT_JOB_EVENT, content::Source<PrintJob>(this),
+      content::Details<JobEventDetails>(details.get()));
+
+  for (auto& observer : observers_) {
+    observer.OnUserInitCancelled();
+  }
+}
+
 void PrintJob::OnFailed() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
diff --git a/chrome/browser/printing/print_job.h b/chrome/browser/printing/print_job.h
index e19f62354edb8acad722c6680296b7d2f55f51fe..b5539171655d78634ee89faf3516d23ce5718353 100644
--- a/chrome/browser/printing/print_job.h
+++ b/chrome/browser/printing/print_job.h
@@ -53,6 +53,7 @@ class PrintJob : public base::RefCountedThreadSafe<PrintJob> {
    public:
     virtual void OnDocDone(int job_id, PrintedDocument* document) {}
     virtual void OnJobDone() {}
+    virtual void OnUserInitCancelled() {}
     virtual void OnFailed() {}
   };
 
@@ -100,6 +101,9 @@ class PrintJob : public base::RefCountedThreadSafe<PrintJob> {
   // Called when the document is done printing.
   virtual void OnDocDone(int job_id, PrintedDocument* document);
 
+  // Called if the user cancels the print job.
+  virtual void OnUserInitCancelled();
+
   // Called if the document fails to print.
   virtual void OnFailed();
 
@@ -257,6 +261,9 @@ class JobEventDetails : public base::RefCountedThreadSafe<JobEventDetails> {
  public:
   // Event type.
   enum Type {
+    // Print... dialog box has been closed with CANCEL button.
+    USER_INIT_CANCELED,
+
     // A new document started printing.
     NEW_DOC,
 
diff --git a/chrome/browser/printing/print_job_worker.cc b/chrome/browser/printing/print_job_worker.cc
index d8f67ab5116483eb2eeb4cc09f19bbcbccb74b37..b4ab0984765c9711ddacf32f7147108cdfbc5096 100644
--- a/chrome/browser/printing/print_job_worker.cc
+++ b/chrome/browser/printing/print_job_worker.cc
@@ -20,13 +20,13 @@
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/printing/print_job.h"
-#include "chrome/grit/generated_resources.h"
 #include "components/crash/core/common/crash_keys.h"
 #include "components/device_event_log/device_event_log.h"
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
+#include "electron/grit/electron_resources.h"
 #include "printing/backend/print_backend.h"
 #include "printing/buildflags/buildflags.h"
 #include "printing/mojom/print.mojom.h"
@@ -125,6 +125,10 @@ void FailedNotificationCallback(PrintJob* print_job) {
   print_job->OnFailed();
 }
 
+void UserInitCancelledNotificationCallback(PrintJob* print_job) {
+  print_job->OnUserInitCancelled();
+}
+
 #if defined(OS_WIN)
 void PageNotificationCallback(PrintJob* print_job, PrintedPage* page) {
   print_job->OnPageDone(page);
@@ -245,16 +249,21 @@ void PrintJobWorker::UpdatePrintSettings(base::Value new_settings,
 #endif  // defined(OS_LINUX) && defined(USE_CUPS)
   }
 
-  mojom::ResultCode result;
   {
 #if defined(OS_WIN)
     // Blocking is needed here because Windows printer drivers are oftentimes
     // not thread-safe and have to be accessed on the UI thread.
     base::ScopedAllowBlocking allow_blocking;
 #endif
-    result = printing_context_->UpdatePrintSettings(std::move(new_settings));
+    // Reset settings from previous print job
+    printing_context_->ResetSettings();
+    mojom::ResultCode get_default_result = printing_context_->UseDefaultSettings();
+    if (get_default_result == mojom::ResultCode::kSuccess) {
+      mojom::ResultCode update_result =
+              printing_context_->UpdatePrintSettings(std::move(new_settings));
+      GetSettingsDone(std::move(callback), update_result);
+    }
   }
-  GetSettingsDone(std::move(callback), result);
 }
 
 #if defined(OS_CHROMEOS)
@@ -270,6 +279,12 @@ void PrintJobWorker::UpdatePrintSettingsFromPOD(
 
 void PrintJobWorker::GetSettingsDone(SettingsCallback callback,
                                      mojom::ResultCode result) {
+  if (result == mojom::ResultCode::kCanceled) {
+    print_job_->PostTask(
+      FROM_HERE,
+      base::BindOnce(&UserInitCancelledNotificationCallback,
+                                      base::RetainedRef(print_job_.get())));
+  }
   std::move(callback).Run(printing_context_->TakeAndResetSettings(), result);
 }
 
diff --git a/chrome/browser/printing/print_view_manager_base.cc b/chrome/browser/printing/print_view_manager_base.cc
index c9f1502da55d89de0eede73a7d39047c090594d0..1320afa83016ea72e5dbc23b1ed63cf91d439102 100644
--- a/chrome/browser/printing/print_view_manager_base.cc
+++ b/chrome/browser/printing/print_view_manager_base.cc
@@ -29,10 +29,10 @@
 #include "chrome/browser/printing/print_view_manager_common.h"
 #include "chrome/browser/printing/printer_query.h"
 #include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/ui/simple_message_box.h"
-#include "chrome/browser/ui/webui/print_preview/printer_handler.h"
 #include "chrome/common/pref_names.h"
+#if 0
 #include "chrome/grit/generated_resources.h"
+#endif
 #include "components/prefs/pref_service.h"
 #include "components/printing/browser/print_composite_client.h"
 #include "components/printing/browser/print_manager_utils.h"
@@ -47,6 +47,7 @@
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
+#include "electron/grit/electron_resources.h"
 #include "mojo/public/cpp/system/buffer.h"
 #include "printing/buildflags/buildflags.h"
 #include "printing/metafile_skia.h"
@@ -110,6 +111,8 @@ crosapi::mojom::PrintJobPtr PrintJobToMojom(int job_id,
 #endif
 
 void ShowWarningMessageBox(const std::u16string& message) {
+  LOG(ERROR) << "Invalid printer settings " << message;
+#if 0
   // Runs always on the UI thread.
   static bool is_dialog_shown = false;
   if (is_dialog_shown)
@@ -118,6 +121,7 @@ void ShowWarningMessageBox(const std::u16string& message) {
   base::AutoReset<bool> auto_reset(&is_dialog_shown, true);
 
   chrome::ShowWarningMessageBox(nullptr, std::u16string(), message);
+#endif
 }
 
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
@@ -217,7 +221,9 @@ void UpdatePrintSettingsReplyOnIO(
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(printer_query);
   mojom::PrintPagesParamsPtr params = CreateEmptyPrintPagesParamsPtr();
-  if (printer_query->last_status() == mojom::ResultCode::kSuccess) {
+  // We call update without first printing from defaults,
+  // so the last printer status will still be defaulted to PrintingContext::FAILED
+  if (printer_query) {
     RenderParamsFromPrintSettings(printer_query->settings(),
                                   params->params.get());
     params->params->document_cookie = printer_query->cookie();
@@ -319,12 +325,14 @@ PrintViewManagerBase::PrintViewManagerBase(content::WebContents* web_contents)
     : PrintManager(web_contents),
       queue_(g_browser_process->print_job_manager()->queue()) {
   DCHECK(queue_);
+#if 0 // Printing is always enabled.
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   printing_enabled_.Init(
       prefs::kPrintingEnabled, profile->GetPrefs(),
       base::BindRepeating(&PrintViewManagerBase::UpdatePrintingEnabled,
                           weak_ptr_factory_.GetWeakPtr()));
+#endif
 }
 
 PrintViewManagerBase::~PrintViewManagerBase() {
@@ -332,7 +340,10 @@ PrintViewManagerBase::~PrintViewManagerBase() {
   DisconnectFromCurrentPrintJob();
 }
 
-bool PrintViewManagerBase::PrintNow(content::RenderFrameHost* rfh) {
+bool PrintViewManagerBase::PrintNow(content::RenderFrameHost* rfh,
+                                    bool silent,
+                                    base::Value settings,
+                                    CompletionCallback callback)  {
   auto weak_this = weak_ptr_factory_.GetWeakPtr();
   DisconnectFromCurrentPrintJob();
   if (!weak_this)
@@ -347,7 +358,13 @@ bool PrintViewManagerBase::PrintNow(content::RenderFrameHost* rfh) {
   // go in `ReleasePrintJob()`.
 
   SetPrintingRFH(rfh);
-  GetPrintRenderFrame(rfh)->PrintRequestedPages();
+  callback_ = std::move(callback);
+
+  if (!callback_.is_null()) {
+    print_job_->AddObserver(*this);
+  }
+
+  GetPrintRenderFrame(rfh)->PrintRequestedPages(silent, std::move(settings));
 
   for (auto& observer : GetObservers())
     observer.OnPrintNow(rfh);
@@ -506,9 +523,9 @@ void PrintViewManagerBase::ScriptedPrintReply(
 void PrintViewManagerBase::UpdatePrintingEnabled() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   // The Unretained() is safe because ForEachFrame() is synchronous.
-  web_contents()->ForEachFrame(base::BindRepeating(
-      &PrintViewManagerBase::SendPrintingEnabled, base::Unretained(this),
-      printing_enabled_.GetValue()));
+  web_contents()->ForEachFrame(
+      base::BindRepeating(&PrintViewManagerBase::SendPrintingEnabled,
+                          base::Unretained(this), true));
 }
 
 void PrintViewManagerBase::NavigationStopped() {
@@ -622,12 +639,13 @@ void PrintViewManagerBase::DidPrintDocument(
 void PrintViewManagerBase::GetDefaultPrintSettings(
     GetDefaultPrintSettingsCallback callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+#if 0 // Printing is always enabled.
   if (!printing_enabled_.GetValue()) {
     GetDefaultPrintSettingsReply(std::move(callback),
                                  mojom::PrintParams::New());
     return;
   }
-
+#endif
   content::RenderFrameHost* render_frame_host = GetCurrentTargetFrame();
   auto callback_wrapper =
       base::BindOnce(&PrintViewManagerBase::GetDefaultPrintSettingsReply,
@@ -645,18 +663,20 @@ void PrintViewManagerBase::UpdatePrintSettings(
     base::Value job_settings,
     UpdatePrintSettingsCallback callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+#if 0 // Printing is always enabled.
   if (!printing_enabled_.GetValue()) {
     UpdatePrintSettingsReply(std::move(callback),
                              CreateEmptyPrintPagesParamsPtr(), false);
     return;
   }
-
+#endif
   if (!job_settings.FindIntKey(kSettingPrinterType)) {
     UpdatePrintSettingsReply(std::move(callback),
                              CreateEmptyPrintPagesParamsPtr(), false);
     return;
   }
 
+#if 0
   content::BrowserContext* context =
       web_contents() ? web_contents()->GetBrowserContext() : nullptr;
   PrefService* prefs =
@@ -666,6 +686,7 @@ void PrintViewManagerBase::UpdatePrintSettings(
     if (value > 0)
       job_settings.SetIntKey(kSettingRasterizePdfDpi, value);
   }
+#endif
 
   auto callback_wrapper =
       base::BindOnce(&PrintViewManagerBase::UpdatePrintSettingsReply,
@@ -714,7 +735,6 @@ void PrintViewManagerBase::PrintingFailed(int32_t cookie) {
   PrintManager::PrintingFailed(cookie);
 
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
-  ShowPrintErrorDialog();
 #endif
 
   ReleasePrinterQuery();
@@ -729,6 +749,11 @@ void PrintViewManagerBase::RemoveObserver(Observer& observer) {
 }
 
 void PrintViewManagerBase::ShowInvalidPrinterSettingsError() {
+  if (!callback_.is_null()) {
+    std::string cb_str = "Invalid printer settings";
+    std::move(callback_).Run(printing_succeeded_, cb_str);
+  }
+
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::BindOnce(&ShowWarningMessageBox,
                                 l10n_util::GetStringUTF16(
@@ -739,8 +764,10 @@ void PrintViewManagerBase::RenderFrameHostStateChanged(
     content::RenderFrameHost* render_frame_host,
     content::RenderFrameHost::LifecycleState /*old_state*/,
     content::RenderFrameHost::LifecycleState new_state) {
+#if 0 // Printing is always enabled.
   if (new_state == content::RenderFrameHost::LifecycleState::kActive)
     SendPrintingEnabled(printing_enabled_.GetValue(), render_frame_host);
+#endif
 }
 
 void PrintViewManagerBase::DidStartLoading() {
@@ -808,6 +835,11 @@ void PrintViewManagerBase::OnJobDone() {
   ReleasePrintJob();
 }
 
+void PrintViewManagerBase::OnUserInitCancelled() {
+  printing_cancelled_ = true;
+  ReleasePrintJob();
+}
+
 void PrintViewManagerBase::OnFailed() {
   TerminatePrintJob(true);
 }
@@ -869,7 +901,10 @@ bool PrintViewManagerBase::CreateNewPrintJob(
 
   // Disconnect the current |print_job_|.
   auto weak_this = weak_ptr_factory_.GetWeakPtr();
-  DisconnectFromCurrentPrintJob();
+  if (callback_.is_null()) {
+    // Disconnect the current |print_job_| only when calling window.print()
+    DisconnectFromCurrentPrintJob();
+  }
   if (!weak_this)
     return false;
 
@@ -891,8 +926,6 @@ bool PrintViewManagerBase::CreateNewPrintJob(
                             : PrintJob::Source::PRINT_PREVIEW,
                         /*source_id=*/"");
 #endif
-  print_job_->AddObserver(*this);
-
   printing_succeeded_ = false;
   return true;
 }
@@ -944,14 +977,21 @@ void PrintViewManagerBase::ReleasePrintJob() {
   content::RenderFrameHost* rfh = printing_rfh_;
   printing_rfh_ = nullptr;
 
+  if (!callback_.is_null()) {
+    print_job_->RemoveObserver(*this);
+
+    std::string cb_str = "";
+    if (!printing_succeeded_)
+      cb_str = printing_cancelled_ ? "cancelled" : "failed";
+    std::move(callback_).Run(printing_succeeded_, cb_str);
+  }
+
   if (!print_job_)
     return;
 
   if (rfh)
     GetPrintRenderFrame(rfh)->PrintingDone(printing_succeeded_);
 
-  print_job_->RemoveObserver(*this);
-
   // Don't close the worker thread.
   print_job_ = nullptr;
 }
@@ -989,7 +1029,7 @@ bool PrintViewManagerBase::RunInnerMessageLoop() {
 }
 
 bool PrintViewManagerBase::OpportunisticallyCreatePrintJob(int cookie) {
-  if (print_job_)
+  if (print_job_ && print_job_->document())
     return true;
 
   if (!cookie) {
diff --git a/chrome/browser/printing/print_view_manager_base.h b/chrome/browser/printing/print_view_manager_base.h
index 5771a3ebd76145c6cf8a2ccc33abc886802ed59f..1562d6331a9cafd530db42c436e878bac427566d 100644
--- a/chrome/browser/printing/print_view_manager_base.h
+++ b/chrome/browser/printing/print_view_manager_base.h
@@ -37,6 +37,8 @@ namespace printing {
 class PrintQueriesQueue;
 class PrinterQuery;
 
+using CompletionCallback = base::OnceCallback<void(bool, const std::string&)>;
+
 // Base class for managing the print commands for a WebContents.
 class PrintViewManagerBase : public PrintManager, public PrintJob::Observer {
  public:
@@ -58,7 +60,10 @@ class PrintViewManagerBase : public PrintManager, public PrintJob::Observer {
   // Prints the current document immediately. Since the rendering is
   // asynchronous, the actual printing will not be completed on the return of
   // this function. Returns false if printing is impossible at the moment.
-  virtual bool PrintNow(content::RenderFrameHost* rfh);
+  virtual bool PrintNow(content::RenderFrameHost* rfh,
+                        bool silent,
+                        base::Value settings,
+                        CompletionCallback callback);
 
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
   // Prints the document in |print_data| with settings specified in
@@ -143,6 +148,7 @@ class PrintViewManagerBase : public PrintManager, public PrintJob::Observer {
   // PrintJob::Observer overrides:
   void OnDocDone(int job_id, PrintedDocument* document) override;
   void OnJobDone() override;
+  void OnUserInitCancelled() override;
   void OnFailed() override;
 
   base::ObserverList<Observer>& GetObservers() { return observers_; }
@@ -252,9 +258,15 @@ class PrintViewManagerBase : public PrintManager, public PrintJob::Observer {
   // The current RFH that is printing with a system printing dialog.
   raw_ptr<content::RenderFrameHost> printing_rfh_ = nullptr;
 
+  // Respond with success of the print job.
+  CompletionCallback callback_;
+
   // Indication of success of the print job.
   bool printing_succeeded_ = false;
 
+  // Indication of whether the print job was manually cancelled
+  bool printing_cancelled_ = false;
+
   // Set while running an inner message loop inside RenderAllMissingPagesNow().
   // This means we are _blocking_ until all the necessary pages have been
   // rendered or the print settings are being loaded.
diff --git a/components/printing/common/print.mojom b/components/printing/common/print.mojom
index 51ebcb4ae399018d3fd8566656596a7ef1f148af..5f2b807fc364131f4c3e6a1646ec522ddc826d9c 100644
--- a/components/printing/common/print.mojom
+++ b/components/printing/common/print.mojom
@@ -274,7 +274,7 @@ interface PrintPreviewUI {
 interface PrintRenderFrame {
   // Tells the RenderFrame to switch the CSS to print media type, render every
   // requested page, and then switch back the CSS to display media type.
-  PrintRequestedPages();
+  PrintRequestedPages(bool silent, mojo_base.mojom.DictionaryValue settings);
 
   // Tells the RenderFrame to switch the CSS to print media type, render every
   // requested page using the print preview document's frame/node, and then
diff --git a/components/printing/renderer/print_render_frame_helper.cc b/components/printing/renderer/print_render_frame_helper.cc
index 650b5550f982fa5c5c522efaa9b8e305b7edc5e7..260b5521dccadf07eba2c67fa3d9c3da80b49104 100644
--- a/components/printing/renderer/print_render_frame_helper.cc
+++ b/components/printing/renderer/print_render_frame_helper.cc
@@ -39,6 +39,7 @@
 #include "printing/metafile_skia.h"
 #include "printing/mojom/print.mojom.h"
 #include "printing/print_job_constants.h"
+#include "printing/print_settings.h"
 #include "printing/units.h"
 #include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
 #include "third_party/blink/public/common/associated_interfaces/associated_interface_registry.h"
@@ -1226,7 +1227,8 @@ void PrintRenderFrameHelper::ScriptedPrint(bool user_initiated) {
     if (!weak_this)
       return;
 
-    Print(web_frame, blink::WebNode(), PrintRequestType::kScripted);
+    Print(web_frame, blink::WebNode(), PrintRequestType::kScripted,
+          false /* silent */, base::DictionaryValue() /* new_settings */);
     if (!weak_this)
       return;
 
@@ -1257,7 +1259,7 @@ void PrintRenderFrameHelper::BindPrintRenderFrameReceiver(
   receivers_.Add(this, std::move(receiver));
 }
 
-void PrintRenderFrameHelper::PrintRequestedPages() {
+void PrintRenderFrameHelper::PrintRequestedPages(bool silent, base::Value settings) {
   ScopedIPC scoped_ipc(weak_ptr_factory_.GetWeakPtr());
   if (ipc_nesting_level_ > kAllowedIpcDepthForPrint)
     return;
@@ -1272,7 +1274,7 @@ void PrintRenderFrameHelper::PrintRequestedPages() {
   // plugin node and print that instead.
   auto plugin = delegate_->GetPdfElement(frame);
 
-  Print(frame, plugin, PrintRequestType::kRegular);
+  Print(frame, plugin, PrintRequestType::kRegular, silent, std::move(settings));
 
   if (!render_frame_gone_)
     frame->DispatchAfterPrintEvent();
@@ -1303,7 +1305,8 @@ void PrintRenderFrameHelper::PrintForSystemDialog() {
   }
 
   Print(frame, print_preview_context_.source_node(),
-        PrintRequestType::kRegular);
+        PrintRequestType::kRegular, false,
+        base::DictionaryValue());
   if (!render_frame_gone_)
     print_preview_context_.DispatchAfterPrintEvent();
   // WARNING: |this| may be gone at this point. Do not do any more work here and
@@ -1350,6 +1353,8 @@ void PrintRenderFrameHelper::PrintPreview(base::Value settings) {
   if (ipc_nesting_level_ > kAllowedIpcDepthForPrint)
     return;
 
+  blink::WebLocalFrame* frame = render_frame()->GetWebFrame();
+  print_preview_context_.InitWithFrame(frame);
   print_preview_context_.OnPrintPreview();
 
   if (print_preview_context_.IsForArc()) {
@@ -1886,7 +1891,8 @@ void PrintRenderFrameHelper::PrintNode(const blink::WebNode& node) {
       return;
 
     Print(duplicate_node.GetDocument().GetFrame(), duplicate_node,
-          PrintRequestType::kRegular);
+          PrintRequestType::kRegular, false /* silent */,
+          base::DictionaryValue() /* new_settings */);
     // Check if |this| is still valid.
     if (!weak_this)
       return;
@@ -1901,7 +1907,9 @@ void PrintRenderFrameHelper::PrintNode(const blink::WebNode& node) {
 
 void PrintRenderFrameHelper::Print(blink::WebLocalFrame* frame,
                                    const blink::WebNode& node,
-                                   PrintRequestType print_request_type) {
+                                   PrintRequestType print_request_type,
+                                   bool silent,
+                                   base::Value settings) {
   // If still not finished with earlier print request simply ignore.
   if (prep_frame_view_)
     return;
@@ -1909,7 +1917,7 @@ void PrintRenderFrameHelper::Print(blink::WebLocalFrame* frame,
   FrameReference frame_ref(frame);
 
   uint32_t expected_page_count = 0;
-  if (!CalculateNumberOfPages(frame, node, &expected_page_count)) {
+  if (!CalculateNumberOfPages(frame, node, &expected_page_count, base::Value::AsDictionaryValue(settings))) {
     DidFinishPrinting(FAIL_PRINT_INIT);
     return;  // Failed to init print page settings.
   }
@@ -1928,8 +1936,15 @@ void PrintRenderFrameHelper::Print(blink::WebLocalFrame* frame,
         print_pages_params_->params->print_scaling_option;
 
     auto self = weak_ptr_factory_.GetWeakPtr();
-    mojom::PrintPagesParamsPtr print_settings = GetPrintSettingsFromUser(
+    mojom::PrintPagesParamsPtr print_settings;
+
+    if (silent) {
+      print_settings = mojom::PrintPagesParams::New();
+      print_settings->params = print_pages_params_->params->Clone();
+    } else {
+      print_settings = GetPrintSettingsFromUser(
         frame_ref.GetFrame(), node, expected_page_count, print_request_type);
+    }
     // Check if |this| is still valid.
     if (!self)
       return;
@@ -2177,36 +2192,51 @@ void PrintRenderFrameHelper::IPCProcessed() {
   }
 }
 
-bool PrintRenderFrameHelper::InitPrintSettings(bool fit_to_paper_size) {
-  mojom::PrintPagesParams settings;
-  settings.params = mojom::PrintParams::New();
-  GetPrintManagerHost()->GetDefaultPrintSettings(&settings.params);
+bool PrintRenderFrameHelper::InitPrintSettings(
+    bool fit_to_paper_size,
+    const base::DictionaryValue& new_settings) {
+  mojom::PrintPagesParamsPtr settings;
+
+  if (new_settings.DictEmpty()) {
+    settings = mojom::PrintPagesParams::New();
+    settings->params = mojom::PrintParams::New();
+    GetPrintManagerHost()->GetDefaultPrintSettings(&settings->params);
+  } else {
+    bool canceled = false;
+    int cookie =
+      print_pages_params_ ? print_pages_params_->params->document_cookie : 0;
+    GetPrintManagerHost()->UpdatePrintSettings(cookie, new_settings.Clone(), &settings, &canceled);
+    if (canceled)
+      return false;
+  }
 
   // Check if the printer returned any settings, if the settings is empty, we
   // can safely assume there are no printer drivers configured. So we safely
   // terminate.
   bool result = true;
-  if (!PrintMsg_Print_Params_IsValid(*settings.params))
+  if (!PrintMsg_Print_Params_IsValid(*settings->params))
     result = false;
 
   // Reset to default values.
   ignore_css_margins_ = false;
-  settings.pages.clear();
+  settings->pages.clear();
 
-  settings.params->print_scaling_option =
+  settings->params->print_scaling_option =
       fit_to_paper_size ? mojom::PrintScalingOption::kFitToPrintableArea
                         : mojom::PrintScalingOption::kSourceSize;
 
-  SetPrintPagesParams(settings);
+  SetPrintPagesParams(*settings);
   return result;
 }
 
-bool PrintRenderFrameHelper::CalculateNumberOfPages(blink::WebLocalFrame* frame,
-                                                    const blink::WebNode& node,
-                                                    uint32_t* number_of_pages) {
+bool PrintRenderFrameHelper::CalculateNumberOfPages(
+    blink::WebLocalFrame* frame,
+    const blink::WebNode& node,
+    uint32_t* number_of_pages,
+    const base::DictionaryValue& settings) {
   DCHECK(frame);
   bool fit_to_paper_size = !IsPrintingNodeOrPdfFrame(frame, node);
-  if (!InitPrintSettings(fit_to_paper_size)) {
+  if (!InitPrintSettings(fit_to_paper_size, settings)) {
     notify_browser_of_print_failure_ = false;
     GetPrintManagerHost()->ShowInvalidPrinterSettingsError();
     return false;
@@ -2579,18 +2609,7 @@ void PrintRenderFrameHelper::RequestPrintPreview(PrintPreviewRequestType type) {
 }
 
 bool PrintRenderFrameHelper::CheckForCancel() {
-  const mojom::PrintParams& print_params = *print_pages_params_->params;
-  bool cancel = false;
-
-  if (!GetPrintManagerHost()->CheckForCancel(print_params.preview_ui_id,
-                                             print_params.preview_request_id,
-                                             &cancel)) {
-    cancel = true;
-  }
-
-  if (cancel)
-    notify_browser_of_print_failure_ = false;
-  return cancel;
+  return false;
 }
 
 bool PrintRenderFrameHelper::PreviewPageRendered(
diff --git a/components/printing/renderer/print_render_frame_helper.h b/components/printing/renderer/print_render_frame_helper.h
index 90236920457c931c86426049c6cbc30b592b597f..353178863eba37b9112e784ffa4b3519076e91b9 100644
--- a/components/printing/renderer/print_render_frame_helper.h
+++ b/components/printing/renderer/print_render_frame_helper.h
@@ -256,7 +256,7 @@ class PrintRenderFrameHelper
       mojo::PendingAssociatedReceiver<mojom::PrintRenderFrame> receiver);
 
   // printing::mojom::PrintRenderFrame:
-  void PrintRequestedPages() override;
+  void PrintRequestedPages(bool silent, base::Value settings) override;
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
   void PrintForSystemDialog() override;
   void SetPrintPreviewUI(
@@ -323,7 +323,9 @@ class PrintRenderFrameHelper
   // WARNING: |this| may be gone after this method returns.
   void Print(blink::WebLocalFrame* frame,
              const blink::WebNode& node,
-             PrintRequestType print_request_type);
+             PrintRequestType print_request_type,
+             bool silent,
+             base::Value settings);
 
   // Notification when printing is done - signal tear-down/free resources.
   void DidFinishPrinting(PrintingResult result);
@@ -332,12 +334,14 @@ class PrintRenderFrameHelper
 
   // Initialize print page settings with default settings.
   // Used only for native printing workflow.
-  bool InitPrintSettings(bool fit_to_paper_size);
+  bool InitPrintSettings(bool fit_to_paper_size,
+                         const base::DictionaryValue& settings);
 
   // Calculate number of pages in source document.
   bool CalculateNumberOfPages(blink::WebLocalFrame* frame,
                               const blink::WebNode& node,
-                              uint32_t* number_of_pages);
+                              uint32_t* number_of_pages,
+                              const base::DictionaryValue& settings);
 
 #if BUILDFLAG(ENABLE_PRINT_PREVIEW)
   // Set options for print preset from source PDF document.
diff --git a/printing/printing_context.cc b/printing/printing_context.cc
index f8f0f4bdfbb8db883f883f62f9d6e4b987d7b113..c2505f5e0049dc7ee8783056538ca4c2d0968744 100644
--- a/printing/printing_context.cc
+++ b/printing/printing_context.cc
@@ -120,7 +120,6 @@ mojom::ResultCode PrintingContext::UsePdfSettings() {
 
 mojom::ResultCode PrintingContext::UpdatePrintSettings(
     base::Value job_settings) {
-  ResetSettings();
   {
     std::unique_ptr<PrintSettings> settings =
         PrintSettingsFromJobSettings(job_settings);
diff --git a/printing/printing_context.h b/printing/printing_context.h
index 7d937e7e3f19df351d410185fc4dc3b7c8937f2e..e87170e6957733f06bcc296bcca3fc331557ed46 100644
--- a/printing/printing_context.h
+++ b/printing/printing_context.h
@@ -175,6 +175,9 @@ class COMPONENT_EXPORT(PRINTING) PrintingContext {
 
   std::unique_ptr<PrintSettings> TakeAndResetSettings();
 
+  // Reinitializes the settings for object reuse.
+  void ResetSettings();
+
   int job_id() const { return job_id_; }
 
  protected:
@@ -185,9 +188,6 @@ class COMPONENT_EXPORT(PRINTING) PrintingContext {
   static std::unique_ptr<PrintingContext> CreateImpl(Delegate* delegate,
                                                      bool skip_system_calls);
 
-  // Reinitializes the settings for object reuse.
-  void ResetSettings();
-
   // Determine if system calls should be skipped by this instance.
   bool skip_system_calls() const {
 #if BUILDFLAG(ENABLE_OOP_PRINTING)