DevTools: add about:flag for ADB-less remote debugging.

chrome/browser/devtools/devtools_adb_bridge.cc

 // Copyright (c) 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 "chrome/browser/devtools/devtools_adb_bridge.h"
 
 #include <map>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/bind.h"
+#include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/json/json_reader.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/memory/singleton.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/values.h"
+#include "chrome/browser/devtools/adb/android_rsa.h"
 #include "chrome/browser/devtools/adb/android_usb_device.h"
 #include "chrome/browser/devtools/adb_client_socket.h"
 #include "chrome/browser/devtools/devtools_window.h"
 #include "chrome/browser/devtools/tethering_adb_filter.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/common/chrome_switches.h"
+#include "components/browser_context_keyed_service/browser_context_dependency_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/devtools_client_host.h"
 #include "content/public/browser/devtools_external_agent_proxy.h"
 #include "content/public/browser/devtools_external_agent_proxy_delegate.h"
 #include "content/public/browser/devtools_manager.h"
+#include "crypto/rsa_private_key.h"
 #include "net/base/net_errors.h"
 #include "net/server/web_socket.h"
 
 using content::BrowserThread;
 using net::WebSocket;
 
 namespace {
 
 static const char kDevToolsAdbBridgeThreadName[] = "Chrome_DevToolsADBThread";
 static const char kHostDevicesCommand[] = "host:devices";
@@ skipping 134 matching lines @@
   }
 
   void Respond(int result, const std::string& response) {
     callback_.Run(result, response);
   }
 
   std::string query_;
   Callback callback_;
 };
 
-static void ReceivedDevices(const AndroidDevicesCallback& callback,
-                            Profile* profile,
-                            int result,
-                            const std::string& response) {
-  AndroidDevices devices;
-#if defined(DEBUG_DEVTOOLS)
-  devices.push_back(new AdbDeviceImpl(""));  // For desktop remote debugging.
-  std::vector<scoped_refptr<AndroidUsbDevice> > usb_devices;
-  AndroidUsbDevice::Enumerate(profile, &usb_devices);
-  for (size_t i = 0; i < usb_devices.size(); ++i)
-    devices.push_back(new UsbDeviceImpl(usb_devices[i]));
-#endif  // defined(DEBUG_DEVTOOLS)
-  if (result != net::OK) {
-    callback.Run(devices);
-    return;
-  }
-
-  std::vector<std::string> serials;
-  Tokenize(response, "\n", &serials);
-  for (size_t i = 0; i < serials.size(); ++i) {
-    std::vector<std::string> tokens;
-    Tokenize(serials[i], "\t ", &tokens);
-    devices.push_back(new AdbDeviceImpl(tokens[0]));
-  }
-  callback.Run(devices);
-}
-
-static void EnumerateDevices(Profile* profile,
-                             const AndroidDevicesCallback& callback) {
-  AdbClientSocket::AdbQuery(
-      kAdbPort, kHostDevicesCommand,
-      base::Bind(&ReceivedDevices, callback, profile));
-}
-
 class AdbPagesCommand : public base::RefCounted<AdbPagesCommand> {
  public:
-  explicit AdbPagesCommand(const PagesCallback& callback)
-     : callback_(callback) {
+  explicit AdbPagesCommand(DevToolsAdbBridge* bridge,
+                           const PagesCallback& callback)
+     : bridge_(bridge),
+       callback_(callback) {
     pages_.reset(new DevToolsAdbBridge::RemotePages());
   }
 
-  void Run(Profile* profile) {
-    EnumerateDevices(profile,
-                     base::Bind(&AdbPagesCommand::ReceivedDevices, this));
+  void Run() {
+    bridge_->EnumerateDevices(base::Bind(&AdbPagesCommand::ReceivedDevices,
+                                         this));
   }
 
  private:
   friend class base::RefCounted<AdbPagesCommand>;
   virtual ~AdbPagesCommand() {}
 
   void ReceivedDevices(const AndroidDevices& devices) {
     devices_ = devices;
     ProcessSerials();
   }
@@ skipping 161 matching lines @@
       std::string package = path_field.substr(1, socket_name_pos - 2);
       if (socket_name_pos + channel_pattern.size() < path_field.size() - 1) {
         package += path_field.substr(
             socket_name_pos + channel_pattern.size(), path_field.size() - 1);
       }
       package[0] = base::ToUpperASCII(package[0]);
       socket_to_package_[socket] = package;
     }
   }
 
+  scoped_refptr<DevToolsAdbBridge> bridge_;
   PagesCallback callback_;
   AndroidDevices devices_;
   std::vector<std::string> sockets_;
   std::map<std::string, std::string> socket_to_package_;
   scoped_ptr<DevToolsAdbBridge::RemotePages> pages_;
 };
 
 }  // namespace
 
 const char kDevToolsChannelNameFormat[] = "%s_devtools_remote";
 
 class AgentHostDelegate;
 
 typedef std::map<std::string, AgentHostDelegate*> AgentHostDelegates;
 
 base::LazyInstance<AgentHostDelegates>::Leaky g_host_delegates =
     LAZY_INSTANCE_INITIALIZER;
 
+DevToolsAdbBridge::Wrapper::Wrapper(Profile* profile)
+    : bridge_(new DevToolsAdbBridge(profile)) {
+}
+
+DevToolsAdbBridge::Wrapper::~Wrapper() {
+}
+
+DevToolsAdbBridge* DevToolsAdbBridge::Wrapper::Get() {
+  return bridge_.get();
+}
+
+// static
+DevToolsAdbBridge::Factory* DevToolsAdbBridge::Factory::GetInstance() {
+  return Singleton<DevToolsAdbBridge::Factory>::get();
+}
+
+// static
+DevToolsAdbBridge* DevToolsAdbBridge::Factory::GetForProfile(
+    Profile* profile) {
+  return static_cast<DevToolsAdbBridge::Wrapper*>(
+      GetInstance()->GetServiceForBrowserContext(profile, true))->Get();
+}
+
+DevToolsAdbBridge::Factory::Factory()
+    : BrowserContextKeyedServiceFactory(
+          "DevToolsAdbBridge",
+          BrowserContextDependencyManager::GetInstance()) {}
+
+DevToolsAdbBridge::Factory::~Factory() {}
+
+BrowserContextKeyedService*
+DevToolsAdbBridge::Factory::BuildServiceInstanceFor(
+    content::BrowserContext* context) const {
+  return new DevToolsAdbBridge::Wrapper(Profile::FromBrowserContext(context));
+}
+
 DevToolsAdbBridge::AndroidDevice::AndroidDevice(const std::string& serial)
     : serial_(serial) {
 }
 
 void DevToolsAdbBridge::AndroidDevice::HttpQuery(
     const std::string& la_name,
     const std::string& request,
     const CommandCallback& callback) {
   OpenSocket(la_name, base::Bind(&AndroidDevice::OnHttpSocketOpened, this,
                                  request, callback));
@@ skipping 188 matching lines @@
   scoped_refptr<DevToolsAdbBridge::RefCountedAdbThread> adb_thread_;
   scoped_ptr<net::StreamSocket> socket_;
   scoped_ptr<content::DevToolsExternalAgentProxy> proxy_;
   std::string response_buffer_;
   TetheringAdbFilter tethering_adb_filter_;
   DISALLOW_COPY_AND_ASSIGN(AgentHostDelegate);
 };
 
 class AdbAttachCommand : public base::RefCounted<AdbAttachCommand> {
  public:
-  AdbAttachCommand(const base::WeakPtr<DevToolsAdbBridge>& bridge,
+  AdbAttachCommand(DevToolsAdbBridge* bridge,
                    const std::string& serial,
                    const std::string& socket,
                    const std::string& debug_url,
                    const std::string& frontend_url)
       : bridge_(bridge),
         serial_(serial),
         socket_(socket),
         debug_url_(debug_url),
         frontend_url_(frontend_url) {
   }
 
-  void Run(Profile* profile) {
-
-    // scoped_refptr<DevToolsAdbBridge::AndroidDevice> device =
-    // new AdbDeviceImpl(serial_);
-
-    DevToolsAdbBridge* bridge = bridge_.get();
-    if (!bridge)
-      return;
-
-    EnumerateDevices(profile, base::Bind(&AdbAttachCommand::ReceivedDevices,
+  void Run() {
+    bridge_->EnumerateDevices(base::Bind(&AdbAttachCommand::ReceivedDevices,
                                          this));
   }
 
  private:
   friend class base::RefCounted<AdbAttachCommand>;
   virtual ~AdbAttachCommand() {}
 
   void ReceivedDevices(const AndroidDevices& devices) {
     for (AndroidDevices::const_iterator it = devices.begin();
          it != devices.end(); ++it) {
@@ skipping 11 matching lines @@
     if (result != net::OK || socket == NULL)
       return;
 
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&AdbAttachCommand::OpenDevToolsWindow, this, socket));
   }
 
   void OpenDevToolsWindow(net::StreamSocket* socket) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-    DevToolsAdbBridge* bridge = bridge_.get();
-    if (!bridge)
-      return;
-
     std::string id = base::StringPrintf("%s:%s", serial_.c_str(),
                                         debug_url_.c_str());
     AgentHostDelegates::iterator it = g_host_delegates.Get().find(id);
     AgentHostDelegate* delegate;
     if (it != g_host_delegates.Get().end())
       delegate = it->second;
     else
-      delegate = new AgentHostDelegate(id, serial_, bridge->adb_thread_,
+      delegate = new AgentHostDelegate(id, serial_, bridge_->adb_thread_,
                                        socket);
     DevToolsWindow::OpenExternalFrontend(
-        bridge->profile_, frontend_url_, delegate->GetAgentHost().get());
+        bridge_->profile_, frontend_url_, delegate->GetAgentHost().get());
   }
 
-  base::WeakPtr<DevToolsAdbBridge> bridge_;
+  scoped_refptr<DevToolsAdbBridge> bridge_;
   std::string serial_;
   std::string socket_;
   std::string debug_url_;
   std::string frontend_url_;
 };
 
 DevToolsAdbBridge::RemotePage::RemotePage(const std::string& serial,
                                           const std::string& model,
                                           const std::string& package,
                                           const std::string& socket,
@@ skipping 64 matching lines @@
     return;
   // Shut down thread on FILE thread to join into IO.
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&RefCountedAdbThread::StopThread, thread_));
 }
 
 DevToolsAdbBridge::DevToolsAdbBridge(Profile* profile)
     : profile_(profile),
       adb_thread_(RefCountedAdbThread::GetInstance()),
-      weak_factory_(this),
       has_message_loop_(adb_thread_->message_loop() != NULL) {
+  rsa_key_.reset(AndroidRSAPrivateKey(profile));
 }
 
-DevToolsAdbBridge::~DevToolsAdbBridge() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+void DevToolsAdbBridge::EnumerateDevices(
+    const AndroidDevicesCallback& callback) {
+  AdbClientSocket::AdbQuery(
+      kAdbPort, kHostDevicesCommand,
+      base::Bind(&DevToolsAdbBridge::ReceivedDevices, this, callback));
 }
 
 void DevToolsAdbBridge::Query(
     const std::string query,
     const Callback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!has_message_loop_) {
     callback.Run(net::ERR_FAILED, "Could not start ADB thread");
     return;
   }
   scoped_refptr<AdbQueryCommand> command(new AdbQueryCommand(query, callback));
   adb_thread_->message_loop()->PostTask(FROM_HERE,
       base::Bind(&AdbQueryCommand::Run, command));
 }
 
 void DevToolsAdbBridge::Pages(const PagesCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!has_message_loop_)
     return;
 
   scoped_refptr<AdbPagesCommand> command(
-      new AdbPagesCommand(callback));
+      new AdbPagesCommand(this, callback));
   adb_thread_->message_loop()->PostTask(FROM_HERE,
-      base::Bind(&AdbPagesCommand::Run, command, profile_));
+      base::Bind(&AdbPagesCommand::Run, command));
 }
 
 void DevToolsAdbBridge::Attach(const std::string& serial,
                                const std::string& socket,
                                const std::string& debug_url,
                                const std::string& frontend_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!has_message_loop_)
     return;
 
   scoped_refptr<AdbAttachCommand> command(
-      new AdbAttachCommand(weak_factory_.GetWeakPtr(), serial, socket,
+      new AdbAttachCommand(this, serial, socket,
                            debug_url, frontend_url));
   adb_thread_->message_loop()->PostTask(
       FROM_HERE,
-      base::Bind(&AdbAttachCommand::Run, command, profile_));
+      base::Bind(&AdbAttachCommand::Run, command));
 }
+
+DevToolsAdbBridge::~DevToolsAdbBridge() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+}
+
+void DevToolsAdbBridge::ReceivedDevices(const AndroidDevicesCallback& callback,
+                                        int result,
+                                        const std::string& response) {
+  AndroidDevices devices;
+#if defined(DEBUG_DEVTOOLS)
+  devices.push_back(new AdbDeviceImpl(""));  // For desktop remote debugging.
+#endif  // defined(DEBUG_DEVTOOLS)
+
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kRemoteDebuggingRawUSB)) {
+    AndroidUsbDevices usb_devices;
+    AndroidUsbDevice::Enumerate(profile_, rsa_key_.get(), &usb_devices);
+    for (AndroidUsbDevices::iterator it = usb_devices.begin();
+         it != usb_devices.end(); ++it) {
+      devices.push_back(new UsbDeviceImpl(*it));
+    }
+  }
+
+  if (result != net::OK) {
+    callback.Run(devices);
+    return;
+  }
+
+  std::vector<std::string> serials;
+  Tokenize(response, "\n", &serials);
+  for (size_t i = 0; i < serials.size(); ++i) {
+    std::vector<std::string> tokens;
+    Tokenize(serials[i], "\t ", &tokens);
+    devices.push_back(new AdbDeviceImpl(tokens[0]));
+  }
+  callback.Run(devices);
+}