Store devices that only need to be enumerated once

device/usb/usb_service_impl.cc

Index: device/usb/usb_service_impl.cc
diff --git a/device/usb/usb_service_impl.cc b/device/usb/usb_service_impl.cc
index 2624991c9401dd051eb0e20ca4eee5fb0890db67..124182356f1cfa7126754a9e3bf95ddd945bea1c 100644
--- a/device/usb/usb_service_impl.cc
+++ b/device/usb/usb_service_impl.cc
@@ -158,6 +158,7 @@ void OnDeviceOpenedReadDescriptors(
     bool read_bos_descriptors,
     const base::Closure& success_closure,
     const base::Closure& failure_closure,
+    const base::Closure& add_ignored_device_closure,
     scoped_refptr<UsbDeviceHandle> device_handle) {
   if (device_handle) {
     std::unique_ptr<std::map<uint8_t, base::string16>> string_map(
@@ -195,6 +196,7 @@ void OnDeviceOpenedReadDescriptors(
                                                       device_handle, barrier));
     }
   } else {
+    add_ignored_device_closure.Run();
     failure_closure.Run();
   }
 }
@@ -205,7 +207,8 @@ void EnumerateUdevDevice(scoped_refptr<UsbDeviceImpl> device,
                          bool read_bos_descriptors,
                          scoped_refptr<base::SequencedTaskRunner> task_runner,
                          const base::Closure& success_closure,
-                         const base::Closure& failure_closure) {
+                         const base::Closure& failure_closure,
+                         const base::Closure& add_ignored_device_closure) {
   ScopedUdevPtr udev(udev_new());
   ScopedUdevEnumeratePtr udev_enumerate(udev_enumerate_new(udev.get()));
 
@@ -258,7 +261,8 @@ void EnumerateUdevDevice(scoped_refptr<UsbDeviceImpl> device,
               FROM_HERE,
               base::Bind(&UsbDevice::Open, device,
                          base::Bind(&OnDeviceOpenedReadDescriptors, 0, 0, 0,
-                                    true, success_closure, failure_closure)));
+                                    true, success_closure, failure_closure,
+                                    add_ignored_device_closure)));
         } else {
           task_runner->PostTask(FROM_HERE, success_closure);
         }
@@ -417,10 +421,18 @@ void UsbServiceImpl::OnDeviceList(libusb_device** platform_devices,
                            base::Bind(&UsbServiceImpl::RefreshDevicesComplete,
                                       weak_factory_.GetWeakPtr()));
   std::list<PlatformUsbDevice> new_devices;
+  std::set<PlatformUsbDevice> existing_ignored_devices;
 
   // Look for new and existing devices.
   for (size_t i = 0; i < device_count; ++i) {
     PlatformUsbDevice platform_device = platform_devices[i];
+    // Ignore some devices.
+    if (ignored_devices_.find(platform_device) != ignored_devices_.end()) {

[Reilly Grant (use Gerrit), 2016/04/22 21:12:04]

if (ContainsValue(ignored_devices, platform_device))

[juncai, 2016/04/22 22:02:43]

Done.

+      existing_ignored_devices.insert(platform_device);
+      refresh_complete.Run();
+      continue;
+    }
+
     auto it = platform_devices_.find(platform_device);
 
     if (it == platform_devices_.end()) {
@@ -445,6 +457,15 @@ void UsbServiceImpl::OnDeviceList(libusb_device** platform_devices,
     }
   }
 
+  // Remove devices not seen in this enumeration from |ignored_devices_|.
+  for (auto it = ignored_devices_.begin(); it != ignored_devices_.end();
+       /* incremented internally */) {
+    auto current = it++;
+    if (existing_ignored_devices.find(*current) ==
+        existing_ignored_devices.end())

[Reilly Grant (use Gerrit), 2016/04/22 21:12:04]

if (!ContainsValue(existing_ignore_devices, *current))

[juncai, 2016/04/22 22:02:43]

Done.

+      ignored_devices_.erase(current);
+  }
+
   for (PlatformUsbDevice platform_device : new_devices) {
     EnumerateDevice(platform_device, refresh_complete);
   }
@@ -488,6 +509,7 @@ void UsbServiceImpl::EnumerateDevice(PlatformUsbDevice platform_device,
   if (rv == LIBUSB_SUCCESS) {
     if (descriptor.bDeviceClass == LIBUSB_CLASS_HUB) {
       // Don't try to enumerate hubs. We never want to connect to a hub.
+      ignored_devices_.insert(platform_device);
       refresh_complete.Run();
       return;
     }
@@ -497,23 +519,26 @@ void UsbServiceImpl::EnumerateDevice(PlatformUsbDevice platform_device,
     base::Closure add_device =
         base::Bind(&UsbServiceImpl::AddDevice, weak_factory_.GetWeakPtr(),
                    refresh_complete, device);
+    base::Closure add_ignored_device =
+        base::Bind(&UsbServiceImpl::AddIgnoredDevice,
+                   weak_factory_.GetWeakPtr(), platform_device);
     bool read_bos_descriptors = descriptor.bcdUSB >= kUsbVersion2_1;
 
 #if defined(USE_UDEV)
     blocking_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&EnumerateUdevDevice, device, read_bos_descriptors,
-                   task_runner_, add_device, refresh_complete));
+        FROM_HERE, base::Bind(&EnumerateUdevDevice, device,
+                              read_bos_descriptors, task_runner_, add_device,
+                              refresh_complete, add_ignored_device));

[Reilly Grant (use Gerrit), 2016/04/22 21:12:04]

Instead of passing 3 callbacks here can we just pass two: add_device and
enumeration_failed?

enumeration_failed would AddIgnoredDevice and then run refresh_complete just
like AddDevice adds the device and then runs refresh_complete.

[juncai, 2016/04/22 22:02:43]

Done.

 #else
     if (descriptor.iManufacturer == 0 && descriptor.iProduct == 0 &&
         descriptor.iSerialNumber == 0 && !read_bos_descriptors) {
       // Don't bother disturbing the device if it has no descriptors to offer.
       add_device.Run();
     } else {
-      device->Open(base::Bind(&OnDeviceOpenedReadDescriptors,
-                              descriptor.iManufacturer, descriptor.iProduct,
-                              descriptor.iSerialNumber, read_bos_descriptors,
-                              add_device, refresh_complete));
+      device->Open(base::Bind(
+          &OnDeviceOpenedReadDescriptors, descriptor.iManufacturer,
+          descriptor.iProduct, descriptor.iSerialNumber, read_bos_descriptors,
+          add_device, refresh_complete, add_ignored_device));
     }
 #endif
   } else {
@@ -616,4 +641,8 @@ void UsbServiceImpl::OnPlatformDeviceRemoved(
   libusb_unref_device(platform_device);
 }
 
+void UsbServiceImpl::AddIgnoredDevice(PlatformUsbDevice platform_device) {
+  ignored_devices_.insert(platform_device);

[Reilly Grant (use Gerrit), 2016/04/22 21:12:04]

We should probably call libusb_ref_device(platform_device) here so that the
pointer remains value.

[juncai, 2016/04/22 22:02:43]

Done.

+}
+
 }  // namespace device