chrome: Add support for Alloy style browsers and windows (see #3681)

Split the Alloy runtime into bootstrap and style components. Support
creation of Alloy style browsers and windows with the Chrome runtime.
Chrome runtime (`--enable-chrome-runtime`) + Alloy style
(`--use-alloy-style`) supports Views (`--use-views`), native parent
(`--use-native`) and windowless rendering
(`--off-screen-rendering-enabled`).

Print preview is supported in all cases except with windowless rendering
on all platforms and native parent on MacOS. It is disabled by default
with Alloy style for legacy compatibility. Where supported it can be
enabled or disabled globally using `--[enable|disable]-print-preview` or
configured on a per-RequestContext basis using the
`printing.print_preview_disabled` preference. It also behaves as
expected when triggered via the PDF viewer print button.

Chrome runtime + Alloy style behavior differs from Alloy runtime in the
following significant ways:

- Supports Chrome error pages by default.
- DevTools popups are Chrome style only (cannot be windowless).
- The Alloy extension API will not supported.

Chrome runtime + Alloy style passes all expected Alloy ceftests except
the following:

- `DisplayTest.AutoResize` (Alloy extension API not supported)
- `DownloadTest.*` (Download API not yet supported)
- `ExtensionTest.*` (Alloy extension API not supported)

This change also adds Chrome runtime support for
CefContextMenuHandler::RunContextMenu (see #3293).

This change also explicitly blocks (and doesn't retry) FrameAttached
requests from PDF viewer and print preview excluded frames (see #3664).

Known issues specific to Chrome runtime + Alloy style:
- DevTools popup with windowless rendering doesn't load successfully.
  Use windowed rendering or remote debugging as a workaround.
- Chrome style Window with Alloy style BrowserView (`--use-alloy-style
  --use-chrome-style-window`) does not show Chrome theme changes.

To test:
- Run `ceftests --enable-chrome-runtime --use-alloy-style
       [--use-chrome-style-window] [--use-views|--use-native]
       --gtest_filter=...`
- Run `cefclient --enable-chrome-runtime --use-alloy-style
       [--use-chrome-style-window]
       [--use-views|--use-native|--off-screen-rendering-enabled]`
- Run `cefsimple --enable-chrome-runtime --use-alloy-style [--use-views]`

libcef/renderer/alloy/alloy_content_renderer_client.cc

@@ -34,7 +34,6 @@
 #include "libcef/renderer/alloy/url_loader_throttle_provider_impl.h"
 #include "libcef/renderer/browser_impl.h"
 #include "libcef/renderer/extensions/extensions_renderer_client.h"
-#include "libcef/renderer/extensions/print_render_frame_helper_delegate.h"
 #include "libcef/renderer/render_frame_observer.h"
 #include "libcef/renderer/render_manager.h"
 #include "libcef/renderer/thread_util.h"
@@ -56,6 +55,7 @@
 #include "chrome/renderer/loadtimes_extension_bindings.h"
 #include "chrome/renderer/media/chrome_key_systems.h"
 #include "chrome/renderer/plugins/chrome_plugin_placeholder.h"
+#include "chrome/renderer/printing/chrome_print_render_frame_helper_delegate.h"
 #include "components/content_settings/core/common/content_settings_types.h"
 #include "components/nacl/common/nacl_constants.h"
 #include "components/pdf/common/constants.h"
@@ -295,18 +295,19 @@ void AlloyContentRendererClient::RenderFrameCreated(
 
   bool browser_created;
   std::optional<bool> is_windowless;
+  std::optional<bool> print_preview_enabled;
   render_manager_->RenderFrameCreated(render_frame, render_frame_observer,
-                                      browser_created, is_windowless);
+                                      browser_created, is_windowless,
+                                      print_preview_enabled);
   if (browser_created) {
     OnBrowserCreated(render_frame->GetWebView(), is_windowless);
   }
 
-  if (is_windowless.has_value()) {
-    new printing::PrintRenderFrameHelper(
-        render_frame,
-        base::WrapUnique(
-            new extensions::CefPrintRenderFrameHelperDelegate(*is_windowless)));
-  }
+  // |print_preview_enabled| may be empty, in which case the
+  // kDisablePrintPreview command-line flag will be checked.
+  new printing::PrintRenderFrameHelper(
+      render_frame, std::make_unique<ChromePrintRenderFrameHelperDelegate>(
+                        print_preview_enabled));
 }
 
 void AlloyContentRendererClient::WebViewCreated(
@@ -315,7 +316,9 @@ void AlloyContentRendererClient::WebViewCreated(
     const url::Origin* outermost_origin) {
   bool browser_created;
   std::optional<bool> is_windowless;
-  render_manager_->WebViewCreated(web_view, browser_created, is_windowless);
+  std::optional<bool> print_preview_enabled;
+  render_manager_->WebViewCreated(web_view, browser_created, is_windowless,
+                                  print_preview_enabled);
   if (browser_created) {
     OnBrowserCreated(web_view, is_windowless);
   }

libcef/renderer/browser_impl.cc

@@ -277,11 +277,13 @@ void CefBrowserImpl::GetFrameNames(std::vector<CefString>& names) {
 CefBrowserImpl::CefBrowserImpl(blink::WebView* web_view,
                                int browser_id,
                                bool is_popup,
-                               bool is_windowless)
+                               bool is_windowless,
+                               bool print_preview_enabled)
     : blink::WebViewObserver(web_view),
       browser_id_(browser_id),
       is_popup_(is_popup),
-      is_windowless_(is_windowless) {}
+      is_windowless_(is_windowless),
+      print_preview_enabled_(print_preview_enabled) {}
 
 CefBrowserImpl::~CefBrowserImpl() = default;
 

libcef/renderer/browser_impl.h

@@ -67,7 +67,8 @@ class CefBrowserImpl : public CefBrowser, public blink::WebViewObserver {
   CefBrowserImpl(blink::WebView* web_view,
                  int browser_id,
                  bool is_popup,
-                 bool is_windowless);
+                 bool is_windowless,
+                 bool print_preview_enabled);
 
   CefBrowserImpl(const CefBrowserImpl&) = delete;
   CefBrowserImpl& operator=(const CefBrowserImpl&) = delete;
@@ -81,6 +82,7 @@ class CefBrowserImpl : public CefBrowser, public blink::WebViewObserver {
   int browser_id() const { return browser_id_; }
   bool is_popup() const { return is_popup_; }
   bool is_windowless() const { return is_windowless_; }
+  bool print_preview_enabled() const { return print_preview_enabled_; }
 
   // blink::WebViewObserver methods.
   void OnDestruct() override;
@@ -93,9 +95,10 @@ class CefBrowserImpl : public CefBrowser, public blink::WebViewObserver {
   // ID of the browser that this RenderView is associated with. During loading
   // of cross-origin requests multiple RenderViews may be associated with the
   // same browser ID.
-  int browser_id_;
-  bool is_popup_;
-  bool is_windowless_;
+  const int browser_id_;
+  const bool is_popup_;
+  const bool is_windowless_;
+  const bool print_preview_enabled_;
 
   // Map of unique frame tokens to CefFrameImpl references.
   using FrameMap = std::map<blink::LocalFrameToken, CefRefPtr<CefFrameImpl>>;

libcef/renderer/chrome/chrome_content_renderer_client_cef.cc

@@ -9,7 +9,10 @@
 #include "libcef/renderer/render_manager.h"
 #include "libcef/renderer/thread_util.h"
 
+#include "chrome/renderer/printing/chrome_print_render_frame_helper_delegate.h"
+#include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_thread.h"
+#include "third_party/blink/public/web/web_view.h"
 
 ChromeContentRendererClientCef::ChromeContentRendererClientCef()
     : render_manager_(new CefRenderManager) {}
@@ -39,19 +42,28 @@ void ChromeContentRendererClientCef::RenderThreadConnected() {
 
 void ChromeContentRendererClientCef::RenderFrameCreated(
     content::RenderFrame* render_frame) {
-  ChromeContentRendererClient::RenderFrameCreated(render_frame);
-
   // Will delete itself when no longer needed.
   CefRenderFrameObserver* render_frame_observer =
       new CefRenderFrameObserver(render_frame);
 
   bool browser_created;
   std::optional<bool> is_windowless;
+  std::optional<bool> print_preview_enabled;
   render_manager_->RenderFrameCreated(render_frame, render_frame_observer,
-                                      browser_created, is_windowless);
-  if (is_windowless.has_value() && *is_windowless) {
-    LOG(ERROR) << "The chrome runtime does not support windowless browsers";
+                                      browser_created, is_windowless,
+                                      print_preview_enabled);
+  if (browser_created) {
+    OnBrowserCreated(render_frame->GetWebView(), is_windowless);
   }
+
+  if (print_preview_enabled.has_value()) {
+    // This value will be used when the when ChromeContentRendererClient
+    // creates the new ChromePrintRenderFrameHelperDelegate below.
+    ChromePrintRenderFrameHelperDelegate::SetNextPrintPreviewEnabled(
+        *print_preview_enabled);
+  }
+
+  ChromeContentRendererClient::RenderFrameCreated(render_frame);
 }
 
 void ChromeContentRendererClientCef::WebViewCreated(
@@ -63,9 +75,11 @@ void ChromeContentRendererClientCef::WebViewCreated(
 
   bool browser_created;
   std::optional<bool> is_windowless;
-  render_manager_->WebViewCreated(web_view, browser_created, is_windowless);
-  if (is_windowless.has_value() && *is_windowless) {
-    LOG(ERROR) << "The chrome runtime does not support windowless browsers";
+  std::optional<bool> print_preview_enabled;
+  render_manager_->WebViewCreated(web_view, browser_created, is_windowless,
+                                  print_preview_enabled);
+  if (browser_created) {
+    OnBrowserCreated(web_view, is_windowless);
   }
 }
 
@@ -101,3 +115,17 @@ void ChromeContentRendererClientCef::ExposeInterfacesToBrowser(
 
   render_manager_->ExposeInterfacesToBrowser(binders);
 }
+
+void ChromeContentRendererClientCef::OnBrowserCreated(
+    blink::WebView* web_view,
+    std::optional<bool> is_windowless) {
+#if BUILDFLAG(IS_MAC)
+  const bool windowless = is_windowless.has_value() && *is_windowless;
+
+  // FIXME: It would be better if this API would be a callback from the
+  // WebKit layer, or if it would be exposed as an WebView instance method; the
+  // current implementation uses a static variable, and WebKit needs to be
+  // patched in order to make it work for each WebView instance
+  web_view->SetUseExternalPopupMenusThisInstance(!windowless);
+#endif
+}

libcef/renderer/chrome/chrome_content_renderer_client_cef.h

@@ -47,6 +47,9 @@ class ChromeContentRendererClientCef : public ChromeContentRendererClient {
   void ExposeInterfacesToBrowser(mojo::BinderMap* binders) override;
 
  private:
+  void OnBrowserCreated(blink::WebView* web_view,
+                        std::optional<bool> is_windowless);
+
   std::unique_ptr<CefRenderManager> render_manager_;
 
   scoped_refptr<base::SingleThreadTaskRunner> render_task_runner_;

libcef/renderer/extensions/print_render_frame_helper_delegate.cc

@@ -1,72 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "libcef/renderer/extensions/print_render_frame_helper_delegate.h"
-
-#include <vector>
-
-#include "libcef/common/extensions/extensions_util.h"
-
-#include "base/command_line.h"
-#include "base/strings/string_util.h"
-#include "chrome/common/chrome_switches.h"
-#include "chrome/common/extensions/extension_constants.h"
-#include "chrome/common/pdf_util.h"
-#include "chrome/common/url_constants.h"
-#include "content/public/renderer/render_frame.h"
-#include "extensions/common/constants.h"
-#include "extensions/renderer/guest_view/mime_handler_view/post_message_support.h"
-#include "services/service_manager/public/cpp/interface_provider.h"
-#include "third_party/blink/public/web/web_document.h"
-#include "third_party/blink/public/web/web_element.h"
-#include "third_party/blink/public/web/web_local_frame.h"
-
-namespace extensions {
-
-CefPrintRenderFrameHelperDelegate::CefPrintRenderFrameHelperDelegate(
-    bool is_windowless)
-    : is_windowless_(is_windowless) {}
-
-CefPrintRenderFrameHelperDelegate::~CefPrintRenderFrameHelperDelegate() =
-    default;
-
-// Return the PDF object element if |frame| is the out of process PDF extension.
-blink::WebElement CefPrintRenderFrameHelperDelegate::GetPdfElement(
-    blink::WebLocalFrame* frame) {
-  if (frame->Parent() &&
-      IsPdfInternalPluginAllowedOrigin(frame->Parent()->GetSecurityOrigin())) {
-    auto plugin_element = frame->GetDocument().QuerySelector("embed");
-    DCHECK(!plugin_element.IsNull());
-    return plugin_element;
-  }
-
-  return blink::WebElement();
-}
-
-bool CefPrintRenderFrameHelperDelegate::IsPrintPreviewEnabled() {
-  return !is_windowless_ && PrintPreviewEnabled();
-}
-
-bool CefPrintRenderFrameHelperDelegate::ShouldGenerateTaggedPDF() {
-  return true;
-}
-
-bool CefPrintRenderFrameHelperDelegate::OverridePrint(
-    blink::WebLocalFrame* frame) {
-  auto* post_message_support =
-      extensions::PostMessageSupport::FromWebLocalFrame(frame);
-  if (post_message_support) {
-    // This message is handled in chrome/browser/resources/pdf/pdf.js and
-    // instructs the PDF plugin to print. This is to make window.print() on a
-    // PDF plugin document correctly print the PDF. See
-    // https://crbug.com/448720.
-    base::Value::Dict message;
-    message.Set("type", "print");
-    post_message_support->PostMessageFromValue(base::Value(std::move(message)));
-    return true;
-  }
-  return false;
-}
-
-}  // namespace extensions

libcef/renderer/extensions/print_render_frame_helper_delegate.h

@@ -1,29 +0,0 @@
-// Copyright 2015 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef CEF_LIBCEF_RENDERER_EXTENSIONS_PRINT_RENDER_FRAME_HELPER_DELEGATE_H_
-#define CEF_LIBCEF_RENDERER_EXTENSIONS_PRINT_RENDER_FRAME_HELPER_DELEGATE_H_
-
-#include "components/printing/renderer/print_render_frame_helper.h"
-
-namespace extensions {
-
-class CefPrintRenderFrameHelperDelegate
-    : public printing::PrintRenderFrameHelper::Delegate {
- public:
-  explicit CefPrintRenderFrameHelperDelegate(bool is_windowless);
-  ~CefPrintRenderFrameHelperDelegate() override;
-
-  blink::WebElement GetPdfElement(blink::WebLocalFrame* frame) override;
-  bool IsPrintPreviewEnabled() override;
-  bool ShouldGenerateTaggedPDF() override;
-  bool OverridePrint(blink::WebLocalFrame* frame) override;
-
- private:
-  bool is_windowless_;
-};
-
-}  // namespace extensions
-
-#endif  // CEF_LIBCEF_RENDERER_EXTENSIONS_PRINT_RENDER_FRAME_HELPER_DELEGATE_H_

libcef/renderer/frame_impl.cc

@@ -486,11 +486,13 @@ void CefFrameImpl::ConnectBrowserFrame(ConnectReason reason) {
   // Don't attempt to connect an invalid or bfcache'd frame. If a bfcache'd
   // frame returns to active status a reconnect will be triggered via
   // OnWasShown().
-  if (!frame_ || blink_glue::IsInBackForwardCache(frame_)) {
+  if (!frame_ || attach_denied_ || blink_glue::IsInBackForwardCache(frame_)) {
     browser_connection_state_ = ConnectionState::DISCONNECTED;
     browser_connect_timer_.Stop();
     VLOG(1) << frame_debug_str_ << " connection retry canceled (reason="
-            << (frame_ ? "BFCACHED" : "INVALID") << ")";
+            << (frame_ ? (attach_denied_ ? "ATTACH_DENIED" : "BFCACHED")
+                       : "INVALID")
+            << ")";
     return;
   }
 
@@ -610,6 +612,11 @@ void CefFrameImpl::OnDisconnect(DisconnectReason reason,
     return;
   }
 
+  if (attach_denied_) {
+    VLOG(1) << frame_debug_str_ << " connection attach denied";
+    return;
+  }
+
   const auto connection_state = browser_connection_state_;
   const bool frame_is_valid = !!frame_;
   VLOG(1) << frame_debug_str_ << " disconnected "
@@ -649,8 +656,8 @@ void CefFrameImpl::OnDisconnect(DisconnectReason reason,
 
 void CefFrameImpl::SendToBrowserFrame(const std::string& function_name,
                                       BrowserFrameAction action) {
-  if (!frame_) {
-    // We've been detached.
+  if (!frame_ || attach_denied_) {
+    // We're detached.
     LOG(WARNING) << function_name << " sent to detached " << frame_debug_str_
                  << " will be ignored";
     return;
@@ -695,7 +702,7 @@ void CefFrameImpl::MaybeInitializeScriptContext() {
   frame_->MainWorldScriptContext();
 }
 
-void CefFrameImpl::FrameAttachedAck() {
+void CefFrameImpl::FrameAttachedAck(bool allow) {
   // Sent from the browser process in response to ConnectBrowserFrame() sending
   // FrameAttached().
   CHECK_EQ(ConnectionState::CONNECTION_PENDING, browser_connection_state_);
@@ -703,6 +710,15 @@ void CefFrameImpl::FrameAttachedAck() {
   browser_connect_retry_ct_ = 0;
   browser_connect_timer_.Stop();
 
+  if (!allow) {
+    // This will be followed by a connection disconnect from the browser side.
+    attach_denied_ = true;
+    while (!queued_browser_actions_.empty()) {
+      queued_browser_actions_.pop();
+    }
+    return;
+  }
+
   auto& browser_frame = GetBrowserFrame();
   CHECK(browser_frame);
 

libcef/renderer/frame_impl.h

@@ -145,7 +145,7 @@ class CefFrameImpl
   void MaybeInitializeScriptContext();
 
   // cef::mojom::RenderFrame methods:
-  void FrameAttachedAck() override;
+  void FrameAttachedAck(bool allow) override;
   void FrameDetached() override;
   void SendMessage(const std::string& name,
                    base::Value::List arguments) override;
@@ -177,6 +177,8 @@ class CefFrameImpl
   bool context_created_ = false;
   std::queue<std::pair<std::string, LocalFrameAction>> queued_context_actions_;
 
+  bool attach_denied_ = false;
+
   // Number of times that browser reconnect has been attempted.
   size_t browser_connect_retry_ct_ = 0;
 

libcef/renderer/render_manager.cc

@@ -57,19 +57,25 @@ class CefGuestView : public blink::WebViewObserver {
  public:
   CefGuestView(CefRenderManager* manager,
                blink::WebView* web_view,
-               bool is_windowless)
+               std::optional<bool> is_windowless,
+               std::optional<bool> print_preview_enabled)
       : blink::WebViewObserver(web_view),
         manager_(manager),
-        is_windowless_(is_windowless) {}
+        is_windowless_(is_windowless),
+        print_preview_enabled_(print_preview_enabled) {}
 
-  bool is_windowless() const { return is_windowless_; }
+  std::optional<bool> is_windowless() const { return is_windowless_; }
+  std::optional<bool> print_preview_enabled() const {
+    return print_preview_enabled_;
+  }
 
  private:
   // RenderViewObserver methods.
   void OnDestruct() override { manager_->OnGuestViewDestroyed(this); }
 
   CefRenderManager* const manager_;
-  const bool is_windowless_;
+  const std::optional<bool> is_windowless_;
+  const std::optional<bool> print_preview_enabled_;
 };
 
 CefRenderManager::CefRenderManager() {
@@ -105,9 +111,11 @@ void CefRenderManager::RenderFrameCreated(
     content::RenderFrame* render_frame,
     CefRenderFrameObserver* render_frame_observer,
     bool& browser_created,
-    std::optional<bool>& is_windowless) {
+    std::optional<bool>& is_windowless,
+    std::optional<bool>& print_preview_enabled) {
   auto browser = MaybeCreateBrowser(render_frame->GetWebView(), render_frame,
-                                    &browser_created, &is_windowless);
+                                    &browser_created, &is_windowless,
+                                    &print_preview_enabled);
   if (browser) {
     // Attach the frame to the observer for message routing purposes.
     render_frame_observer->AttachFrame(
@@ -120,16 +128,19 @@ void CefRenderManager::RenderFrameCreated(
   render_frame->GetWebView()->SetSupportsAppRegion(true);
 }
 
-void CefRenderManager::WebViewCreated(blink::WebView* web_view,
-                                      bool& browser_created,
-                                      std::optional<bool>& is_windowless) {
+void CefRenderManager::WebViewCreated(
+    blink::WebView* web_view,
+    bool& browser_created,
+    std::optional<bool>& is_windowless,
+    std::optional<bool>& print_preview_enabled) {
   content::RenderFrame* render_frame = nullptr;
   if (web_view->MainFrame()->IsWebLocalFrame()) {
     render_frame = content::RenderFrame::FromWebFrame(
         web_view->MainFrame()->ToWebLocalFrame());
   }
 
-  MaybeCreateBrowser(web_view, render_frame, &browser_created, &is_windowless);
+  MaybeCreateBrowser(web_view, render_frame, &browser_created, &is_windowless,
+                     &print_preview_enabled);
 }
 
 void CefRenderManager::DevToolsAgentAttached() {
@@ -195,12 +206,6 @@ bool CefRenderManager::IsExtensionProcess() {
       extensions::switches::kExtensionProcess);
 }
 
-// static
-bool CefRenderManager::IsPdfProcess() {
-  return base::CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kPdfRenderer);
-}
-
 void CefRenderManager::BindReceiver(
     mojo::PendingReceiver<cef::mojom::RenderManager> receiver) {
   receivers_.Add(this, std::move(receiver));
@@ -291,7 +296,8 @@ CefRefPtr<CefBrowserImpl> CefRenderManager::MaybeCreateBrowser(
     blink::WebView* web_view,
     content::RenderFrame* render_frame,
     bool* browser_created,
-    std::optional<bool>* is_windowless) {
+    std::optional<bool>* is_windowless,
+    std::optional<bool>* print_preview_enabled) {
   if (browser_created) {
     *browser_created = false;
   }
@@ -307,6 +313,9 @@ CefRefPtr<CefBrowserImpl> CefRenderManager::MaybeCreateBrowser(
     if (is_windowless) {
       *is_windowless = browser->is_windowless();
     }
+    if (print_preview_enabled) {
+      *print_preview_enabled = browser->print_preview_enabled();
+    }
     return browser;
   }
 
@@ -315,37 +324,42 @@ CefRefPtr<CefBrowserImpl> CefRenderManager::MaybeCreateBrowser(
     if (is_windowless) {
       *is_windowless = guest_view->is_windowless();
     }
+    if (print_preview_enabled) {
+      *print_preview_enabled = guest_view->print_preview_enabled();
+    }
     return nullptr;
   }
 
-  const bool is_pdf = IsPdfProcess();
-
+  // Retrieve browser information synchronously.
   auto params = cef::mojom::NewBrowserInfo::New();
-  if (!is_pdf) {
-    // Retrieve browser information synchronously.
-    GetBrowserManager()->GetNewBrowserInfo(
-        render_frame->GetWebFrame()->GetLocalFrameToken(), &params);
-    if (params->browser_id == 0) {
-      // The popup may have been canceled during creation.
-      return nullptr;
-    }
+  GetBrowserManager()->GetNewBrowserInfo(
+      render_frame->GetWebFrame()->GetLocalFrameToken(), &params);
+  if (params->browser_id == 0) {
+    // The popup may have been canceled during creation.
+    return nullptr;
   }
 
   if (is_windowless) {
     *is_windowless = params->is_windowless;
   }
+  if (print_preview_enabled) {
+    *print_preview_enabled = params->print_preview_enabled;
+  }
 
-  if (is_pdf || params->is_guest_view || params->browser_id < 0) {
-    // Don't create a CefBrowser for a PDF renderer, guest view, or if the new
-    // browser info response has timed out.
+  if (params->is_guest_view || params->browser_id < 0) {
+    // Don't create a CefBrowser for a guest view (PDF renderer, PDF extension
+    // or print preview dialog), or if the new browser info response has timed
+    // out.
     guest_views_.insert(std::make_pair(
         web_view,
-        std::make_unique<CefGuestView>(this, web_view, params->is_windowless)));
+        std::make_unique<CefGuestView>(this, web_view, params->is_windowless,
+                                       params->print_preview_enabled)));
     return nullptr;
   }
 
-  browser = new CefBrowserImpl(web_view, params->browser_id, params->is_popup,
-                               params->is_windowless);
+  browser = new CefBrowserImpl(web_view, params->browser_id, *params->is_popup,
+                               *params->is_windowless,
+                               *params->print_preview_enabled);
   browsers_.insert(std::make_pair(web_view, browser));
 
   // Notify the render process handler.

libcef/renderer/render_manager.h

@@ -53,10 +53,12 @@ class CefRenderManager : public cef::mojom::RenderManager {
   void RenderFrameCreated(content::RenderFrame* render_frame,
                           CefRenderFrameObserver* render_frame_observer,
                           bool& browser_created,
-                          std::optional<bool>& is_windowless);
+                          std::optional<bool>& is_windowless,
+                          std::optional<bool>& print_preview_enabled);
   void WebViewCreated(blink::WebView* web_view,
                       bool& browser_created,
-                      std::optional<bool>& is_windowless);
+                      std::optional<bool>& is_windowless,
+                      std::optional<bool>& print_preview_enabled);
   void DevToolsAgentAttached();
   void DevToolsAgentDetached();
   void ExposeInterfacesToBrowser(mojo::BinderMap* binders);
@@ -73,9 +75,6 @@ class CefRenderManager : public cef::mojom::RenderManager {
   // Returns true if this renderer process is hosting an extension.
   static bool IsExtensionProcess();
 
-  // Returns true if this renderer process is hosting a PDF.
-  static bool IsPdfProcess();
-
  private:
   friend class CefBrowserImpl;
   friend class CefGuestView;
@@ -97,7 +96,8 @@ class CefRenderManager : public cef::mojom::RenderManager {
       blink::WebView* web_view,
       content::RenderFrame* render_frame,
       bool* browser_created,
-      std::optional<bool>* is_windowless);
+      std::optional<bool>* is_windowless,
+      std::optional<bool>* print_preview_enabled);
 
   // Called from CefBrowserImpl::OnDestruct().
   void OnBrowserDestroyed(CefBrowserImpl* browser);