Merge components/usb_service into device/usb.

extensions/browser/api/usb/usb_api.cc

Index: extensions/browser/api/usb/usb_api.cc
diff --git a/extensions/browser/api/usb/usb_api.cc b/extensions/browser/api/usb/usb_api.cc
index 20ed11752d5bb07569e85134c6ec14e0dd901385..6f36c3bff7d387d1e59c3ccc396589befbc00eed 100644
--- a/extensions/browser/api/usb/usb_api.cc
+++ b/extensions/browser/api/usb/usb_api.cc
@@ -9,9 +9,9 @@
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
-#include "components/usb_service/usb_device_handle.h"
-#include "components/usb_service/usb_service.h"
 #include "device/core/device_client.h"
+#include "device/usb/usb_device_handle.h"
+#include "device/usb/usb_service.h"
 #include "extensions/browser/api/usb/usb_device_resource.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/api/usb.h"
@@ -50,18 +50,18 @@ using usb::RequestType;
 using usb::SynchronizationType;
 using usb::TransferType;
 using usb::UsageType;
-using usb_service::UsbConfigDescriptor;
-using usb_service::UsbDevice;
-using usb_service::UsbDeviceHandle;
-using usb_service::UsbEndpointDescriptor;
-using usb_service::UsbEndpointDirection;
-using usb_service::UsbInterfaceAltSettingDescriptor;
-using usb_service::UsbInterfaceDescriptor;
-using usb_service::UsbService;
-using usb_service::UsbSynchronizationType;
-using usb_service::UsbTransferStatus;
-using usb_service::UsbTransferType;
-using usb_service::UsbUsageType;
+using device::UsbConfigDescriptor;
+using device::UsbDevice;
+using device::UsbDeviceHandle;
+using device::UsbEndpointDescriptor;
+using device::UsbEndpointDirection;
+using device::UsbInterfaceAltSettingDescriptor;
+using device::UsbInterfaceDescriptor;
+using device::UsbService;
+using device::UsbSynchronizationType;
+using device::UsbTransferStatus;
+using device::UsbTransferType;
+using device::UsbUsageType;
 
 typedef std::vector<scoped_refptr<UsbDevice> > DeviceVector;
 typedef scoped_ptr<DeviceVector> ScopedDeviceVector;
@@ -115,10 +115,10 @@ const int kMaxPacketLength = 64 * 1024;
 bool ConvertDirectionToApi(const UsbEndpointDirection& input,
                            Direction* output) {
   switch (input) {
-    case usb_service::USB_DIRECTION_INBOUND:
+    case device::USB_DIRECTION_INBOUND:
       *output = usb::DIRECTION_IN;
       return true;
-    case usb_service::USB_DIRECTION_OUTBOUND:
+    case device::USB_DIRECTION_OUTBOUND:
       *output = usb::DIRECTION_OUT;
       return true;
     default:
@@ -130,16 +130,16 @@ bool ConvertDirectionToApi(const UsbEndpointDirection& input,
 bool ConvertSynchronizationTypeToApi(const UsbSynchronizationType& input,
                                      usb::SynchronizationType* output) {
   switch (input) {
-    case usb_service::USB_SYNCHRONIZATION_NONE:
+    case device::USB_SYNCHRONIZATION_NONE:
       *output = usb::SYNCHRONIZATION_TYPE_NONE;
       return true;
-    case usb_service::USB_SYNCHRONIZATION_ASYNCHRONOUS:
+    case device::USB_SYNCHRONIZATION_ASYNCHRONOUS:
       *output = usb::SYNCHRONIZATION_TYPE_ASYNCHRONOUS;
       return true;
-    case usb_service::USB_SYNCHRONIZATION_ADAPTIVE:
+    case device::USB_SYNCHRONIZATION_ADAPTIVE:
       *output = usb::SYNCHRONIZATION_TYPE_ADAPTIVE;
       return true;
-    case usb_service::USB_SYNCHRONIZATION_SYNCHRONOUS:
+    case device::USB_SYNCHRONIZATION_SYNCHRONOUS:
       *output = usb::SYNCHRONIZATION_TYPE_SYNCHRONOUS;
       return true;
     default:
@@ -151,16 +151,16 @@ bool ConvertSynchronizationTypeToApi(const UsbSynchronizationType& input,
 bool ConvertTransferTypeToApi(const UsbTransferType& input,
                               usb::TransferType* output) {
   switch (input) {
-    case usb_service::USB_TRANSFER_CONTROL:
+    case device::USB_TRANSFER_CONTROL:
       *output = usb::TRANSFER_TYPE_CONTROL;
       return true;
-    case usb_service::USB_TRANSFER_INTERRUPT:
+    case device::USB_TRANSFER_INTERRUPT:
       *output = usb::TRANSFER_TYPE_INTERRUPT;
       return true;
-    case usb_service::USB_TRANSFER_ISOCHRONOUS:
+    case device::USB_TRANSFER_ISOCHRONOUS:
       *output = usb::TRANSFER_TYPE_ISOCHRONOUS;
       return true;
-    case usb_service::USB_TRANSFER_BULK:
+    case device::USB_TRANSFER_BULK:
       *output = usb::TRANSFER_TYPE_BULK;
       return true;
     default:
@@ -171,13 +171,13 @@ bool ConvertTransferTypeToApi(const UsbTransferType& input,
 
 bool ConvertUsageTypeToApi(const UsbUsageType& input, usb::UsageType* output) {
   switch (input) {
-    case usb_service::USB_USAGE_DATA:
+    case device::USB_USAGE_DATA:
       *output = usb::USAGE_TYPE_DATA;
       return true;
-    case usb_service::USB_USAGE_FEEDBACK:
+    case device::USB_USAGE_FEEDBACK:
       *output = usb::USAGE_TYPE_FEEDBACK;
       return true;
-    case usb_service::USB_USAGE_EXPLICIT_FEEDBACK:
+    case device::USB_USAGE_EXPLICIT_FEEDBACK:
       *output = usb::USAGE_TYPE_EXPLICITFEEDBACK;
       return true;
     default:
@@ -189,10 +189,10 @@ bool ConvertUsageTypeToApi(const UsbUsageType& input, usb::UsageType* output) {
 bool ConvertDirection(const Direction& input, UsbEndpointDirection* output) {
   switch (input) {
     case usb::DIRECTION_IN:
-      *output = usb_service::USB_DIRECTION_INBOUND;
+      *output = device::USB_DIRECTION_INBOUND;
       return true;
     case usb::DIRECTION_OUT:
-      *output = usb_service::USB_DIRECTION_OUTBOUND;
+      *output = device::USB_DIRECTION_OUTBOUND;
       return true;
     default:
       NOTREACHED();
@@ -274,9 +274,9 @@ scoped_refptr<net::IOBuffer> CreateBufferForTransfer(
   scoped_refptr<net::IOBuffer> buffer =
       new net::IOBuffer(std::max(static_cast<size_t>(1), size));
 
-  if (direction == usb_service::USB_DIRECTION_INBOUND) {
+  if (direction == device::USB_DIRECTION_INBOUND) {
     return buffer;
-  } else if (direction == usb_service::USB_DIRECTION_OUTBOUND) {
+  } else if (direction == device::USB_DIRECTION_OUTBOUND) {
     if (input.data.get() && size <= input.data->size()) {
       memcpy(buffer->data(), input.data->data(), size);
       return buffer;
@@ -288,21 +288,21 @@ scoped_refptr<net::IOBuffer> CreateBufferForTransfer(
 
 const char* ConvertTransferStatusToErrorString(const UsbTransferStatus status) {
   switch (status) {
-    case usb_service::USB_TRANSFER_COMPLETED:
+    case device::USB_TRANSFER_COMPLETED:
       return "";
-    case usb_service::USB_TRANSFER_ERROR:
+    case device::USB_TRANSFER_ERROR:
       return kErrorGeneric;
-    case usb_service::USB_TRANSFER_TIMEOUT:
+    case device::USB_TRANSFER_TIMEOUT:
       return kErrorTimeout;
-    case usb_service::USB_TRANSFER_CANCELLED:
+    case device::USB_TRANSFER_CANCELLED:
       return kErrorCancelled;
-    case usb_service::USB_TRANSFER_STALLED:
+    case device::USB_TRANSFER_STALLED:
       return kErrorStalled;
-    case usb_service::USB_TRANSFER_DISCONNECT:
+    case device::USB_TRANSFER_DISCONNECT:
       return kErrorDisconnect;
-    case usb_service::USB_TRANSFER_OVERFLOW:
+    case device::USB_TRANSFER_OVERFLOW:
       return kErrorOverflow;
-    case usb_service::USB_TRANSFER_LENGTH_SHORT:
+    case device::USB_TRANSFER_LENGTH_SHORT:
       return kErrorTransferLength;
     default:
       NOTREACHED();
@@ -500,7 +500,7 @@ UsbAsyncApiTransferFunction::~UsbAsyncApiTransferFunction() {
 void UsbAsyncApiTransferFunction::OnCompleted(UsbTransferStatus status,
                                               scoped_refptr<net::IOBuffer> data,
                                               size_t length) {
-  if (status != usb_service::USB_TRANSFER_COMPLETED)
+  if (status != device::USB_TRANSFER_COMPLETED)
     SetError(ConvertTransferStatusToErrorString(status));
 
   SetResult(CreateTransferInfo(status, data, length));