Add an Observer interface to UsbService for device add/remove.

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.h"
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 155 matching lines @@
       scoped_refptr<UsbDeviceImpl> new_device = AddDevice(platform_devices[i]);
       if (new_device) {
         connected_devices.insert(new_device.get());
       }
     } else {
       connected_devices.insert(platform_devices_[platform_devices[i]].get());
     }
   }
 
   // Find disconnected devices.
-  for (PlatformDeviceMap::iterator it = platform_devices_.begin();
-       it != platform_devices_.end();
-       ++it) {
-    if (!ContainsKey(connected_devices, it->second.get())) {
-      disconnected_devices.push_back(it->first);
-      devices_.erase(it->second->unique_id());
-      it->second->OnDisconnect();
+  for (const auto& map_entry : platform_devices_) {
+    PlatformUsbDevice platform_device = map_entry.first;
+    scoped_refptr<UsbDeviceImpl> device = map_entry.second;
+    if (!ContainsKey(connected_devices, device.get())) {
+      disconnected_devices.push_back(platform_device);
+      devices_.erase(device->unique_id());
+      NotifyDeviceRemoved(device);
+      device->OnDisconnect();

[asargent_no_longer_on_chrome, 2015/01/05 22:01:58]

I assume you've already thought about the ramifications of notifying observers
of the UsbDevice removal before calling OnDisconnect on the device itself. Would
there ever be a case where an implementor of the Observer interface might need
to know or care about this ordering? If so it might be worth a mention in a
comment above the Observer interface. 

[Reilly Grant (use Gerrit), 2015/01/05 22:10:34]

I'm actually about to remove the observer list from UsbDevice for other reasons
so I'll be removing this call. I'll update the patch with that change.

     }
   }
 
   // Remove disconnected devices from platform_devices_.
-  for (size_t i = 0; i < disconnected_devices.size(); ++i) {
+  for (const PlatformUsbDevice& platform_device : disconnected_devices) {
     // UsbDevice will be destroyed after this. The corresponding
     // PlatformUsbDevice will be unref'ed during this process.
-    platform_devices_.erase(disconnected_devices[i]);
+    platform_devices_.erase(platform_device);
   }
 
   libusb_free_device_list(platform_devices, true);
 }
 
 scoped_refptr<UsbDeviceImpl> UsbServiceImpl::AddDevice(
     PlatformUsbDevice platform_device) {
   libusb_device_descriptor descriptor;
   int rv = libusb_get_device_descriptor(platform_device, &descriptor);
   if (rv == LIBUSB_SUCCESS) {
     uint32 unique_id;
     do {
       unique_id = ++next_unique_id_;
     } while (devices_.find(unique_id) != devices_.end());
 
     scoped_refptr<UsbDeviceImpl> new_device(new UsbDeviceImpl(
         context_, ui_task_runner_, platform_device, descriptor.idVendor,
         descriptor.idProduct, unique_id));
     platform_devices_[platform_device] = new_device;
     devices_[unique_id] = new_device;
+    NotifyDeviceAdded(new_device);
     return new_device;
   } else {
     VLOG(1) << "Failed to get device descriptor: "
             << ConvertPlatformUsbErrorToString(rv);
     return nullptr;
   }
 }
 
 // static
 int LIBUSB_CALL UsbServiceImpl::HotplugCallback(libusb_context* context,
@@ skipping 46 matching lines @@
 
   PlatformDeviceMap::iterator it = platform_devices_.find(platform_device);
   if (it != platform_devices_.end()) {
     scoped_refptr<UsbDeviceImpl> device = it->second;
     DeviceMap::iterator dev_it = devices_.find(device->unique_id());
     if (dev_it != devices_.end()) {
       devices_.erase(dev_it);
     } else {
       NOTREACHED();
     }
+    NotifyDeviceRemoved(device);
     device->OnDisconnect();
     platform_devices_.erase(it);
   } else {
     NOTREACHED();
   }
 
   libusb_unref_device(platform_device);
 }
 
 // static
@@ skipping 16 matching lines @@
     g_usb_service_instance.Get().reset(instance);
   }
   return instance;
 }
 
 // static
 void UsbService::SetInstanceForTest(UsbService* instance) {
   g_usb_service_instance.Get().reset(instance);
 }
 
+UsbService::UsbService() {
+}
+
+UsbService::~UsbService() {

[asargent_no_longer_on_chrome, 2015/01/05 22:01:58]

Consider adding a DCHECK in the destructor here that observer_list_ is empty, to
catch cases where someone is accidentally holding on to a pointer to this object
for later calling RemoveObserver (eg via a ScopedObserver). 

[Reilly Grant (use Gerrit), 2015/01/05 22:10:34]

There's a template flag I can pass to ObserverList that adds this check.

+}
+
+void UsbService::AddObserver(Observer* observer) {
+  observer_list_.AddObserver(observer);
+}
+
+void UsbService::RemoveObserver(Observer* observer) {
+  observer_list_.RemoveObserver(observer);
+}
+
+void UsbService::NotifyDeviceAdded(scoped_refptr<UsbDevice> device) {
+  FOR_EACH_OBSERVER(Observer, observer_list_, OnDeviceAdded(device));
+}
+
+void UsbService::NotifyDeviceRemoved(scoped_refptr<UsbDevice> device) {
+  FOR_EACH_OBSERVER(Observer, observer_list_, OnDeviceRemoved(device));
+}
+
 }  // namespace device