DevTools: request usb permission on ChromeOS.

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"
@@ skipping 81 matching lines @@
   }
  private:
   virtual ~AdbDeviceImpl() {}
 };
 
 class UsbDeviceImpl : public DevToolsAdbBridge::AndroidDevice {
  public:
   explicit UsbDeviceImpl(AndroidUsbDevice* device)
       : AndroidDevice(device->serial()),
         device_(device) {
+    device_->InitOnCallerThread();
   }
 
   virtual void RunCommand(const std::string& command,
                           const CommandCallback& callback) OVERRIDE {
     net::StreamSocket* socket = device_->CreateSocket(command);
     int result = socket->Connect(base::Bind(&UsbDeviceImpl::OpenedForCommand,
                                             this, callback, socket));
     if (result != net::ERR_IO_PENDING)
       callback.Run(result, std::string());
   }
@@ skipping 53 matching lines @@
   virtual ~UsbDeviceImpl() {}
   scoped_refptr<AndroidUsbDevice> device_;
 };
 
 class AdbPagesCommand : public base::RefCountedThreadSafe<
     AdbPagesCommand,
     content::BrowserThread::DeleteOnUIThread> {
  public:
   typedef base::Callback<void(DevToolsAdbBridge::RemoteDevices*)> Callback;
 
-  AdbPagesCommand(DevToolsAdbBridge* bridge, const Callback& callback)
+  AdbPagesCommand(DevToolsAdbBridge* bridge,
+                  crypto::RSAPrivateKey* rsa_key,
+                  const Callback& callback)
      : bridge_(bridge),
        callback_(callback) {
     remote_devices_.reset(new DevToolsAdbBridge::RemoteDevices());
-    bridge_->GetAdbMessageLoop()->PostTask(FROM_HERE,
-        base::Bind(&DevToolsAdbBridge::EnumerateUsbDevices, bridge_,
-                   base::Bind(&AdbPagesCommand::ReceivedUsbDevices, this)));
+
+    if (CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kRemoteDebuggingRawUSB)) {
+      AndroidUsbDevice::Enumerate(rsa_key,
+          base::Bind(&AdbPagesCommand::ReceivedUsbDevices, this));
+    } else {
+      ReceivedUsbDevices(AndroidUsbDevices());
+    }
   }
 
  private:
   friend struct content::BrowserThread::DeleteOnThread<
       content::BrowserThread::UI>;
   friend class base::DeleteHelper<AdbPagesCommand>;
 
   virtual ~AdbPagesCommand() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   }
 
-  void ReceivedUsbDevices(const AndroidDevices& devices) {
+  void ReceivedUsbDevices(const AndroidUsbDevices& usb_devices) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    bridge_->GetAdbMessageLoop()->PostTask(
+        FROM_HERE, base::Bind(&AdbPagesCommand::WrapUsbDevices, this,
+                              usb_devices));
+  }
+
+  void WrapUsbDevices(const AndroidUsbDevices& usb_devices) {
     DCHECK_EQ(bridge_->GetAdbMessageLoop(), base::MessageLoop::current());
-    devices_ = devices;
-    bridge_->EnumerateAdbDevices(
+
+#if defined(DEBUG_DEVTOOLS)
+    devices_.push_back(new AdbDeviceImpl(""));  // For desktop remote debugging.
+#endif  // defined(DEBUG_DEVTOOLS)
+
+    for (AndroidUsbDevices::const_iterator it = usb_devices.begin();
+         it != usb_devices.end(); ++it) {
+      devices_.push_back(new UsbDeviceImpl(*it));
+    }
+
+    AdbClientSocket::AdbQuery(
+        kAdbPort, kHostDevicesCommand,
         base::Bind(&AdbPagesCommand::ReceivedAdbDevices, this));
   }
 
-  void ReceivedAdbDevices(const AndroidDevices& devices) {
-    devices_.insert(devices_.end(), devices.begin(), devices.end());
+  void ReceivedAdbDevices(
+      int result,
+      const std::string& response) {
+    DCHECK_EQ(bridge_->GetAdbMessageLoop(), base::MessageLoop::current());
+    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]));
+    }
     ProcessSerials();
   }
 
   void ProcessSerials() {
     DCHECK_EQ(bridge_->GetAdbMessageLoop(), base::MessageLoop::current());
     if (devices_.size() == 0) {
       BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
           base::Bind(&AdbPagesCommand::Respond, this));
       return;
@@ skipping 649 matching lines @@
 
 DevToolsAdbBridge::DevToolsAdbBridge(Profile* profile)
     : profile_(profile),
       adb_thread_(RefCountedAdbThread::GetInstance()),
       has_message_loop_(adb_thread_->message_loop() != NULL) {
   rsa_key_.reset(AndroidRSAPrivateKey(profile));
   port_forwarding_controller_.reset(
       new PortForwardingController(this, profile->GetPrefs()));
 }
 
-void DevToolsAdbBridge::EnumerateUsbDevices(
-    const AndroidDevicesCallback& callback) {
-  DCHECK_EQ(base::MessageLoop::current(), adb_thread_->message_loop());
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kRemoteDebuggingRawUSB)) {
-    AndroidUsbDevice::Enumerate(rsa_key_.get(),
-        base::Bind(&DevToolsAdbBridge::ReceivedUsbDevices, this, callback));
-  } else {
-    ReceivedUsbDevices(callback, AndroidUsbDevices());
-  }
-}
-
-void DevToolsAdbBridge::EnumerateAdbDevices(
-    const AndroidDevicesCallback& callback) {
-  DCHECK_EQ(base::MessageLoop::current(), adb_thread_->message_loop());
-
-  AdbClientSocket::AdbQuery(
-      kAdbPort, kHostDevicesCommand,
-      base::Bind(&DevToolsAdbBridge::ReceivedAdbDevices, this, callback));
-}
-
 void DevToolsAdbBridge::AddListener(Listener* listener) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (listeners_.empty())
     RequestRemoteDevices();
   listeners_.push_back(listener);
 }
 
 void DevToolsAdbBridge::RemoveListener(Listener* listener) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   Listeners::iterator it =
       std::find(listeners_.begin(), listeners_.end(), listener);
   DCHECK(it != listeners_.end());
   listeners_.erase(it);
 }
 
 base::MessageLoop* DevToolsAdbBridge::GetAdbMessageLoop() {
   return adb_thread_->message_loop();
 }
 
 DevToolsAdbBridge::~DevToolsAdbBridge() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(listeners_.empty());
 }
 
-void DevToolsAdbBridge::ReceivedUsbDevices(
-    const AndroidDevicesCallback& callback,
-    const AndroidUsbDevices& usb_devices) {
-  AndroidDevices devices;
-
-#if defined(DEBUG_DEVTOOLS)
-  devices.push_back(new AdbDeviceImpl(""));  // For desktop remote debugging.
-#endif  // defined(DEBUG_DEVTOOLS)
-
-  for (AndroidUsbDevices::const_iterator it = usb_devices.begin();
-       it != usb_devices.end(); ++it) {
-    devices.push_back(new UsbDeviceImpl(*it));
-  }
-
-  callback.Run(devices);
-}
-
-void DevToolsAdbBridge::ReceivedAdbDevices(
-    const AndroidDevicesCallback& callback,
-    int result,
-    const std::string& response) {
-  AndroidDevices devices;
-  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);
-}
-
 void DevToolsAdbBridge::RequestRemoteDevices() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!has_message_loop_)
     return;
 
   new AdbPagesCommand(
-      this, base::Bind(&DevToolsAdbBridge::ReceivedRemoteDevices, this));
+      this, rsa_key_.get(),
+      base::Bind(&DevToolsAdbBridge::ReceivedRemoteDevices, this));
 }
 
 void DevToolsAdbBridge::ReceivedRemoteDevices(RemoteDevices* devices_ptr) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   scoped_ptr<RemoteDevices> devices(devices_ptr);
   port_forwarding_controller_->UpdateDeviceList(*devices.get());
 
   Listeners copy(listeners_);
   for (Listeners::iterator it = copy.begin(); it != copy.end(); ++it)
     (*it)->RemoteDevicesChanged(devices.get());
 
   if (listeners_.empty())
     return;
 
   BrowserThread::PostDelayedTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&DevToolsAdbBridge::RequestRemoteDevices, this),
       base::TimeDelta::FromMilliseconds(kAdbPollingIntervalMs));
 }