Merge components/usb_service into device/usb.

chrome/browser/devtools/device/usb/android_usb_device.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 "chrome/browser/devtools/device/usb/android_usb_device.h"
 
 #include <set>
 
 #include "base/barrier_closure.h"
 #include "base/base64.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/devtools/device/usb/android_rsa.h"
 #include "chrome/browser/devtools/device/usb/android_usb_socket.h"
-#include "components/usb_service/usb_device.h"
-#include "components/usb_service/usb_interface.h"
-#include "components/usb_service/usb_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "crypto/rsa_private_key.h"
 #include "device/core/device_client.h"
+#include "device/usb/usb_device.h"
+#include "device/usb/usb_interface.h"
+#include "device/usb/usb_service.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/socket/stream_socket.h"
 
-using usb_service::UsbConfigDescriptor;
-using usb_service::UsbDevice;
-using usb_service::UsbDeviceHandle;
-using usb_service::UsbInterfaceAltSettingDescriptor;
-using usb_service::UsbInterfaceDescriptor;
-using usb_service::UsbEndpointDescriptor;
-using usb_service::UsbService;
-using usb_service::UsbTransferStatus;
+using device::UsbConfigDescriptor;
+using device::UsbDevice;
+using device::UsbDeviceHandle;
+using device::UsbInterfaceAltSettingDescriptor;
+using device::UsbInterfaceDescriptor;
+using device::UsbEndpointDescriptor;
+using device::UsbService;
+using device::UsbTransferStatus;
 
 namespace {
 
 const size_t kHeaderSize = 24;
 
 const int kAdbClass = 0xff;
 const int kAdbSubclass = 0x42;
 const int kAdbProtocol = 0x1;
 
 const int kUsbTimeout = 0;
 
 const uint32 kMaxPayload = 4096;
 const uint32 kVersion = 0x01000000;
 
 static const char kHostConnectMessage[] = "host::";
 
 using content::BrowserThread;
 
 typedef std::vector<scoped_refptr<UsbDevice> > UsbDevices;
 typedef std::set<scoped_refptr<UsbDevice> > UsbDeviceSet;
 
 // Stores android wrappers around claimed usb devices on caller thread.
 base::LazyInstance<std::vector<AndroidUsbDevice*> >::Leaky g_devices =
     LAZY_INSTANCE_INITIALIZER;
 
-bool IsAndroidInterface(
-    scoped_refptr<const usb_service::UsbInterfaceDescriptor> interface) {
+bool IsAndroidInterface(scoped_refptr<const UsbInterfaceDescriptor> interface) {
   if (interface->GetNumAltSettings() == 0)
     return false;
 
   scoped_refptr<const UsbInterfaceAltSettingDescriptor> idesc =
       interface->GetAltSetting(0);
 
   if (idesc->GetInterfaceClass() != kAdbClass ||
       idesc->GetInterfaceSubclass() != kAdbSubclass ||
       idesc->GetInterfaceProtocol() != kAdbProtocol ||
       idesc->GetNumEndpoints() != 2) {
@@ skipping 10 matching lines @@
   scoped_refptr<const UsbInterfaceAltSettingDescriptor> idesc =
       interface->GetAltSetting(0);
 
   int inbound_address = 0;
   int outbound_address = 0;
   int zero_mask = 0;
 
   for (size_t i = 0; i < idesc->GetNumEndpoints(); ++i) {
     scoped_refptr<const UsbEndpointDescriptor> edesc =
         idesc->GetEndpoint(i);
-    if (edesc->GetTransferType() != usb_service::USB_TRANSFER_BULK)
+    if (edesc->GetTransferType() != device::USB_TRANSFER_BULK)
       continue;
-    if (edesc->GetDirection() == usb_service::USB_DIRECTION_INBOUND)
+    if (edesc->GetDirection() == device::USB_DIRECTION_INBOUND)
       inbound_address = edesc->GetAddress();
     else
       outbound_address = edesc->GetAddress();
     zero_mask = edesc->GetMaximumPacketSize() - 1;
   }
 
   if (inbound_address == 0 || outbound_address == 0)
     return NULL;
 
   if (!usb_handle->ClaimInterface(interface_id))
@@ skipping 317 matching lines @@
 
 void AndroidUsbDevice::ProcessOutgoing() {
   DCHECK(message_loop_ == base::MessageLoop::current());
 
   if (outgoing_queue_.empty() || !usb_handle_.get())
     return;
 
   BulkMessage message = outgoing_queue_.front();
   outgoing_queue_.pop();
   DumpMessage(true, message->data(), message->size());
-  usb_handle_->BulkTransfer(usb_service::USB_DIRECTION_OUTBOUND,
+  usb_handle_->BulkTransfer(device::USB_DIRECTION_OUTBOUND,
                             outbound_address_,
                             message.get(),
                             message->size(),
                             kUsbTimeout,
                             base::Bind(&AndroidUsbDevice::OutgoingMessageSent,
                                        weak_factory_.GetWeakPtr()));
 }
 
 void AndroidUsbDevice::OutgoingMessageSent(UsbTransferStatus status,
                                            scoped_refptr<net::IOBuffer> buffer,
                                            size_t result) {
   DCHECK(message_loop_ == base::MessageLoop::current());
 
-  if (status != usb_service::USB_TRANSFER_COMPLETED)
+  if (status != device::USB_TRANSFER_COMPLETED)
     return;
   message_loop_->PostTask(FROM_HERE,
                           base::Bind(&AndroidUsbDevice::ProcessOutgoing, this));
 }
 
 void AndroidUsbDevice::ReadHeader() {
   DCHECK(message_loop_ == base::MessageLoop::current());
 
   if (!usb_handle_.get())
     return;
   scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(kHeaderSize);
   usb_handle_->BulkTransfer(
-      usb_service::USB_DIRECTION_INBOUND,
+      device::USB_DIRECTION_INBOUND,
       inbound_address_,
       buffer.get(),
       kHeaderSize,
       kUsbTimeout,
       base::Bind(&AndroidUsbDevice::ParseHeader, weak_factory_.GetWeakPtr()));
 }
 
 void AndroidUsbDevice::ParseHeader(UsbTransferStatus status,
                                    scoped_refptr<net::IOBuffer> buffer,
                                    size_t result) {
   DCHECK(message_loop_ == base::MessageLoop::current());
 
-  if (status == usb_service::USB_TRANSFER_TIMEOUT) {
+  if (status == device::USB_TRANSFER_TIMEOUT) {
     message_loop_->PostTask(FROM_HERE,
                             base::Bind(&AndroidUsbDevice::ReadHeader, this));
     return;
   }
 
-  if (status != usb_service::USB_TRANSFER_COMPLETED || result != kHeaderSize) {
+  if (status != device::USB_TRANSFER_COMPLETED || result != kHeaderSize) {
     TransferError(status);
     return;
   }
 
   DumpMessage(false, buffer->data(), result);
   std::vector<uint32> header(6);
   memcpy(&header[0], buffer->data(), result);
   scoped_refptr<AdbMessage> message =
       new AdbMessage(header[0], header[1], header[2], "");
   uint32 data_length = header[3];
   uint32 data_check = header[4];
   uint32 magic = header[5];
   if ((message->command ^ 0xffffffff) != magic) {
-    TransferError(usb_service::USB_TRANSFER_ERROR);
+    TransferError(device::USB_TRANSFER_ERROR);
     return;
   }
 
   if (data_length == 0) {
     message_loop_->PostTask(FROM_HERE,
                             base::Bind(&AndroidUsbDevice::HandleIncoming, this,
                                        message));
     return;
   }
 
   message_loop_->PostTask(FROM_HERE,
                           base::Bind(&AndroidUsbDevice::ReadBody, this,
                                      message, data_length, data_check));
 }
 
 void AndroidUsbDevice::ReadBody(scoped_refptr<AdbMessage> message,
                                 uint32 data_length,
                                 uint32 data_check) {
   DCHECK(message_loop_ == base::MessageLoop::current());
 
   if (!usb_handle_.get())
     return;
   scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(data_length);
-  usb_handle_->BulkTransfer(usb_service::USB_DIRECTION_INBOUND,
+  usb_handle_->BulkTransfer(device::USB_DIRECTION_INBOUND,
                             inbound_address_,
                             buffer.get(),
                             data_length,
                             kUsbTimeout,
                             base::Bind(&AndroidUsbDevice::ParseBody,
                                        weak_factory_.GetWeakPtr(),
                                        message,
                                        data_length,
                                        data_check));
 }
 
 void AndroidUsbDevice::ParseBody(scoped_refptr<AdbMessage> message,
                                  uint32 data_length,
                                  uint32 data_check,
                                  UsbTransferStatus status,
                                  scoped_refptr<net::IOBuffer> buffer,
                                  size_t result) {
   DCHECK(message_loop_ == base::MessageLoop::current());
 
-  if (status == usb_service::USB_TRANSFER_TIMEOUT) {
+  if (status == device::USB_TRANSFER_TIMEOUT) {
     message_loop_->PostTask(FROM_HERE,
                             base::Bind(&AndroidUsbDevice::ReadBody, this,
                             message, data_length, data_check));
     return;
   }
 
-  if (status != usb_service::USB_TRANSFER_COMPLETED ||
+  if (status != device::USB_TRANSFER_COMPLETED ||
       static_cast<uint32>(result) != data_length) {
     TransferError(status);
     return;
   }
 
   DumpMessage(false, buffer->data(), data_length);
   message->body = std::string(buffer->data(), result);
   if (Checksum(message->body) != data_check) {
-    TransferError(usb_service::USB_TRANSFER_ERROR);
+    TransferError(device::USB_TRANSFER_ERROR);
     return;
   }
 
   message_loop_->PostTask(FROM_HERE,
                           base::Bind(&AndroidUsbDevice::HandleIncoming, this,
                                      message));
 }
 
 void AndroidUsbDevice::HandleIncoming(scoped_refptr<AdbMessage> message) {
   DCHECK(message_loop_ == base::MessageLoop::current());
@@ skipping 90 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&ReleaseInterface, usb_handle, interface_id_));
 }
 
 void AndroidUsbDevice::SocketDeleted(uint32 socket_id) {
   DCHECK(message_loop_ == base::MessageLoop::current());
 
   sockets_.erase(socket_id);
 }