Add browser tests for USB device add/remove events.

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 "device/usb/usb_service_impl.h"
 
-#include <map>
 #include <set>
 
 #include "base/bind.h"
-#include "base/lazy_instance.h"
+#include "base/location.h"
 #include "base/memory/weak_ptr.h"
-#include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
-#include "device/usb/usb_context.h"
-#include "device/usb/usb_device_impl.h"
 #include "device/usb/usb_error.h"
-#include "third_party/libusb/src/libusb/libusb.h"
 
 #if defined(OS_WIN)
 #include <usbiodef.h>
 
 #include "base/scoped_observer.h"
 #include "device/core/device_monitor_win.h"
 #endif  // OS_WIN
 
 namespace device {
 
-namespace {
-
-base::LazyInstance<scoped_ptr<UsbService> >::Leaky g_usb_service_instance =
-    LAZY_INSTANCE_INITIALIZER;
-
-}  // namespace
-
-typedef struct libusb_device* PlatformUsbDevice;
-typedef struct libusb_context* PlatformUsbContext;
-
-class UsbServiceImpl : public UsbService,
-                       private base::MessageLoop::DestructionObserver {
- public:
-  explicit UsbServiceImpl(
-      PlatformUsbContext context,
-      scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner);
-  ~UsbServiceImpl() override;
-
- private:
-  // device::UsbService implementation
-  scoped_refptr<UsbDevice> GetDeviceById(uint32 unique_id) override;
-  void GetDevices(std::vector<scoped_refptr<UsbDevice>>* devices) override;
-
-  // base::MessageLoop::DestructionObserver implementation.
-  void WillDestroyCurrentMessageLoop() override;
-
-  // Enumerate USB devices from OS and update devices_ map.
-  void RefreshDevices();
-
-  // Adds a new UsbDevice to the devices_ map based on the given libusb device.
-  scoped_refptr<UsbDeviceImpl> AddDevice(PlatformUsbDevice platform_device);
-
-  // Handle hotplug events from libusb.
-  static int LIBUSB_CALL HotplugCallback(libusb_context* context,
-                                         PlatformUsbDevice device,
-                                         libusb_hotplug_event event,
-                                         void* user_data);
-  // These functions release a reference to the provided platform device.
-  void OnDeviceAdded(PlatformUsbDevice platform_device);
-  void OnDeviceRemoved(PlatformUsbDevice platform_device);
-
-  scoped_refptr<UsbContext> context_;
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
-  scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
-
-#if defined(OS_WIN)
-  class UIThreadHelper;
-  UIThreadHelper* ui_thread_helper_;
-#endif  // OS_WIN
-
-  // TODO(reillyg): Figure out a better solution for device IDs.
-  uint32 next_unique_id_;
-
-  // When available the device list will be updated when new devices are
-  // connected instead of only when a full enumeration is requested.
-  // TODO(reillyg): Support this on all platforms. crbug.com/411715
-  bool hotplug_enabled_;
-  libusb_hotplug_callback_handle hotplug_handle_;
-
-  // The map from unique IDs to UsbDevices.
-  typedef std::map<uint32, scoped_refptr<UsbDeviceImpl> > DeviceMap;
-  DeviceMap devices_;
-
-  // The map from PlatformUsbDevices to UsbDevices.
-  typedef std::map<PlatformUsbDevice, scoped_refptr<UsbDeviceImpl> >
-      PlatformDeviceMap;
-  PlatformDeviceMap platform_devices_;
-
-  base::WeakPtrFactory<UsbServiceImpl> weak_factory_;
-
-  DISALLOW_COPY_AND_ASSIGN(UsbServiceImpl);
-};
-
 #if defined(OS_WIN)
 // This class lives on the application main thread so that it can listen for
 // device change notification window messages. It registers for notifications
 // regarding devices implementating the "UsbDevice" interface, which represents
 // most of the devices the UsbService will enumerate.
 class UsbServiceImpl::UIThreadHelper final
     : private DeviceMonitorWin::Observer {
  public:
   UIThreadHelper(base::WeakPtr<UsbServiceImpl> usb_service)
       : task_runner_(base::ThreadTaskRunnerHandle::Get()),
@@ skipping 20 matching lines @@
     task_runner_->PostTask(
         FROM_HERE, base::Bind(&UsbServiceImpl::RefreshDevices, usb_service_));
   }
 
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   base::WeakPtr<UsbServiceImpl> usb_service_;
   ScopedObserver<DeviceMonitorWin, DeviceMonitorWin::Observer> device_observer_;
 };
 #endif
 
+// static
+UsbService* UsbServiceImpl::Create(
+    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
+  PlatformUsbContext context = NULL;
+  const int rv = libusb_init(&context);
+  if (rv != LIBUSB_SUCCESS) {
+    VLOG(1) << "Failed to initialize libusb: "
+            << ConvertPlatformUsbErrorToString(rv);
+    return nullptr;
+  }
+  if (!context) {
+    return nullptr;
+  }
+
+  return new UsbServiceImpl(context, ui_task_runner);
+}
+
 scoped_refptr<UsbDevice> UsbServiceImpl::GetDeviceById(uint32 unique_id) {
   DCHECK(CalledOnValidThread());
   RefreshDevices();
   DeviceMap::iterator it = devices_.find(unique_id);
   if (it != devices_.end()) {
     return it->second;
   }
   return NULL;
 }
 
 void UsbServiceImpl::GetDevices(
     std::vector<scoped_refptr<UsbDevice> >* devices) {
   DCHECK(CalledOnValidThread());
   STLClearObject(devices);
 
   if (!hotplug_enabled_) {
     RefreshDevices();
   }
 
   for (const auto& map_entry : devices_) {
     devices->push_back(map_entry.second);
   }
 }
 
-void UsbServiceImpl::WillDestroyCurrentMessageLoop() {
-  DCHECK(CalledOnValidThread());
-  g_usb_service_instance.Get().reset(NULL);
-}
-
 UsbServiceImpl::UsbServiceImpl(
     PlatformUsbContext context,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner)
     : context_(new UsbContext(context)),
       ui_task_runner_(ui_task_runner),
       next_unique_id_(0),
       hotplug_enabled_(false),
       weak_factory_(this) {
-  base::MessageLoop::current()->AddDestructionObserver(this);
   task_runner_ = base::ThreadTaskRunnerHandle::Get();
   int rv = libusb_hotplug_register_callback(
       context_->context(),
       static_cast<libusb_hotplug_event>(LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED |
                                         LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT),
       LIBUSB_HOTPLUG_ENUMERATE, LIBUSB_HOTPLUG_MATCH_ANY,
       LIBUSB_HOTPLUG_MATCH_ANY, LIBUSB_HOTPLUG_MATCH_ANY,
       &UsbServiceImpl::HotplugCallback, this, &hotplug_handle_);
   if (rv == LIBUSB_SUCCESS) {
     hotplug_enabled_ = true;
   } else {
 #if defined(OS_WIN)
     ui_thread_helper_ = new UIThreadHelper(weak_factory_.GetWeakPtr());
     ui_task_runner_->PostTask(FROM_HERE,
                               base::Bind(&UIThreadHelper::Start,
                                          base::Unretained(ui_thread_helper_)));
 #endif  // OS_WIN
   }
 }
 
 UsbServiceImpl::~UsbServiceImpl() {
-  base::MessageLoop::current()->RemoveDestructionObserver(this);
   if (hotplug_enabled_) {
     libusb_hotplug_deregister_callback(context_->context(), hotplug_handle_);
   }
 #if defined(OS_WIN)
   if (ui_thread_helper_) {
     ui_task_runner_->DeleteSoon(FROM_HERE, ui_thread_helper_);
   }
 #endif  // OS_WIN
   for (const auto& map_entry : devices_) {
     map_entry.second->OnDisconnect();
@@ skipping 135 matching lines @@
 
     NotifyDeviceRemoved(device);
     device->OnDisconnect();
   } else {
     NOTREACHED();
   }
 
   libusb_unref_device(platform_device);
 }
 
-void UsbService::Observer::OnDeviceAdded(scoped_refptr<UsbDevice> device) {
-}
-
-void UsbService::Observer::OnDeviceRemoved(scoped_refptr<UsbDevice> device) {
-}
-
-// static
-UsbService* UsbService::GetInstance(
-    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
-  UsbService* instance = g_usb_service_instance.Get().get();
-  if (!instance) {
-    PlatformUsbContext context = NULL;
-
-    const int rv = libusb_init(&context);
-    if (rv != LIBUSB_SUCCESS) {
-      VLOG(1) << "Failed to initialize libusb: "
-              << ConvertPlatformUsbErrorToString(rv);
-      return NULL;
-    }
-    if (!context)
-      return NULL;
-
-    instance = new UsbServiceImpl(context, ui_task_runner);
-    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() {
-}
-
-void UsbService::AddObserver(Observer* observer) {
-  DCHECK(CalledOnValidThread());
-  observer_list_.AddObserver(observer);
-}
-
-void UsbService::RemoveObserver(Observer* observer) {
-  DCHECK(CalledOnValidThread());
-  observer_list_.RemoveObserver(observer);
-}
-
-void UsbService::NotifyDeviceAdded(scoped_refptr<UsbDevice> device) {
-  DCHECK(CalledOnValidThread());
-  FOR_EACH_OBSERVER(Observer, observer_list_, OnDeviceAdded(device));
-}
-
-void UsbService::NotifyDeviceRemoved(scoped_refptr<UsbDevice> device) {
-  DCHECK(CalledOnValidThread());
-  FOR_EACH_OBSERVER(Observer, observer_list_, OnDeviceRemoved(device));
-}
-
 }  // namespace device