Extracted UsbService as interface.

components/usb_service/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 "components/usb_service/usb_service.h"
 
+#include <map>
 #include <set>
-#include <vector>
 
 #include "base/lazy_instance.h"
+#include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "components/usb_service/usb_context.h"
 #include "components/usb_service/usb_device.h"
 #include "content/public/browser/browser_thread.h"
 #include "third_party/libusb/src/libusb/libusb.h"
 
 namespace usb_service {
 
 namespace {
 
 base::LazyInstance<scoped_ptr<UsbService> >::Leaky g_usb_service_instance =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
-// static
-UsbService* UsbService::GetInstance() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
-  UsbService* instance = g_usb_service_instance.Get().get();
-  if (!instance) {
-    PlatformUsbContext context = NULL;
-    if (libusb_init(&context) != LIBUSB_SUCCESS)
-      return NULL;
-    if (!context)
-      return NULL;
+typedef struct libusb_device* PlatformUsbDevice;
+typedef struct libusb_context* PlatformUsbContext;
 
-    instance = new UsbService(context);
-    g_usb_service_instance.Get().reset(instance);
-  }
-  return instance;
-}
+class UsbServiceImpl
+    : public UsbService,
+      private base::MessageLoop::DestructionObserver {
+ public:
+  explicit UsbServiceImpl(PlatformUsbContext context);
+  virtual ~UsbServiceImpl();
 
-scoped_refptr<UsbDevice> UsbService::GetDeviceById(uint32 unique_id) {
+ private:
+  // usb_service::UsbService implementation
+  virtual scoped_refptr<UsbDevice> GetDeviceById(uint32 unique_id) OVERRIDE;
+  virtual void GetDevices(
+      std::vector<scoped_refptr<UsbDevice> >* devices) OVERRIDE;
+
+  // base::MessageLoop::DestructionObserver implementation.
+  virtual void WillDestroyCurrentMessageLoop() OVERRIDE;
+
+  // Enumerate USB devices from OS and Update devices_ map.
+  void RefreshDevices();
+
+  scoped_refptr<UsbContext> context_;
+
+  // TODO(ikarienator): Figure out a better solution.
+  uint32 next_unique_id_;
+
+  // The map from PlatformUsbDevices to UsbDevices.
+  typedef std::map<PlatformUsbDevice, scoped_refptr<UsbDevice> > DeviceMap;
+  DeviceMap devices_;
+
+  DISALLOW_COPY_AND_ASSIGN(UsbServiceImpl);
+};
+
+scoped_refptr<UsbDevice> UsbServiceImpl::GetDeviceById(uint32 unique_id) {
   DCHECK(CalledOnValidThread());
   RefreshDevices();
   for (DeviceMap::iterator it = devices_.begin(); it != devices_.end(); ++it) {
     if (it->second->unique_id() == unique_id)
       return it->second;
   }
   return NULL;
 }
 
-void UsbService::GetDevices(std::vector<scoped_refptr<UsbDevice> >* devices) {
+void UsbServiceImpl::GetDevices(
+    std::vector<scoped_refptr<UsbDevice> >* devices) {
   DCHECK(CalledOnValidThread());
   STLClearObject(devices);
   RefreshDevices();
 
   for (DeviceMap::iterator it = devices_.begin(); it != devices_.end(); ++it) {
     devices->push_back(it->second);
   }
 }
 
-void UsbService::WillDestroyCurrentMessageLoop() {
+void UsbServiceImpl::WillDestroyCurrentMessageLoop() {
   DCHECK(CalledOnValidThread());
   g_usb_service_instance.Get().reset(NULL);
 }
 
-UsbService::UsbService(PlatformUsbContext context)
+UsbServiceImpl::UsbServiceImpl(PlatformUsbContext context)
     : context_(new UsbContext(context)), next_unique_id_(0) {
   base::MessageLoop::current()->AddDestructionObserver(this);
 }
 
-UsbService::~UsbService() {
+UsbServiceImpl::~UsbServiceImpl() {
   base::MessageLoop::current()->RemoveDestructionObserver(this);
   for (DeviceMap::iterator it = devices_.begin(); it != devices_.end(); ++it) {
     it->second->OnDisconnect();
   }
 }
 
-void UsbService::RefreshDevices() {
+void UsbServiceImpl::RefreshDevices() {
   DCHECK(CalledOnValidThread());
 
   libusb_device** platform_devices = NULL;
   const ssize_t device_count =
       libusb_get_device_list(context_->context(), &platform_devices);
 
   std::set<UsbDevice*> connected_devices;
   std::vector<PlatformUsbDevice> disconnected_devices;
 
   // Populates new devices.
@@ skipping 25 matching lines @@
   // Remove disconnected devices from devices_.
   for (size_t i = 0; i < disconnected_devices.size(); ++i) {
     // UsbDevice will be destroyed after this. The corresponding
     // PlatformUsbDevice will be unref'ed during this process.
     devices_.erase(disconnected_devices[i]);
   }
 
   libusb_free_device_list(platform_devices, true);
 }
 
+// static
+UsbService* UsbService::GetInstance() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
+  UsbService* instance = g_usb_service_instance.Get().get();
+  if (!instance) {
+    PlatformUsbContext context = NULL;
+    if (libusb_init(&context) != LIBUSB_SUCCESS)
+      return NULL;
+    if (!context)
+      return NULL;
+
+    instance = new UsbServiceImpl(context);
+    g_usb_service_instance.Get().reset(instance);
+  }
+  return instance;
+}
+
+// static
+void UsbService::SetInstanceForTest(UsbService* instance) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
+  g_usb_service_instance.Get().reset(instance);
+}
+
 }  // namespace usb_service