DevTools: request usb permission on ChromeOS.

chrome/browser/devtools/adb/android_usb_device.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/adb/android_usb_device.h"
 
 #include <set>
 
+#include "base/barrier_closure.h"
 #include "base/base64.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/devtools/adb/android_rsa.h"
 #include "chrome/browser/devtools/adb/android_usb_socket.h"
 #include "chrome/browser/usb/usb_device.h"
 #include "chrome/browser/usb/usb_interface.h"
@@ skipping 15 matching lines @@
 const int kUsbTimeout = 0;
 
 const uint32 kMaxPayload = 4096;
 const uint32 kVersion = 0x01000000;
 
 static const char kHostConnectMessage[] = "host::";
 
 using content::BrowserThread;
 
 typedef std::vector<scoped_refptr<UsbDevice> > UsbDevices;
+typedef std::set<scoped_refptr<UsbDevice> > UsbDeviceSet;
 
 base::LazyInstance<AndroidUsbDevices>::Leaky g_devices =
     LAZY_INSTANCE_INITIALIZER;
 
-scoped_refptr<AndroidUsbDevice> ClaimInterface(
-    crypto::RSAPrivateKey* rsa_key,
-    scoped_refptr<UsbDeviceHandle> usb_device,
-    scoped_refptr<const UsbInterfaceDescriptor> interface,
-    int interface_id) {
+bool IsAndroidInterface(
+    scoped_refptr<const UsbInterfaceDescriptor> interface) {
   if (interface->GetNumAltSettings() == 0)
-    return NULL;
+    return false;
 
   scoped_refptr<const UsbInterfaceAltSettingDescriptor> idesc =
       interface->GetAltSetting(0);
 
   if (idesc->GetInterfaceClass() != kAdbClass ||
       idesc->GetInterfaceSubclass() != kAdbSubclass ||
       idesc->GetInterfaceProtocol() != kAdbProtocol ||
       idesc->GetNumEndpoints() != 2) {
-    return NULL;
+    return false;
   }
+  return true;
+}
+
+scoped_refptr<AndroidUsbDevice> ClaimInterface(
+    crypto::RSAPrivateKey* rsa_key,
+    scoped_refptr<UsbDeviceHandle> usb_handle,
+    scoped_refptr<const UsbInterfaceDescriptor> interface,
+    int interface_id) {
+  scoped_refptr<const UsbInterfaceAltSettingDescriptor> idesc =
+      interface->GetAltSetting(0);
 
   int inbound_address = 0;
   int outbound_address = 0;
   int zero_mask = 0;
 
   for (size_t i = 0; i < idesc->GetNumEndpoints(); ++i) {
     scoped_refptr<const UsbEndpointDescriptor> edesc =
         idesc->GetEndpoint(i);
     if (edesc->GetTransferType() != USB_TRANSFER_BULK)
       continue;
     if (edesc->GetDirection() == USB_DIRECTION_INBOUND)
       inbound_address = edesc->GetAddress();
     else
       outbound_address = edesc->GetAddress();
     zero_mask = edesc->GetMaximumPacketSize() - 1;
   }
 
   if (inbound_address == 0 || outbound_address == 0)
     return NULL;
 
-  if (!usb_device->ClaimInterface(interface_id))
+  if (!usb_handle->ClaimInterface(interface_id))
     return NULL;
 
   base::string16 serial;
-  if (!usb_device->GetSerial(&serial) || serial.empty())
+  if (!usb_handle->GetSerial(&serial) || serial.empty())
     return NULL;
 
-  return new AndroidUsbDevice(rsa_key, usb_device, UTF16ToASCII(serial),
+  return new AndroidUsbDevice(rsa_key, usb_handle, UTF16ToASCII(serial),
                               inbound_address, outbound_address, zero_mask);
 }
 
 uint32 Checksum(const std::string& data) {
   unsigned char* x = (unsigned char*)data.data();
   int count = data.length();
   uint32 sum = 0;
   while (count-- > 0)
     sum += *x++;
   return sum;
@@ skipping 41 matching lines @@
                        const std::string& body)
     : command(command),
       arg0(arg0),
       arg1(arg1),
       body(body) {
 }
 
 AdbMessage::~AdbMessage() {
 }
 
+static void RespondOnUIThread(const AndroidUsbDevicesCallback& callback,
+                              const AndroidUsbDevices& devices) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  callback.Run(devices);
+}
+
+static void RespondOnFileThread(const AndroidUsbDevicesCallback& callback) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  // Copy g_devices.Get() on file thread.
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&RespondOnUIThread, callback, g_devices.Get()));
+}
+
+static void OpenAndroidDevicesOnFileThread(
+    crypto::RSAPrivateKey* rsa_key,
+    const base::Closure& barrier,
+    scoped_refptr<UsbDevice> device,
+    int interface_id,
+    bool success) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  if (success) {
+    scoped_refptr<UsbConfigDescriptor> config = device->ListInterfaces();
+    scoped_refptr<UsbDeviceHandle> usb_handle = device->Open();
+    if (usb_handle) {
+      scoped_refptr<AndroidUsbDevice> device =
+        ClaimInterface(rsa_key, usb_handle, config->GetInterface(interface_id),
+                       interface_id);
+      if (device.get())
+        g_devices.Get().push_back(device);
+      else
+        usb_handle->Close();
+    }
+  }
+  barrier.Run();
+}
+
 static void EnumerateOnFileThread(crypto::RSAPrivateKey* rsa_key,
-                                  AndroidUsbDevices* result) {
+                                  const AndroidUsbDevicesCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   UsbService* service = UsbService::GetInstance();
-  AndroidUsbDevices& devices = g_devices.Get();
-
   UsbDevices usb_devices;
   service->GetDevices(&usb_devices);
 
+  AndroidUsbDevices& devices = g_devices.Get();
+
   // GC Android devices with no actual usb device.
   AndroidUsbDevices::iterator it = devices.begin();
-  std::set<UsbDevice*> claimed_devices;
+  UsbDeviceSet claimed_devices;
   while (it != devices.end()) {
     bool found_device = false;
     for (UsbDevices::iterator it2 = usb_devices.begin();
          it2 != usb_devices.end() && !found_device; ++it2) {
       UsbDevice* usb_device = it2->get();
       AndroidUsbDevice* device = it->get();
       if (usb_device == device->usb_device()->device()) {
         found_device = true;
         claimed_devices.insert(usb_device);
       }
     }
 
     if (!found_device)
       it = devices.erase(it);
     else
       ++it;
   }
 
   // Add new devices.
+  base::Closure barrier = base::BarrierClosure(
+      usb_devices.size(), base::Bind(&RespondOnFileThread, callback));
+
   for (UsbDevices::iterator it = usb_devices.begin(); it != usb_devices.end();
        ++it) {
-    if (ContainsKey(claimed_devices, it->get()))
+    if (ContainsKey(claimed_devices, it->get())) {
+      barrier.Run();
       continue;
+    }
 
     scoped_refptr<UsbConfigDescriptor> config = (*it)->ListInterfaces();
-    if (!config)
+    if (!config) {
+      barrier.Run();
       continue;
+    }
 
-    scoped_refptr<UsbDeviceHandle> usb_device = (*it)->Open();
-    if (!usb_device)
-      continue;
+    bool has_android_interface = false;
+    for (size_t j = 0; j < config->GetNumInterfaces(); ++j) {
+      if (!IsAndroidInterface(config->GetInterface(j)))
+        continue;
 
-    bool claimed = false;
-    for (size_t j = 0; j < config->GetNumInterfaces(); ++j) {
-      scoped_refptr<AndroidUsbDevice> device =
-          ClaimInterface(rsa_key, usb_device, config->GetInterface(j), j);
-      if (device.get()) {
-        devices.push_back(device);
-        claimed = true;
-      }
+      // Request permission on Chrome OS.
+#if defined(OS_CHROMEOS)
+      (*it)->RequestUsbAcess(j, base::Bind(&OpenAndroidDevicesOnFileThread,
+                                           rsa_key, barrier, *it, j));
+#else
+      OpenAndroidDevicesOnFileThread(rsa_key, barrier, *it, j, true);
+#endif  // defined(OS_CHROMEOS)
+
+      has_android_interface = true;
+      break;
     }
-    if (!claimed)
-      usb_device->Close();
+    if (!has_android_interface)
+      barrier.Run();
   }
-
-  *result = devices;
-}
-
-static void InitDevicesOnCallerThread(
-    AndroidUsbDevices* devices,
-    const AndroidUsbDevicesCallback& callback) {
-  for (AndroidUsbDevices::iterator it = devices->begin(); it != devices->end();
-       ++it) {
-    (*it)->InitOnCallerThread();
-  }
-  callback.Run(*devices);
-  delete devices;
 }
 
 // static
 void AndroidUsbDevice::Enumerate(crypto::RSAPrivateKey* rsa_key,
                                  const AndroidUsbDevicesCallback& callback) {
-  AndroidUsbDevices* devices = new AndroidUsbDevices();
-  BrowserThread::PostTaskAndReply(
-      BrowserThread::FILE, FROM_HERE,
-      base::Bind(&EnumerateOnFileThread, rsa_key, devices),
-      base::Bind(&InitDevicesOnCallerThread, devices, callback));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
+                          base::Bind(&EnumerateOnFileThread, rsa_key,
+                                     callback));
 }
 
 AndroidUsbDevice::AndroidUsbDevice(crypto::RSAPrivateKey* rsa_key,
                                    scoped_refptr<UsbDeviceHandle> usb_device,
                                    const std::string& serial,
                                    int inbound_address,
                                    int outbound_address,
                                    int zero_mask)
     : message_loop_(NULL),
       rsa_key_(rsa_key->Copy()),
@@ skipping 32 matching lines @@
   // Delay open request if not yet connected.
   if (!is_connected_) {
     pending_messages_.push_back(m);
     return;
   }
   Queue(m);
 }
 
 AndroidUsbDevice::~AndroidUsbDevice() {
   Terminate();
+  usb_device_->AddRef();
+  BrowserThread::ReleaseSoon(BrowserThread::FILE, FROM_HERE,
+                             usb_device_.get());
 }
 
 void AndroidUsbDevice::Queue(scoped_refptr<AdbMessage> message) {
   // Queue header.
   std::vector<uint32> header;
   header.push_back(message->command);
   header.push_back(message->arg0);
   header.push_back(message->arg1);
   bool append_zero = true;
   if (message->body.empty())
@@ skipping 211 matching lines @@
   }
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&ReleaseInterface, usb_device_));
 }
 
 void AndroidUsbDevice::SocketDeleted(uint32 socket_id) {
   sockets_.erase(socket_id);
 }