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 399 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 (ContainsValue(ignored_devices_, platform_device)) {
+      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 (!ContainsValue(existing_ignored_devices, *current))
+      ignored_devices_.erase(current);

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

We should libusb_unref_device here and in the UsbServiceImpl destructor. Can you
do a sanity test (by adding an OutputDebugString in libusb) that we are indeed
not leaking libusb_device objects when they are unplugged?

[juncai, 2016/04/26 19:26:44]

Done.

Also did some sanity check and found a potential device leak at function
UsbServiceImpl::OnDeviceList() and fixed it. I think after the fix, when
unplugging either hub or non-hub device, Chrome doesn't leak any device.

+  }
+
   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 enumeration_failed = base::Bind(
+        &UsbServiceImpl::EnumerationFailed, weak_factory_.GetWeakPtr(),
+        platform_device, refresh_complete);
     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));
+                   task_runner_, add_device, enumeration_failed));
 #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));
+                              add_device, enumeration_failed));
     }
 #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::EnumerationFailed(PlatformUsbDevice platform_device,
+                                       const base::Closure& refresh_complete) {
+  libusb_ref_device(platform_device);
+  ignored_devices_.insert(platform_device);
+  refresh_complete.Run();
+}
+
 }  // namespace device