Merge components/usb_service into device/usb.

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 "components/usb_service/usb_service.h"
+#include "device/usb/usb_service.h"
 
 #include <map>
 #include <set>
 
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
-#include "components/usb_service/usb_context.h"
-#include "components/usb_service/usb_device_impl.h"
-#include "components/usb_service/usb_error.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"
 
-namespace usb_service {
+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 {
+class UsbServiceImpl : public UsbService,
+                       private base::MessageLoop::DestructionObserver {
  public:
   explicit UsbServiceImpl(
       PlatformUsbContext context,
       scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner);
   virtual ~UsbServiceImpl();
 
  private:
-  // usb_service::UsbService implementation
+  // device::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();
 
@@ skipping 54 matching lines @@
 }
 
 void UsbServiceImpl::RefreshDevices() {
   DCHECK(CalledOnValidThread());
 
   libusb_device** platform_devices = NULL;
   const ssize_t device_count =
       libusb_get_device_list(context_->context(), &platform_devices);
   if (device_count < 0) {
     VLOG(1) << "Failed to get device list: "
-            << ConvertErrorToString(device_count);
+            << ConvertPlatformUsbErrorToString(device_count);
   }
 
   std::set<UsbDevice*> connected_devices;
   std::vector<PlatformUsbDevice> disconnected_devices;
 
   // Populates new devices.
   for (ssize_t i = 0; i < device_count; ++i) {
     if (!ContainsKey(devices_, platform_devices[i])) {
       libusb_device_descriptor descriptor;
       const int rv =
           libusb_get_device_descriptor(platform_devices[i], &descriptor);
       // This test is needed. A valid vendor/produce pair is required.
       if (rv != LIBUSB_SUCCESS) {
         VLOG(1) << "Failed to get device descriptor: "
-                << ConvertErrorToString(rv);
+                << ConvertPlatformUsbErrorToString(rv);
         continue;
       }
       UsbDeviceImpl* new_device = new UsbDeviceImpl(context_,
                                                     ui_task_runner_,
                                                     platform_devices[i],
                                                     descriptor.idVendor,
                                                     descriptor.idProduct,
                                                     ++next_unique_id_);
       devices_[platform_devices[i]] = new_device;
       connected_devices.insert(new_device);
@@ skipping 21 matching lines @@
 
 // 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: " << ConvertErrorToString(rv);
+      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);
 }
 
-}  // namespace usb_service
+}  // namespace device