chrome: Add DevTools protocol support (see issue #2969)

Testable with the following:
$ ceftests --enable-chrome-runtime --gtest_filter=DevToolsMessageTest.*

libcef/browser/alloy/alloy_browser_host_impl.cc

@@ -528,82 +528,6 @@ bool AlloyBrowserHostImpl::HasDevTools() {
   return devtools_manager_->HasDevTools();
 }
 
-bool AlloyBrowserHostImpl::SendDevToolsMessage(const void* message,
-                                               size_t message_size) {
-  if (!message || message_size == 0)
-    return false;
-
-  if (!CEF_CURRENTLY_ON_UIT()) {
-    std::string message_str(static_cast<const char*>(message), message_size);
-    CEF_POST_TASK(
-        CEF_UIT,
-        base::BindOnce(
-            [](CefRefPtr<AlloyBrowserHostImpl> self, std::string message_str) {
-              self->SendDevToolsMessage(message_str.data(), message_str.size());
-            },
-            CefRefPtr<AlloyBrowserHostImpl>(this), std::move(message_str)));
-    return false;
-  }
-
-  if (!EnsureDevToolsManager())
-    return false;
-  return devtools_manager_->SendDevToolsMessage(message, message_size);
-}
-
-int AlloyBrowserHostImpl::ExecuteDevToolsMethod(
-    int message_id,
-    const CefString& method,
-    CefRefPtr<CefDictionaryValue> params) {
-  if (!CEF_CURRENTLY_ON_UIT()) {
-    CEF_POST_TASK(
-        CEF_UIT,
-        base::BindOnce(
-            base::IgnoreResult(&AlloyBrowserHostImpl::ExecuteDevToolsMethod),
-            this, message_id, method, params));
-    return 0;
-  }
-
-  if (!EnsureDevToolsManager())
-    return 0;
-  return devtools_manager_->ExecuteDevToolsMethod(message_id, method, params);
-}
-
-CefRefPtr<CefRegistration> AlloyBrowserHostImpl::AddDevToolsMessageObserver(
-    CefRefPtr<CefDevToolsMessageObserver> observer) {
-  if (!observer)
-    return nullptr;
-  auto registration = CefDevToolsManager::CreateRegistration(observer);
-  InitializeDevToolsRegistrationOnUIThread(registration);
-  return registration.get();
-}
-
-bool AlloyBrowserHostImpl::EnsureDevToolsManager() {
-  CEF_REQUIRE_UIT();
-  if (!web_contents())
-    return false;
-
-  if (!devtools_manager_) {
-    devtools_manager_.reset(new CefDevToolsManager(this));
-  }
-  return true;
-}
-
-void AlloyBrowserHostImpl::InitializeDevToolsRegistrationOnUIThread(
-    CefRefPtr<CefRegistration> registration) {
-  if (!CEF_CURRENTLY_ON_UIT()) {
-    CEF_POST_TASK(
-        CEF_UIT,
-        base::BindOnce(
-            &AlloyBrowserHostImpl::InitializeDevToolsRegistrationOnUIThread,
-            this, registration));
-    return;
-  }
-
-  if (!EnsureDevToolsManager())
-    return;
-  devtools_manager_->InitializeRegistrationOnUIThread(registration);
-}
-
 void AlloyBrowserHostImpl::SetAccessibilityState(
     cef_state_t accessibility_state) {
   if (!CEF_CURRENTLY_ON_UIT()) {
@@ -857,8 +781,6 @@ void AlloyBrowserHostImpl::DestroyBrowser() {
   recently_audible_timer_.Stop();
   audio_capturer_.reset(nullptr);
 
-  devtools_manager_.reset(nullptr);
-
   CefBrowserHostBase::DestroyBrowser();
 }
 

libcef/browser/alloy/alloy_browser_host_impl.h

@@ -31,7 +31,6 @@
 
 class CefAudioCapturer;
 class CefBrowserInfo;
-class CefDevToolsManager;
 class SiteInstance;
 
 // CefBrowser implementation for the alloy runtime. Method calls are delegated
@@ -112,12 +111,6 @@ class AlloyBrowserHostImpl : public CefBrowserHostBase,
                     const CefPoint& inspect_element_at) override;
   void CloseDevTools() override;
   bool HasDevTools() override;
-  bool SendDevToolsMessage(const void* message, size_t message_size) override;
-  int ExecuteDevToolsMethod(int message_id,
-                            const CefString& method,
-                            CefRefPtr<CefDictionaryValue> params) override;
-  CefRefPtr<CefRegistration> AddDevToolsMessageObserver(
-      CefRefPtr<CefDevToolsMessageObserver> observer) override;
   bool IsWindowRenderingDisabled() override;
   void WasResized() override;
   void WasHidden(bool hidden) override;
@@ -352,10 +345,6 @@ class AlloyBrowserHostImpl : public CefBrowserHostBase,
   void StartAudioCapturer();
   void OnRecentlyAudibleTimerFired();
 
-  bool EnsureDevToolsManager();
-  void InitializeDevToolsRegistrationOnUIThread(
-      CefRefPtr<CefRegistration> registration);
-
   void SetFocusInternal(bool focus);
 
   CefWindowHandle opener_;
@@ -381,9 +370,6 @@ class AlloyBrowserHostImpl : public CefBrowserHostBase,
   // Used for creating and managing context menus.
   std::unique_ptr<CefMenuManager> menu_manager_;
 
-  // Used for creating and managing DevTools instances.
-  std::unique_ptr<CefDevToolsManager> devtools_manager_;
-
   // Used for capturing audio for CefAudioHandler.
   std::unique_ptr<CefAudioCapturer> audio_capturer_;
 

libcef/browser/browser_host_base.cc

@@ -185,6 +185,8 @@ void CefBrowserHostBase::InitializeBrowser() {
 void CefBrowserHostBase::DestroyBrowser() {
   CEF_REQUIRE_UIT();
 
+  devtools_manager_.reset(nullptr);
+
   platform_delegate_.reset(nullptr);
 
   contents_delegate_->RemoveObserver(this);
@@ -289,6 +291,54 @@ void CefBrowserHostBase::DownloadImage(
           max_image_size, callback));
 }
 
+bool CefBrowserHostBase::SendDevToolsMessage(const void* message,
+                                             size_t message_size) {
+  if (!message || message_size == 0)
+    return false;
+
+  if (!CEF_CURRENTLY_ON_UIT()) {
+    std::string message_str(static_cast<const char*>(message), message_size);
+    CEF_POST_TASK(
+        CEF_UIT,
+        base::BindOnce(
+            [](CefRefPtr<CefBrowserHostBase> self, std::string message_str) {
+              self->SendDevToolsMessage(message_str.data(), message_str.size());
+            },
+            CefRefPtr<CefBrowserHostBase>(this), std::move(message_str)));
+    return false;
+  }
+
+  if (!EnsureDevToolsManager())
+    return false;
+  return devtools_manager_->SendDevToolsMessage(message, message_size);
+}
+
+int CefBrowserHostBase::ExecuteDevToolsMethod(
+    int message_id,
+    const CefString& method,
+    CefRefPtr<CefDictionaryValue> params) {
+  if (!CEF_CURRENTLY_ON_UIT()) {
+    CEF_POST_TASK(
+        CEF_UIT, base::BindOnce(base::IgnoreResult(
+                                    &CefBrowserHostBase::ExecuteDevToolsMethod),
+                                this, message_id, method, params));
+    return 0;
+  }
+
+  if (!EnsureDevToolsManager())
+    return 0;
+  return devtools_manager_->ExecuteDevToolsMethod(message_id, method, params);
+}
+
+CefRefPtr<CefRegistration> CefBrowserHostBase::AddDevToolsMessageObserver(
+    CefRefPtr<CefDevToolsMessageObserver> observer) {
+  if (!observer)
+    return nullptr;
+  auto registration = CefDevToolsManager::CreateRegistration(observer);
+  InitializeDevToolsRegistrationOnUIThread(registration);
+  return registration.get();
+}
+
 void CefBrowserHostBase::GetNavigationEntries(
     CefRefPtr<CefNavigationEntryVisitor> visitor,
     bool current_only) {
@@ -811,3 +861,30 @@ CefRefPtr<CefBrowserView> CefBrowserHostBase::GetBrowserView() const {
   return nullptr;
 }
 #endif  // defined(TOOLKIT_VIEWS)
+
+bool CefBrowserHostBase::EnsureDevToolsManager() {
+  CEF_REQUIRE_UIT();
+  if (!contents_delegate_->web_contents())
+    return false;
+
+  if (!devtools_manager_) {
+    devtools_manager_.reset(new CefDevToolsManager(this));
+  }
+  return true;
+}
+
+void CefBrowserHostBase::InitializeDevToolsRegistrationOnUIThread(
+    CefRefPtr<CefRegistration> registration) {
+  if (!CEF_CURRENTLY_ON_UIT()) {
+    CEF_POST_TASK(
+        CEF_UIT,
+        base::BindOnce(
+            &CefBrowserHostBase::InitializeDevToolsRegistrationOnUIThread, this,
+            registration));
+    return;
+  }
+
+  if (!EnsureDevToolsManager())
+    return;
+  devtools_manager_->InitializeRegistrationOnUIThread(registration);
+}

libcef/browser/browser_host_base.h

@@ -12,6 +12,7 @@
 #include "libcef/browser/browser_contents_delegate.h"
 #include "libcef/browser/browser_info.h"
 #include "libcef/browser/browser_platform_delegate.h"
+#include "libcef/browser/devtools/devtools_manager.h"
 #include "libcef/browser/frame_host_impl.h"
 #include "libcef/browser/request_context_impl.h"
 
@@ -165,6 +166,12 @@ class CefBrowserHostBase : public CefBrowserHost,
   void SendMouseWheelEvent(const CefMouseEvent& event,
                            int deltaX,
                            int deltaY) override;
+  bool SendDevToolsMessage(const void* message, size_t message_size) override;
+  int ExecuteDevToolsMethod(int message_id,
+                            const CefString& method,
+                            CefRefPtr<CefDictionaryValue> params) override;
+  CefRefPtr<CefRegistration> AddDevToolsMessageObserver(
+      CefRefPtr<CefDevToolsMessageObserver> observer) override;
   void GetNavigationEntries(CefRefPtr<CefNavigationEntryVisitor> visitor,
                             bool current_only) override;
   CefRefPtr<CefNavigationEntry> GetVisibleNavigationEntry() override;
@@ -256,6 +263,10 @@ class CefBrowserHostBase : public CefBrowserHost,
 #endif
 
  protected:
+  bool EnsureDevToolsManager();
+  void InitializeDevToolsRegistrationOnUIThread(
+      CefRefPtr<CefRegistration> registration);
+
   // Called from LoadMainFrameURL to perform the actual navigation.
   virtual bool Navigate(const content::OpenURLParams& params);
 
@@ -284,6 +295,9 @@ class CefBrowserHostBase : public CefBrowserHost,
   bool is_fullscreen_ = false;
   CefRefPtr<CefFrameHostImpl> focused_frame_;
 
+  // Used for creating and managing DevTools instances.
+  std::unique_ptr<CefDevToolsManager> devtools_manager_;
+
  private:
   IMPLEMENT_REFCOUNTING(CefBrowserHostBase);
   DISALLOW_COPY_AND_ASSIGN(CefBrowserHostBase);

libcef/browser/chrome/chrome_browser_host_impl.cc

@@ -283,26 +283,6 @@ bool ChromeBrowserHostImpl::HasDevTools() {
   return false;
 }
 
-bool ChromeBrowserHostImpl::SendDevToolsMessage(const void* message,
-                                                size_t message_size) {
-  NOTIMPLEMENTED();
-  return false;
-}
-
-int ChromeBrowserHostImpl::ExecuteDevToolsMethod(
-    int message_id,
-    const CefString& method,
-    CefRefPtr<CefDictionaryValue> params) {
-  NOTIMPLEMENTED();
-  return 0;
-}
-
-CefRefPtr<CefRegistration> ChromeBrowserHostImpl::AddDevToolsMessageObserver(
-    CefRefPtr<CefDevToolsMessageObserver> observer) {
-  NOTIMPLEMENTED();
-  return nullptr;
-}
-
 bool ChromeBrowserHostImpl::IsWindowRenderingDisabled() {
   return false;
 }

libcef/browser/chrome/chrome_browser_host_impl.h

@@ -90,12 +90,6 @@ class ChromeBrowserHostImpl : public CefBrowserHostBase {
                     const CefPoint& inspect_element_at) override;
   void CloseDevTools() override;
   bool HasDevTools() override;
-  bool SendDevToolsMessage(const void* message, size_t message_size) override;
-  int ExecuteDevToolsMethod(int message_id,
-                            const CefString& method,
-                            CefRefPtr<CefDictionaryValue> params) override;
-  CefRefPtr<CefRegistration> AddDevToolsMessageObserver(
-      CefRefPtr<CefDevToolsMessageObserver> observer) override;
   bool IsWindowRenderingDisabled() override;
   void WasResized() override;
   void WasHidden(bool hidden) override;

libcef/browser/devtools/devtools_manager.cc

@@ -6,6 +6,7 @@
 
 #include "libcef/browser/devtools/devtools_controller.h"
 #include "libcef/browser/devtools/devtools_frontend.h"
+#include "libcef/features/runtime.h"
 
 #include "content/public/browser/web_contents.h"
 
@@ -31,7 +32,7 @@ class CefDevToolsRegistrationImpl : public CefRegistration,
     controller_->RemoveObserver(this);
   }
 
-  void Initialize(AlloyBrowserHostImpl* browser,
+  void Initialize(CefBrowserHostBase* browser,
                   base::WeakPtr<CefDevToolsController> controller) {
     CEF_REQUIRE_UIT();
     DCHECK(browser && controller);
@@ -83,7 +84,7 @@ class CefDevToolsRegistrationImpl : public CefRegistration,
 
   CefRefPtr<CefDevToolsMessageObserver> observer_;
 
-  AlloyBrowserHostImpl* browser_ = nullptr;
+  CefBrowserHostBase* browser_ = nullptr;
   base::WeakPtr<CefDevToolsController> controller_;
 
   IMPLEMENT_REFCOUNTING_DELETE_ON_UIT(CefDevToolsRegistrationImpl);
@@ -92,7 +93,7 @@ class CefDevToolsRegistrationImpl : public CefRegistration,
 
 }  // namespace
 
-CefDevToolsManager::CefDevToolsManager(AlloyBrowserHostImpl* inspected_browser)
+CefDevToolsManager::CefDevToolsManager(CefBrowserHostBase* inspected_browser)
     : inspected_browser_(inspected_browser), weak_ptr_factory_(this) {
   CEF_REQUIRE_UIT();
 }
@@ -115,11 +116,16 @@ void CefDevToolsManager::ShowDevTools(const CefWindowInfo& windowInfo,
     return;
   }
 
+  if (cef::IsChromeRuntimeEnabled()) {
+    NOTIMPLEMENTED();
+  } else {
+    auto alloy_browser = static_cast<AlloyBrowserHostImpl*>(inspected_browser_);
     devtools_frontend_ = CefDevToolsFrontend::Show(
-      inspected_browser_, windowInfo, client, settings, inspect_element_at,
+        alloy_browser, windowInfo, client, settings, inspect_element_at,
         base::BindOnce(&CefDevToolsManager::OnFrontEndDestroyed,
                        weak_ptr_factory_.GetWeakPtr()));
   }
+}
 
 void CefDevToolsManager::CloseDevTools() {
   CEF_REQUIRE_UIT();
@@ -193,8 +199,8 @@ void CefDevToolsManager::OnFrontEndDestroyed() {
 
 bool CefDevToolsManager::EnsureController() {
   if (!devtools_controller_) {
-    devtools_controller_.reset(
+    devtools_controller_.reset(new CefDevToolsController(
-        new CefDevToolsController(inspected_browser_->web_contents()));
+        inspected_browser_->contents_delegate()->web_contents()));
   }
   return true;
 }

libcef/browser/devtools/devtools_manager.h

@@ -10,7 +10,7 @@
 
 #include "base/memory/weak_ptr.h"
 
-class AlloyBrowserHostImpl;
+class CefBrowserHostBase;
 class CefDevToolsController;
 class CefDevToolsFrontend;
 
@@ -23,7 +23,7 @@ class WebContents;
 class CefDevToolsManager {
  public:
   // |inspected_browser| will outlive this object.
-  explicit CefDevToolsManager(AlloyBrowserHostImpl* inspected_browser);
+  explicit CefDevToolsManager(CefBrowserHostBase* inspected_browser);
   ~CefDevToolsManager();
 
   // See CefBrowserHost methods of the same name for documentation.
@@ -52,7 +52,7 @@ class CefDevToolsManager {
 
   bool EnsureController();
 
-  AlloyBrowserHostImpl* const inspected_browser_;
+  CefBrowserHostBase* const inspected_browser_;
 
   // CefDevToolsFrontend will delete itself when the frontend WebContents is
   // destroyed.