content/shell/browser/shell_devtools_manager_delegate.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/shell/browser/shell_devtools_manager_delegate.h"
   6
   7 #include <vector>
   8
   9 #include "base/bind.h"
  10 #include "base/command_line.h"
  11 #include "base/files/file_path.h"
  12 #include "base/strings/string_number_conversions.h"
  13 #include "base/strings/stringprintf.h"
  14 #include "base/strings/utf_string_conversions.h"
  15 #include "components/devtools_discovery/basic_target_descriptor.h"
  16 #include "components/devtools_discovery/devtools_discovery_manager.h"
  17 #include "components/devtools_http_handler/devtools_http_handler.h"
  18 #include "content/public/browser/devtools_agent_host.h"
  19 #include "content/public/browser/devtools_frontend_host.h"
  20 #include "content/public/browser/devtools_target.h"
  21 #include "content/public/browser/favicon_status.h"
  22 #include "content/public/browser/navigation_entry.h"
  23 #include "content/public/browser/render_view_host.h"
  24 #include "content/public/browser/web_contents.h"
  25 #include "content/public/common/content_switches.h"
  26 #include "content/public/common/url_constants.h"
  27 #include "content/public/common/user_agent.h"
  28 #include "content/shell/browser/shell.h"
  29 #include "content/shell/common/shell_content_client.h"
  30 #include "grit/shell_resources.h"
  31 #include "net/base/net_errors.h"
  32 #include "net/socket/tcp_server_socket.h"
  33 #include "ui/base/resource/resource_bundle.h"
  34
  35 #if defined(OS_ANDROID)
  36 #include "content/public/browser/android/devtools_auth.h"
  37 #include "net/socket/unix_domain_server_socket_posix.h"
  38 #endif
  39
  40 using devtools_http_handler::DevToolsHttpHandler;
  41
  42 namespace content {
  43
  44 namespace {
  45
  46 #if defined(OS_ANDROID)
  47 const char kFrontEndURL[] =
  48     "http://chrome-devtools-frontend.appspot.com/serve_rev/%s/inspector.html";
  49 #endif
  50
  51 const int kBackLog = 10;
  52
  53 #if defined(OS_ANDROID)
  54 class UnixDomainServerSocketFactory
  55     : public DevToolsHttpHandler::ServerSocketFactory {
  56  public:
  57   explicit UnixDomainServerSocketFactory(const std::string& socket_name)
  58       : socket_name_(socket_name) {}
  59
  60  private:
  61   // DevToolsHttpHandler::ServerSocketFactory.
  62   scoped_ptr<net::ServerSocket> CreateForHttpServer() override {
  63     scoped_ptr<net::ServerSocket> socket(
  64         new net::UnixDomainServerSocket(
  65             base::Bind(&CanUserConnectToDevTools),
  66             true /* use_abstract_namespace */));
  67     if (socket->ListenWithAddressAndPort(socket_name_, 0, kBackLog) != net::OK)
  68       return scoped_ptr<net::ServerSocket>();
  69
  70     return socket;
  71   }
  72
  73   std::string socket_name_;
  74
  75   DISALLOW_COPY_AND_ASSIGN(UnixDomainServerSocketFactory);
  76 };
  77 #else
  78 class TCPServerSocketFactory
  79     : public DevToolsHttpHandler::ServerSocketFactory {
  80  public:
  81   TCPServerSocketFactory(const std::string& address, uint16 port)
  82       : address_(address), port_(port) {
  83   }
  84
  85  private:
  86   // DevToolsHttpHandler::ServerSocketFactory.
  87   scoped_ptr<net::ServerSocket> CreateForHttpServer() override {
  88     scoped_ptr<net::ServerSocket> socket(
  89         new net::TCPServerSocket(nullptr, net::NetLog::Source()));
  90     if (socket->ListenWithAddressAndPort(address_, port_, kBackLog) != net::OK)
  91       return scoped_ptr<net::ServerSocket>();
  92
  93     return socket;
  94   }
  95
  96   std::string address_;
  97   uint16 port_;
  98
  99   DISALLOW_COPY_AND_ASSIGN(TCPServerSocketFactory);
 100 };
 101 #endif
 102
 103 scoped_ptr<DevToolsHttpHandler::ServerSocketFactory>
 104 CreateSocketFactory() {
 105   const base::CommandLine& command_line =
 106       *base::CommandLine::ForCurrentProcess();
 107 #if defined(OS_ANDROID)
 108   std::string socket_name = "content_shell_devtools_remote";
 109   if (command_line.HasSwitch(switches::kRemoteDebuggingSocketName)) {
 110     socket_name = command_line.GetSwitchValueASCII(
 111         switches::kRemoteDebuggingSocketName);
 112   }
 113   return scoped_ptr<DevToolsHttpHandler::ServerSocketFactory>(
 114       new UnixDomainServerSocketFactory(socket_name));
 115 #else
 116   // See if the user specified a port on the command line (useful for
 117   // automation). If not, use an ephemeral port by specifying 0.
 118   uint16 port = 0;
 119   if (command_line.HasSwitch(switches::kRemoteDebuggingPort)) {
 120     int temp_port;
 121     std::string port_str =
 122         command_line.GetSwitchValueASCII(switches::kRemoteDebuggingPort);
 123     if (base::StringToInt(port_str, &temp_port) &&
 124         temp_port > 0 && temp_port < 65535) {
 125       port = static_cast<uint16>(temp_port);
 126     } else {
 127       DLOG(WARNING) << "Invalid http debugger port number " << temp_port;
 128     }
 129   }
 130   return scoped_ptr<DevToolsHttpHandler::ServerSocketFactory>(
 131       new TCPServerSocketFactory("127.0.0.1", port));
 132 #endif
 133 }
 134
 135 // ShellDevToolsDelegate ----------------------------------------------------
 136
 137 class ShellDevToolsDelegate :
 138     public devtools_http_handler::DevToolsHttpHandlerDelegate {
 139  public:
 140   explicit ShellDevToolsDelegate(BrowserContext* browser_context);
 141   ~ShellDevToolsDelegate() override;
 142
 143   // devtools_http_handler::DevToolsHttpHandlerDelegate implementation.
 144   std::string GetDiscoveryPageHTML() override;
 145   std::string GetFrontendResource(const std::string& path) override;
 146
 147  private:
 148   BrowserContext* browser_context_;
 149
 150   DISALLOW_COPY_AND_ASSIGN(ShellDevToolsDelegate);
 151 };
 152
 153 ShellDevToolsDelegate::ShellDevToolsDelegate(BrowserContext* browser_context)
 154     : browser_context_(browser_context) {
 155 }
 156
 157 ShellDevToolsDelegate::~ShellDevToolsDelegate() {
 158 }
 159
 160 std::string ShellDevToolsDelegate::GetDiscoveryPageHTML() {
 161 #if defined(OS_ANDROID)
 162   return std::string();
 163 #else
 164   return ResourceBundle::GetSharedInstance().GetRawDataResource(
 165       IDR_CONTENT_SHELL_DEVTOOLS_DISCOVERY_PAGE).as_string();
 166 #endif
 167 }
 168
 169 std::string ShellDevToolsDelegate::GetFrontendResource(
 170     const std::string& path) {
 171   return content::DevToolsFrontendHost::GetFrontendResource(path).as_string();
 172 }
 173
 174 }  // namespace
 175
 176 // ShellDevToolsManagerDelegate ----------------------------------------------
 177
 178 // static
 179 DevToolsHttpHandler*
 180 ShellDevToolsManagerDelegate::CreateHttpHandler(
 181     BrowserContext* browser_context) {
 182   std::string frontend_url;
 183 #if defined(OS_ANDROID)
 184   frontend_url = base::StringPrintf(kFrontEndURL, GetWebKitRevision().c_str());
 185 #endif
 186   return new DevToolsHttpHandler(
 187       CreateSocketFactory(),
 188       frontend_url,
 189       new ShellDevToolsDelegate(browser_context),
 190       new ShellDevToolsManagerDelegate(browser_context),
 191       base::FilePath(),
 192       base::FilePath(),
 193       std::string(),
 194       GetShellUserAgent());
 195 }
 196
 197 ShellDevToolsManagerDelegate::ShellDevToolsManagerDelegate(
 198     BrowserContext* browser_context)
 199     : browser_context_(browser_context) {
 200 }
 201
 202 ShellDevToolsManagerDelegate::~ShellDevToolsManagerDelegate() {
 203 }
 204
 205 base::DictionaryValue* ShellDevToolsManagerDelegate::HandleCommand(
 206     DevToolsAgentHost* agent_host,
 207     base::DictionaryValue* command) {
 208   return NULL;
 209 }
 210
 211 std::string ShellDevToolsManagerDelegate::GetPageThumbnailData(
 212     const GURL& url) {
 213   return std::string();
 214 }
 215
 216 scoped_ptr<DevToolsTarget>
 217 ShellDevToolsManagerDelegate::CreateNewTarget(const GURL& url) {
 218   Shell* shell = Shell::CreateNewWindow(browser_context_,
 219                                         url,
 220                                         NULL,
 221                                         gfx::Size());
 222   return scoped_ptr<DevToolsTarget>(
 223       new devtools_discovery::BasicTargetDescriptor(
 224           DevToolsAgentHost::GetOrCreateFor(shell->web_contents())));
 225 }
 226
 227 void ShellDevToolsManagerDelegate::EnumerateTargets(TargetCallback callback) {
 228   TargetList targets;
 229   devtools_discovery::DevToolsDiscoveryManager* discovery_manager =
 230       devtools_discovery::DevToolsDiscoveryManager::GetInstance();
 231   for (const auto& descriptor : discovery_manager->GetDescriptors())
 232     targets.push_back(descriptor);
 233   callback.Run(targets);
 234 }
 235
 236 }  // namespace content