DevTools: untangle device discovery request from the devtools android bridge.

chrome/browser/devtools/devtools_window.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/devtools/devtools_window.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
@@ skipping 448 matching lines @@
 
 // static
 void DevToolsWindow::OpenDevToolsWindow(
     content::WebContents* inspected_web_contents) {
   ToggleDevToolsWindow(
         inspected_web_contents, true, DevToolsToggleAction::Show(), "");
 }
 
 // static
 void DevToolsWindow::OpenDevToolsWindow(
+    scoped_refptr<content::DevToolsAgentHost> agent_host,
+    Profile* profile) {
+  if (!profile)
+    profile = Profile::FromBrowserContext(agent_host->GetBrowserContext());
+
+  if (!profile)
+    return;
+
+  std::string type = agent_host->GetType();
+  bool is_worker = type == DevToolsAgentHost::kTypeServiceWorker ||
+                   type == DevToolsAgentHost::kTypeSharedWorker;
+
+  if (!agent_host->GetFrontendURL().empty()) {
+    bool is_v8_only = type == "node";
+    DevToolsWindow::OpenExternalFrontend(profile, agent_host->GetFrontendURL(),
+                                         agent_host, is_worker, is_v8_only);
+    return;
+  }
+
+  if (is_worker) {
+    DevToolsWindow::OpenDevToolsWindowForWorker(profile, agent_host);
+    return;
+  }
+
+  if (type == content::DevToolsAgentHost::kTypeFrame) {
+    DevToolsWindow::OpenDevToolsWindowForFrame(profile, agent_host);
+    return;
+  }
+
+  content::WebContents* web_contents = agent_host->GetWebContents();
+  if (web_contents)
+    DevToolsWindow::OpenDevToolsWindow(web_contents);
+}
+
+// static
+void DevToolsWindow::OpenDevToolsWindow(
     content::WebContents* inspected_web_contents,
     const DevToolsToggleAction& action) {
   ToggleDevToolsWindow(inspected_web_contents, true, action, "");
 }
 
 // static
-void DevToolsWindow::OpenDevToolsWindow(
+void DevToolsWindow::OpenDevToolsWindowForFrame(
     Profile* profile,
     const scoped_refptr<content::DevToolsAgentHost>& agent_host) {
   DevToolsWindow* window = FindDevToolsWindow(agent_host.get());
   if (!window) {
     window = DevToolsWindow::Create(profile, GURL(), nullptr, false, false,
                                     std::string(), false, std::string());
     if (!window)
       return;
     window->bindings_->AttachTo(agent_host);
   }
@@ skipping 76 matching lines @@
     int y) {
   scoped_refptr<DevToolsAgentHost> agent(
       DevToolsAgentHost::GetOrCreateFor(inspected_frame_host));
   bool should_measure_time = FindDevToolsWindow(agent.get()) == NULL;
   base::TimeTicks start_time = base::TimeTicks::Now();
   // TODO(loislo): we should initiate DevTools window opening from within
   // renderer. Otherwise, we still can hit a race condition here.
   if (agent->GetType() == content::DevToolsAgentHost::kTypePage) {
     OpenDevToolsWindow(agent->GetWebContents());
   } else {
-    OpenDevToolsWindow(Profile::FromBrowserContext(agent->GetBrowserContext()),
-                       agent);
+    OpenDevToolsWindowForFrame(Profile::FromBrowserContext(
+                                   agent->GetBrowserContext()), agent);
   }
   DevToolsWindow* window = FindDevToolsWindow(agent.get());
   if (window) {
     agent->InspectElement(window->bindings_, x, y);
     if (should_measure_time)
       window->inspect_element_start_time_ = start_time;
   }
 }
 
 void DevToolsWindow::ScheduleShow(const DevToolsToggleAction& action) {
@@ skipping 487 matching lines @@
   else if (!is_docked_ && !browser_->window()->IsActive())
     browser_->window()->Activate();
 }
 
 void DevToolsWindow::CloseWindow() {
   DCHECK(is_docked_);
   life_stage_ = kClosing;
   main_web_contents_->DispatchBeforeUnload();
 }
 
+void DevToolsWindow::Inspect(scoped_refptr<content::DevToolsAgentHost> host) {
+  DevToolsWindow::OpenDevToolsWindow(host, nullptr);
+}
+
 void DevToolsWindow::SetInspectedPageBounds(const gfx::Rect& rect) {
   DevToolsContentsResizingStrategy strategy(rect);
   if (contents_resizing_strategy_.Equals(strategy))
     return;
 
   contents_resizing_strategy_.CopyFrom(strategy);
   UpdateBrowserWindow();
 }
 
 void DevToolsWindow::InspectElementCompleted() {
@@ skipping 230 matching lines @@
 bool DevToolsWindow::ReloadInspectedWebContents(bool bypass_cache) {
   // Only route reload via front-end if the agent is attached.
   WebContents* wc = GetInspectedWebContents();
   if (!wc || wc->GetCrashedStatus() != base::TERMINATION_STATUS_STILL_RUNNING)
     return false;
   base::FundamentalValue bypass_cache_value(bypass_cache);
   bindings_->CallClientFunction("DevToolsAPI.reloadInspectedPage",
                                 &bypass_cache_value, nullptr, nullptr);
   return true;
 }