Introducing chrome.usb.getDevices/openDevice API

chrome/browser/usb/usb_service.cc

 // Copyright (c) 2012 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/usb/usb_service.h"
 
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 46 matching lines @@
   }
   UsbService* service_;
   content::NotificationRegistrar registrar_;
 };
 
 }  // namespace
 
 using content::BrowserThread;
 
 UsbService::UsbService()
-    : context_(new UsbContext()) {
+    : context_(new UsbContext()),
+      next_unique_id_(0) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 }
 
 UsbService::~UsbService() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   for (DeviceMap::iterator it = devices_.begin();
       it != devices_.end(); ++it) {
     it->second->OnDisconnect();
   }
 }
@@ skipping 82 matching lines @@
   // devices then there is no point in attempting to enumerate the devices. On
   // platforms without a permission broker, we assume permission is granted.
   if (!success) {
     callback.Run(devices.Pass());
     return;
   }
 
   RefreshDevices();
 
   for (DeviceMap::iterator it = devices_.begin();
-      it != devices_.end();   ++it) {
+      it != devices_.end(); ++it) {
     if (DeviceMatches(it->second, vendor_id, product_id))
       devices->push_back(it->second);
   }
 
   callback.Run(devices.Pass());
 }
 
+scoped_refptr<UsbDevice> UsbService::GetDeviceById(uint32 unique_id) {
+  RefreshDevices();
+  for (DeviceMap::iterator it = devices_.begin();
+      it != devices_.end(); ++it) {
+    if (it->second->unique_id() == unique_id)
+      return it->second;
+  }
+  return NULL;
+}
+
 void UsbService::RefreshDevices() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   libusb_device** platform_devices = NULL;
   const ssize_t device_count =
       libusb_get_device_list(context_->context(), &platform_devices);
 
   std::set<UsbDevice*> connected_devices;
   vector<PlatformUsbDevice> disconnected_devices;
 
   // Populates new devices.
   for (ssize_t i = 0; i < device_count; ++i) {
     if (!ContainsKey(devices_, platform_devices[i])) {
       libusb_device_descriptor descriptor;
       // This test is needed. A valid vendor/produce pair is required.
       if (0 != libusb_get_device_descriptor(platform_devices[i], &descriptor))
         continue;
       UsbDevice* new_device = new UsbDevice(context_,
-                                        platform_devices[i],
-                                        descriptor.idVendor,
-                                        descriptor.idProduct);
+                                            platform_devices[i],
+                                            descriptor.idVendor,
+                                            descriptor.idProduct,
+                                            ++next_unique_id_);
       devices_[platform_devices[i]] = new_device;
       connected_devices.insert(new_device);
     } else {
       connected_devices.insert(devices_[platform_devices[i]].get());
     }
   }
 
   // Find disconnected devices.
   for (DeviceMap::iterator it = devices_.begin(); it != devices_.end(); ++it) {
     if (!ContainsKey(connected_devices, it->second)) {
       disconnected_devices.push_back(it->first);
     }
   }
 
   // Remove disconnected devices from devices_.
   for (size_t i = 0; i < disconnected_devices.size(); ++i) {
     // UsbDevice will be destroyed after this. The corresponding
     // PlatformUsbDevice will be unref'ed during this process.
     devices_.erase(disconnected_devices[i]);
   }
 
   libusb_free_device_list(platform_devices, true);
 }
 
 bool UsbService::DeviceMatches(scoped_refptr<UsbDevice> device,
                                const uint16 vendor_id,
                                const uint16 product_id) {
   return device->vendor_id() == vendor_id && device->product_id() == product_id;
 }