Merge components/usb_service into device/usb.

extensions/browser/api/usb/usb_api.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 "extensions/browser/api/usb/usb_api.h"
 
 #include <string>
 #include <vector>
 
 #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"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/common/permissions/usb_device_permission.h"
 
 namespace usb = extensions::core_api::usb;
 namespace BulkTransfer = usb::BulkTransfer;
 namespace ClaimInterface = usb::ClaimInterface;
 namespace CloseDevice = usb::CloseDevice;
@@ skipping 18 matching lines @@
 using usb::Direction;
 using usb::EndpointDescriptor;
 using usb::GenericTransferInfo;
 using usb::InterfaceDescriptor;
 using usb::IsochronousTransferInfo;
 using usb::Recipient;
 using usb::RequestType;
 using usb::SynchronizationType;
 using usb::TransferType;
 using usb::UsageType;
-using usb_service::UsbConfigDescriptor;
-using usb_service::UsbDevice;
-using usb_service::UsbDeviceFilter;
-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::UsbDeviceFilter;
+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;
 
 namespace {
 
 const char kDataKey[] = "data";
 const char kResultCodeKey[] = "resultCode";
 
 const char kErrorInitService[] = "Failed to initialize USB service.";
@@ skipping 33 matching lines @@
 const char kErrorResetDevice[] =
     "Error resetting the device. The device has been closed.";
 
 const size_t kMaxTransferLength = 100 * 1024 * 1024;
 const int kMaxPackets = 4 * 1024 * 1024;
 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:
       NOTREACHED();
       return false;
   }
 }
 
 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:
       NOTREACHED();
       return false;
   }
 }
 
 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:
       NOTREACHED();
       return false;
   }
 }
 
 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:
       NOTREACHED();
       return false;
   }
 }
 
 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();
       return false;
   }
 }
 
 bool ConvertRequestType(const RequestType& input,
                         UsbDeviceHandle::TransferRequestType* output) {
   switch (input) {
@@ skipping 61 matching lines @@
     size_t size) {
   if (size >= kMaxTransferLength)
     return NULL;
 
   // Allocate a |size|-bytes buffer, or a one-byte buffer if |size| is 0. This
   // is due to an impedance mismatch between IOBuffer and URBs. An IOBuffer
   // cannot represent a zero-length buffer, while an URB can.
   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;
     }
   }
   NOTREACHED();
   return NULL;
 }
 
 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();
       return "";
   }
 }
 
 #if defined(OS_CHROMEOS)
 void RequestUsbDevicesAccessHelper(
     ScopedDeviceVector devices,
@@ skipping 114 matching lines @@
     output->SetInterfaceClass(*input.interface_class);
   }
   if (input.interface_subclass) {
     output->SetInterfaceSubclass(*input.interface_subclass);
   }
   if (input.interface_protocol) {
     output->SetInterfaceProtocol(*input.interface_protocol);
   }
 }
 
-bool UsbAsyncApiFunction::HasDevicePermission(
-    scoped_refptr<usb_service::UsbDevice> device) {
+bool UsbAsyncApiFunction::HasDevicePermission(scoped_refptr<UsbDevice> device) {
   UsbDevicePermission::CheckParam param(
       device->vendor_id(),
       device->product_id(),
       UsbDevicePermissionData::UNSPECIFIED_INTERFACE);
   return extension()->permissions_data()->CheckAPIPermissionWithParam(
       APIPermission::kUsbDevice, &param);
 }
 
 scoped_refptr<UsbDevice> UsbAsyncApiFunction::GetDeviceOrCompleteWithError(
     const Device& input_device) {
@@ skipping 57 matching lines @@
 
 UsbAsyncApiTransferFunction::UsbAsyncApiTransferFunction() {
 }
 
 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));
   AsyncWorkCompleted();
 }
 
 bool UsbAsyncApiTransferFunction::ConvertDirectionSafely(
     const Direction& input,
     UsbEndpointDirection* output) {
   const bool converted = ConvertDirection(input, output);
@@ skipping 686 matching lines @@
     SetResult(new base::FundamentalValue(false));
     CompleteWithError(kErrorResetDevice);
     return;
   }
 
   SetResult(new base::FundamentalValue(true));
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions