Store devices that only need to be enumerated once

device/usb/usb_service_impl.cc

 // Copyright 2014 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 "device/usb/usb_service_impl.h"
 
 #include <stdint.h>
 
 #include <list>
 #include <memory>
@@ skipping 140 matching lines @@
   barrier.Run();
 }
 
 void OnDeviceOpenedReadDescriptors(
     uint8_t manufacturer,
     uint8_t product,
     uint8_t serial_number,
     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(
         new std::map<uint8_t, base::string16>());
     if (manufacturer != 0)
       (*string_map)[manufacturer] = base::string16();
     if (product != 0)
       (*string_map)[product] = base::string16();
     if (serial_number != 0)
       (*string_map)[serial_number] = base::string16();
@@ skipping 17 matching lines @@
           device_handle, std::move(string_map),
           base::Bind(&SaveStringsAndRunContinuation, device, manufacturer,
                      product, serial_number, barrier));
     }
 
     if (read_bos_descriptors) {
       ReadWebUsbDescriptors(device_handle, base::Bind(&OnReadBosDescriptor,
                                                       device_handle, barrier));
     }
   } else {
+    add_ignored_device_closure.Run();
     failure_closure.Run();
   }
 }
 
 #if defined(USE_UDEV)
 
 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()));
 
   udev_enumerate_add_match_subsystem(udev_enumerate.get(), "usb");
   if (udev_enumerate_scan_devices(udev_enumerate.get()) != 0) {
     task_runner->PostTask(FROM_HERE, failure_closure);
     return;
   }
 
   std::string bus_number =
@@ skipping 32 matching lines @@
 
       value = udev_device_get_devnode(udev_device.get());
       if (value) {
         device->set_device_path(value);
 
         if (read_bos_descriptors) {
           task_runner->PostTask(
               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);
         }
         return;
       }
 
       break;
     }
   }
 
@@ skipping 138 matching lines @@
   if (!platform_devices) {
     RefreshDevicesComplete();
     return;
   }
 
   base::Closure refresh_complete =
       base::BarrierClosure(static_cast<int>(device_count),
                            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()) {
       libusb_ref_device(platform_device);
       new_devices.push_back(platform_device);
     } else {
       it->second->set_visited(true);
       refresh_complete.Run();
     }
   }
 
   // Remove devices not seen in this enumeration.
   for (PlatformDeviceMap::iterator it = platform_devices_.begin();
        it != platform_devices_.end();
        /* incremented internally */) {
     PlatformDeviceMap::iterator current = it++;
     const scoped_refptr<UsbDeviceImpl>& device = current->second;
     if (device->was_visited()) {
       device->set_visited(false);
     } else {
       RemoveDevice(device);
     }
   }
 
+  // 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);
   }
 
   libusb_free_device_list(platform_devices, true);
 }
 
 void UsbServiceImpl::RefreshDevicesComplete() {
   DCHECK(CalledOnValidThread());
   DCHECK(enumeration_in_progress_);
@@ skipping 23 matching lines @@
 void UsbServiceImpl::EnumerateDevice(PlatformUsbDevice platform_device,
                                      const base::Closure& refresh_complete) {
   DCHECK(context_);
   devices_being_enumerated_.insert(platform_device);
 
   libusb_device_descriptor descriptor;
   int rv = libusb_get_device_descriptor(platform_device, &descriptor);
   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;
     }
 
     scoped_refptr<UsbDeviceImpl> device(new UsbDeviceImpl(
         context_, platform_device, descriptor, blocking_task_runner_));
     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 {
     USB_LOG(EVENT) << "Failed to get device descriptor: "
                    << ConvertPlatformUsbErrorToString(rv);
     refresh_complete.Run();
   }
 }
 
 void UsbServiceImpl::AddDevice(const base::Closure& refresh_complete,
@@ skipping 82 matching lines @@
   DCHECK(CalledOnValidThread());
   PlatformDeviceMap::iterator it = platform_devices_.find(platform_device);
   if (it != platform_devices_.end()) {
     RemoveDevice(it->second);
   } else {
     devices_being_enumerated_.erase(platform_device);
   }
   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