DevTools: remove devtools_discovery (merged into content).

content/shell/browser/shell_devtools_manager_delegate.cc

 // Copyright 2013 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 "content/shell/browser/shell_devtools_manager_delegate.h"
 
 #include <stdint.h>
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
-#include "components/devtools_discovery/devtools_discovery_manager.h"
 #include "components/devtools_http_handler/devtools_http_handler.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/devtools_frontend_host.h"
 #include "content/public/browser/favicon_status.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/url_constants.h"
@@ skipping 96 matching lines @@
       port = static_cast<uint16_t>(temp_port);
     } else {
       DLOG(WARNING) << "Invalid http debugger port number " << temp_port;
     }
   }
   return std::unique_ptr<DevToolsHttpHandler::ServerSocketFactory>(
       new TCPServerSocketFactory("127.0.0.1", port));
 #endif
 }
 
-scoped_refptr<content::DevToolsAgentHost>
-CreateNewShellTarget(BrowserContext* browser_context, const GURL& url) {
-  Shell* shell = Shell::CreateNewWindow(browser_context,
-                                        url,
-                                        nullptr,
-                                        gfx::Size());
-  return DevToolsAgentHost::GetOrCreateFor(shell->web_contents());
-}
-
 // ShellDevToolsDelegate ----------------------------------------------------
 
 class ShellDevToolsDelegate :
     public devtools_http_handler::DevToolsHttpHandlerDelegate {
  public:
-  explicit ShellDevToolsDelegate(BrowserContext* browser_context);
+  explicit ShellDevToolsDelegate();
   ~ShellDevToolsDelegate() override;
 
   // devtools_http_handler::DevToolsHttpHandlerDelegate implementation.
   std::string GetDiscoveryPageHTML() override;
   std::string GetFrontendResource(const std::string& path) override;
   std::string GetPageThumbnailData(const GURL& url) override;
   DevToolsExternalAgentProxyDelegate*
       HandleWebSocketConnection(const std::string& path) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ShellDevToolsDelegate);
 };
 
-ShellDevToolsDelegate::ShellDevToolsDelegate(BrowserContext* browser_context) {
-  devtools_discovery::DevToolsDiscoveryManager::GetInstance()->
-      SetCreateCallback(base::Bind(&CreateNewShellTarget,
-                                   base::Unretained(browser_context)));
+ShellDevToolsDelegate::ShellDevToolsDelegate() {
 }
 
 ShellDevToolsDelegate::~ShellDevToolsDelegate() {
-  devtools_discovery::DevToolsDiscoveryManager::GetInstance()->
-      SetCreateCallback(
-          devtools_discovery::DevToolsDiscoveryManager::CreateCallback());
 }
 
 std::string ShellDevToolsDelegate::GetDiscoveryPageHTML() {
 #if defined(OS_ANDROID)
   return std::string();
 #else
   return ResourceBundle::GetSharedInstance().GetRawDataResource(
       IDR_CONTENT_SHELL_DEVTOOLS_DISCOVERY_PAGE).as_string();
 #endif
 }
@@ skipping 20 matching lines @@
 DevToolsHttpHandler*
 ShellDevToolsManagerDelegate::CreateHttpHandler(
     BrowserContext* browser_context) {
   std::string frontend_url;
 #if defined(OS_ANDROID)
   frontend_url = base::StringPrintf(kFrontEndURL, GetWebKitRevision().c_str());
 #endif
   return new DevToolsHttpHandler(
       CreateSocketFactory(),
       frontend_url,
-      new ShellDevToolsDelegate(browser_context),
+      new ShellDevToolsDelegate(),
       browser_context->GetPath(),
       base::FilePath(),
       std::string(),
       GetShellUserAgent());
 }
 
-ShellDevToolsManagerDelegate::ShellDevToolsManagerDelegate() {
+ShellDevToolsManagerDelegate::ShellDevToolsManagerDelegate(
+    BrowserContext* browser_context)
+    : browser_context_(browser_context) {
 }
 
 ShellDevToolsManagerDelegate::~ShellDevToolsManagerDelegate() {
 }
 
 base::DictionaryValue* ShellDevToolsManagerDelegate::HandleCommand(
     DevToolsAgentHost* agent_host,
     base::DictionaryValue* command_dict) {
-  std::unique_ptr<base::DictionaryValue> result =
-      devtools_discovery::DevToolsDiscoveryManager::GetInstance()
-          ->HandleCreateTargetCommand(command_dict);
-  return result.release();  // Caller takes ownership.
+  return HandleCreateTargetCommand(command_dict).release();
 }
 
 std::string ShellDevToolsManagerDelegate::GetTargetType(RenderFrameHost* host) {
   return DevToolsAgentHost::kTypePage;
 }
 
 std::string ShellDevToolsManagerDelegate::GetTargetTitle(
     RenderFrameHost* host) {
   return "";
 }
 
+
+scoped_refptr<DevToolsAgentHost>
+ShellDevToolsManagerDelegate::CreateNewTarget(const GURL& url) {
+  Shell* shell = Shell::CreateNewWindow(browser_context_,
+                                        url,
+                                        nullptr,
+                                        gfx::Size());
+  return DevToolsAgentHost::GetOrCreateFor(shell->web_contents());
+}
+
+std::unique_ptr<base::DictionaryValue>
+ShellDevToolsManagerDelegate::HandleCreateTargetCommand(
+    base::DictionaryValue* command_dict) {
+  int id;
+  std::string method;
+  std::string url;
+  const base::DictionaryValue* params_dict = nullptr;
+  if (command_dict->GetInteger("id", &id) &&
+      command_dict->GetString("method", &method) &&
+      method == "Browser.createTarget" &&
+      command_dict->GetDictionary("params", &params_dict) &&
+      params_dict->GetString("url", &url)) {
+    scoped_refptr<content::DevToolsAgentHost> agent_host =
+        CreateNewTarget(GURL(url));
+    if (!agent_host)
+      return nullptr;
+    std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
+    result->SetInteger("id", id);
+    std::unique_ptr<base::DictionaryValue> cmd_result(
+        new base::DictionaryValue());
+    cmd_result->SetString("targetId", agent_host->GetId());
+    result->Set("result", std::move(cmd_result));
+    return result;
+  }
+  return nullptr;
+}
+
 }  // namespace content