chrome: Support Chrome and DevTools command execution (fixes #3282, fixes #3600)

Add new CefBrowserHost::[Can]ExecuteChromeCommand methods for executing
arbitrary Chrome commands.

Add support for existing CefBrowserHost::ShowDevTools, CloseDevTools and
HasDevTools methods.

DevTools windows now support the same Views callbacks as normal popup
windows with the new CefLifeSpanHandler::OnBeforeDevToolsPopup callback
as the DevTools-specific equivalent of OnBeforePopup.

Always create DevTools as an undocked window to support use of
ShowDevTools with default Chrome browser windows.

To test:

Run `ceftests --enable-chrome-runtime [--use-views]
     --gtest_filter=V8Test.OnUncaughtExceptionDevTools`

OR:

1. Run `cefclient --enable-chrome-runtime [--use-native]`
2. Select "Show DevTools", "Close DevTools" or "Inspect" from the
   right-click menu.
3. Notice that the DevTools window is Views-hosted (or native-hosted)
   and works as expected.

Add --use-default-popup to get a default styled popup in step 3.

include/capi/cef_browser_capi.h

@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=13ba2d807f2c1ac3adfc65f2bdb269baecba57ec$
+// $hash=eed525e9abcbf8e8b959067e0056ca470c5210c7$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_BROWSER_CAPI_H_
@@ -955,6 +955,25 @@ typedef struct _cef_browser_host_t {
   ///
   void(CEF_CALLBACK* exit_fullscreen)(struct _cef_browser_host_t* self,
                                       int will_cause_resize);
+
+  ///
+  /// Returns true (1) if a Chrome command is supported and enabled. Values for
+  /// |command_id| can be found in the cef_command_ids.h file. This function can
+  /// only be called on the UI thread. Only used with the Chrome runtime.
+  ///
+  int(CEF_CALLBACK* can_execute_chrome_command)(
+      struct _cef_browser_host_t* self,
+      int command_id);
+
+  ///
+  /// Execute a Chrome command. Values for |command_id| can be found in the
+  /// cef_command_ids.h file. |disposition| provides information about the
+  /// intended command target. Only used with the Chrome runtime.
+  ///
+  void(CEF_CALLBACK* execute_chrome_command)(
+      struct _cef_browser_host_t* self,
+      int command_id,
+      cef_window_open_disposition_t disposition);
 } cef_browser_host_t;
 
 ///

include/capi/cef_life_span_handler_capi.h

@@ -33,7 +33,7 @@
 // by hand. See the translator.README.txt file in the tools directory for
 // more information.
 //
-// $hash=1c807597b96889f44a1e5199e860e8db4948b473$
+// $hash=32a0c21a71aa7137fa9660b942f597705bc8b05e$
 //
 
 #ifndef CEF_INCLUDE_CAPI_CEF_LIFE_SPAN_HANDLER_CAPI_H_
@@ -100,6 +100,34 @@ typedef struct _cef_life_span_handler_t {
       struct _cef_dictionary_value_t** extra_info,
       int* no_javascript_access);
 
+  ///
+  /// Called on the UI thread before a new DevTools popup browser is created.
+  /// The |browser| value represents the source of the popup request. Optionally
+  /// modify |windowInfo|, |client|, |settings| and |extra_info| values. The
+  /// |client|, |settings| and |extra_info| values will default to the source
+  /// browser's values. Any modifications to |windowInfo| will be ignored if the
+  /// parent browser is Views-hosted (wrapped in a cef_browser_view_t).
+  ///
+  /// The |extra_info| parameter provides an opportunity to specify extra
+  /// information specific to the created popup browser that will be passed to
+  /// cef_render_process_handler_t::on_browser_created() in the render process.
+  /// The existing |extra_info| object, if any, will be read-only but may be
+  /// replaced with a new object.
+  ///
+  /// Views-hosted source browsers will create Views-hosted DevTools popups
+  /// unless |use_default_window| is set to to true (1). DevTools popups can be
+  /// blocked by returning true (1) from cef_command_handler_t::OnChromeCommand
+  /// for IDC_DEV_TOOLS. Only used with the Chrome runtime.
+  ///
+  void(CEF_CALLBACK* on_before_dev_tools_popup)(
+      struct _cef_life_span_handler_t* self,
+      struct _cef_browser_t* browser,
+      struct _cef_window_info_t* windowInfo,
+      struct _cef_client_t** client,
+      struct _cef_browser_settings_t* settings,
+      struct _cef_dictionary_value_t** extra_info,
+      int* use_default_window);
+
   ///
   /// Called after a new browser is created. It is now safe to begin performing
   /// actions with |browser|. cef_frame_handler_t callbacks related to initial

include/cef_api_hash.h

@@ -42,13 +42,13 @@
 // way that may cause binary incompatibility with other builds. The universal
 // hash value will change if any platform is affected whereas the platform hash
 // values will change only if that particular platform is affected.
-#define CEF_API_HASH_UNIVERSAL "c0c754c1ca4f72f6ca6a80861b38b34a61ed5116"
+#define CEF_API_HASH_UNIVERSAL "ce9401699c6753553cba867b1f5c329f759d2c67"
 #if defined(OS_WIN)
-#define CEF_API_HASH_PLATFORM "b8db902c4604f9447ece1184f0d4f674503d0655"
+#define CEF_API_HASH_PLATFORM "e094f42b7a60d2c8c9bcb3db51907a3b42f51d04"
 #elif defined(OS_MAC)
-#define CEF_API_HASH_PLATFORM "a01475fc7c5d8bdc91e29add1aae56c7445a4d4b"
+#define CEF_API_HASH_PLATFORM "6ce44bd7182aa7e9544f5ca33c310f2a096ab638"
 #elif defined(OS_LINUX)
-#define CEF_API_HASH_PLATFORM "75cbf2876ee57cc093f9ab7905e19034754a4b8a"
+#define CEF_API_HASH_PLATFORM "8e9886cd490aefc89283d65f5f7d104a51e2d289"
 #endif
 
 #ifdef __cplusplus

include/cef_browser.h

@@ -988,6 +988,24 @@ class CefBrowserHost : public virtual CefBaseRefCounted {
   ///
   /*--cef()--*/
   virtual void ExitFullscreen(bool will_cause_resize) = 0;
+
+  ///
+  /// Returns true if a Chrome command is supported and enabled. Values for
+  /// |command_id| can be found in the cef_command_ids.h file. This method can
+  /// only be called on the UI thread. Only used with the Chrome runtime.
+  ///
+  /*--cef()--*/
+  virtual bool CanExecuteChromeCommand(int command_id) = 0;
+
+  ///
+  /// Execute a Chrome command. Values for |command_id| can be found in the
+  /// cef_command_ids.h file. |disposition| provides information about the
+  /// intended command target. Only used with the Chrome runtime.
+  ///
+  /*--cef()--*/
+  virtual void ExecuteChromeCommand(
+      int command_id,
+      cef_window_open_disposition_t disposition) = 0;
 };
 
 #endif  // CEF_INCLUDE_CEF_BROWSER_H_

include/cef_life_span_handler.h

@@ -94,6 +94,33 @@ class CefLifeSpanHandler : public virtual CefBaseRefCounted {
     return false;
   }
 
+  ///
+  /// Called on the UI thread before a new DevTools popup browser is created.
+  /// The |browser| value represents the source of the popup request. Optionally
+  /// modify |windowInfo|, |client|, |settings| and |extra_info| values. The
+  /// |client|, |settings| and |extra_info| values will default to the source
+  /// browser's values. Any modifications to |windowInfo| will be ignored if the
+  /// parent browser is Views-hosted (wrapped in a CefBrowserView).
+  ///
+  /// The |extra_info| parameter provides an opportunity to specify extra
+  /// information specific to the created popup browser that will be passed to
+  /// CefRenderProcessHandler::OnBrowserCreated() in the render process. The
+  /// existing |extra_info| object, if any, will be read-only but may be
+  /// replaced with a new object.
+  ///
+  /// Views-hosted source browsers will create Views-hosted DevTools popups
+  /// unless |use_default_window| is set to to true. DevTools popups can be
+  /// blocked by returning true from CefCommandHandler::OnChromeCommand for
+  /// IDC_DEV_TOOLS. Only used with the Chrome runtime.
+  ///
+  /*--cef()--*/
+  virtual void OnBeforeDevToolsPopup(CefRefPtr<CefBrowser> browser,
+                                     CefWindowInfo& windowInfo,
+                                     CefRefPtr<CefClient>& client,
+                                     CefBrowserSettings& settings,
+                                     CefRefPtr<CefDictionaryValue>& extra_info,
+                                     bool* use_default_window) {}
+
   ///
   /// Called after a new browser is created. It is now safe to begin performing
   /// actions with |browser|. CefFrameHandler callbacks related to initial main

include/internal/cef_types.h

@@ -1004,52 +1004,52 @@ typedef enum {
 /// renumbered.
 ///
 typedef enum {
-  WOD_UNKNOWN,
+  CEF_WOD_UNKNOWN,
 
   ///
   /// Current tab. This is the default in most cases.
   ///
-  WOD_CURRENT_TAB,
+  CEF_WOD_CURRENT_TAB,
 
   ///
   /// Indicates that only one tab with the url should exist in the same window.
   ///
-  WOD_SINGLETON_TAB,
+  CEF_WOD_SINGLETON_TAB,
 
   ///
   /// Shift key + Middle mouse button or meta/ctrl key while clicking.
   ///
-  WOD_NEW_FOREGROUND_TAB,
+  CEF_WOD_NEW_FOREGROUND_TAB,
 
   ///
   /// Middle mouse button or meta/ctrl key while clicking.
   ///
-  WOD_NEW_BACKGROUND_TAB,
+  CEF_WOD_NEW_BACKGROUND_TAB,
 
   ///
   /// New popup window.
   ///
-  WOD_NEW_POPUP,
+  CEF_WOD_NEW_POPUP,
 
   ///
   /// Shift key while clicking.
   ///
-  WOD_NEW_WINDOW,
+  CEF_WOD_NEW_WINDOW,
 
   ///
   /// Alt key while clicking.
   ///
-  WOD_SAVE_TO_DISK,
+  CEF_WOD_SAVE_TO_DISK,
 
   ///
   /// New off-the-record (incognito) window.
   ///
-  WOD_OFF_THE_RECORD,
+  CEF_WOD_OFF_THE_RECORD,
 
   ///
   /// Special case error condition from the renderer.
   ///
-  WOD_IGNORE_ACTION,
+  CEF_WOD_IGNORE_ACTION,
 
   ///
   /// Activates an existing tab containing the url, rather than navigating.
@@ -1059,12 +1059,14 @@ typedef enum {
   /// no session history; and behaves like CURRENT_TAB instead of
   /// NEW_FOREGROUND_TAB when no existing tab is found.
   ///
-  WOD_SWITCH_TO_TAB,
+  CEF_WOD_SWITCH_TO_TAB,
 
   ///
   /// Creates a new document picture-in-picture window showing a child WebView.
   ///
-  WOD_NEW_PICTURE_IN_PICTURE,
+  CEF_WOD_NEW_PICTURE_IN_PICTURE,
+
+  CEF_WOD_MAX_VALUE = CEF_WOD_NEW_PICTURE_IN_PICTURE,
 } cef_window_open_disposition_t;
 
 ///

libcef/browser/alloy/alloy_browser_host_impl.cc

@@ -57,33 +57,6 @@ using content::KeyboardEventProcessingResult;
 
 namespace {
 
-class ShowDevToolsHelper {
- public:
-  ShowDevToolsHelper(CefRefPtr<AlloyBrowserHostImpl> browser,
-                     const CefWindowInfo& windowInfo,
-                     CefRefPtr<CefClient> client,
-                     const CefBrowserSettings& settings,
-                     const CefPoint& inspect_element_at)
-      : browser_(browser),
-        window_info_(windowInfo),
-        client_(client),
-        settings_(settings),
-        inspect_element_at_(inspect_element_at) {}
-
-  CefRefPtr<AlloyBrowserHostImpl> browser_;
-  CefWindowInfo window_info_;
-  CefRefPtr<CefClient> client_;
-  CefBrowserSettings settings_;
-  CefPoint inspect_element_at_;
-};
-
-void ShowDevToolsWithHelper(ShowDevToolsHelper* helper) {
-  helper->browser_->ShowDevTools(helper->window_info_, helper->client_,
-                                 helper->settings_,
-                                 helper->inspect_element_at_);
-  delete helper;
-}
-
 static constexpr base::TimeDelta kRecentlyAudibleTimeout = base::Seconds(2);
 
 }  // namespace
@@ -358,22 +331,15 @@ void AlloyBrowserHostImpl::StopFinding(bool clearSelection) {
   }
 }
 
-void AlloyBrowserHostImpl::ShowDevTools(const CefWindowInfo& windowInfo,
+void AlloyBrowserHostImpl::ShowDevToolsOnUIThread(
-                                        CefRefPtr<CefClient> client,
+    std::unique_ptr<CefShowDevToolsParams> params) {
-                                        const CefBrowserSettings& settings,
+  CEF_REQUIRE_UIT();
-                                        const CefPoint& inspect_element_at) {
-  if (!CEF_CURRENTLY_ON_UIT()) {
-    ShowDevToolsHelper* helper = new ShowDevToolsHelper(
-        this, windowInfo, client, settings, inspect_element_at);
-    CEF_POST_TASK(CEF_UIT, base::BindOnce(ShowDevToolsWithHelper, helper));
-    return;
-  }
-
   if (!EnsureDevToolsManager()) {
     return;
   }
-  devtools_manager_->ShowDevTools(windowInfo, client, settings,
+  devtools_manager_->ShowDevTools(params->window_info_, params->client_,
-                                  inspect_element_at);
+                                  params->settings_,
+                                  params->inspect_element_at_);
 }
 
 void AlloyBrowserHostImpl::CloseDevTools() {
@@ -438,6 +404,16 @@ bool AlloyBrowserHostImpl::IsBackgroundHost() {
   return is_background_host_;
 }
 
+bool AlloyBrowserHostImpl::CanExecuteChromeCommand(int command_id) {
+  return false;
+}
+
+void AlloyBrowserHostImpl::ExecuteChromeCommand(
+    int command_id,
+    cef_window_open_disposition_t disposition) {
+  NOTIMPLEMENTED();
+}
+
 bool AlloyBrowserHostImpl::IsWindowRenderingDisabled() {
   return IsWindowless();
 }

libcef/browser/alloy/alloy_browser_host_impl.h

@@ -85,10 +85,6 @@ class AlloyBrowserHostImpl : public CefBrowserHostBase,
             bool matchCase,
             bool findNext) override;
   void StopFinding(bool clearSelection) override;
-  void ShowDevTools(const CefWindowInfo& windowInfo,
-                    CefRefPtr<CefClient> client,
-                    const CefBrowserSettings& settings,
-                    const CefPoint& inspect_element_at) override;
   void CloseDevTools() override;
   bool HasDevTools() override;
   bool IsWindowRenderingDisabled() override;
@@ -127,6 +123,9 @@ class AlloyBrowserHostImpl : public CefBrowserHostBase,
                             const CefSize& max_size) override;
   CefRefPtr<CefExtension> GetExtension() override;
   bool IsBackgroundHost() override;
+  bool CanExecuteChromeCommand(int command_id) override;
+  void ExecuteChromeCommand(int command_id,
+                            cef_window_open_disposition_t disposition) override;
 
   // Returns true if windowless rendering is enabled.
   bool IsWindowless() const override;
@@ -285,6 +284,10 @@ class AlloyBrowserHostImpl : public CefBrowserHostBase,
       override;
   void WebContentsDestroyed() override;
 
+ protected:
+  void ShowDevToolsOnUIThread(
+      std::unique_ptr<CefShowDevToolsParams> params) override;
+
  private:
   friend class CefBrowserPlatformDelegateAlloy;
 

libcef/browser/alloy/browser_platform_delegate_alloy.cc

@@ -39,20 +39,15 @@ content::WebContents* CefBrowserPlatformDelegateAlloy::CreateWebContents(
   REQUIRE_ALLOY_RUNTIME();
   DCHECK(primary_);
 
-  // Get or create the request context and browser context.
-  CefRefPtr<CefRequestContextImpl> request_context_impl =
-      CefRequestContextImpl::GetOrCreateForRequestContext(
-          create_params.request_context);
-  CHECK(request_context_impl);
-  auto cef_browser_context = request_context_impl->GetBrowserContext();
-  CHECK(cef_browser_context);
-  auto browser_context = cef_browser_context->AsBrowserContext();
-
   if (!create_params.request_context) {
     // Using the global request context.
-    create_params.request_context = request_context_impl.get();
+    create_params.request_context = CefRequestContext::GetGlobalContext();
   }
 
+  auto* browser_context =
+      CefRequestContextImpl::GetBrowserContext(create_params.request_context);
+  CHECK(browser_context);
+
   scoped_refptr<content::SiteInstance> site_instance;
   if (extensions::ExtensionsEnabled() && !create_params.url.empty()) {
     GURL gurl = url_util::MakeGURL(create_params.url, /*fixup=*/true);

libcef/browser/browser_host_base.cc

@@ -505,6 +505,22 @@ void CefBrowserHostBase::PrintToPDF(const CefString& path,
   print_util::PrintToPDF(web_contents, path, settings, callback);
 }
 
+void CefBrowserHostBase::ShowDevTools(const CefWindowInfo& windowInfo,
+                                      CefRefPtr<CefClient> client,
+                                      const CefBrowserSettings& settings,
+                                      const CefPoint& inspect_element_at) {
+  auto params = std::make_unique<CefShowDevToolsParams>(
+      windowInfo, client, settings, inspect_element_at);
+
+  if (!CEF_CURRENTLY_ON_UIT()) {
+    CEF_POST_TASK(CEF_UIT,
+                  base::BindOnce(&CefBrowserHostBase::ShowDevToolsOnUIThread,
+                                 this, std::move(params)));
+  } else {
+    ShowDevToolsOnUIThread(std::move(params));
+  }
+}
+
 bool CefBrowserHostBase::SendDevToolsMessage(const void* message,
                                              size_t message_size) {
   if (!message || message_size == 0) {

libcef/browser/browser_host_base.h

@@ -94,6 +94,23 @@ struct CefBrowserCreateParams {
       extensions::mojom::ViewType::kInvalid;
 };
 
+// Parameters passed to ShowDevToolsOnUIThread().
+struct CefShowDevToolsParams {
+  CefShowDevToolsParams(const CefWindowInfo& windowInfo,
+                        CefRefPtr<CefClient> client,
+                        const CefBrowserSettings& settings,
+                        const CefPoint& inspect_element_at)
+      : window_info_(windowInfo),
+        client_(client),
+        settings_(settings),
+        inspect_element_at_(inspect_element_at) {}
+
+  CefWindowInfo window_info_;
+  CefRefPtr<CefClient> client_;
+  CefBrowserSettings settings_;
+  CefPoint inspect_element_at_;
+};
+
 // Base class for CefBrowserHost implementations. Includes functionality that is
 // shared by the alloy and chrome runtimes. All methods are thread-safe unless
 // otherwise indicated.
@@ -191,6 +208,10 @@ class CefBrowserHostBase : public CefBrowserHost,
   void PrintToPDF(const CefString& path,
                   const CefPdfPrintSettings& settings,
                   CefRefPtr<CefPdfPrintCallback> callback) override;
+  void ShowDevTools(const CefWindowInfo& windowInfo,
+                    CefRefPtr<CefClient> client,
+                    const CefBrowserSettings& settings,
+                    const CefPoint& inspect_element_at) override;
   void ReplaceMisspelling(const CefString& word) override;
   void AddWordToDictionary(const CefString& word) override;
   void SendKeyEvent(const CefKeyEvent& event) override;
@@ -346,6 +367,10 @@ class CefBrowserHostBase : public CefBrowserHost,
   // Called from LoadMainFrameURL to perform the actual navigation.
   virtual bool Navigate(const content::OpenURLParams& params);
 
+  // Called from ShowDevTools to perform the actual show.
+  virtual void ShowDevToolsOnUIThread(
+      std::unique_ptr<CefShowDevToolsParams> params) = 0;
+
   // Create the CefFileDialogManager if it doesn't already exist.
   bool EnsureFileDialogManager();
 

libcef/browser/browser_info.cc

@@ -33,6 +33,16 @@ CefBrowserInfo::CefBrowserInfo(int browser_id,
       is_windowless_(is_windowless),
       extra_info_(extra_info) {
   DCHECK_GT(browser_id, 0);
+
+  if (extra_info_ && !extra_info_->IsReadOnly()) {
+    // |extra_info_| should always be read-only to avoid accidental future
+    // modification. Take a copy instead of modifying the passed-in object for
+    // backwards compatibility.
+    extra_info_ = extra_info_->Copy(/*exclude_empty_children=*/false);
+    auto extra_info_impl =
+        static_cast<CefDictionaryValueImpl*>(extra_info_.get());
+    extra_info_impl->MarkReadOnly();
+  }
 }
 
 CefBrowserInfo::~CefBrowserInfo() {

libcef/browser/browser_info_manager.cc

@@ -193,15 +193,8 @@ bool CefBrowserInfoManager::CanCreateWindow(
       pending_popup->use_default_browser_creation = true;
     }
 
-    // In most cases, Views-hosted browsers should create Views-hosted popups
+    create_params.popup_with_views_hosted_opener = ShouldCreateViewsHostedPopup(
-    // and native browsers should use default popup handling. With the Chrome
+        browser, pending_popup->use_default_browser_creation);
-    // runtime, we should additionally use default handling (a) when using an
-    // external parent and (b) when using default Browser creation.
-    create_params.popup_with_views_hosted_opener =
-        browser->HasView() &&
-        !browser->platform_delegate()->HasExternalParent() &&
-        !pending_popup->use_default_browser_creation;
-
     create_params.settings = pending_popup->settings;
     create_params.client = pending_popup->client;
     create_params.extra_info = pending_popup->extra_info;
@@ -420,6 +413,19 @@ bool CefBrowserInfoManager::MaybeAllowNavigation(
   return true;
 }
 
+// static
+bool CefBrowserInfoManager::ShouldCreateViewsHostedPopup(
+    CefRefPtr<CefBrowserHostBase> opener,
+    bool use_default_browser_creation) {
+  // In most cases, Views-hosted browsers should create Views-hosted popups
+  // and native browsers should use default popup handling. With the Chrome
+  // runtime, we should additionally use default handling (a) when using an
+  // external parent and (b) when using default Browser creation.
+  return opener->HasView() &&
+         !opener->platform_delegate()->HasExternalParent() &&
+         !use_default_browser_creation;
+}
+
 CefBrowserInfoManager::BrowserInfoList
 CefBrowserInfoManager::GetBrowserInfoList() {
   base::AutoLock lock_scope(browser_info_lock_);

libcef/browser/browser_info_manager.h

@@ -143,6 +143,9 @@ class CefBrowserInfoManager : public content::RenderProcessHostObserver {
                             const content::OpenURLParams& params,
                             CefRefPtr<CefBrowserHostBase>& browser) const;
 
+  static bool ShouldCreateViewsHostedPopup(CefRefPtr<CefBrowserHostBase> opener,
+                                           bool use_default_browser_creation);
+
  private:
   // RenderProcessHostObserver methods:
   void RenderProcessHostDestroyed(content::RenderProcessHost* host) override;

libcef/browser/chrome/browser_delegate.h

@@ -16,6 +16,7 @@
 #include "ui/base/window_open_disposition.h"
 
 class Browser;
+class Profile;
 
 namespace cef {
 
@@ -40,6 +41,14 @@ class BrowserDelegate : public content::WebContentsDelegate {
 
   ~BrowserDelegate() override {}
 
+  // Optionally override Browser creation in
+  // DevToolsWindow::CreateDevToolsBrowser. The returned Browser, if any, will
+  // take ownership of |devtools_contents|.
+  virtual Browser* CreateDevToolsBrowser(
+      Profile* profile,
+      Browser* opener,
+      std::unique_ptr<content::WebContents>& devtools_contents) = 0;
+
   // Optionally override chrome::AddWebContents behavior. This is most often
   // called via Browser::AddNewContents for new popup browsers and provides an
   // opportunity for CEF to create a new Browser instead of proceeding with

libcef/browser/chrome/chrome_browser_delegate.cc

@@ -12,6 +12,7 @@
 #include "libcef/browser/browser_platform_delegate.h"
 #include "libcef/browser/chrome/chrome_browser_host_impl.h"
 #include "libcef/browser/chrome/views/chrome_browser_view.h"
+#include "libcef/browser/chrome/views/chrome_child_window.h"
 #include "libcef/browser/media_access_query.h"
 #include "libcef/browser/request_context_impl.h"
 #include "libcef/browser/views/browser_view_impl.h"
@@ -38,7 +39,8 @@ ChromeBrowserDelegate::ChromeBrowserDelegate(
   DCHECK(browser_);
 
   if (opener) {
-    DCHECK(browser->is_type_picture_in_picture());
+    DCHECK(browser->is_type_picture_in_picture() ||
+           browser->is_type_devtools());
     auto opener_host = ChromeBrowserHostImpl::GetBrowserForBrowser(opener);
     DCHECK(opener_host);
     if (opener_host) {
@@ -49,6 +51,134 @@ ChromeBrowserDelegate::ChromeBrowserDelegate(
 
 ChromeBrowserDelegate::~ChromeBrowserDelegate() = default;
 
+Browser* ChromeBrowserDelegate::CreateDevToolsBrowser(
+    Profile* profile,
+    Browser* opener,
+    std::unique_ptr<content::WebContents>& devtools_contents) {
+  // |opener| is the same value that will be passed to the ChromeBrowserDelegate
+  // constructor for the new popup Browser. It may be nullptr in certain rare
+  // situations (e.g. if DevTools is launched for a WebContents that is not a
+  // Browser Tab). In that case, the popup browser host will instead be created
+  // via SetAsDelegate.
+  auto opener_browser_host =
+      opener ? ChromeBrowserHostImpl::GetBrowserForBrowser(opener) : nullptr;
+  if (!opener_browser_host) {
+    return nullptr;
+  }
+
+  // We expect openers and popups to have the same Profile.
+  CHECK_EQ(
+      CefRequestContextImpl::GetProfile(opener_browser_host->request_context()),
+      profile);
+
+  //
+  // 1. Get configuration settings from the user and create the new platform
+  // delegate. Logical equivalent of CefBrowserInfoManager::CanCreateWindow()
+  // for normal popups.
+  //
+
+  auto opener_client = opener_browser_host->GetClient();
+  auto life_span_handler =
+      opener_client ? opener_client->GetLifeSpanHandler() : nullptr;
+
+  CefBrowserCreateParams create_params;
+  CefWindowInfo window_info;
+
+  // If |client| is empty, or if the user clears |client| in
+  // OnBeforeDevToolsPopup, we'll use the result of GetDefaultClient() later on
+  // in CreateBrowserHost().
+  if (pending_show_devtools_params_) {
+    // Start with the params passed to CefBrowserHost::ShowDevTools().
+    create_params.client = pending_show_devtools_params_->client_;
+    create_params.settings = pending_show_devtools_params_->settings_;
+    window_info = pending_show_devtools_params_->window_info_;
+
+    // Pending params are only used a single time.
+    pending_show_devtools_params_.reset();
+  } else {
+    // Start with the same client and settings as the opener.
+    create_params.client = opener_client;
+    create_params.settings = opener_browser_host->settings();
+
+#if BUILDFLAG(IS_WIN)
+    window_info.SetAsPopup(nullptr, CefString());
+#endif
+  }
+
+  // Start with the same extra info as the opener, for consistency with
+  // current Alloy runtime behavior (see CefDevToolsFrontend::Show). This
+  // value, if non-empty, will be read-only.
+  create_params.extra_info = opener_browser_host->browser_info()->extra_info();
+  DCHECK(!create_params.extra_info || create_params.extra_info->IsReadOnly());
+
+  // Use default (non-Views-hosted) window if OnBeforeDevToolsPopup is
+  // unhandled.
+  bool use_default_window = !life_span_handler;
+
+  if (life_span_handler) {
+    life_span_handler->OnBeforeDevToolsPopup(
+        opener_browser_host.get(), window_info, create_params.client,
+        create_params.settings, create_params.extra_info, &use_default_window);
+  }
+
+  if (opener_browser_host->platform_delegate()->HasExternalParent()) {
+    // A parent window handle for DevTools creation is only supported if the
+    // opener also has an external parent.
+    create_params.MaybeSetWindowInfo(window_info);
+  } else if (chrome_child_window::HasParentHandle(window_info)) {
+    LOG(ERROR) << "Parent window handle not supported for this DevTools window";
+  }
+
+  create_params.popup_with_views_hosted_opener =
+      CefBrowserInfoManager::ShouldCreateViewsHostedPopup(opener_browser_host,
+                                                          use_default_window);
+
+  auto platform_delegate = CefBrowserPlatformDelegate::Create(create_params);
+  CHECK(platform_delegate);
+
+  //
+  // 2. Create the new browser host. Logical equivalent of WebContentsCreated()
+  // for normal popups.
+  //
+
+  // Create a new browser host that remains alive until the associated
+  // WebContents is destroyed. Associate that browser host with the WebContents
+  // and execute initial client callbacks. Deliver required information to the
+  // renderer process.
+  auto browser_host = CreateBrowserHostForPopup(
+      devtools_contents.get(), create_params.settings, create_params.client,
+      create_params.extra_info, std::move(platform_delegate),
+      /*is_devtools_popup=*/true, opener_browser_host);
+
+  //
+  // 3. Create the new Browser. Logical equivalent of AddWebContents() for
+  // normal popups.
+  //
+
+  // Use Browser creation params specific to DevTools popups.
+  auto chrome_params = Browser::CreateParams::CreateForDevTools(profile);
+
+  // Pass |opener| to the ChromeBrowserDelegate constructor for the new popup
+  // Browser.
+  chrome_params.opener = opener;
+
+  // Create a new Browser and give it ownership of the new WebContents.
+  // Results in a call to SetAsDelegate to associate the Browser with the
+  // browser host.
+  browser_host->AddNewContents(std::move(devtools_contents),
+                               std::move(chrome_params));
+
+  // Give the opener browser a reference to the new DevTools browser. Do this
+  // last because don't want the client to attempt access to the DevTools
+  // browser via opener browser methods (e.g. ShowDevTools, CloseDevTools, etc)
+  // while creation is still in progress.
+  opener_browser_host->SetDevToolsBrowserHost(browser_host->GetWeakPtr());
+
+  auto browser = browser_host->browser();
+  CHECK(browser);
+  return browser;
+}
+
 std::unique_ptr<content::WebContents> ChromeBrowserDelegate::AddWebContents(
     std::unique_ptr<content::WebContents> new_contents) {
   if (CefBrowserInfoManager::GetInstance()->AddWebContents(
@@ -58,7 +188,9 @@ std::unique_ptr<content::WebContents> ChromeBrowserDelegate::AddWebContents(
         ChromeBrowserHostImpl::GetBrowserForContents(new_contents.get());
     if (new_browser) {
       // Create a new Browser and give it ownership of the new WebContents.
-      new_browser->AddNewContents(std::move(new_contents));
+      // Results in a call to SetAsDelegate to associate the Browser with the
+      // browser host.
+      new_browser->AddNewContents(std::move(new_contents), std::nullopt);
     } else {
       LOG(ERROR) << "No host found for chrome popup browser";
     }
@@ -92,19 +224,26 @@ void ChromeBrowserDelegate::SetAsDelegate(content::WebContents* web_contents,
     return;
   }
 
+  const bool is_devtools_popup = browser_->is_type_devtools();
+
+  // We should never reach here for DevTools popups that have an opener, as
+  // CreateDevToolsBrowser should have already created the browser host.
+  DCHECK(!is_devtools_popup || !opener_host_);
+
   auto platform_delegate = CefBrowserPlatformDelegate::Create(create_params_);
   CHECK(platform_delegate);
 
   auto browser_info = CefBrowserInfoManager::GetInstance()->CreateBrowserInfo(
-      /*is_popup=*/false, /*is_windowless=*/false, create_params_.extra_info);
+      is_devtools_popup, /*is_windowless=*/false, create_params_.extra_info);
 
   auto request_context_impl =
       CefRequestContextImpl::GetOrCreateForRequestContext(
           create_params_.request_context);
 
-  CreateBrowser(web_contents, create_params_.settings, create_params_.client,
+  CreateBrowserHost(web_contents, create_params_.settings,
-                std::move(platform_delegate), browser_info, /*opener=*/nullptr,
+                    create_params_.client, std::move(platform_delegate),
-                request_context_impl);
+                    browser_info, is_devtools_popup, /*opener=*/nullptr,
+                    request_context_impl);
 }
 
 bool ChromeBrowserDelegate::ShowStatusBubble(bool show_by_default) {
@@ -125,6 +264,11 @@ bool ChromeBrowserDelegate::ShowStatusBubble(bool show_by_default) {
 
 bool ChromeBrowserDelegate::HandleCommand(int command_id,
                                           WindowOpenDisposition disposition) {
+  // Verify that our enum matches Chromium's values.
+  static_assert(static_cast<int>(CEF_WOD_MAX_VALUE) ==
+                    static_cast<int>(WindowOpenDisposition::MAX_VALUE),
+                "enum mismatch");
+
   if (auto browser = ChromeBrowserHostImpl::GetBrowserForBrowser(browser_)) {
     if (auto client = browser->GetClient()) {
       if (auto handler = client->GetCommandHandler()) {
@@ -301,19 +445,13 @@ void ChromeBrowserDelegate::WebContentsCreated(
     return;
   }
 
-  auto browser_info =
+  // Create a new browser host that remains alive until the associated
-      CefBrowserInfoManager::GetInstance()->CreatePopupBrowserInfo(
+  // WebContents is destroyed. Associate that browser host with the WebContents
-          new_contents, /*is_windowless=*/false, extra_info);
+  // and execute initial client callbacks. Deliver required information to the
-  CHECK(browser_info->is_popup());
+  // renderer process.
-
+  CreateBrowserHostForPopup(new_contents, settings, client, extra_info,
-  // Popups must share the same RequestContext as the parent.
+                            std::move(platform_delegate),
-  auto request_context_impl = opener->request_context();
+                            /*is_devtools_popup=*/false, opener);
-  CHECK(request_context_impl);
-
-  // We don't officially own |new_contents| until AddNewContents() is called.
-  // However, we need to install observers/delegates here.
-  CreateBrowser(new_contents, settings, client, std::move(platform_delegate),
-                browser_info, opener, request_context_impl);
 }
 
 content::WebContents* ChromeBrowserDelegate::OpenURLFromTab(
@@ -423,12 +561,19 @@ bool ChromeBrowserDelegate::HandleKeyboardEvent(
   return false;
 }
 
-void ChromeBrowserDelegate::CreateBrowser(
+void ChromeBrowserDelegate::SetPendingShowDevToolsParams(
+    std::unique_ptr<CefShowDevToolsParams> params) {
+  DCHECK(!pending_show_devtools_params_);
+  pending_show_devtools_params_ = std::move(params);
+}
+
+CefRefPtr<ChromeBrowserHostImpl> ChromeBrowserDelegate::CreateBrowserHost(
     content::WebContents* web_contents,
-    CefBrowserSettings settings,
+    const CefBrowserSettings& settings,
     CefRefPtr<CefClient> client,
     std::unique_ptr<CefBrowserPlatformDelegate> platform_delegate,
     scoped_refptr<CefBrowserInfo> browser_info,
+    bool is_devtools_popup,
     CefRefPtr<ChromeBrowserHostImpl> opener,
     CefRefPtr<CefRequestContextImpl> request_context_impl) {
   CEF_REQUIRE_UIT();
@@ -464,12 +609,40 @@ void ChromeBrowserDelegate::CreateBrowser(
   CefRefPtr<ChromeBrowserHostImpl> browser_host =
       new ChromeBrowserHostImpl(settings, client, std::move(platform_delegate),
                                 browser_info, request_context_impl);
-  browser_host->Attach(web_contents, opener);
+  browser_host->Attach(web_contents, is_devtools_popup, opener);
 
-  // The Chrome browser for a popup won't be created until AddNewContents().
+  // The Chrome browser for a normal popup won't be created until
+  // AddNewContents().
   if (!opener) {
     browser_host->SetBrowser(browser_);
   }
+
+  return browser_host;
+}
+
+CefRefPtr<ChromeBrowserHostImpl>
+ChromeBrowserDelegate::CreateBrowserHostForPopup(
+    content::WebContents* web_contents,
+    const CefBrowserSettings& settings,
+    CefRefPtr<CefClient> client,
+    CefRefPtr<CefDictionaryValue> extra_info,
+    std::unique_ptr<CefBrowserPlatformDelegate> platform_delegate,
+    bool is_devtools_popup,
+    CefRefPtr<ChromeBrowserHostImpl> opener) {
+  auto browser_info =
+      CefBrowserInfoManager::GetInstance()->CreatePopupBrowserInfo(
+          web_contents, /*is_windowless=*/false, extra_info);
+  CHECK(browser_info->is_popup());
+
+  // Popups must share the same RequestContext as the parent.
+  auto request_context_impl = opener->request_context();
+  CHECK(request_context_impl);
+
+  // We don't officially own |web_contents| until AddNewContents() is called.
+  // However, we need to install observers/delegates here.
+  return CreateBrowserHost(web_contents, settings, client,
+                           std::move(platform_delegate), browser_info,
+                           is_devtools_popup, opener, request_context_impl);
 }
 
 CefBrowserContentsDelegate* ChromeBrowserDelegate::GetDelegateForWebContents(

libcef/browser/chrome/chrome_browser_delegate.h

@@ -39,6 +39,9 @@ class ChromeBrowserHostImpl;
 // but the Browser object will change when the tab is dragged between windows.
 class ChromeBrowserDelegate : public cef::BrowserDelegate {
  public:
+  // The |create_params| and |opener| values are specified via the
+  // Browser::CreateParams passed to Browser::Create. |opener| will only be
+  // specified for certain special Browser types.
   ChromeBrowserDelegate(Browser* browser,
                         const CefBrowserCreateParams& create_params,
                         const Browser* opener);
@@ -49,6 +52,10 @@ class ChromeBrowserDelegate : public cef::BrowserDelegate {
   ~ChromeBrowserDelegate() override;
 
   // cef::BrowserDelegate methods:
+  Browser* CreateDevToolsBrowser(
+      Profile* profile,
+      Browser* opener,
+      std::unique_ptr<content::WebContents>& devtools_contents) override;
   std::unique_ptr<content::WebContents> AddWebContents(
       std::unique_ptr<content::WebContents> new_contents) override;
   void OnWebContentsCreated(content::WebContents* new_contents) override;
@@ -104,18 +111,31 @@ class ChromeBrowserDelegate : public cef::BrowserDelegate {
       content::WebContents* source,
       const content::NativeWebKeyboardEvent& event) override;
 
+  void SetPendingShowDevToolsParams(
+      std::unique_ptr<CefShowDevToolsParams> params);
+
   Browser* browser() const { return browser_; }
 
  private:
-  void CreateBrowser(
+  CefRefPtr<ChromeBrowserHostImpl> CreateBrowserHost(
       content::WebContents* web_contents,
-      CefBrowserSettings settings,
+      const CefBrowserSettings& settings,
       CefRefPtr<CefClient> client,
       std::unique_ptr<CefBrowserPlatformDelegate> platform_delegate,
       scoped_refptr<CefBrowserInfo> browser_info,
+      bool is_devtools_popup,
       CefRefPtr<ChromeBrowserHostImpl> opener,
       CefRefPtr<CefRequestContextImpl> request_context_impl);
 
+  CefRefPtr<ChromeBrowserHostImpl> CreateBrowserHostForPopup(
+      content::WebContents* web_contents,
+      const CefBrowserSettings& settings,
+      CefRefPtr<CefClient> client,
+      CefRefPtr<CefDictionaryValue> extra_info,
+      std::unique_ptr<CefBrowserPlatformDelegate> platform_delegate,
+      bool is_devtools_popup,
+      CefRefPtr<ChromeBrowserHostImpl> opener);
+
   CefBrowserContentsDelegate* GetDelegateForWebContents(
       content::WebContents* web_contents);
 
@@ -130,6 +150,8 @@ class ChromeBrowserDelegate : public cef::BrowserDelegate {
   absl::optional<bool> show_status_bubble_;
   absl::optional<SkRegion> draggable_region_;
   mutable absl::optional<bool> frameless_pip_;
+
+  std::unique_ptr<CefShowDevToolsParams> pending_show_devtools_params_;
 };
 
 #endif  // CEF_LIBCEF_BROWSER_CHROME_CHROME_BROWSER_DELEGATE_H_

libcef/browser/chrome/chrome_browser_host_impl.cc

@@ -6,6 +6,7 @@
 
 #include "libcef/browser/browser_platform_delegate.h"
 #include "libcef/browser/chrome/browser_platform_delegate_chrome.h"
+#include "libcef/browser/chrome/chrome_browser_delegate.h"
 #include "libcef/browser/thread_util.h"
 #include "libcef/browser/views/browser_view_impl.h"
 #include "libcef/common/net/url_util.h"
@@ -13,8 +14,8 @@
 
 #include "base/logging.h"
 #include "base/notreached.h"
+#include "chrome/browser/devtools/devtools_window.h"
 #include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
@@ -28,7 +29,7 @@
 // static
 CefRefPtr<ChromeBrowserHostImpl> ChromeBrowserHostImpl::Create(
     const CefBrowserCreateParams& params) {
-  auto browser = CreateBrowser(params);
+  auto browser = CreateBrowser(params, std::nullopt);
 
   GURL url = url_util::MakeGURL(params.url, /*fixup=*/true);
   if (url.is_empty()) {
@@ -99,7 +100,8 @@ CefRefPtr<ChromeBrowserHostImpl> ChromeBrowserHostImpl::GetBrowserForBrowser(
 ChromeBrowserHostImpl::~ChromeBrowserHostImpl() = default;
 
 void ChromeBrowserHostImpl::AddNewContents(
-    std::unique_ptr<content::WebContents> contents) {
+    std::unique_ptr<content::WebContents> contents,
+    std::optional<Browser::CreateParams> browser_create_params) {
   DCHECK(contents);
   DCHECK(!browser_);
 
@@ -111,7 +113,7 @@ void ChromeBrowserHostImpl::AddNewContents(
   params.browser_view = GetBrowserView();
 
   // Create the new Browser representation.
-  auto browser = CreateBrowser(params);
+  auto browser = CreateBrowser(params, std::move(browser_create_params));
 
   // Add the WebContents to the Browser.
   browser->tab_strip_model()->AddWebContents(
@@ -199,20 +201,66 @@ void ChromeBrowserHostImpl::StopFinding(bool clearSelection) {
   NOTIMPLEMENTED();
 }
 
-void ChromeBrowserHostImpl::ShowDevTools(const CefWindowInfo& windowInfo,
+void ChromeBrowserHostImpl::ShowDevToolsOnUIThread(
-                                         CefRefPtr<CefClient> client,
+    std::unique_ptr<CefShowDevToolsParams> params) {
-                                         const CefBrowserSettings& settings,
+  CEF_REQUIRE_UIT();
-                                         const CefPoint& inspect_element_at) {
+
-  NOTIMPLEMENTED();
+  if (!browser_) {
+    return;
+  }
+
+  auto* web_contents = GetWebContents();
+  if (!web_contents) {
+    return;
+  }
+
+  auto* profile = CefRequestContextImpl::GetProfile(request_context());
+  if (!DevToolsWindow::AllowDevToolsFor(profile, web_contents)) {
+    LOG(WARNING) << "DevTools is not allowed for this browser";
+    return;
+  }
+
+  auto inspect_element_at = params->inspect_element_at_;
+
+  if (!devtools_browser_host_) {
+    // Configure parameters for ChromeBrowserDelegate::CreateDevToolsBrowser
+    // which will be called indirectly to create the DevTools window.
+    auto chrome_browser_delegate =
+        static_cast<ChromeBrowserDelegate*>(browser_->cef_delegate());
+    chrome_browser_delegate->SetPendingShowDevToolsParams(std::move(params));
+  }
+
+  // Focus the existing DevTools window or create a new one.
+  if (!inspect_element_at.IsEmpty()) {
+    DevToolsWindow::InspectElement(web_contents->GetPrimaryMainFrame(),
+                                   inspect_element_at.x, inspect_element_at.y);
+  } else {
+    DevToolsWindow::OpenDevToolsWindow(web_contents, profile);
+  }
+
+  // The DevTools browser host should now exist.
+  DCHECK(devtools_browser_host_);
 }
 
 void ChromeBrowserHostImpl::CloseDevTools() {
-  NOTIMPLEMENTED();
+  if (!CEF_CURRENTLY_ON_UIT()) {
+    CEF_POST_TASK(CEF_UIT,
+                  base::BindOnce(&ChromeBrowserHostImpl::CloseDevTools, this));
+    return;
+  }
+
+  if (devtools_browser_host_) {
+    devtools_browser_host_->TryCloseBrowser();
+  }
 }
 
 bool ChromeBrowserHostImpl::HasDevTools() {
-  NOTIMPLEMENTED();
+  if (!CEF_CURRENTLY_ON_UIT()) {
-  return false;
+    DCHECK(false) << "called on invalid thread";
+    return false;
+  }
+
+  return !!devtools_browser_host_;
 }
 
 bool ChromeBrowserHostImpl::IsWindowRenderingDisabled() {
@@ -332,6 +380,36 @@ bool ChromeBrowserHostImpl::IsBackgroundHost() {
   return false;
 }
 
+bool ChromeBrowserHostImpl::CanExecuteChromeCommand(int command_id) {
+  // Verify that this method is being called on the UI thread.
+  if (!CEF_CURRENTLY_ON_UIT()) {
+    DCHECK(false) << "called on invalid thread";
+    return false;
+  }
+
+  if (browser_) {
+    return chrome::SupportsCommand(browser_, command_id) &&
+           chrome::IsCommandEnabled(browser_, command_id);
+  }
+  return false;
+}
+
+void ChromeBrowserHostImpl::ExecuteChromeCommand(
+    int command_id,
+    cef_window_open_disposition_t disposition) {
+  if (!CEF_CURRENTLY_ON_UIT()) {
+    CEF_POST_TASK(CEF_UIT,
+                  base::BindOnce(&ChromeBrowserHostImpl::ExecuteChromeCommand,
+                                 this, command_id, disposition));
+    return;
+  }
+
+  if (browser_) {
+    chrome::ExecuteCommandWithDisposition(
+        browser_, command_id, static_cast<WindowOpenDisposition>(disposition));
+  }
+}
+
 ChromeBrowserView* ChromeBrowserHostImpl::chrome_browser_view() const {
   if (browser_ && is_views_hosted_) {
     return static_cast<ChromeBrowserView*>(browser_->window());
@@ -389,19 +467,16 @@ ChromeBrowserHostImpl::ChromeBrowserHostImpl(
 
 // static
 Browser* ChromeBrowserHostImpl::CreateBrowser(
-    const CefBrowserCreateParams& params) {
+    const CefBrowserCreateParams& params,
-  // Get or create the request context and profile.
+    std::optional<Browser::CreateParams> browser_create_params) {
-  CefRefPtr<CefRequestContextImpl> request_context_impl =
+  Browser::CreateParams chrome_params = [&params, &browser_create_params]() {
-      CefRequestContextImpl::GetOrCreateForRequestContext(
+    if (!browser_create_params.has_value()) {
-          params.request_context);
+      auto* profile = CefRequestContextImpl::GetProfile(params.request_context);
-  CHECK(request_context_impl);
+      return Browser::CreateParams(profile, /*user_gesture=*/false);
-  auto cef_browser_context = request_context_impl->GetBrowserContext();
+    } else {
-  CHECK(cef_browser_context);
+      return std::move(*browser_create_params);
-  auto profile = cef_browser_context->AsProfile();
+    }
-  CHECK(profile);
+  }();
-
-  Browser::CreateParams chrome_params =
-      Browser::CreateParams(profile, /*user_gesture=*/false);
 
   // Pass |params| to cef::BrowserDelegate::Create from the Browser constructor.
   chrome_params.cef_params = base::MakeRefCounted<DelegateCreateParams>(params);
@@ -412,10 +487,12 @@ Browser* ChromeBrowserHostImpl::CreateBrowser(
   // documentation.
   ChromeBrowserView* chrome_browser_view = nullptr;
   if (params.browser_view) {
-    // Don't show most controls.
+    if (chrome_params.type == Browser::TYPE_NORMAL) {
-    chrome_params.type = Browser::TYPE_POPUP;
+      // Don't show most controls.
-    // Don't show title bar or address.
+      chrome_params.type = Browser::TYPE_POPUP;
-    chrome_params.trusted_source = true;
+      // Don't show title bar or address.
+      chrome_params.trusted_source = true;
+    }
 
     auto view_impl =
         static_cast<CefBrowserViewImpl*>(params.browser_view.get());
@@ -456,6 +533,7 @@ Browser* ChromeBrowserHostImpl::CreateBrowser(
 }
 
 void ChromeBrowserHostImpl::Attach(content::WebContents* web_contents,
+                                   bool is_devtools_popup,
                                    CefRefPtr<ChromeBrowserHostImpl> opener) {
   DCHECK(web_contents);
 
@@ -464,7 +542,7 @@ void ChromeBrowserHostImpl::Attach(content::WebContents* web_contents,
     // new browser's platform delegate.
     opener->platform_delegate_->PopupWebContentsCreated(
         settings_, client_, web_contents, platform_delegate_.get(),
-        /*is_devtools_popup=*/false);
+        is_devtools_popup);
   }
 
   platform_delegate_->WebContentsCreated(web_contents,
@@ -480,7 +558,7 @@ void ChromeBrowserHostImpl::Attach(content::WebContents* web_contents,
   // Notify that the browser has been created. These must be delivered in the
   // expected order.
 
-  if (opener && opener->platform_delegate_) {
+  if (opener) {
     // 1. Notify the opener browser's platform delegate. With Views this will
     // result in a call to CefBrowserViewDelegate::OnPopupBrowserViewCreated().
     // We want to call this method first because the implementation will often
@@ -488,9 +566,7 @@ void ChromeBrowserHostImpl::Attach(content::WebContents* web_contents,
     // CefBrowserHost::GetWindowHandle() will return kNullWindowHandle in
     // OnAfterCreated(), which breaks client expectations (e.g. clients expect
     // everything about the browser to be valid at that time).
-    opener->platform_delegate_->PopupBrowserCreated(
+    opener->platform_delegate_->PopupBrowserCreated(this, is_devtools_popup);
-        this,
-        /*is_devtools_popup=*/false);
   }
 
   // 2. Notify the browser's LifeSpanHandler. This must always be the first
@@ -509,14 +585,27 @@ void ChromeBrowserHostImpl::Attach(content::WebContents* web_contents,
 
 void ChromeBrowserHostImpl::SetBrowser(Browser* browser) {
   CEF_REQUIRE_UIT();
+  if (browser == browser_) {
+    return;
+  }
+
   browser_ = browser;
   static_cast<CefBrowserPlatformDelegateChrome*>(platform_delegate_.get())
       ->set_chrome_browser(browser);
   if (browser_) {
     host_window_handle_ = platform_delegate_->GetHostWindowHandle();
+  } else {
+    host_window_handle_ = kNullWindowHandle;
   }
 }
 
+void ChromeBrowserHostImpl::SetDevToolsBrowserHost(
+    base::WeakPtr<ChromeBrowserHostImpl> devtools_browser_host) {
+  CEF_REQUIRE_UIT();
+  DCHECK(!devtools_browser_host_);
+  devtools_browser_host_ = devtools_browser_host;
+}
+
 void ChromeBrowserHostImpl::WindowDestroyed() {
   CEF_REQUIRE_UIT();
   if (auto view = chrome_browser_view()) {

libcef/browser/chrome/chrome_browser_host_impl.h

@@ -12,8 +12,8 @@
 #include "libcef/browser/chrome/browser_delegate.h"
 
 #include "base/memory/weak_ptr.h"
+#include "chrome/browser/ui/browser.h"
 
-class Browser;
 class ChromeBrowserDelegate;
 class ChromeBrowserView;
 
@@ -72,10 +72,6 @@ class ChromeBrowserHostImpl : public CefBrowserHostBase {
             bool matchCase,
             bool findNext) override;
   void StopFinding(bool clearSelection) override;
-  void ShowDevTools(const CefWindowInfo& windowInfo,
-                    CefRefPtr<CefClient> client,
-                    const CefBrowserSettings& settings,
-                    const CefPoint& inspect_element_at) override;
   void CloseDevTools() override;
   bool HasDevTools() override;
   bool IsWindowRenderingDisabled() override;
@@ -114,6 +110,9 @@ class ChromeBrowserHostImpl : public CefBrowserHostBase {
                             const CefSize& max_size) override;
   CefRefPtr<CefExtension> GetExtension() override;
   bool IsBackgroundHost() override;
+  bool CanExecuteChromeCommand(int command_id) override;
+  void ExecuteChromeCommand(int command_id,
+                            cef_window_open_disposition_t disposition) override;
 
   Browser* browser() const { return browser_; }
 
@@ -126,6 +125,8 @@ class ChromeBrowserHostImpl : public CefBrowserHostBase {
 
  protected:
   bool Navigate(const content::OpenURLParams& params) override;
+  void ShowDevToolsOnUIThread(
+      std::unique_ptr<CefShowDevToolsParams> params) override;
 
  private:
   friend class ChromeBrowserDelegate;
@@ -138,22 +139,32 @@ class ChromeBrowserHostImpl : public CefBrowserHostBase {
       CefRefPtr<CefRequestContextImpl> request_context);
 
   // Create a new Browser without initializing the WebContents.
-  static Browser* CreateBrowser(const CefBrowserCreateParams& params);
+  // |browser_create_params| may be empty for default Browser creation behavior.
+  static Browser* CreateBrowser(
+      const CefBrowserCreateParams& params,
+      std::optional<Browser::CreateParams> browser_create_params);
 
   // Called from ChromeBrowserDelegate::CreateBrowser when this object is first
   // created. Must be called on the UI thread.
   void Attach(content::WebContents* web_contents,
+              bool is_devtools_popup,
               CefRefPtr<ChromeBrowserHostImpl> opener);
 
   // Called from ChromeBrowserDelegate::AddNewContents to take ownership of a
-  // popup WebContents.
+  // popup WebContents. |browser_create_params| may be empty for default Browser
-  void AddNewContents(std::unique_ptr<content::WebContents> contents);
+  // creation behavior.
+  void AddNewContents(
+      std::unique_ptr<content::WebContents> contents,
+      std::optional<Browser::CreateParams> browser_create_params);
 
   // Called when this object changes Browser ownership (e.g. initially created,
   // dragging between windows, etc). The old Browser, if any, will be cleared
   // before the new Browser is added. Must be called on the UI thread.
   void SetBrowser(Browser* browser);
 
+  void SetDevToolsBrowserHost(
+      base::WeakPtr<ChromeBrowserHostImpl> devtools_browser_host);
+
   // CefBrowserHostBase methods:
   void WindowDestroyed() override;
   bool WillBeDestroyed() const override;
@@ -168,6 +179,8 @@ class ChromeBrowserHostImpl : public CefBrowserHostBase {
   Browser* browser_ = nullptr;
   CefWindowHandle host_window_handle_ = kNullWindowHandle;
 
+  base::WeakPtr<ChromeBrowserHostImpl> devtools_browser_host_;
+
   base::WeakPtrFactory<ChromeBrowserHostImpl> weak_ptr_factory_{this};
 };
 

libcef/browser/chrome/views/chrome_browser_frame.cc

@@ -4,6 +4,8 @@
 
 #include "libcef/browser/chrome/views/chrome_browser_frame.h"
 
+#include "libcef/browser/chrome/chrome_browser_host_impl.h"
+
 #include "chrome/browser/themes/theme_service.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
@@ -57,3 +59,24 @@ ChromeBrowserFrame::CreateNonClientFrameView() {
   // Bypass the BrowserFrame implementation.
   return views::Widget::CreateNonClientFrameView();
 }
+
+void ChromeBrowserFrame::Activate() {
+  if (browser_view_ && browser_view_->browser() &&
+      browser_view_->browser()->is_type_devtools()) {
+    if (auto browser_host = ChromeBrowserHostImpl::GetBrowserForBrowser(
+            browser_view_->browser())) {
+      if (browser_host->platform_delegate()->HasExternalParent()) {
+        // Handle activation of DevTools with external parent via the platform
+        // delegate. On Windows the default platform implementation
+        // (HWNDMessageHandler::Activate) will call SetForegroundWindow but that
+        // doesn't seem to work for DevTools windows when activated via the
+        // right-click context menu.
+        browser_host->SetFocus(true);
+        return;
+      }
+    }
+  }
+
+  // Proceed with default handling.
+  BrowserFrame::Activate();
+}

libcef/browser/chrome/views/chrome_browser_frame.h

@@ -103,6 +103,7 @@ class ChromeBrowserFrame : public BrowserFrame {
   views::internal::RootView* CreateRootView() override;
   std::unique_ptr<views::NonClientFrameView> CreateNonClientFrameView()
       override;
+  void Activate() override;
 
   BrowserView* browser_view() const { return browser_view_; }
 

libcef/browser/chrome/views/chrome_child_window.cc

@@ -126,8 +126,6 @@ class ChildBrowserViewDelegate : public CefBrowserViewDelegate {
   bool OnPopupBrowserViewCreated(CefRefPtr<CefBrowserView> browser_view,
                                  CefRefPtr<CefBrowserView> popup_browser_view,
                                  bool is_devtools) override {
-    DCHECK(!is_devtools);
-
     auto new_browser = static_cast<CefBrowserHostBase*>(
         popup_browser_view->GetBrowser().get());
     auto new_platform_delegate = new_browser->platform_delegate();

libcef/browser/net_service/browser_urlrequest_impl.cc

@@ -202,14 +202,8 @@ class CefBrowserURLRequest::Context
       scoped_refptr<base::SequencedTaskRunner> task_runner) {
     CEF_REQUIRE_UIT();
 
-    // Get or create the request context and browser context.
+    auto* browser_context =
-    CefRefPtr<CefRequestContextImpl> request_context_impl =
+        CefRequestContextImpl::GetBrowserContext(request_context);
-        CefRequestContextImpl::GetOrCreateForRequestContext(request_context);
-    CHECK(request_context_impl);
-    CefBrowserContext* cef_browser_context =
-        request_context_impl->GetBrowserContext();
-    CHECK(cef_browser_context);
-    auto browser_context = cef_browser_context->AsBrowserContext();
     CHECK(browser_context);
 
     scoped_refptr<net_service::URLLoaderFactoryGetter> loader_factory_getter;

libcef/browser/request_context_impl.cc

@@ -89,6 +89,17 @@ class ResolveHostHelper : public network::ResolveHostClientBase {
   mojo::Receiver<network::mojom::ResolveHostClient> receiver_{this};
 };
 
+CefBrowserContext* GetCefBrowserContext(
+    CefRefPtr<CefRequestContext> request_context) {
+  CEF_REQUIRE_UIT();
+  CefRefPtr<CefRequestContextImpl> request_context_impl =
+      CefRequestContextImpl::GetOrCreateForRequestContext(request_context);
+  CHECK(request_context_impl);
+  auto* cef_browser_context = request_context_impl->GetBrowserContext();
+  CHECK(cef_browser_context);
+  return cef_browser_context;
+}
+
 }  // namespace
 
 // CefBrowserContext
@@ -184,6 +195,21 @@ CefRequestContextImpl::GetOrCreateForRequestContext(
   return CefRequestContextImpl::GetOrCreateRequestContext(config);
 }
 
+content::BrowserContext* CefRequestContextImpl::GetBrowserContext(
+    CefRefPtr<CefRequestContext> request_context) {
+  auto* browser_context =
+      GetCefBrowserContext(request_context)->AsBrowserContext();
+  CHECK(browser_context);
+  return browser_context;
+}
+
+Profile* CefRequestContextImpl::GetProfile(
+    CefRefPtr<CefRequestContext> request_context) {
+  auto* profile = GetCefBrowserContext(request_context)->AsProfile();
+  CHECK(profile);
+  return profile;
+}
+
 bool CefRequestContextImpl::VerifyBrowserContext() const {
   if (!CEF_CURRENTLY_ON_UIT()) {
     DCHECK(false) << "called on invalid thread";

libcef/browser/request_context_impl.h

@@ -38,6 +38,15 @@ class CefRequestContextImpl : public CefRequestContext {
   static CefRefPtr<CefRequestContextImpl> GetOrCreateForRequestContext(
       CefRefPtr<CefRequestContext> request_context);
 
+  // Returns the BrowserContext for the specified |request_context|. Will return
+  // the global BrowserContext if |request_context| is NULL.
+  static content::BrowserContext* GetBrowserContext(
+      CefRefPtr<CefRequestContext> request_context);
+
+  // Returns the Profile for the specified |request_context|. Will return the
+  // global Profile if |request_context| is NULL.
+  static Profile* GetProfile(CefRefPtr<CefRequestContext> request_context);
+
   // Verify that the browser context can be directly accessed (e.g. on the UI
   // thread and initialized).
   bool VerifyBrowserContext() const;

libcef/common/value_base.h

@@ -296,6 +296,13 @@ class CefValueBase : public CefType, public CefValueController::Object {
   // True if access to the underlying value is read-only.
   inline bool read_only() const { return read_only_; }
 
+  // Convert a writable value to read-only. The reverse could be surprising and
+  // is therefore not supported.
+  void MarkReadOnly() {
+    DCHECK(!read_only_);
+    read_only_ = true;
+  }
+
   // True if the underlying value has been detached.
   inline bool detached() const { return !controller_.get(); }
 

libcef_dll/cpptoc/browser_host_cpptoc.cc

@@ -9,7 +9,7 @@
 // implementations. See the translator.README.txt file in the tools directory
 // for more information.
 //
-// $hash=5358aa617ebb6d7d074e2d346599fbd6777f1770$
+// $hash=a5c3b05b23c536eba7ce2e7242c3840e93729b29$
 //
 
 #include "libcef_dll/cpptoc/browser_host_cpptoc.h"
@@ -1468,6 +1468,44 @@ void CEF_CALLBACK browser_host_exit_fullscreen(struct _cef_browser_host_t* self,
                                                                     : false);
 }
 
+int CEF_CALLBACK
+browser_host_can_execute_chrome_command(struct _cef_browser_host_t* self,
+                                        int command_id) {
+  shutdown_checker::AssertNotShutdown();
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  DCHECK(self);
+  if (!self) {
+    return 0;
+  }
+
+  // Execute
+  bool _retval =
+      CefBrowserHostCppToC::Get(self)->CanExecuteChromeCommand(command_id);
+
+  // Return type: bool
+  return _retval;
+}
+
+void CEF_CALLBACK
+browser_host_execute_chrome_command(struct _cef_browser_host_t* self,
+                                    int command_id,
+                                    cef_window_open_disposition_t disposition) {
+  shutdown_checker::AssertNotShutdown();
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  DCHECK(self);
+  if (!self) {
+    return;
+  }
+
+  // Execute
+  CefBrowserHostCppToC::Get(self)->ExecuteChromeCommand(command_id,
+                                                        disposition);
+}
+
 }  // namespace
 
 // CONSTRUCTOR - Do not edit by hand.
@@ -1547,6 +1585,9 @@ CefBrowserHostCppToC::CefBrowserHostCppToC() {
   GetStruct()->is_audio_muted = browser_host_is_audio_muted;
   GetStruct()->is_fullscreen = browser_host_is_fullscreen;
   GetStruct()->exit_fullscreen = browser_host_exit_fullscreen;
+  GetStruct()->can_execute_chrome_command =
+      browser_host_can_execute_chrome_command;
+  GetStruct()->execute_chrome_command = browser_host_execute_chrome_command;
 }
 
 // DESTRUCTOR - Do not edit by hand.

libcef_dll/cpptoc/life_span_handler_cpptoc.cc

@@ -9,7 +9,7 @@
 // implementations. See the translator.README.txt file in the tools directory
 // for more information.
 //
-// $hash=e96fe0660b55afa20c3bb5fdebc85635ccc53d09$
+// $hash=4990c06888649a2cb06ba7028f16f9cd762f3ad0$
 //
 
 #include "libcef_dll/cpptoc/life_span_handler_cpptoc.h"
@@ -169,6 +169,126 @@ int CEF_CALLBACK life_span_handler_on_before_popup(
   return _retval;
 }
 
+void CEF_CALLBACK life_span_handler_on_before_dev_tools_popup(
+    struct _cef_life_span_handler_t* self,
+    cef_browser_t* browser,
+    cef_window_info_t* windowInfo,
+    cef_client_t** client,
+    struct _cef_browser_settings_t* settings,
+    struct _cef_dictionary_value_t** extra_info,
+    int* use_default_window) {
+  shutdown_checker::AssertNotShutdown();
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  DCHECK(self);
+  if (!self) {
+    return;
+  }
+  // Verify param: browser; type: refptr_diff
+  DCHECK(browser);
+  if (!browser) {
+    return;
+  }
+  // Verify param: windowInfo; type: struct_byref
+  DCHECK(windowInfo);
+  if (!windowInfo) {
+    return;
+  }
+  if (!template_util::has_valid_size(windowInfo)) {
+    DCHECK(false) << "invalid windowInfo->[base.]size";
+    return;
+  }
+  // Verify param: client; type: refptr_same_byref
+  DCHECK(client);
+  if (!client) {
+    return;
+  }
+  // Verify param: settings; type: struct_byref
+  DCHECK(settings);
+  if (!settings) {
+    return;
+  }
+  if (!template_util::has_valid_size(settings)) {
+    DCHECK(false) << "invalid settings->[base.]size";
+    return;
+  }
+  // Verify param: extra_info; type: refptr_diff_byref
+  DCHECK(extra_info);
+  if (!extra_info) {
+    return;
+  }
+  // Verify param: use_default_window; type: bool_byaddr
+  DCHECK(use_default_window);
+  if (!use_default_window) {
+    return;
+  }
+
+  // Translate param: windowInfo; type: struct_byref
+  CefWindowInfo windowInfoObj;
+  if (windowInfo) {
+    windowInfoObj.AttachTo(*windowInfo);
+  }
+  // Translate param: client; type: refptr_same_byref
+  CefRefPtr<CefClient> clientPtr;
+  if (client && *client) {
+    clientPtr = CefClientCppToC::Unwrap(*client);
+  }
+  CefClient* clientOrig = clientPtr.get();
+  // Translate param: settings; type: struct_byref
+  CefBrowserSettings settingsObj;
+  if (settings) {
+    settingsObj.AttachTo(*settings);
+  }
+  // Translate param: extra_info; type: refptr_diff_byref
+  CefRefPtr<CefDictionaryValue> extra_infoPtr;
+  if (extra_info && *extra_info) {
+    extra_infoPtr = CefDictionaryValueCToCpp::Wrap(*extra_info);
+  }
+  CefDictionaryValue* extra_infoOrig = extra_infoPtr.get();
+  // Translate param: use_default_window; type: bool_byaddr
+  bool use_default_windowBool =
+      (use_default_window && *use_default_window) ? true : false;
+
+  // Execute
+  CefLifeSpanHandlerCppToC::Get(self)->OnBeforeDevToolsPopup(
+      CefBrowserCToCpp::Wrap(browser), windowInfoObj, clientPtr, settingsObj,
+      extra_infoPtr, &use_default_windowBool);
+
+  // Restore param: windowInfo; type: struct_byref
+  if (windowInfo) {
+    windowInfoObj.DetachTo(*windowInfo);
+  }
+  // Restore param: client; type: refptr_same_byref
+  if (client) {
+    if (clientPtr.get()) {
+      if (clientPtr.get() != clientOrig) {
+        *client = CefClientCppToC::Wrap(clientPtr);
+      }
+    } else {
+      *client = nullptr;
+    }
+  }
+  // Restore param: settings; type: struct_byref
+  if (settings) {
+    settingsObj.DetachTo(*settings);
+  }
+  // Restore param: extra_info; type: refptr_diff_byref
+  if (extra_info) {
+    if (extra_infoPtr.get()) {
+      if (extra_infoPtr.get() != extra_infoOrig) {
+        *extra_info = CefDictionaryValueCToCpp::Unwrap(extra_infoPtr);
+      }
+    } else {
+      *extra_info = nullptr;
+    }
+  }
+  // Restore param: use_default_window; type: bool_byaddr
+  if (use_default_window) {
+    *use_default_window = use_default_windowBool ? true : false;
+  }
+}
+
 void CEF_CALLBACK
 life_span_handler_on_after_created(struct _cef_life_span_handler_t* self,
                                    cef_browser_t* browser) {
@@ -244,6 +364,8 @@ life_span_handler_on_before_close(struct _cef_life_span_handler_t* self,
 
 CefLifeSpanHandlerCppToC::CefLifeSpanHandlerCppToC() {
   GetStruct()->on_before_popup = life_span_handler_on_before_popup;
+  GetStruct()->on_before_dev_tools_popup =
+      life_span_handler_on_before_dev_tools_popup;
   GetStruct()->on_after_created = life_span_handler_on_after_created;
   GetStruct()->do_close = life_span_handler_do_close;
   GetStruct()->on_before_close = life_span_handler_on_before_close;

libcef_dll/ctocpp/browser_host_ctocpp.cc

@@ -9,7 +9,7 @@
 // implementations. See the translator.README.txt file in the tools directory
 // for more information.
 //
-// $hash=4d51bbece0dd5773f9c97163008d6b2f4bf1ccbf$
+// $hash=b06e3bbc86769bbc2485d4ab9530b5c39dc73243$
 //
 
 #include "libcef_dll/ctocpp/browser_host_ctocpp.h"
@@ -1261,6 +1261,41 @@ void CefBrowserHostCToCpp::ExitFullscreen(bool will_cause_resize) {
   _struct->exit_fullscreen(_struct, will_cause_resize);
 }
 
+NO_SANITIZE("cfi-icall")
+bool CefBrowserHostCToCpp::CanExecuteChromeCommand(int command_id) {
+  shutdown_checker::AssertNotShutdown();
+
+  cef_browser_host_t* _struct = GetStruct();
+  if (CEF_MEMBER_MISSING(_struct, can_execute_chrome_command)) {
+    return false;
+  }
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Execute
+  int _retval = _struct->can_execute_chrome_command(_struct, command_id);
+
+  // Return type: bool
+  return _retval ? true : false;
+}
+
+NO_SANITIZE("cfi-icall")
+void CefBrowserHostCToCpp::ExecuteChromeCommand(
+    int command_id,
+    cef_window_open_disposition_t disposition) {
+  shutdown_checker::AssertNotShutdown();
+
+  cef_browser_host_t* _struct = GetStruct();
+  if (CEF_MEMBER_MISSING(_struct, execute_chrome_command)) {
+    return;
+  }
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Execute
+  _struct->execute_chrome_command(_struct, command_id, disposition);
+}
+
 // CONSTRUCTOR - Do not edit by hand.
 
 CefBrowserHostCToCpp::CefBrowserHostCToCpp() {}

libcef_dll/ctocpp/browser_host_ctocpp.h

@@ -9,7 +9,7 @@
 // implementations. See the translator.README.txt file in the tools directory
 // for more information.
 //
-// $hash=5c1df6572bffebd983970394be27397837db0b25$
+// $hash=e07873b7e67c06fb54dafa370eca83d2c698ffb9$
 //
 
 #ifndef CEF_LIBCEF_DLL_CTOCPP_BROWSER_HOST_CTOCPP_H_
@@ -136,6 +136,9 @@ class CefBrowserHostCToCpp : public CefCToCppRefCounted<CefBrowserHostCToCpp,
   bool IsAudioMuted() override;
   bool IsFullscreen() override;
   void ExitFullscreen(bool will_cause_resize) override;
+  bool CanExecuteChromeCommand(int command_id) override;
+  void ExecuteChromeCommand(int command_id,
+                            cef_window_open_disposition_t disposition) override;
 };
 
 #endif  // CEF_LIBCEF_DLL_CTOCPP_BROWSER_HOST_CTOCPP_H_

libcef_dll/ctocpp/life_span_handler_ctocpp.cc

@@ -9,7 +9,7 @@
 // implementations. See the translator.README.txt file in the tools directory
 // for more information.
 //
-// $hash=d141b95304de99ab093db8f6c524a05e26f4edb5$
+// $hash=d85695db88a025b1f7e4e4604f3085da29d5eabf$
 //
 
 #include "libcef_dll/ctocpp/life_span_handler_ctocpp.h"
@@ -109,6 +109,76 @@ bool CefLifeSpanHandlerCToCpp::OnBeforePopup(
   return _retval ? true : false;
 }
 
+NO_SANITIZE("cfi-icall")
+void CefLifeSpanHandlerCToCpp::OnBeforeDevToolsPopup(
+    CefRefPtr<CefBrowser> browser,
+    CefWindowInfo& windowInfo,
+    CefRefPtr<CefClient>& client,
+    CefBrowserSettings& settings,
+    CefRefPtr<CefDictionaryValue>& extra_info,
+    bool* use_default_window) {
+  shutdown_checker::AssertNotShutdown();
+
+  cef_life_span_handler_t* _struct = GetStruct();
+  if (CEF_MEMBER_MISSING(_struct, on_before_dev_tools_popup)) {
+    return;
+  }
+
+  // AUTO-GENERATED CONTENT - DELETE THIS COMMENT BEFORE MODIFYING
+
+  // Verify param: browser; type: refptr_diff
+  DCHECK(browser.get());
+  if (!browser.get()) {
+    return;
+  }
+  // Verify param: use_default_window; type: bool_byaddr
+  DCHECK(use_default_window);
+  if (!use_default_window) {
+    return;
+  }
+
+  // Translate param: client; type: refptr_same_byref
+  cef_client_t* clientStruct = NULL;
+  if (client.get()) {
+    clientStruct = CefClientCToCpp::Unwrap(client);
+  }
+  cef_client_t* clientOrig = clientStruct;
+  // Translate param: extra_info; type: refptr_diff_byref
+  cef_dictionary_value_t* extra_infoStruct = NULL;
+  if (extra_info.get()) {
+    extra_infoStruct = CefDictionaryValueCppToC::Wrap(extra_info);
+  }
+  cef_dictionary_value_t* extra_infoOrig = extra_infoStruct;
+  // Translate param: use_default_window; type: bool_byaddr
+  int use_default_windowInt = use_default_window ? *use_default_window : 0;
+
+  // Execute
+  _struct->on_before_dev_tools_popup(_struct, CefBrowserCppToC::Wrap(browser),
+                                     &windowInfo, &clientStruct, &settings,
+                                     &extra_infoStruct, &use_default_windowInt);
+
+  // Restore param:client; type: refptr_same_byref
+  if (clientStruct) {
+    if (clientStruct != clientOrig) {
+      client = CefClientCToCpp::Wrap(clientStruct);
+    }
+  } else {
+    client = nullptr;
+  }
+  // Restore param:extra_info; type: refptr_diff_byref
+  if (extra_infoStruct) {
+    if (extra_infoStruct != extra_infoOrig) {
+      extra_info = CefDictionaryValueCppToC::Unwrap(extra_infoStruct);
+    }
+  } else {
+    extra_info = nullptr;
+  }
+  // Restore param:use_default_window; type: bool_byaddr
+  if (use_default_window) {
+    *use_default_window = use_default_windowInt ? true : false;
+  }
+}
+
 NO_SANITIZE("cfi-icall")
 void CefLifeSpanHandlerCToCpp::OnAfterCreated(CefRefPtr<CefBrowser> browser) {
   shutdown_checker::AssertNotShutdown();

libcef_dll/ctocpp/life_span_handler_ctocpp.h

@@ -9,7 +9,7 @@
 // implementations. See the translator.README.txt file in the tools directory
 // for more information.
 //
-// $hash=229117f1ecb1cc27b5ab5eebd79e64c30d73a855$
+// $hash=53f00e60e361c79c69a8f19474a234d5011454f5$
 //
 
 #ifndef CEF_LIBCEF_DLL_CTOCPP_LIFE_SPAN_HANDLER_CTOCPP_H_
@@ -49,6 +49,12 @@ class CefLifeSpanHandlerCToCpp
                      CefBrowserSettings& settings,
                      CefRefPtr<CefDictionaryValue>& extra_info,
                      bool* no_javascript_access) override;
+  void OnBeforeDevToolsPopup(CefRefPtr<CefBrowser> browser,
+                             CefWindowInfo& windowInfo,
+                             CefRefPtr<CefClient>& client,
+                             CefBrowserSettings& settings,
+                             CefRefPtr<CefDictionaryValue>& extra_info,
+                             bool* use_default_window) override;
   void OnAfterCreated(CefRefPtr<CefBrowser> browser) override;
   bool DoClose(CefRefPtr<CefBrowser> browser) override;
   void OnBeforeClose(CefRefPtr<CefBrowser> browser) override;

patch/patch.cfg

@@ -117,6 +117,10 @@ patches = [
     # Windows: Fix incorrect DIPToScreenRect usage in DesktopWindowTreeHostWin
     # when |has_external_parent_| is true.
     # https://github.com/chromiumembedded/cef/issues/3359
+    #
+    # chrome: Allow override of Widget::Activate() to support activation of
+    # DevTools windows with external parent.
+    # https://github.com/chromiumembedded/cef/issues/3282
     'name': 'views_widget',
   },
   {

patch/patches/chrome_browser_browser.patch

@@ -12,6 +12,68 @@ index 2480282a19d12..dbd1fbf8a15b5 100644
  
    return false;
  }
+diff --git chrome/browser/devtools/devtools_window.cc chrome/browser/devtools/devtools_window.cc
+index 4d99a769d6069..0ebd577182dc6 100644
+--- chrome/browser/devtools/devtools_window.cc
++++ chrome/browser/devtools/devtools_window.cc
+@@ -31,6 +31,7 @@
+ #include "chrome/browser/profiles/profile.h"
+ #include "chrome/browser/task_manager/web_contents_tags.h"
+ #include "chrome/browser/ui/browser.h"
++#include "chrome/browser/ui/browser_finder.h"
+ #include "chrome/browser/ui/browser_list.h"
+ #include "chrome/browser/ui/browser_tabstrip.h"
+ #include "chrome/browser/ui/browser_window.h"
+@@ -1162,6 +1163,13 @@ DevToolsWindow* DevToolsWindow::Create(
+         !browser->is_type_normal()) {
+       can_dock = false;
+     }
++
++#if BUILDFLAG(ENABLE_CEF)
++    if (can_dock && browser && browser->cef_delegate()) {
++      // Don't dock DevTools for CEF-managed browsers.
++      can_dock = false;
++    }
++#endif
+   }
+ 
+   // Create WebContents with devtools.
+@@ -1738,12 +1746,29 @@ void DevToolsWindow::CreateDevToolsBrowser() {
+       Browser::CreationStatus::kOk) {
+     return;
+   }
+-  browser_ =
+-      Browser::Create(Browser::CreateParams::CreateForDevTools(profile_));
+-  browser_->tab_strip_model()->AddWebContents(
+-      OwnedMainWebContents::TakeWebContents(
+-          std::move(owned_main_web_contents_)),
+-      -1, ui::PAGE_TRANSITION_AUTO_TOPLEVEL, AddTabTypes::ADD_ACTIVE);
++
++  auto opener = chrome::FindBrowserWithWebContents(GetInspectedWebContents());
++  auto devtools_contents = OwnedMainWebContents::TakeWebContents(
++      std::move(owned_main_web_contents_));
++
++#if BUILDFLAG(ENABLE_CEF)
++  if (opener && opener->cef_delegate()) {
++    // If a Browser is created, it will take ownership of |devtools_contents|.
++    browser_ = opener->cef_delegate()->CreateDevToolsBrowser(
++        profile_, opener, devtools_contents);
++  }
++#endif
++
++  if (!browser_) {
++    auto create_params = Browser::CreateParams::CreateForDevTools(profile_);
++    create_params.opener = opener;
++
++    browser_ = Browser::Create(std::move(create_params));
++    browser_->tab_strip_model()->AddWebContents(
++        std::move(devtools_contents),
++        -1, ui::PAGE_TRANSITION_AUTO_TOPLEVEL, AddTabTypes::ADD_ACTIVE);
++  }
++
+   OverrideAndSyncDevToolsRendererPrefs();
+ }
+ 
 diff --git chrome/browser/ui/BUILD.gn chrome/browser/ui/BUILD.gn
 index eca90c39e0d44..2157b6d86ab02 100644
 --- chrome/browser/ui/BUILD.gn
@@ -333,7 +395,7 @@ index 9ba2025634365..b6ceaa7f0b531 100644
      case TYPE_NORMAL:
        return NormalBrowserSupportsWindowFeature(feature, check_can_support);
 diff --git chrome/browser/ui/browser.h chrome/browser/ui/browser.h
-index db37e861d2546..c47dfc31131f7 100644
+index db37e861d2546..ea85b9966267d 100644
 --- chrome/browser/ui/browser.h
 +++ chrome/browser/ui/browser.h
 @@ -22,6 +22,7 @@
@@ -364,7 +426,7 @@ index db37e861d2546..c47dfc31131f7 100644
 +    scoped_refptr<cef::BrowserDelegate::CreateParams> cef_params;
 +
 +    // Specify the Browser that is opening this popup.
-+    // Currently only used with TYPE_PICTURE_IN_PICTURE.
++    // Currently only used with TYPE_PICTURE_IN_PICTURE and TYPE_DEVTOOLS.
 +    raw_ptr<Browser, DanglingUntriaged> opener = nullptr;
 +#endif
 +

patch/patches/chrome_runtime_views.patch

@@ -231,7 +231,7 @@ index 59024587ef6b7..0c30aa71768cf 100644
  
  void FindBarHost::RegisterAccelerators() {
 diff --git chrome/browser/ui/views/frame/browser_frame.cc chrome/browser/ui/views/frame/browser_frame.cc
-index bb4b3821bcfda..9734fe4aaffcf 100644
+index bb4b3821bcfda..4014f61a7057f 100644
 --- chrome/browser/ui/views/frame/browser_frame.cc
 +++ chrome/browser/ui/views/frame/browser_frame.cc
 @@ -114,15 +114,23 @@ ui::ColorProviderKey::SchemeVariant GetSchemeVariant(
@@ -260,7 +260,7 @@ index bb4b3821bcfda..9734fe4aaffcf 100644
  }
  
  BrowserFrame::~BrowserFrame() {}
-@@ -228,6 +236,12 @@ void BrowserFrame::LayoutWebAppWindowTitle(
+@@ -228,10 +236,20 @@ void BrowserFrame::LayoutWebAppWindowTitle(
  }
  
  int BrowserFrame::GetTopInset() const {
@@ -273,7 +273,15 @@ index bb4b3821bcfda..9734fe4aaffcf 100644
    return browser_frame_view_->GetTopInset(false);
  }
  
-@@ -240,6 +254,8 @@ BrowserNonClientFrameView* BrowserFrame::GetFrameView() const {
+ void BrowserFrame::UpdateThrobber(bool running) {
++  if (!browser_frame_view_) {
++    // Not supported with CEF Views-hosted DevTools windows.
++    return;
++  }
+   browser_frame_view_->UpdateThrobber(running);
+ }
+ 
+@@ -240,6 +258,8 @@ BrowserNonClientFrameView* BrowserFrame::GetFrameView() const {
  }
  
  bool BrowserFrame::UseCustomFrame() const {
@@ -282,7 +290,7 @@ index bb4b3821bcfda..9734fe4aaffcf 100644
    return native_browser_frame_->UseCustomFrame();
  }
  
-@@ -253,20 +269,30 @@ bool BrowserFrame::ShouldDrawFrameHeader() const {
+@@ -253,20 +273,30 @@ bool BrowserFrame::ShouldDrawFrameHeader() const {
  
  void BrowserFrame::GetWindowPlacement(gfx::Rect* bounds,
                                        ui::WindowShowState* show_state) const {
@@ -313,7 +321,7 @@ index bb4b3821bcfda..9734fe4aaffcf 100644
    browser_frame_view_->OnBrowserViewInitViewsComplete();
  }
  
-@@ -367,6 +393,8 @@ ui::ColorProviderKey::ThemeInitializerSupplier* BrowserFrame::GetCustomTheme()
+@@ -367,6 +397,8 @@ ui::ColorProviderKey::ThemeInitializerSupplier* BrowserFrame::GetCustomTheme()
  }
  
  void BrowserFrame::OnNativeWidgetWorkspaceChanged() {
@@ -322,7 +330,7 @@ index bb4b3821bcfda..9734fe4aaffcf 100644
    chrome::SaveWindowWorkspace(browser_view_->browser(), GetWorkspace());
    chrome::SaveWindowVisibleOnAllWorkspaces(browser_view_->browser(),
                                             IsVisibleOnAllWorkspaces());
-@@ -478,6 +506,8 @@ void BrowserFrame::OnNativeThemeUpdated(ui::NativeTheme* observed_theme) {
+@@ -478,6 +510,8 @@ void BrowserFrame::OnNativeThemeUpdated(ui::NativeTheme* observed_theme) {
  
  ui::ColorProviderKey BrowserFrame::GetColorProviderKey() const {
    auto key = Widget::GetColorProviderKey();
@@ -331,7 +339,7 @@ index bb4b3821bcfda..9734fe4aaffcf 100644
  
    key.app_controller = browser_view_->browser()->app_controller();
  
-@@ -632,5 +662,8 @@ bool BrowserFrame::RegenerateFrameOnThemeChange(
+@@ -632,5 +666,8 @@ bool BrowserFrame::RegenerateFrameOnThemeChange(
  }
  
  bool BrowserFrame::IsIncognitoBrowser() const {

patch/patches/views_widget.patch

@@ -414,7 +414,7 @@ index 2f552f72074e3..3f057242d198c 100644
  }
  
 diff --git ui/views/widget/widget.h ui/views/widget/widget.h
-index 419b75d0608b2..d772dc17d165c 100644
+index 419b75d0608b2..57bb1fca770ed 100644
 --- ui/views/widget/widget.h
 +++ ui/views/widget/widget.h
 @@ -351,6 +351,8 @@ class VIEWS_EXPORT Widget : public internal::NativeWidgetDelegate,
@@ -426,6 +426,15 @@ index 419b75d0608b2..d772dc17d165c 100644
      // Specifies the initial bounds of the Widget. Default is empty, which means
      // the NativeWidget may specify a default size. If the parent is specified,
      // |bounds| is in the parent's coordinate system. If the parent is not
+@@ -742,7 +744,7 @@ class VIEWS_EXPORT Widget : public internal::NativeWidgetDelegate,
+   void ShowInactive();
+ 
+   // Activates the widget, assuming it already exists and is visible.
+-  void Activate();
++  virtual void Activate();
+ 
+   // Deactivates the widget, making the next window in the Z order the active
+   // window.
 diff --git ui/views/widget/widget_delegate.h ui/views/widget/widget_delegate.h
 index 6d87be86ae8b3..02fe7a11958d0 100644
 --- ui/views/widget/widget_delegate.h

tests/cefclient/browser/client_handler.cc

@@ -583,7 +583,7 @@ bool ClientHandler::OnChromeCommand(CefRefPtr<CefBrowser> browser,
   } else if (!with_controls_) {
     // If controls are hidden, block all commands that don't target the current
     // tab or aren't specifically allowed.
-    block = disposition != WOD_CURRENT_TAB || !allowed;
+    block = disposition != CEF_WOD_CURRENT_TAB || !allowed;
   }
 
   if (block) {
@@ -644,11 +644,12 @@ void ClientHandler::OnBeforeContextMenu(CefRefPtr<CefBrowser> browser,
       model->AddSeparator();
     }
 
+    // Add DevTools items to all context menus.
+    model->AddItem(CLIENT_ID_SHOW_DEVTOOLS, "&Show DevTools");
+    model->AddItem(CLIENT_ID_CLOSE_DEVTOOLS, "Close DevTools");
+
     if (!use_chrome_runtime) {
-      // TODO(chrome-runtime): Add support for this.
+      // Chrome runtime already gives us an "Inspect" menu item.
-      // Add DevTools items to all context menus.
-      model->AddItem(CLIENT_ID_SHOW_DEVTOOLS, "&Show DevTools");
-      model->AddItem(CLIENT_ID_CLOSE_DEVTOOLS, "Close DevTools");
       model->AddSeparator();
       model->AddItem(CLIENT_ID_INSPECT_ELEMENT, "Inspect Element");
     }
@@ -938,15 +939,36 @@ bool ClientHandler::OnBeforePopup(
     bool* no_javascript_access) {
   CEF_REQUIRE_UI_THREAD();
 
-  if (target_disposition == WOD_NEW_PICTURE_IN_PICTURE) {
+  if (target_disposition == CEF_WOD_NEW_PICTURE_IN_PICTURE) {
     // Use default handling for document picture-in-picture popups.
     client = nullptr;
     return false;
   }
 
-  // Return true to cancel the popup window.
+  // Potentially create a new RootWindow for the popup browser that will be
-  return !CreatePopupWindow(browser, false, popupFeatures, windowInfo, client,
+  // created asynchronously.
-                            settings);
+  CreatePopupWindow(browser, /*is_devtools=*/false, popupFeatures, windowInfo,
+                    client, settings);
+
+  // Allow popup creation.
+  return false;
+}
+
+void ClientHandler::OnBeforeDevToolsPopup(
+    CefRefPtr<CefBrowser> browser,
+    CefWindowInfo& windowInfo,
+    CefRefPtr<CefClient>& client,
+    CefBrowserSettings& settings,
+    CefRefPtr<CefDictionaryValue>& extra_info,
+    bool* use_default_window) {
+  CEF_REQUIRE_UI_THREAD();
+
+  // Potentially create a new RootWindow for the DevTools popup browser that
+  // will be created immediately after this method returns.
+  if (!CreatePopupWindow(browser, /*is_devtools=*/true, CefPopupFeatures(),
+                         windowInfo, client, settings)) {
+    *use_default_window = true;
+  }
 }
 
 void ClientHandler::OnAfterCreated(CefRefPtr<CefBrowser> browser) {
@@ -1081,8 +1103,8 @@ bool ClientHandler::OnOpenURLFromTab(
     const CefString& target_url,
     CefRequestHandler::WindowOpenDisposition target_disposition,
     bool user_gesture) {
-  if (target_disposition == WOD_NEW_BACKGROUND_TAB ||
+  if (target_disposition == CEF_WOD_NEW_BACKGROUND_TAB ||
-      target_disposition == WOD_NEW_FOREGROUND_TAB) {
+      target_disposition == CEF_WOD_NEW_FOREGROUND_TAB) {
     // Handle middle-click and ctrl + left-click by opening the URL in a new
     // browser window.
     auto config = std::make_unique<RootWindowConfig>();
@@ -1303,25 +1325,21 @@ void ClientHandler::ShowDevTools(CefRefPtr<CefBrowser> browser,
   CefRefPtr<CefClient> client;
   CefBrowserSettings settings;
 
-  MainContext::Get()->PopulateBrowserSettings(&settings);
-
   CefRefPtr<CefBrowserHost> host = browser->GetHost();
 
   // Test if the DevTools browser already exists.
-  bool has_devtools = host->HasDevTools();
+  if (!MainContext::Get()->UseChromeRuntime() && !host->HasDevTools()) {
-  if (!has_devtools) {
+    // Potentially create a new RootWindow for the DevTools browser that will be
-    // Create a new RootWindow for the DevTools browser that will be created
+    // created by ShowDevTools(). For Chrome runtime this occurs in
-    // by ShowDevTools().
+    // OnBeforeDevToolsPopup instead.
-    has_devtools = CreatePopupWindow(browser, true, CefPopupFeatures(),
+    CreatePopupWindow(browser, /*is_devtools=*/true, CefPopupFeatures(),
-                                     windowInfo, client, settings);
+                      windowInfo, client, settings);
   }
 
-  if (has_devtools) {
+  // Create the DevTools browser if it doesn't already exist.
-    // Create the DevTools browser if it doesn't already exist.
+  // Otherwise, focus the existing DevTools browser and inspect the element
-    // Otherwise, focus the existing DevTools browser and inspect the element
+  // at |inspect_element_at| if non-empty.
-    // at |inspect_element_at| if non-empty.
+  host->ShowDevTools(windowInfo, client, settings, inspect_element_at);
-    host->ShowDevTools(windowInfo, client, settings, inspect_element_at);
-  }
 }
 
 void ClientHandler::CloseDevTools(CefRefPtr<CefBrowser> browser) {
@@ -1407,11 +1425,10 @@ bool ClientHandler::CreatePopupWindow(CefRefPtr<CefBrowser> browser,
 
   // The popup browser will be parented to a new native window.
   // Don't show URL bar and navigation buttons on DevTools windows.
-  MainContext::Get()->GetRootWindowManager()->CreateRootWindowAsPopup(
+  // May return nullptr if UseDefaultPopup() returns true.
+  return !!MainContext::Get()->GetRootWindowManager()->CreateRootWindowAsPopup(
       with_controls_ && !is_devtools, is_osr_, popupFeatures, windowInfo,
       client, settings);
-
-  return true;
 }
 
 void ClientHandler::NotifyBrowserCreated(CefRefPtr<CefBrowser> browser) {

tests/cefclient/browser/client_handler.h

@@ -224,6 +224,12 @@ class ClientHandler : public CefClient,
       CefBrowserSettings& settings,
       CefRefPtr<CefDictionaryValue>& extra_info,
       bool* no_javascript_access) override;
+  void OnBeforeDevToolsPopup(CefRefPtr<CefBrowser> browser,
+                             CefWindowInfo& windowInfo,
+                             CefRefPtr<CefClient>& client,
+                             CefBrowserSettings& settings,
+                             CefRefPtr<CefDictionaryValue>& extra_info,
+                             bool* use_default_window) override;
   void OnAfterCreated(CefRefPtr<CefBrowser> browser) override;
   bool DoClose(CefRefPtr<CefBrowser> browser) override;
   void OnBeforeClose(CefRefPtr<CefBrowser> browser) override;
@@ -348,9 +354,8 @@ class ClientHandler : public CefClient,
   friend class ClientDownloadImageCallback;
 
   // Create a new popup window using the specified information. |is_devtools|
-  // will be true if the window will be used for DevTools. Return true to
+  // will be true if the window will be used for DevTools. Returns true if a
-  // proceed with popup browser creation or false to cancel the popup browser.
+  // RootWindow was created for the popup.
-  // May be called on any thead.
   bool CreatePopupWindow(CefRefPtr<CefBrowser> browser,
                          bool is_devtools,
                          const CefPopupFeatures& popupFeatures,

tests/cefclient/browser/main_context.h

@@ -42,6 +42,10 @@ class MainContext {
   // Returns true if the Chrome runtime will be used.
   virtual bool UseChromeRuntime() = 0;
 
+  // Returns true if a native parent window is being used with the Chrome
+  // runtime.
+  virtual bool UseChromeRuntimeNative() = 0;
+
   // Returns true if the Views framework will be used.
   virtual bool UseViews() = 0;
 

tests/cefclient/browser/main_context_impl.cc

@@ -111,8 +111,9 @@ MainContextImpl::MainContextImpl(CefRefPtr<CefCommandLine> command_line,
   }
 
 #if defined(OS_WIN) || defined(OS_LINUX)
-  if (use_chrome_runtime_ && !use_views_ &&
+  use_chrome_runtime_native_ =
-      !command_line->HasSwitch(switches::kUseNative)) {
+      use_chrome_runtime_ && command_line->HasSwitch(switches::kUseNative);
+  if (use_chrome_runtime_ && !use_views_ && !use_chrome_runtime_native_) {
     LOG(WARNING) << "Chrome runtime defaults to the Views framework.";
     use_views_ = true;
   }
@@ -174,6 +175,10 @@ bool MainContextImpl::UseChromeRuntime() {
   return use_chrome_runtime_;
 }
 
+bool MainContextImpl::UseChromeRuntimeNative() {
+  return use_chrome_runtime_native_;
+}
+
 bool MainContextImpl::UseViews() {
   return use_views_;
 }

tests/cefclient/browser/main_context_impl.h

@@ -29,6 +29,7 @@ class MainContextImpl : public MainContext {
   std::string GetMainURL() override;
   cef_color_t GetBackgroundColor() override;
   bool UseChromeRuntime() override;
+  bool UseChromeRuntimeNative() override;
   bool UseViews() override;
   bool UseWindowlessRendering() override;
   bool TouchEventsEnabled() override;
@@ -74,6 +75,7 @@ class MainContextImpl : public MainContext {
   bool use_windowless_rendering_;
   int windowless_frame_rate_ = 0;
   bool use_chrome_runtime_;
+  bool use_chrome_runtime_native_ = false;
   bool use_views_;
 
   std::unique_ptr<RootWindowManager> root_window_manager_;

tests/cefclient/browser/root_window.h

@@ -28,6 +28,9 @@ enum class WindowType {
 
   // The window is a modal dialog.
   DIALOG,
+
+  // The window is a DevTools popup.
+  DEVTOOLS,
 };
 
 // Used to configure how a RootWindow is created.

tests/cefclient/browser/root_window_views.cc

@@ -249,7 +249,7 @@ void RootWindowViews::OnViewsWindowClosing(CefRefPtr<ViewsWindow> window) {
   CEF_REQUIRE_UI_THREAD();
   DCHECK(window_);
 
-  if (config_->window_type != WindowType::NORMAL) {
+  if (!window_->SupportsWindowRestore()) {
     return;
   }
 
@@ -516,7 +516,7 @@ void RootWindowViews::InitOnUIThread(
     // Initial state was specified via the config object.
     initial_bounds_ = config_->bounds;
     initial_show_state_ = config_->show_state;
-  } else if (config_->window_type == WindowType::NORMAL) {
+  } else if (ViewsWindow::SupportsWindowRestore(config_->window_type)) {
     // Initial state may be specified via the command-line or global
     // preferences.
     std::optional<CefRect> bounds;

tests/cefclient/browser/views_window.cc

@@ -399,10 +399,21 @@ void ViewsWindow::OnExtensionsChanged(const ExtensionSet& extensions) {
       base::BindOnce(&ViewsWindow::OnExtensionIconsLoaded, this, extensions));
 }
 
+// static
+bool ViewsWindow::SupportsWindowRestore(WindowType type) {
+  // Only support window restore with normal windows.
+  return type == WindowType::NORMAL;
+}
+
+bool ViewsWindow::SupportsWindowRestore() const {
+  return SupportsWindowRestore(type_);
+}
+
 bool ViewsWindow::GetWindowRestorePreferences(
     cef_show_state_t& show_state,
     std::optional<CefRect>& dip_bounds) {
   CEF_REQUIRE_UI_THREAD();
+  DCHECK(SupportsWindowRestore());
   if (!window_) {
     return false;
   }
@@ -460,7 +471,9 @@ CefRefPtr<CefBrowserViewDelegate> ViewsWindow::GetDelegateForPopupBrowserView(
   DCHECK(popup_delegate != delegate_);
 
   // Create a new ViewsWindow for the popup BrowserView.
-  return new ViewsWindow(WindowType::NORMAL, popup_delegate, nullptr);
+  return new ViewsWindow(
+      is_devtools ? WindowType::DEVTOOLS : WindowType::NORMAL, popup_delegate,
+      nullptr);
 }
 
 bool ViewsWindow::OnPopupBrowserViewCreated(
@@ -676,12 +689,12 @@ void ViewsWindow::OnWindowCreated(CefRefPtr<CefWindow> window) {
 
   delegate_->OnViewsWindowCreated(this);
 
-  if (type_ == WindowType::NORMAL) {
+  if (type_ == WindowType::NORMAL || type_ == WindowType::DEVTOOLS) {
     const CefRect bounds = delegate_->GetInitialBounds();
     if (bounds.IsEmpty()) {
       // Size the Window and center it at the default size.
       window_->CenterWindow(CefSize(kDefaultWidth, kDefaultHeight));
-    } else {
+    } else if (SupportsWindowRestore()) {
       // Remember the bounds from the previous application run in case the user
       // does not move or resize the window during this application run.
       last_visible_bounds_ = bounds;
@@ -758,7 +771,7 @@ void ViewsWindow::OnWindowActivationChanged(CefRefPtr<CefWindow> window,
 
 void ViewsWindow::OnWindowBoundsChanged(CefRefPtr<CefWindow> window,
                                         const CefRect& new_bounds) {
-  if (type_ == WindowType::NORMAL && !window->IsMinimized() &&
+  if (SupportsWindowRestore() && !window->IsMinimized() &&
       !window->IsMaximized() && !window->IsFullscreen()) {
     // Track the last visible bounds for window restore purposes.
     last_visible_bounds_ = new_bounds;
@@ -845,20 +858,18 @@ bool ViewsWindow::GetTitlebarHeight(CefRefPtr<CefWindow> window,
 
 bool ViewsWindow::CanResize(CefRefPtr<CefWindow> window) {
   CEF_REQUIRE_UI_THREAD();
-  // Only allow resize of normal windows.
+  // Only allow resize of normal and DevTools windows.
-  return type_ == WindowType::NORMAL;
+  return type_ == WindowType::NORMAL || type_ == WindowType::DEVTOOLS;
 }
 
 bool ViewsWindow::CanMaximize(CefRefPtr<CefWindow> window) {
   CEF_REQUIRE_UI_THREAD();
-  // Only allow maximize of normal windows.
+  return CanResize(window);
-  return type_ == WindowType::NORMAL;
 }
 
 bool ViewsWindow::CanMinimize(CefRefPtr<CefWindow> window) {
   CEF_REQUIRE_UI_THREAD();
-  // Only allow minimize of normal windows.
+  return CanResize(window);
-  return type_ == WindowType::NORMAL;
 }
 
 bool ViewsWindow::OnAccelerator(CefRefPtr<CefWindow> window, int command_id) {

tests/cefclient/browser/views_window.h

@@ -127,6 +127,8 @@ class ViewsWindow : public CefBrowserViewDelegate,
   void OnBeforeContextMenu(CefRefPtr<CefMenuModel> model);
   void OnExtensionsChanged(const ExtensionSet& extensions);
 
+  static bool SupportsWindowRestore(WindowType type);
+  bool SupportsWindowRestore() const;
   bool GetWindowRestorePreferences(cef_show_state_t& show_state,
                                    std::optional<CefRect>& dip_bounds);
   void SetTitlebarHeight(const std::optional<float>& height);

tests/ceftests/navigation_unittest.cc

@@ -1980,7 +1980,7 @@ class LoadNavTestHandler : public TestHandler {
       EXPECT_TRUE(user_gesture);
     }
 
-    EXPECT_EQ(WOD_NEW_BACKGROUND_TAB, target_disposition);
+    EXPECT_EQ(CEF_WOD_NEW_BACKGROUND_TAB, target_disposition);
 
     // OnOpenURLFromTab should be called before OnBeforeBrowse for the file URL.
     EXPECT_FALSE(got_before_browse_);

tests/ceftests/request_context_unittest.cc

@@ -298,7 +298,7 @@ class PopupTestHandler : public TestHandler {
     const std::string& url = target_url;
     EXPECT_STREQ(url.c_str(), popup_url_.c_str());
 
-    EXPECT_EQ(WOD_NEW_FOREGROUND_TAB, target_disposition);
+    EXPECT_EQ(CEF_WOD_NEW_FOREGROUND_TAB, target_disposition);
 
     if (mode_ == MODE_WINDOW_OPEN) {
       EXPECT_FALSE(user_gesture);
@@ -528,7 +528,7 @@ class PopupNavTestHandler : public TestHandler {
     EXPECT_STREQ(kPopupNavPageUrl, frame->GetURL().ToString().c_str());
     EXPECT_STREQ(kPopupNavPopupUrl, target_url.ToString().c_str());
     EXPECT_STREQ(kPopupNavPopupName, target_frame_name.ToString().c_str());
-    EXPECT_EQ(WOD_NEW_FOREGROUND_TAB, target_disposition);
+    EXPECT_EQ(CEF_WOD_NEW_FOREGROUND_TAB, target_disposition);
     EXPECT_FALSE(user_gesture);
     EXPECT_FALSE(*no_javascript_access);
 

tests/ceftests/test_handler.cc

@@ -23,7 +23,7 @@
 
 namespace {
 
-bool UseViews() {
+bool UseViewsGlobal() {
   static bool use_views = []() {
     return CefCommandLine::GetGlobalCommandLine()->HasSwitch(
         client::switches::kUseViews);
@@ -237,7 +237,8 @@ void TestHandler::UIThreadHelper::TaskHelper(base::OnceClosure task) {
 std::atomic<size_t> TestHandler::test_handler_count_{0U};
 
 TestHandler::TestHandler(CompletionState* completion_state)
-    : debug_string_prefix_(MakeDebugStringPrefix()) {
+    : debug_string_prefix_(MakeDebugStringPrefix()),
+      use_views_(UseViewsGlobal()) {
   test_handler_count_++;
 
   if (completion_state) {
@@ -281,7 +282,8 @@ void TestHandler::OnAfterCreated(CefRefPtr<CefBrowser> browser) {
   }
   browser_map_.insert(std::make_pair(browser_id, browser));
 
-  OnCreated(browser_id, NT_BROWSER);
+  const bool views_hosted = !!CefBrowserView::GetForBrowser(browser);
+  OnCreated(browser_id, NT_BROWSER, views_hosted);
 }
 
 void TestHandler::OnBeforeClose(CefRefPtr<CefBrowser> browser) {
@@ -302,19 +304,31 @@ void TestHandler::OnBeforeClose(CefRefPtr<CefBrowser> browser) {
 }
 
 void TestHandler::OnWindowCreated(int browser_id) {
-  CHECK(UseViews());
+  CHECK(use_views_);
   EXPECT_UI_THREAD();
-  OnCreated(browser_id, NT_WINDOW);
+  OnCreated(browser_id, NT_WINDOW, /*views_hosted=*/true);
 }
 
 void TestHandler::OnWindowDestroyed(int browser_id) {
-  CHECK(UseViews());
+  CHECK(use_views_);
   EXPECT_UI_THREAD();
   OnClosed(browser_id, NT_WINDOW);
 }
 
-void TestHandler::OnCreated(int browser_id, NotifyType type) {
+void TestHandler::OnCreated(int browser_id,
+                            NotifyType type,
+                            bool views_hosted) {
+  CHECK(use_views_ || !views_hosted);
+
+  const bool has_value = browser_status_map_.contains(browser_id);
+
   auto& browser_status = browser_status_map_[browser_id];
+  if (has_value) {
+    CHECK_EQ(browser_status.views_hosted, views_hosted);
+  } else {
+    browser_status.views_hosted = views_hosted;
+  }
+
   EXPECT_FALSE(browser_status.got_created[type])
       << "Duplicate call to OnCreated(" << browser_id << ", "
       << (type == NT_BROWSER ? "BROWSER" : "WINDOW") << ")";
@@ -324,7 +338,7 @@ void TestHandler::OnCreated(int browser_id, NotifyType type) {
   bool creation_complete = false;
 
   // When using Views, wait for both Browser and Window notifications.
-  if (UseViews()) {
+  if (browser_status.views_hosted) {
     creation_complete = browser_status.got_created[NT_BROWSER] &&
                         browser_status.got_created[NT_WINDOW];
   } else {
@@ -347,7 +361,7 @@ void TestHandler::OnClosed(int browser_id, NotifyType type) {
   browser_status.got_closed[type].yes();
 
   // When using Views, wait for both Browser and Window notifications.
-  if (UseViews()) {
+  if (browser_status.views_hosted) {
     close_complete = browser_status.got_closed[NT_BROWSER] &&
                      browser_status.got_closed[NT_WINDOW];
   } else {
@@ -517,8 +531,7 @@ void TestHandler::OnTestTimeout(int timeout_ms, bool treat_as_error) {
 void TestHandler::CreateBrowser(const CefString& url,
                                 CefRefPtr<CefRequestContext> request_context,
                                 CefRefPtr<CefDictionaryValue> extra_info) {
-  if (UseViews() && !CefCurrentlyOn(TID_UI)) {
+  if (!CefCurrentlyOn(TID_UI)) {
-    // Views classes must be accessed on the UI thread.
     CefPostTask(TID_UI, base::BindOnce(&TestHandler::CreateBrowser, this, url,
                                        request_context, extra_info));
     return;
@@ -527,7 +540,7 @@ void TestHandler::CreateBrowser(const CefString& url,
   CefWindowInfo windowInfo;
   CefBrowserSettings settings;
 
-  if (UseViews()) {
+  if (use_views_) {
     // Create the BrowserView.
     CefRefPtr<CefBrowserView> browser_view = CefBrowserView::CreateBrowserView(
         this, url, settings, extra_info, request_context,
@@ -615,6 +628,16 @@ void TestHandler::SetTestTimeout(int timeout_ms, bool treat_as_error) {
       *timeout);
 }
 
+void TestHandler::SetUseViews(bool use_views) {
+  if (!CefCurrentlyOn(TID_UI)) {
+    CefPostTask(TID_UI,
+                base::BindOnce(&TestHandler::SetUseViews, this, use_views));
+    return;
+  }
+
+  use_views_ = use_views;
+}
+
 void TestHandler::SetSignalTestCompletionCount(size_t count) {
 #if VERBOSE_DEBUGGING
   LOG(INFO) << debug_string_prefix_

tests/ceftests/test_handler.h

@@ -262,7 +262,7 @@ class TestHandler : public CefClient,
   // number of times.
   void SignalTestCompletion();
 
-  // Reuturns true if SignalTestCompletion() has been called the necessary
+  // Returns true if SignalTestCompletion() has been called the necessary
   // number of times (may be 0), in which case TestComplete() will be called
   // automatically when all browsers have closed. Must be called on the
   // UI thread.
@@ -275,6 +275,11 @@ class TestHandler : public CefClient,
   // Call OnTestTimeout() after the specified amount of time.
   void SetTestTimeout(int timeout_ms = 5000, bool treat_as_error = true);
 
+  // Call prior to CreateBrowser() to configure whether browsers will be created
+  // as Views-hosted. Defaults to false unless the `--use-views` command-line
+  // flag is specified.
+  void SetUseViews(bool use_views);
+
   // Returns the single UIThreadHelper instance, creating it if necessary. Must
   // be called on the UI thread.
   UIThreadHelper* GetUIThreadHelper();
@@ -290,7 +295,7 @@ class TestHandler : public CefClient,
     NT_BROWSER,
     NT_WINDOW,
   };
-  void OnCreated(int browser_id, NotifyType type);
+  void OnCreated(int browser_id, NotifyType type, bool views_hosted);
   void OnClosed(int browser_id, NotifyType type);
 
   std::string MakeDebugStringPrefix() const;
@@ -300,10 +305,17 @@ class TestHandler : public CefClient,
   CompletionState* completion_state_;
   bool completion_state_owned_;
 
+  bool use_views_;
+
   // Map of browser ID to browser object. Only accessed on the UI thread.
   BrowserMap browser_map_;
 
   struct NotifyStatus {
+    // True if this particular browser window is Views-hosted (see SetUseViews).
+    // Some tests create popup or DevTools windows with default handling (e.g.
+    // not Views-hosted).
+    bool views_hosted;
+
     // Keyed by NotifyType.
     TrackCallback got_created[2];
     TrackCallback got_closed[2];

tests/ceftests/v8_unittest.cc

@@ -11,10 +11,8 @@
 #include "tests/ceftests/test_handler.h"
 #include "tests/ceftests/test_util.h"
 #include "tests/gtest/include/gtest/gtest.h"
-#include "tests/shared/browser/client_app_browser.h"
 #include "tests/shared/renderer/client_app_renderer.h"
 
-using client::ClientAppBrowser;
 using client::ClientAppRenderer;
 
 // How to add a new test:
@@ -3280,8 +3278,7 @@ class V8TestHandler : public TestHandler {
         CefBrowserSettings settings;
 
 #if defined(OS_WIN)
-        windowInfo.SetAsPopup(browser->GetHost()->GetWindowHandle(),
+        windowInfo.SetAsPopup(nullptr, "DevTools");
-                              "DevTools");
 #endif
 
         browser->GetHost()->ShowDevTools(windowInfo, this, settings,