Merge components/usb_service into device/usb.

device/usb/usb_device_handle_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_device_handle_impl.h"
+#include "device/usb/usb_device_handle_impl.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "base/synchronization/lock.h"
 #include "base/thread_task_runner_handle.h"
-#include "components/usb_service/usb_context.h"
-#include "components/usb_service/usb_device_impl.h"
-#include "components/usb_service/usb_error.h"
-#include "components/usb_service/usb_interface.h"
-#include "components/usb_service/usb_service.h"
+#include "device/usb/usb_context.h"
+#include "device/usb/usb_device_impl.h"
+#include "device/usb/usb_error.h"
+#include "device/usb/usb_interface.h"
+#include "device/usb/usb_service.h"
 #include "third_party/libusb/src/libusb/libusb.h"
 
-namespace usb_service {
+namespace device {
 
 typedef libusb_device* PlatformUsbDevice;
 
-void HandleTransferCompletion(usb_service::PlatformUsbTransferHandle transfer);
+void HandleTransferCompletion(PlatformUsbTransferHandle transfer);
 
 namespace {
 
 static uint8 ConvertTransferDirection(const UsbEndpointDirection direction) {
   switch (direction) {
     case USB_DIRECTION_INBOUND:
       return LIBUSB_ENDPOINT_IN;
     case USB_DIRECTION_OUTBOUND:
       return LIBUSB_ENDPOINT_OUT;
     default:
@@ skipping 99 matching lines @@
       alternate_setting_(0) {
 }
 
 UsbDeviceHandleImpl::InterfaceClaimer::~InterfaceClaimer() {
   libusb_release_interface(handle_->handle(), interface_number_);
 }
 
 bool UsbDeviceHandleImpl::InterfaceClaimer::Claim() const {
   const int rv = libusb_claim_interface(handle_->handle(), interface_number_);
   if (rv != LIBUSB_SUCCESS) {
-    VLOG(1) << "Failed to claim interface: " << ConvertErrorToString(rv);
+    VLOG(1) << "Failed to claim interface: "
+            << ConvertPlatformUsbErrorToString(rv);
   }
   return rv == LIBUSB_SUCCESS;
 }
 
 struct UsbDeviceHandleImpl::Transfer {
   Transfer();
   ~Transfer();
 
   void Complete(UsbTransferStatus status, size_t bytes_transferred);
 
@@ skipping 191 matching lines @@
   if (!ContainsKey(claimed_interfaces_, interface_number))
     return false;
   const int rv = libusb_set_interface_alt_setting(
       handle_, interface_number, alternate_setting);
   if (rv == LIBUSB_SUCCESS) {
     claimed_interfaces_[interface_number]->set_alternate_setting(
         alternate_setting);
     RefreshEndpointMap();
   } else {
     VLOG(1) << "Failed to set interface (" << interface_number << ", "
-            << alternate_setting << "): " << ConvertErrorToString(rv);
+            << alternate_setting
+            << "): " << ConvertPlatformUsbErrorToString(rv);
   }
   return rv == LIBUSB_SUCCESS;
 }
 
 bool UsbDeviceHandleImpl::ResetDevice() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!device_)
     return false;
 
   const int rv = libusb_reset_device(handle_);
   if (rv != LIBUSB_SUCCESS) {
-    VLOG(1) << "Failed to reset device: " << ConvertErrorToString(rv);
+    VLOG(1) << "Failed to reset device: "
+            << ConvertPlatformUsbErrorToString(rv);
   }
   return rv == LIBUSB_SUCCESS;
 }
 
 bool UsbDeviceHandleImpl::GetSupportedLanguages() {
   if (!languages_.empty()) {
     return true;
   }
 
   // The 1-byte length field limits the descriptor to 256-bytes (128 uint16s).
   uint16 languages[128];
   int size = libusb_get_string_descriptor(
       handle_,
       0,
       0,
       reinterpret_cast<unsigned char*>(&languages[0]),
       sizeof(languages));
   if (size < 0) {
     VLOG(1) << "Failed to get list of supported languages: "
-            << ConvertErrorToString(size);
+            << ConvertPlatformUsbErrorToString(size);
     return false;
   } else if (size < 2) {
     VLOG(1) << "String descriptor zero has no header.";
     return false;
-  // The first 2 bytes of the descriptor are the total length and type tag.
+    // The first 2 bytes of the descriptor are the total length and type tag.
   } else if ((languages[0] & 0xff) != size) {
     VLOG(1) << "String descriptor zero size mismatch: " << (languages[0] & 0xff)
             << " != " << size;
     return false;
   } else if ((languages[0] >> 8) != LIBUSB_DT_STRING) {
     VLOG(1) << "String descriptor zero is not a string descriptor.";
     return false;
   }
 
   languages_.assign(languages[1], languages[(size - 2) / 2]);
@@ skipping 18 matching lines @@
     // The 1-byte length field limits the descriptor to 256-bytes (128 char16s).
     base::char16 text[128];
     int size =
         libusb_get_string_descriptor(handle_,
                                      string_id,
                                      language_id,
                                      reinterpret_cast<unsigned char*>(&text[0]),
                                      sizeof(text));
     if (size < 0) {
       VLOG(1) << "Failed to get string descriptor " << string_id << " (langid "
-              << language_id << "): " << ConvertErrorToString(size);
+              << language_id << "): " << ConvertPlatformUsbErrorToString(size);
       continue;
     } else if (size < 2) {
       VLOG(1) << "String descriptor " << string_id << " (langid " << language_id
               << ") has no header.";
       continue;
-    // The first 2 bytes of the descriptor are the total length and type tag.
+      // The first 2 bytes of the descriptor are the total length and type tag.
     } else if ((text[0] & 0xff) != size) {
       VLOG(1) << "String descriptor " << string_id << " (langid " << language_id
               << ") size mismatch: " << (text[0] & 0xff) << " != " << size;
       continue;
     } else if ((text[0] >> 8) != LIBUSB_DT_STRING) {
       VLOG(1) << "String descriptor " << string_id << " (langid " << language_id
               << ") is not a string descriptor.";
       continue;
     }
 
     *string = base::string16(text + 1, (size - 2) / 2);
     strings_[string_id] = *string;
     return true;
   }
 
   return false;
 }
 
 bool UsbDeviceHandleImpl::GetManufacturer(base::string16* manufacturer) {
   DCHECK(thread_checker_.CalledOnValidThread());
   PlatformUsbDevice device = libusb_get_device(handle_);
   libusb_device_descriptor desc;
 
   // This is a non-blocking call as libusb has the descriptor in memory.
   const int rv = libusb_get_device_descriptor(device, &desc);
   if (rv != LIBUSB_SUCCESS) {
-    VLOG(1) << "Failed to read device descriptor: " << ConvertErrorToString(rv);
+    VLOG(1) << "Failed to read device descriptor: "
+            << ConvertPlatformUsbErrorToString(rv);
     return false;
   }
 
   if (desc.iManufacturer == 0) {
     return false;
   }
 
   return GetStringDescriptor(desc.iManufacturer, manufacturer);
 }
 
 bool UsbDeviceHandleImpl::GetProduct(base::string16* product) {
   DCHECK(thread_checker_.CalledOnValidThread());
   PlatformUsbDevice device = libusb_get_device(handle_);
   libusb_device_descriptor desc;
 
   // This is a non-blocking call as libusb has the descriptor in memory.
   const int rv = libusb_get_device_descriptor(device, &desc);
   if (rv != LIBUSB_SUCCESS) {
-    VLOG(1) << "Failed to read device descriptor: " << ConvertErrorToString(rv);
+    VLOG(1) << "Failed to read device descriptor: "
+            << ConvertPlatformUsbErrorToString(rv);
     return false;
   }
 
   if (desc.iProduct == 0) {
     return false;
   }
 
   return GetStringDescriptor(desc.iProduct, product);
 }
 
 bool UsbDeviceHandleImpl::GetSerial(base::string16* serial) {
   DCHECK(thread_checker_.CalledOnValidThread());
   PlatformUsbDevice device = libusb_get_device(handle_);
   libusb_device_descriptor desc;
 
   // This is a non-blocking call as libusb has the descriptor in memory.
   const int rv = libusb_get_device_descriptor(device, &desc);
   if (rv != LIBUSB_SUCCESS) {
-    VLOG(1) << "Failed to read device descriptor: " << ConvertErrorToString(rv);
+    VLOG(1) << "Failed to read device descriptor: "
+            << ConvertPlatformUsbErrorToString(rv);
     return false;
   }
 
   if (desc.iSerialNumber == 0) {
     return false;
   }
 
   return GetStringDescriptor(desc.iSerialNumber, serial);
 }
 
@@ skipping 204 matching lines @@
   }
 
   // It's OK for this method to return NULL. libusb_submit_transfer will fail if
   // it requires an interface we didn't claim.
   transfer.claimed_interface = GetClaimedInterfaceForEndpoint(handle->endpoint);
 
   const int rv = libusb_submit_transfer(handle);
   if (rv == LIBUSB_SUCCESS) {
     transfers_[handle] = transfer;
   } else {
-    VLOG(1) << "Failed to submit transfer: " << ConvertErrorToString(rv);
+    VLOG(1) << "Failed to submit transfer: "
+            << ConvertPlatformUsbErrorToString(rv);
     transfer.Complete(USB_TRANSFER_ERROR, 0);
   }
 }
 
 void UsbDeviceHandleImpl::InternalClose() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!device_)
     return;
 
   // Cancel all the transfers.
   for (TransferMap::iterator it = transfers_.begin(); it != transfers_.end();
        ++it) {
     // The callback will be called some time later.
     libusb_cancel_transfer(it->first);
   }
 
   // Attempt-release all the interfaces.
   // It will be retained until the transfer cancellation is finished.
   claimed_interfaces_.clear();
 
   // Cannot close device handle here. Need to wait for libusb_cancel_transfer to
   // finish.
   device_ = NULL;
 }
 
-}  // namespace usb_service
+}  // namespace device