Usb backend refactor step 2: Separate Usb Device Handle and Usb Device (deprecate)

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/stl_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_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 = 0;
 
 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)
@@ skipping 152 matching lines @@
 
 AdbMessage::~AdbMessage() {
 }
 
 // static
 void AndroidUsbDevice::Enumerate(Profile* profile,
                                  crypto::RSAPrivateKey* rsa_key,
                                  AndroidUsbDevices* devices) {
   UsbService* service =
       UsbServiceFactory::GetInstance()->GetForProfile(profile);
-  UsbDevices usb_devices;
-  service->EnumerateDevices(&usb_devices);
+
+  std::vector<int> usb_devices;
+  service->GetDevices(&usb_devices);
 
   // GC Android devices with no actual usb device.
   AndroidUsbDevices::iterator it = g_devices.Get().begin();
-  std::set<UsbDevice*> claimed_devices;
+  std::set<int> 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();
+    for (size_t i = 0; i < usb_devices.size(); ++i) {
+      int usb_device_id = usb_devices[i];
       AndroidUsbDevice* device = it->get();
-      if (usb_device == device->usb_device_) {
+      if (usb_device_id == device->usb_device_->device()) {
         found_device = true;
-        claimed_devices.insert(*it2);
+        claimed_devices.insert(usb_device_id);
       }
     }
 
     if (!found_device)
       it = g_devices.Get().erase(it);
     else
       ++it;
   }
-
+// service->OpenDevice(usb_device_id)
   // 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())
+  for (size_t i = 0; i < usb_devices.size(); ++i) {
+    if (ContainsKey(claimed_devices, usb_devices[i]))
       continue;
+    scoped_refptr<UsbDevice> usb_device = service->OpenDevice(usb_devices[i]);
     scoped_refptr<UsbConfigDescriptor> config = new UsbConfigDescriptor();
     usb_device->ListInterfaces(config.get(), base::Bind(&BoolNoop));
     for (size_t j = 0; j < config->GetNumInterfaces(); ++j) {
       ClaimInterface(rsa_key, usb_device, config->GetInterface(j),
                      &g_devices.Get());
     }
   }
 
   *devices = g_devices.Get();
 }
@@ skipping 266 matching lines @@
     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);
 }