DevTools: allow inspecting browsers using custom front-ends.

chrome/browser/ui/webui/inspect_ui.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/ui/webui/inspect_ui.h"
 
 #include "base/prefs/pref_service.h"
 #include "base/stl_util.h"
 #include "chrome/browser/devtools/devtools_target_impl.h"
 #include "chrome/browser/devtools/devtools_targets_ui.h"
+#include "chrome/browser/devtools/devtools_ui_bindings.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/singleton_tabs.h"
 #include "chrome/browser/ui/webui/theme_source.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
+#include "content/public/browser/devtools_agent_host.h"
+#include "content/public/browser/devtools_manager.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
+#include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/browser/web_ui_data_source.h"
 #include "content/public/browser/web_ui_message_handler.h"
 #include "grit/browser_resources.h"
 
 using content::WebContents;
 using content::WebUIMessageHandler;
 
 namespace {
 
 const char kInitUICommand[]  = "init-ui";
 const char kInspectCommand[]  = "inspect";
 const char kActivateCommand[]  = "activate";
 const char kCloseCommand[]  = "close";
 const char kReloadCommand[]  = "reload";
 const char kOpenCommand[]  = "open";
+const char kInspectBrowser[] = "inspect-browser";
 
 const char kDiscoverUsbDevicesEnabledCommand[] =
     "set-discover-usb-devices-enabled";
 const char kPortForwardingEnabledCommand[] =
     "set-port-forwarding-enabled";
 const char kPortForwardingConfigCommand[] = "set-port-forwarding-config";
 
 const char kPortForwardingDefaultPort[] = "8080";
 const char kPortForwardingDefaultLocation[] = "localhost:8080";
 
 class InspectMessageHandler : public WebUIMessageHandler {
  public:
   explicit InspectMessageHandler(InspectUI* inspect_ui)
       : inspect_ui_(inspect_ui) {}
   virtual ~InspectMessageHandler() {}
 
  private:
   // WebUIMessageHandler implementation.
   virtual void RegisterMessages() OVERRIDE;
 
   void HandleInitUICommand(const base::ListValue* args);
   void HandleInspectCommand(const base::ListValue* args);
   void HandleActivateCommand(const base::ListValue* args);
   void HandleCloseCommand(const base::ListValue* args);
   void HandleReloadCommand(const base::ListValue* args);
   void HandleOpenCommand(const base::ListValue* args);
+  void HandleInspectBrowserCommand(const base::ListValue* args);
   void HandleBooleanPrefChanged(const char* pref_name,
                                 const base::ListValue* args);
   void HandlePortForwardingConfigCommand(const base::ListValue* args);
 
   InspectUI* inspect_ui_;
 
   DISALLOW_COPY_AND_ASSIGN(InspectMessageHandler);
 };
 
 void InspectMessageHandler::RegisterMessages() {
@@ skipping 19 matching lines @@
                  &prefs::kDevToolsPortForwardingEnabled[0]));
   web_ui()->RegisterMessageCallback(kPortForwardingConfigCommand,
       base::Bind(&InspectMessageHandler::HandlePortForwardingConfigCommand,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kReloadCommand,
       base::Bind(&InspectMessageHandler::HandleReloadCommand,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kOpenCommand,
       base::Bind(&InspectMessageHandler::HandleOpenCommand,
                  base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(kInspectBrowser,
+      base::Bind(&InspectMessageHandler::HandleInspectBrowserCommand,
+                 base::Unretained(this)));
 }
 
 void InspectMessageHandler::HandleInitUICommand(const base::ListValue*) {
   inspect_ui_->InitUI();
 }
 
 static bool ParseStringArgs(const base::ListValue* args,
                             std::string* arg0,
                             std::string* arg1,
                             std::string* arg2 = 0) {
@@ skipping 32 matching lines @@
 }
 
 void InspectMessageHandler::HandleOpenCommand(const base::ListValue* args) {
   std::string source_id;
   std::string browser_id;
   std::string url;
   if (ParseStringArgs(args, &source_id, &browser_id, &url))
     inspect_ui_->Open(source_id, browser_id, url);
 }
 
+void InspectMessageHandler::HandleInspectBrowserCommand(
+    const base::ListValue* args) {
+  std::string source_id;
+  std::string browser_id;
+  std::string front_end;
+  if (ParseStringArgs(args, &source_id, &browser_id, &front_end)) {
+    inspect_ui_->InspectBrowserWithCustomFrontend(
+        source_id, browser_id, GURL(front_end));
+  }
+}
+
 void InspectMessageHandler::HandleBooleanPrefChanged(
     const char* pref_name,
     const base::ListValue* args) {
   Profile* profile = Profile::FromWebUI(web_ui());
   if (!profile)
     return;
 
   bool enabled;
   if (args->GetSize() == 1 && args->GetBoolean(0, &enabled))
     profile->GetPrefs()->SetBoolean(pref_name, enabled);
@@ skipping 66 matching lines @@
 static void NoOp(DevToolsTargetImpl*) {}
 
 void InspectUI::Open(const std::string& source_id,
                      const std::string& browser_id,
                      const std::string& url) {
   DevToolsTargetsUIHandler* handler = FindTargetHandler(source_id);
   if (handler)
     handler->Open(browser_id, url, base::Bind(&NoOp));
 }
 
+void InspectUI::InspectBrowserWithCustomFrontend(
+    const std::string& source_id,
+    const std::string& browser_id,
+    const GURL& frontend_url) {
+  DevToolsTargetsUIHandler* handler = FindTargetHandler(source_id);
+  if (!handler)
+    return;
+
+  // Fetch agent host from remote browser.
+  scoped_refptr<content::DevToolsAgentHost> agent_host =
+      handler->GetBrowserAgentHost(browser_id);
+  if (agent_host->IsAttached())
+    return;
+
+  // Create web contents for the front-end.

[Vladislav Kaznacheev, 2014/05/16 13:38:37]

This class is a UI handler. The tab opening and bindings stuff are al
implementation details which could change tomorrow (we might even teach
DevToolsWindow to host this custom frontend)

I suggest moving the implementation details into RemoteBrowser. The code below
should become:

handler->InspectBrowserWithCustomFrontend(inspect_ui, front_end_url).

+  WebContents* inspect_ui = web_ui()->GetWebContents();
+  WebContents* front_end = inspect_ui->GetDelegate()->OpenURLFromTab(
+      inspect_ui,
+      content::OpenURLParams(GURL(content::kAboutBlankURL),
+                    content::Referrer(),
+                    NEW_FOREGROUND_TAB,
+                    content::PAGE_TRANSITION_AUTO_TOPLEVEL,
+                    false));
+
+  // Install devtools bindings.
+  DevToolsUIBindings* bindings = DevToolsUIBindings::GetOrCreateFor(front_end);
+
+  // Navigate to a page.
+  front_end->GetController().LoadURL(
+      frontend_url, content::Referrer(),
+      content::PAGE_TRANSITION_AUTO_TOPLEVEL, std::string());
+
+
+  // Engage remote debugging between front-end and agent host.
+  content::DevToolsManager::GetInstance()->RegisterDevToolsClientHostFor(
+      agent_host, bindings->frontend_host());
+}
+
 void InspectUI::InspectDevices(Browser* browser) {
   content::RecordAction(base::UserMetricsAction("InspectDevices"));
   chrome::NavigateParams params(chrome::GetSingletonTabNavigateParams(
       browser, GURL(chrome::kChromeUIInspectURL)));
   params.path_behavior = chrome::NavigateParams::IGNORE_AND_NAVIGATE;
   ShowSingletonTabOverwritingNTP(browser, params);
 }
 
 void InspectUI::Observe(int type,
     const content::NotificationSource& source,
@@ skipping 140 matching lines @@
   scoped_ptr<base::Value> source_value(base::Value::CreateStringValue(source));
   web_ui()->CallJavascriptFunction(
       "populateTargets",
       *source_value.get(),
       *targets.get());
 }
 
 void InspectUI::PopulatePortStatus(const base::Value& status) {
   web_ui()->CallJavascriptFunction("populatePortStatus", status);
 }