Merge components/usb_service into device/usb.

chrome/browser/devtools/device/usb/android_usb_browsertest.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 <algorithm>
 
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/devtools/device/devtools_android_bridge.h"
 #include "chrome/browser/devtools/device/usb/android_usb_device.h"
 #include "chrome/browser/devtools/device/usb/usb_device_provider.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/test/base/in_process_browser_test.h"
-#include "components/usb_service/usb_device.h"
-#include "components/usb_service/usb_device_handle.h"
-#include "components/usb_service/usb_interface.h"
-#include "components/usb_service/usb_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_utils.h"
+#include "device/usb/usb_device.h"
+#include "device/usb/usb_device_handle.h"
+#include "device/usb/usb_interface.h"
+#include "device/usb/usb_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
-using namespace usb_service;
+using device::UsbConfigDescriptor;
+using device::UsbDevice;
+using device::UsbDeviceHandle;
+using device::UsbEndpointDescriptor;
+using device::UsbEndpointDirection;
+using device::UsbInterfaceDescriptor;
+using device::UsbInterfaceAltSettingDescriptor;
+using device::UsbService;
+using device::UsbSynchronizationType;
+using device::UsbTransferCallback;
+using device::UsbTransferType;
+using device::UsbUsageType;
 
 namespace {
 
 struct AndroidTraits {
   static const int kClass = 0xff;
   static const int kSubclass = 0x42;
   static const int kProtocol = 0x1;
 };
 
 struct NonAndroidTraits {
@@ skipping 107 matching lines @@
   virtual size_t GetNumEndpoints() const OVERRIDE {
     // See IsAndroidInterface function in android_usb_device.cc
     return 2;
   }
 
   virtual scoped_refptr<const UsbEndpointDescriptor> GetEndpoint(
       size_t index) const OVERRIDE {
     EXPECT_GT(static_cast<size_t>(2), index);
     MockUsbEndpointDescriptor* result = new MockUsbEndpointDescriptor();
     result->address_ = index + 1;
-    result->usb_transfer_type_ = USB_TRANSFER_BULK;
-    result->direction_ =
-        ((index == 0) ? USB_DIRECTION_INBOUND : USB_DIRECTION_OUTBOUND);
+    result->usb_transfer_type_ = device::USB_TRANSFER_BULK;
+    result->direction_ = ((index == 0) ? device::USB_DIRECTION_INBOUND
+                                       : device::USB_DIRECTION_OUTBOUND);
     result->maximum_packet_size_ = 1 << 20;  // 1Mb maximum packet size
     return result;
   }
 
   virtual int GetInterfaceNumber() const OVERRIDE { return interface_number_; }
 
   virtual int GetAlternateSetting() const OVERRIDE {
     return alternate_setting_;
   }
 
@@ skipping 118 matching lines @@
                                const size_t length,
                                const unsigned int timeout,
                                const UsbTransferCallback& callback) OVERRIDE {}
 
   virtual void BulkTransfer(const UsbEndpointDirection direction,
                             const uint8 endpoint,
                             net::IOBuffer* buffer,
                             const size_t length,
                             const unsigned int timeout,
                             const UsbTransferCallback& callback) OVERRIDE {
-    if (direction == USB_DIRECTION_OUTBOUND) {
+    if (direction == device::USB_DIRECTION_OUTBOUND) {
       if (remaining_body_length_ == 0) {
         std::vector<uint32> header(6);
         memcpy(&header[0], buffer->data(), length);
         current_message_ = new AdbMessage(header[0], header[1], header[2], "");
         remaining_body_length_ = header[3];
         uint32 magic = header[5];
         if ((current_message_->command ^ 0xffffffff) != magic) {
           DCHECK(false) << "Header checksum error";
           return;
         }
       } else {
         DCHECK(current_message_.get());
         current_message_->body += std::string(buffer->data(), length);
         remaining_body_length_ -= length;
       }
 
       if (remaining_body_length_ == 0) {
         ProcessIncoming();
       }
 
       base::MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(callback,
-                     usb_service::USB_TRANSFER_COMPLETED,
+                     device::USB_TRANSFER_COMPLETED,
                      scoped_refptr<net::IOBuffer>(),
                      0));
 
-    } else if (direction == USB_DIRECTION_INBOUND) {
+    } else if (direction == device::USB_DIRECTION_INBOUND) {
       queries_.push(Query(callback, make_scoped_refptr(buffer), length));
       ProcessQueries();
     }
   }
 
   template <class D>
   void append(D data) {
     std::copy(reinterpret_cast<char*>(&data),
               (reinterpret_cast<char*>(&data)) + sizeof(D),
               std::back_inserter(output_buffer_));
@@ skipping 71 matching lines @@
 
     queries_.pop();
     std::copy(output_buffer_.begin(),
               output_buffer_.begin() + query.size,
               query.buffer->data());
     output_buffer_.erase(output_buffer_.begin(),
                          output_buffer_.begin() + query.size);
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(query.callback,
-                   usb_service::USB_TRANSFER_COMPLETED,
+                   device::USB_TRANSFER_COMPLETED,
                    query.buffer,
                    query.size));
   }
 
   virtual void InterruptTransfer(const UsbEndpointDirection direction,
                                  const uint8 endpoint,
                                  net::IOBuffer* buffer,
                                  const size_t length,
                                  const unsigned int timeout,
                                  const UsbTransferCallback& callback) OVERRIDE {
@@ skipping 423 matching lines @@
   runner_->Run();
   EXPECT_EQ(2, listener.invoked_);
   EXPECT_EQ(listener.invoked_ - 1, scheduler_invoked_);
 }
 
 IN_PROC_BROWSER_TEST_F(AndroidUsbTraitsTest, TestDeviceCounting) {
   MockCountListenerForCheckingTraits listener(adb_bridge_);
   adb_bridge_->AddDeviceCountListener(&listener);
   runner_->Run();
 }