chore: backport printing changes (#15023, #15143) to 4-0-x (#15976)

* refactor: move printing out of chromium_src (#15023) * remove printing related things from chromium_src * chore: add printing build flag and patch * fix: include PrintingService on other platforms too * fix: printing_handler is only needed on Windows * fix: format BUILD.gn properly * fix: rename printing build flag to avoid conflict with chromium * fix: place previously missed printing calls behind build flag * fix: accidentally renamed flag in patch file * fix: don't include all printing strings * fix: allow ShowItemInFolder and OpenItem to block, fixing a DCHECK crash * fix: make things compile, some changes got lost while rebasing * fix: remove rogue line from BUILD.gn * chore: update patch description * style: lint fix * chore: use chromium printing buildflag, move node related stuff out of patch * revert: remove ScopedAllowBlockingForTesting call * fix: fix my rebase blooper * fix: re-add header lost during rebase, update patch * fix: add <map> include, tweak the patch a bit * revert: remove rogue diff from patch * fix: clean up after rebase * refactor: printing implementation (#15143) * refactor: basic printing * move build files to chromium_src/BUILD.gn * remove dependency on chrome prerender sources * spec: move printing specs behind feature flag * build: register pdf compositor service * chore: cleanup api usage from //chrome
2026-04-10 03:01:51 -04:00 · 2018-12-17 12:26:32 -08:00
parent bc68c26c9b
commit f6fa88ac23
66 changed files with 1551 additions and 7534 deletions
--- a/atom/browser/api/atom_api_app.cc
+++ b/atom/browser/api/atom_api_app.cc
@@ -23,7 +23,6 @@
 #include "atom/common/native_mate_converters/net_converter.h"
 #include "atom/common/native_mate_converters/network_converter.h"
 #include "atom/common/native_mate_converters/value_converter.h"
-#include "atom/common/node_includes.h"
 #include "atom/common/options_switches.h"
 #include "base/command_line.h"
 #include "base/environment.h"
@@ -54,6 +53,12 @@
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/image/image.h"

+// clang-format off
+// This header should be declared at the end to avoid
+// redefinition errors.
+#include "atom/common/node_includes.h"  // NOLINT(build/include_alpha)
+// clang-format on
+
 #if defined(OS_WIN)
 #include "atom/browser/ui/win/jump_list.h"
 #include "base/strings/utf_string_conversions.h"
--- a/atom/browser/api/atom_api_web_contents.cc
+++ b/atom/browser/api/atom_api_web_contents.cc
@@ -52,8 +52,6 @@
 #include "brightray/browser/inspectable_web_contents.h"
 #include "brightray/browser/inspectable_web_contents_view.h"
 #include "chrome/browser/browser_process.h"
-#include "chrome/browser/printing/print_preview_message_handler.h"
-#include "chrome/browser/printing/print_view_manager_basic.h"
 #include "chrome/browser/ssl/security_state_tab_helper.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/render_frame_host_manager.h"
@@ -102,34 +100,16 @@
 #include "ui/gfx/font_render_params.h"
 #endif

+#if BUILDFLAG(ENABLE_PRINTING)
+#include "chrome/browser/printing/print_view_manager_basic.h"
+#include "components/printing/common/print_messages.h"
+#endif
+
 #include "atom/common/node_includes.h"

-namespace {
-
-struct PrintSettings {
-  bool silent;
-  bool print_background;
-  base::string16 device_name;
-};
-}  // namespace
-
 namespace mate {

-template <>
-struct Converter<PrintSettings> {
-  static bool FromV8(v8::Isolate* isolate,
-                     v8::Local<v8::Value> val,
-                     PrintSettings* out) {
-    mate::Dictionary dict;
-    if (!ConvertFromV8(isolate, val, &dict))
-      return false;
-    dict.Get("silent", &(out->silent));
-    dict.Get("printBackground", &(out->print_background));
-    dict.Get("deviceName", &(out->device_name));
-    return true;
-  }
-};
-
+#if BUILDFLAG(ENABLE_PRINTING)
 template <>
 struct Converter<printing::PrinterBasicInfo> {
  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
@@ -143,6 +123,7 @@ struct Converter<printing::PrinterBasicInfo> {
    return dict.GetHandle();
  }
 };
+#endif

 template <>
 struct Converter<WindowOpenDisposition> {
@@ -1472,40 +1453,58 @@ bool WebContents::IsDOMReady() const {
  return is_dom_ready_;
 }

+#if BUILDFLAG(ENABLE_PRINTING)
 void WebContents::Print(mate::Arguments* args) {
-  PrintSettings settings = {false, false, base::string16()};
-  if (args->Length() >= 1 && !args->GetNext(&settings)) {
-    args->ThrowError();
+  bool silent, print_background = false;
+  base::string16 device_name;
+  mate::Dictionary options = mate::Dictionary::CreateEmpty(args->isolate());
+  base::DictionaryValue settings;
+  if (args->Length() >= 1 && !args->GetNext(&options)) {
+    args->ThrowError("Invalid print settings specified");
    return;
  }
-  auto* print_view_manager_basic_ptr =
-      printing::PrintViewManagerBasic::FromWebContents(web_contents());
-  if (args->Length() == 2) {
-    base::Callback<void(bool)> callback;
-    if (!args->GetNext(&callback)) {
-      args->ThrowError();
-      return;
-    }
-    print_view_manager_basic_ptr->SetCallback(callback);
+  printing::CompletionCallback callback;
+  if (args->Length() == 2 && !args->GetNext(&callback)) {
+    args->ThrowError("Invalid optional callback provided");
+    return;
  }
-  print_view_manager_basic_ptr->PrintNow(
-      web_contents()->GetMainFrame(), settings.silent,
-      settings.print_background, settings.device_name);
+  options.Get("silent", &silent);
+  options.Get("printBackground", &print_background);
+  if (options.Get("deviceName", &device_name) && !device_name.empty()) {
+    settings.SetString(printing::kSettingDeviceName, device_name);
+  }
+  auto* print_view_manager =
+      printing::PrintViewManagerBasic::FromWebContents(web_contents());
+  auto* focused_frame = web_contents()->GetFocusedFrame();
+  auto* rfh = focused_frame && focused_frame->HasSelection()
+                  ? focused_frame
+                  : web_contents()->GetMainFrame();
+  print_view_manager->PrintNow(
+      rfh,
+      std::make_unique<PrintMsg_PrintPages>(rfh->GetRoutingID(), silent,
+                                            print_background, settings),
+      std::move(callback));
 }

 std::vector<printing::PrinterBasicInfo> WebContents::GetPrinterList() {
  std::vector<printing::PrinterBasicInfo> printers;
-  auto print_backend = printing::PrintBackend::CreateInstance(nullptr);
-  base::ThreadRestrictions::ScopedAllowIO allow_io;
-  print_backend->EnumeratePrinters(&printers);
+  {
+    // TODO(deepak1556): Deprecate this api in favor of an
+    // async version and post a non blocing task call.
+    base::ThreadRestrictions::ScopedAllowIO allow_io;
+    auto print_backend = printing::PrintBackend::CreateInstance(nullptr);
+    print_backend->EnumeratePrinters(&printers);
+  }
  return printers;
 }

-void WebContents::PrintToPDF(const base::DictionaryValue& setting,
-                             const PrintToPDFCallback& callback) {
-  printing::PrintPreviewMessageHandler::FromWebContents(web_contents())
-      ->PrintToPDF(setting, callback);
+void WebContents::PrintToPDF(
+    const base::DictionaryValue& settings,
+    const PrintPreviewMessageHandler::PrintToPDFCallback& callback) {
+  PrintPreviewMessageHandler::FromWebContents(web_contents())
+      ->PrintToPDF(settings, callback);
 }
+#endif

 void WebContents::AddWorkSpace(mate::Arguments* args,
                               const base::FilePath& path) {
@@ -2125,9 +2124,11 @@ void WebContents::BuildPrototype(v8::Isolate* isolate,
      .SetMethod("unregisterServiceWorker",
                 &WebContents::UnregisterServiceWorker)
      .SetMethod("inspectServiceWorker", &WebContents::InspectServiceWorker)
-      .SetMethod("print", &WebContents::Print)
-      .SetMethod("getPrinters", &WebContents::GetPrinterList)
+#if BUILDFLAG(ENABLE_PRINTING)
+      .SetMethod("_print", &WebContents::Print)
+      .SetMethod("_getPrinters", &WebContents::GetPrinterList)
      .SetMethod("_printToPDF", &WebContents::PrintToPDF)
+#endif
      .SetMethod("addWorkSpace", &WebContents::AddWorkSpace)
      .SetMethod("removeWorkSpace", &WebContents::RemoveWorkSpace)
      .SetMethod("showDefinitionForSelection",
--- a/atom/browser/api/atom_api_web_contents.h
+++ b/atom/browser/api/atom_api_web_contents.h
@@ -22,9 +22,14 @@
 #include "content/public/common/favicon_url.h"
 #include "electron/buildflags/buildflags.h"
 #include "native_mate/handle.h"
-#include "printing/backend/print_backend.h"
+#include "printing/buildflags/buildflags.h"
 #include "ui/gfx/image/image.h"

+#if BUILDFLAG(ENABLE_PRINTING)
+#include "atom/browser/printing/print_preview_message_handler.h"
+#include "printing/backend/print_backend.h"
+#endif
+
 namespace blink {
 struct WebDeviceEmulationParams;
 }
@@ -78,10 +83,6 @@ class WebContents : public mate::TrackableObject<WebContents>,
    OFF_SCREEN,       // Used for offscreen rendering
  };

-  // For node.js callback function type: function(error, buffer)
-  using PrintToPDFCallback =
-      base::Callback<void(v8::Local<v8::Value>, v8::Local<v8::Value>)>;
-
  // Create from an existing WebContents.
  static mate::Handle<WebContents> CreateFrom(
      v8::Isolate* isolate,
@@ -155,15 +156,18 @@ class WebContents : public mate::TrackableObject<WebContents>,
  bool IsAudioMuted();
  bool IsCurrentlyAudible();
  bool IsDOMReady() const;
-  void Print(mate::Arguments* args);
-  std::vector<printing::PrinterBasicInfo> GetPrinterList();
  void SetEmbedder(const WebContents* embedder);
  void SetDevToolsWebContents(const WebContents* devtools);
  v8::Local<v8::Value> GetNativeView() const;

+#if BUILDFLAG(ENABLE_PRINTING)
+  void Print(mate::Arguments* args);
+  std::vector<printing::PrinterBasicInfo> GetPrinterList();
  // Print current page as PDF.
-  void PrintToPDF(const base::DictionaryValue& setting,
-                  const PrintToPDFCallback& callback);
+  void PrintToPDF(
+      const base::DictionaryValue& settings,
+      const PrintPreviewMessageHandler::PrintToPDFCallback& callback);
+#endif

  // DevTools workspace api.
  void AddWorkSpace(mate::Arguments* args, const base::FilePath& path);
@@ -485,7 +489,6 @@ class WebContents : public mate::TrackableObject<WebContents>,

  std::unique_ptr<AtomJavaScriptDialogManager> dialog_manager_;
  std::unique_ptr<WebViewGuestDelegate> guest_delegate_;
-
  std::unique_ptr<FrameSubscriber> frame_subscriber_;

  // The host webcontents that may contain this webcontents.
--- a/atom/browser/atom_browser_client.cc
+++ b/atom/browser/atom_browser_client.cc
@@ -39,8 +39,6 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
-#include "chrome/browser/printing/printing_message_filter.h"
-#include "chrome/browser/speech/tts_message_filter.h"
 #include "components/net_log/chrome_net_log.h"
 #include "content/public/browser/browser_ppapi_host.h"
 #include "content/public/browser/client_certificate_delegate.h"
@@ -60,6 +58,7 @@
 #include "net/base/escape.h"
 #include "net/ssl/ssl_cert_request_info.h"
 #include "ppapi/host/ppapi_host.h"
+#include "printing/buildflags/buildflags.h"
 #include "services/device/public/cpp/geolocation/location_provider.h"
 #include "services/network/public/cpp/resource_request_body.h"
 #include "services/proxy_resolver/public/mojom/proxy_resolver.mojom.h"
@@ -85,6 +84,12 @@
 #include "atom/browser/fake_location_provider.h"
 #endif  // BUILDFLAG(OVERRIDE_LOCATION_PROVIDER)

+#if BUILDFLAG(ENABLE_PRINTING)
+#include "chrome/browser/printing/printing_message_filter.h"
+#include "chrome/services/printing/public/mojom/constants.mojom.h"
+#include "components/services/pdf_compositor/public/interfaces/pdf_compositor.mojom.h"
+#endif  // BUILDFLAG(ENABLE_PRINTING)
+
 using content::BrowserThread;

 namespace atom {
@@ -212,8 +217,10 @@ void AtomBrowserClient::RenderProcessWillLaunch(
  if (IsProcessObserved(process_id))
    return;

-  host->AddFilter(new printing::PrintingMessageFilter(process_id));
-  host->AddFilter(new TtsMessageFilter(process_id, host->GetBrowserContext()));
+#if BUILDFLAG(ENABLE_PRINTING)
+  host->AddFilter(new printing::PrintingMessageFilter(
+      process_id, host->GetBrowserContext()));
+#endif

  ProcessPreferences prefs;
  auto* web_preferences =
@@ -537,6 +544,16 @@ void AtomBrowserClient::RegisterOutOfProcessServices(
  (*services)[proxy_resolver::mojom::kProxyResolverServiceName] =
      base::BindRepeating(&l10n_util::GetStringUTF16,
                          IDS_UTILITY_PROCESS_PROXY_RESOLVER_NAME);
+
+#if BUILDFLAG(ENABLE_PRINTING)
+  (*services)[printing::mojom::kServiceName] =
+      base::BindRepeating(&l10n_util::GetStringUTF16,
+                          IDS_UTILITY_PROCESS_PDF_COMPOSITOR_SERVICE_NAME);
+
+  (*services)[printing::mojom::kChromePrintingServiceName] =
+      base::BindRepeating(&l10n_util::GetStringUTF16,
+                          IDS_UTILITY_PROCESS_PRINTING_SERVICE_NAME);
+#endif
 }

 std::unique_ptr<base::Value> AtomBrowserClient::GetServiceManifestOverlay(
--- a/atom/browser/atom_browser_context.cc
+++ b/atom/browser/atom_browser_context.cc
@@ -32,6 +32,7 @@
 #include "brightray/common/application_info.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/pref_names.h"
+#include "components/keyed_service/content/browser_context_dependency_manager.h"
 #include "components/prefs/json_pref_store.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
@@ -119,6 +120,8 @@ AtomBrowserContext::AtomBrowserContext(const std::string& partition,
  proxy_config_monitor_ = std::make_unique<ProxyConfigMonitor>(prefs_.get());
  io_handle_ = new URLRequestContextGetter::Handle(weak_factory_.GetWeakPtr());
  cookie_change_notifier_ = std::make_unique<CookieChangeNotifier>(this);
+
+  BrowserContextDependencyManager::GetInstance()->MarkBrowserContextLive(this);
 }

 AtomBrowserContext::~AtomBrowserContext() {
@@ -126,6 +129,9 @@ AtomBrowserContext::~AtomBrowserContext() {
  NotifyWillBeDestroyed(this);
  ShutdownStoragePartitions();
  io_handle_->ShutdownOnUIThread();
+  // Notify any keyed services of browser context destruction.
+  BrowserContextDependencyManager::GetInstance()->DestroyBrowserContextServices(
+      this);
 }

 void AtomBrowserContext::InitPrefs() {
--- a/atom/browser/atom_browser_main_parts.cc
+++ b/atom/browser/atom_browser_main_parts.cc
@@ -19,7 +19,7 @@
 #include "atom/common/node_bindings.h"
 #include "base/command_line.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "chrome/browser/browser_process.h"
+#include "chrome/browser/browser_process_impl.h"
 #include "chrome/browser/icon_manager.h"
 #include "chrome/browser/net/chrome_net_log_helper.h"
 #include "components/net_log/chrome_net_log.h"
@@ -68,7 +68,7 @@ AtomBrowserMainParts* AtomBrowserMainParts::self_ = nullptr;

 AtomBrowserMainParts::AtomBrowserMainParts(
    const content::MainFunctionParams& params)
-    : fake_browser_process_(new BrowserProcess),
+    : fake_browser_process_(new BrowserProcessImpl),
      browser_(new Browser),
      node_bindings_(NodeBindings::Create(NodeBindings::BROWSER)),
      atom_bindings_(new AtomBindings(uv_default_loop())),
--- a/atom/browser/common_web_contents_delegate.cc
+++ b/atom/browser/common_web_contents_delegate.cc
@@ -21,8 +21,6 @@
 #include "base/json/json_reader.h"
 #include "base/task_scheduler/post_task.h"
 #include "base/threading/sequenced_task_runner_handle.h"
-#include "chrome/browser/printing/print_preview_message_handler.h"
-#include "chrome/browser/printing/print_view_manager_basic.h"
 #include "chrome/browser/ssl/security_state_tab_helper.h"
 #include "chrome/browser/ui/browser_dialogs.h"
 #include "chrome/common/pref_names.h"
@@ -38,12 +36,19 @@
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/security_style_explanation.h"
 #include "content/public/browser/security_style_explanations.h"
+#include "printing/buildflags/buildflags.h"
 #include "storage/browser/fileapi/isolated_context.h"

 #if BUILDFLAG(ENABLE_OSR)
 #include "atom/browser/osr/osr_web_contents_view.h"
 #endif

+#if BUILDFLAG(ENABLE_PRINTING)
+#include "atom/browser/printing/print_preview_message_handler.h"
+#include "chrome/browser/printing/print_view_manager_basic.h"
+#include "components/printing/browser/print_manager_utils.h"
+#endif
+
 using content::BrowserThread;

 namespace atom {
@@ -173,8 +178,11 @@ void CommonWebContentsDelegate::InitWithWebContents(
  browser_context_ = browser_context;
  web_contents->SetDelegate(this);

+#if BUILDFLAG(ENABLE_PRINTING)
+  PrintPreviewMessageHandler::CreateForWebContents(web_contents);
  printing::PrintViewManagerBasic::CreateForWebContents(web_contents);
-  printing::PrintPreviewMessageHandler::CreateForWebContents(web_contents);
+  printing::CreateCompositeClientIfNeeded(web_contents);
+#endif

  // Determien whether the WebContents is offscreen.
  auto* web_preferences = WebContentsPreferences::From(web_contents);
--- a/atom/browser/printing/print_preview_message_handler.cc
+++ b/atom/browser/printing/print_preview_message_handler.cc
@@ -0,0 +1,197 @@
+// Copyright (c) 2018 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/printing/print_preview_message_handler.h"
+
+#include <memory>
+#include <utility>
+
+#include "base/bind.h"
+#include "base/memory/read_only_shared_memory_region.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/ref_counted_memory.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/printing/print_job_manager.h"
+#include "chrome/browser/printing/printer_query.h"
+#include "components/printing/browser/print_composite_client.h"
+#include "components/printing/browser/print_manager_utils.h"
+#include "components/printing/common/print_messages.h"
+#include "components/services/pdf_compositor/public/cpp/pdf_service_mojo_types.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/render_frame_host.h"
+#include "content/public/browser/web_contents.h"
+
+#include "atom/common/node_includes.h"
+
+using content::BrowserThread;
+
+DEFINE_WEB_CONTENTS_USER_DATA_KEY(atom::PrintPreviewMessageHandler);
+
+namespace atom {
+
+namespace {
+
+void StopWorker(int document_cookie) {
+  if (document_cookie <= 0)
+    return;
+  scoped_refptr<printing::PrintQueriesQueue> queue =
+      g_browser_process->print_job_manager()->queue();
+  scoped_refptr<printing::PrinterQuery> printer_query =
+      queue->PopPrinterQuery(document_cookie);
+  if (printer_query.get()) {
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::BindOnce(&printing::PrinterQuery::StopWorker, printer_query));
+  }
+}
+
+scoped_refptr<base::RefCountedMemory> GetDataFromHandle(
+    base::SharedMemoryHandle handle,
+    uint32_t data_size) {
+  auto shared_buf = std::make_unique<base::SharedMemory>(handle, true);
+  if (!shared_buf->Map(data_size)) {
+    return nullptr;
+  }
+
+  return base::MakeRefCounted<base::RefCountedSharedMemory>(
+      std::move(shared_buf), data_size);
+}
+
+}  // namespace
+
+PrintPreviewMessageHandler::PrintPreviewMessageHandler(
+    content::WebContents* web_contents)
+    : content::WebContentsObserver(web_contents), weak_ptr_factory_(this) {
+  DCHECK(web_contents);
+}
+
+PrintPreviewMessageHandler::~PrintPreviewMessageHandler() = default;
+
+bool PrintPreviewMessageHandler::OnMessageReceived(
+    const IPC::Message& message,
+    content::RenderFrameHost* render_frame_host) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP_WITH_PARAM(PrintPreviewMessageHandler, message,
+                                   render_frame_host)
+    IPC_MESSAGE_HANDLER(PrintHostMsg_MetafileReadyForPrinting,
+                        OnMetafileReadyForPrinting)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  if (handled)
+    return true;
+
+  handled = true;
+  IPC_BEGIN_MESSAGE_MAP(PrintPreviewMessageHandler, message)
+    IPC_MESSAGE_HANDLER(PrintHostMsg_PrintPreviewFailed, OnPrintPreviewFailed)
+    IPC_MESSAGE_HANDLER(PrintHostMsg_PrintPreviewCancelled,
+                        OnPrintPreviewCancelled)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void PrintPreviewMessageHandler::OnMetafileReadyForPrinting(
+    content::RenderFrameHost* render_frame_host,
+    const PrintHostMsg_DidPreviewDocument_Params& params,
+    const PrintHostMsg_PreviewIds& ids) {
+  // Always try to stop the worker.
+  StopWorker(params.document_cookie);
+
+  const PrintHostMsg_DidPrintContent_Params& content = params.content;
+  if (!content.metafile_data_handle.IsValid() ||
+      params.expected_pages_count <= 0) {
+    RunPrintToPDFCallback(ids.request_id, nullptr);
+    return;
+  }
+
+  if (printing::IsOopifEnabled()) {
+    auto* client =
+        printing::PrintCompositeClient::FromWebContents(web_contents());
+    DCHECK(client);
+    client->DoCompositeDocumentToPdf(
+        params.document_cookie, render_frame_host, content.metafile_data_handle,
+        content.data_size, content.subframe_content_info,
+        base::BindOnce(&PrintPreviewMessageHandler::OnCompositePdfDocumentDone,
+                       weak_ptr_factory_.GetWeakPtr(),
+                       params.expected_pages_count, ids));
+  } else {
+    RunPrintToPDFCallback(
+        ids.request_id,
+        GetDataFromHandle(content.metafile_data_handle, content.data_size));
+  }
+}
+
+void PrintPreviewMessageHandler::OnCompositePdfDocumentDone(
+    int page_number,
+    const PrintHostMsg_PreviewIds& ids,
+    printing::mojom::PdfCompositor::Status status,
+    base::ReadOnlySharedMemoryRegion region) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  if (status != printing::mojom::PdfCompositor::Status::SUCCESS) {
+    DLOG(ERROR) << "Compositing pdf failed with error " << status;
+    RunPrintToPDFCallback(ids.request_id, nullptr);
+    return;
+  }
+
+  RunPrintToPDFCallback(
+      ids.request_id,
+      base::RefCountedSharedMemoryMapping::CreateFromWholeRegion(region));
+}
+
+void PrintPreviewMessageHandler::OnPrintPreviewFailed(
+    int document_cookie,
+    const PrintHostMsg_PreviewIds& ids) {
+  StopWorker(document_cookie);
+
+  RunPrintToPDFCallback(ids.request_id, nullptr);
+}
+
+void PrintPreviewMessageHandler::OnPrintPreviewCancelled(
+    int document_cookie,
+    const PrintHostMsg_PreviewIds& ids) {
+  StopWorker(document_cookie);
+
+  RunPrintToPDFCallback(ids.request_id, nullptr);
+}
+
+void PrintPreviewMessageHandler::PrintToPDF(
+    const base::DictionaryValue& options,
+    const PrintToPDFCallback& callback) {
+  int request_id;
+  options.GetInteger(printing::kPreviewRequestID, &request_id);
+  print_to_pdf_callback_map_[request_id] = callback;
+
+  auto* focused_frame = web_contents()->GetFocusedFrame();
+  auto* rfh = focused_frame && focused_frame->HasSelection()
+                  ? focused_frame
+                  : web_contents()->GetMainFrame();
+  rfh->Send(new PrintMsg_PrintPreview(rfh->GetRoutingID(), options));
+}
+
+void PrintPreviewMessageHandler::RunPrintToPDFCallback(
+    int request_id,
+    scoped_refptr<base::RefCountedMemory> data_bytes) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::Locker locker(isolate);
+  v8::HandleScope handle_scope(isolate);
+  if (data_bytes && data_bytes->size()) {
+    v8::Local<v8::Value> buffer =
+        node::Buffer::Copy(isolate,
+                           reinterpret_cast<const char*>(data_bytes->front()),
+                           data_bytes->size())
+            .ToLocalChecked();
+    print_to_pdf_callback_map_[request_id].Run(v8::Null(isolate), buffer);
+  } else {
+    v8::Local<v8::String> error_message =
+        v8::String::NewFromUtf8(isolate, "Failed to generate PDF");
+    print_to_pdf_callback_map_[request_id].Run(
+        v8::Exception::Error(error_message), v8::Null(isolate));
+  }
+  print_to_pdf_callback_map_.erase(request_id);
+}
+
+}  // namespace atom
--- a/atom/browser/printing/print_preview_message_handler.h
+++ b/atom/browser/printing/print_preview_message_handler.h
@@ -0,0 +1,74 @@
+// Copyright (c) 2018 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_PRINTING_PRINT_PREVIEW_MESSAGE_HANDLER_H_
+#define ATOM_BROWSER_PRINTING_PRINT_PREVIEW_MESSAGE_HANDLER_H_
+
+#include <map>
+
+#include "base/memory/ref_counted_memory.h"
+#include "base/memory/weak_ptr.h"
+#include "components/services/pdf_compositor/public/interfaces/pdf_compositor.mojom.h"
+#include "content/public/browser/web_contents_observer.h"
+#include "content/public/browser/web_contents_user_data.h"
+#include "v8/include/v8.h"
+
+struct PrintHostMsg_DidPreviewDocument_Params;
+struct PrintHostMsg_PreviewIds;
+
+namespace content {
+class RenderFrameHost;
+}
+
+namespace atom {
+
+// Manages the print preview handling for a WebContents.
+class PrintPreviewMessageHandler
+    : public content::WebContentsObserver,
+      public content::WebContentsUserData<PrintPreviewMessageHandler> {
+ public:
+  using PrintToPDFCallback =
+      base::Callback<void(v8::Local<v8::Value>, v8::Local<v8::Value>)>;
+
+  ~PrintPreviewMessageHandler() override;
+
+  void PrintToPDF(const base::DictionaryValue& options,
+                  const PrintToPDFCallback& callback);
+
+ protected:
+  // content::WebContentsObserver implementation.
+  bool OnMessageReceived(const IPC::Message& message,
+                         content::RenderFrameHost* render_frame_host) override;
+
+ private:
+  friend class content::WebContentsUserData<PrintPreviewMessageHandler>;
+
+  explicit PrintPreviewMessageHandler(content::WebContents* web_contents);
+
+  void OnMetafileReadyForPrinting(
+      content::RenderFrameHost* render_frame_host,
+      const PrintHostMsg_DidPreviewDocument_Params& params,
+      const PrintHostMsg_PreviewIds& ids);
+  void OnCompositePdfDocumentDone(int page_number,
+                                  const PrintHostMsg_PreviewIds& ids,
+                                  printing::mojom::PdfCompositor::Status status,
+                                  base::ReadOnlySharedMemoryRegion region);
+  void OnPrintPreviewFailed(int document_cookie,
+                            const PrintHostMsg_PreviewIds& ids);
+  void OnPrintPreviewCancelled(int document_cookie,
+                               const PrintHostMsg_PreviewIds& ids);
+  void RunPrintToPDFCallback(int request_id,
+                             scoped_refptr<base::RefCountedMemory> data_bytes);
+
+  using PrintToPDFCallbackMap = std::map<int, PrintToPDFCallback>;
+  PrintToPDFCallbackMap print_to_pdf_callback_map_;
+
+  base::WeakPtrFactory<PrintPreviewMessageHandler> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(PrintPreviewMessageHandler);
+};
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_PRINTING_PRINT_PREVIEW_MESSAGE_HANDLER_H_