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

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/base64.h"
+#include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.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_interface.h"
 #include "chrome/browser/usb/usb_service.h"
 #include "chrome/browser/usb/usb_service_factory.h"
+#include "crypto/rsa_private_key.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/socket/stream_socket.h"
 
 namespace {
 
 void Noop() {}
 void BoolNoop(bool success) {}
 
 const size_t kHeaderSize = 24;
 
 const int kAdbClass = 0xff;
 const int kAdbSubclass = 0x42;
 const int kAdbProtocol = 0x1;
 
 const int kUsbTimeout = 1000;
 
 const uint32 kMaxPayload = 4096;
 const uint32 kVersion = 0x01000000;
 
 static const char kHostConnectMessage[] = "host::";
 
+typedef std::vector<scoped_refptr<UsbDevice> > UsbDevices;
+
+base::LazyInstance<AndroidUsbDevices>::Leaky g_devices =
+    LAZY_INSTANCE_INITIALIZER;
+
 static std::string ReadSerialNumSync(libusb_device_handle* handle) {
   libusb_device* device = libusb_get_device(handle);
   libusb_device_descriptor descriptor;
   if (libusb_get_device_descriptor(device, &descriptor) != LIBUSB_SUCCESS)
     return std::string();
 
   if (!descriptor.iSerialNumber)
     return std::string();
 
   uint16 languages[128] = {0};
@@ skipping 30 matching lines @@
         int j;
         for (j = 1; j < res; ++j)
           serial[j - 1] = buffer[j];
         serial[j - 1] = '\0';
         return std::string(serial, j);
     }
   }
   return std::string();
 }
 
-static void InterfaceClaimed(Profile* profile,
+static void InterfaceClaimed(crypto::RSAPrivateKey* rsa_key,
                              scoped_refptr<UsbDevice> usb_device,
                              int inbound_address,
                              int outbound_address,
                              int zero_mask,
-                             AndroidUsbDevice::Devices* devices,
+                             AndroidUsbDevices* devices,
                              bool success) {
   if (!success)
     return;
 
   std::string serial = ReadSerialNumSync(usb_device->handle());
   scoped_refptr<AndroidUsbDevice> device =
-      new AndroidUsbDevice(profile, usb_device, serial, inbound_address,
+      new AndroidUsbDevice(rsa_key, usb_device, serial, inbound_address,
                            outbound_address, zero_mask);
   devices->push_back(device);
 }
 
 static void ClaimInterface(
-    Profile* profile,
+    crypto::RSAPrivateKey* rsa_key,
     scoped_refptr<UsbDevice> usb_device,
     const UsbInterface* interface,
-    AndroidUsbDevice::Devices* devices) {
+    AndroidUsbDevices* devices) {
   if (interface->GetNumAltSettings() == 0)
     return;
 
   scoped_refptr<const UsbInterfaceDescriptor> idesc =
       interface->GetAltSetting(0).get();
 
   if (idesc->GetInterfaceClass() != kAdbClass ||
       idesc->GetInterfaceSubclass() != kAdbSubclass ||
       idesc->GetInterfaceProtocol() != kAdbProtocol ||
       idesc->GetNumEndpoints() != 2) {
@@ skipping 12 matching lines @@
     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;
 
-  usb_device->ClaimInterface(1, base::Bind(&InterfaceClaimed, profile,
-                                           usb_device, inbound_address,
-                                           outbound_address, zero_mask,
-                                           devices));
+  usb_device->ClaimInterface(1, base::Bind(&InterfaceClaimed,
+                                           rsa_key, usb_device,
+                                           inbound_address, outbound_address,
+                                           zero_mask, devices));
 }
 
 static 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 36 matching lines @@
     : command(command),
       arg0(arg0),
       arg1(arg1),
       body(body) {
 }
 
 AdbMessage::~AdbMessage() {
 }
 
 // static
-void AndroidUsbDevice::Enumerate(Profile* profile, Devices* devices) {
+void AndroidUsbDevice::Enumerate(Profile* profile,
+                                 crypto::RSAPrivateKey* rsa_key,
+                                 AndroidUsbDevices* devices) {
   UsbService* service =
       UsbServiceFactory::GetInstance()->GetForProfile(profile);
-
-  // Enumerate usb devices.
   std::vector<scoped_refptr<UsbDevice> > usb_devices;

[vsevik, 2013/07/11 15:59:54]

UsbDevices

[pfeldman, 2013/07/11 16:26:51]

Done.

   service->EnumerateDevices(&usb_devices);
-  for (size_t i = 0; i < usb_devices.size(); ++i) {
-    scoped_refptr<UsbDevice> usb_device = usb_devices[i];
 
-    // Enumerate device interfaces.
+  // GC Android devices with no actual usb device.
+  AndroidUsbDevices::iterator it = g_devices.Get().begin();
+  std::set<UsbDevice*> claimed_devices;
+  while (it != g_devices.Get().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_) {
+        found_device = true;
+        claimed_devices.insert(*it2);
+      }
+    }
+
+    if (!found_device)
+      it = g_devices.Get().erase(it);
+    else
+      ++it;
+  }
+
+  // Add new devices.
+  AndroidUsbDevices new_devices;
+  for (UsbDevices::iterator it = usb_devices.begin(); it != usb_devices.end();
+       ++it) {
+    UsbDevice* usb_device = *it;
+    if (claimed_devices.find(usb_device) != claimed_devices.end())
+      continue;
     scoped_refptr<UsbConfigDescriptor> config = new UsbConfigDescriptor();
     usb_device->ListInterfaces(config.get(), base::Bind(&BoolNoop));
-    for (size_t i = 0; i < config->GetNumInterfaces(); ++i)
-      ClaimInterface(profile, usb_device, config->GetInterface(i), devices);
+    for (size_t j = 0; j < config->GetNumInterfaces(); ++j) {
+      ClaimInterface(rsa_key, usb_device, config->GetInterface(j),
+                     &g_devices.Get());
+    }
   }
+
+  *devices = g_devices.Get();
 }
 
-AndroidUsbDevice::AndroidUsbDevice(Profile* profile,
+AndroidUsbDevice::AndroidUsbDevice(crypto::RSAPrivateKey* rsa_key,
                                    scoped_refptr<UsbDevice> usb_device,
                                    const std::string& serial,
                                    int inbound_address,
                                    int outbound_address,
                                    int zero_mask)
     : message_loop_(NULL),
-      profile_(profile),
+      rsa_key_(rsa_key->Copy()),
       usb_device_(usb_device),
       serial_(serial),
       inbound_address_(inbound_address),
       outbound_address_(outbound_address),
       zero_mask_(zero_mask),
       is_connected_(false),
       signature_sent_(false),
-      last_socket_id_(256) {
+      last_socket_id_(256),
+      terminated_(false) {
   message_loop_ = base::MessageLoop::current();
   Queue(new AdbMessage(AdbMessage::kCommandCNXN, kVersion, kMaxPayload,
                        kHostConnectMessage));
   ReadHeader(true);
 }
 
 net::StreamSocket* AndroidUsbDevice::CreateSocket(const std::string& command) {
   uint32 socket_id = ++last_socket_id_;
   sockets_[socket_id] = new AndroidUsbSocket(this, socket_id, command,
       base::Bind(&AndroidUsbDevice::SocketDeleted, this));
@@ skipping 162 matching lines @@
 }
 
 void AndroidUsbDevice::HandleIncoming(scoped_refptr<AdbMessage> message) {
   switch (message->command) {
     case AdbMessage::kCommandAUTH:
       {
         DCHECK_EQ(message->arg0, static_cast<uint32>(AdbMessage::kAuthToken));
         if (signature_sent_) {
           Queue(new AdbMessage(AdbMessage::kCommandAUTH,
                                AdbMessage::kAuthRSAPublicKey, 0,
-                               AndroidRSAPublicKey(profile_)));
+                               AndroidRSAPublicKey(rsa_key_.get())));
         } else {
           signature_sent_ = true;
-          std::string signature = AndroidRSASign(profile_, message->body);
+          std::string signature = AndroidRSASign(rsa_key_.get(), message->body);
           if (!signature.empty()) {
             Queue(new AdbMessage(AdbMessage::kCommandAUTH,
                                  AdbMessage::kAuthSignature, 0,
                                  signature));
           } else {
             Queue(new AdbMessage(AdbMessage::kCommandAUTH,
                                  AdbMessage::kAuthRSAPublicKey, 0,
-                                 AndroidRSAPublicKey(profile_)));
+                                 AndroidRSAPublicKey(rsa_key_.get())));
           }
         }
       }
       break;
     case AdbMessage::kCommandCNXN:
       {
         is_connected_ = true;
         PendingMessages pending;
         pending.swap(pending_messages_);
         for (PendingMessages::iterator it = pending.begin();
@@ skipping 18 matching lines @@
 }
 
 void AndroidUsbDevice::TransferError(UsbTransferStatus status) {
   LOG(ERROR) << "Transfer error " << status;
   message_loop_->PostTask(FROM_HERE,
                           base::Bind(&AndroidUsbDevice::Terminate,
                                      this));
 }
 
 void AndroidUsbDevice::Terminate() {
+  if (terminated_)
+    return;
+
+  terminated_ = true;
   for (AndroidUsbSockets::iterator it = sockets_.begin();
        it != sockets_.end(); ++it) {
     it->second->Terminated();
   }
+
   usb_device_->ReleaseInterface(1, base::Bind(&BoolNoop));
   usb_device_->Close(base::Bind(&Noop));
 }
 
 void AndroidUsbDevice::SocketDeleted(uint32 socket_id) {
   sockets_.erase(socket_id);
 }