Move classes in the device.usb Mojo namespace to device.mojom

device/usb/mojo/device_impl_unittest.cc

 // Copyright 2015 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 "device/usb/mojo/device_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 16 matching lines @@
 #include "device/usb/mojo/type_converters.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "net/base/io_buffer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::Invoke;
 using ::testing::_;
 
 namespace device {
+
+using mojom::UsbIsochronousPacketPtr;
+using mojom::UsbControlTransferRecipient;
+using mojom::UsbControlTransferType;
+using mojom::UsbDevicePtr;
+
 namespace usb {
 
 namespace {
 
 class ConfigBuilder {
  public:
   explicit ConfigBuilder(uint8_t value) : config_(value, false, false, 0) {}
 
   ConfigBuilder& AddInterface(uint8_t interface_number,
                               uint8_t alternate_setting,
                               uint8_t class_code,
                               uint8_t subclass_code,
                               uint8_t protocol_code) {
     config_.interfaces.emplace_back(interface_number, alternate_setting,
                                     class_code, subclass_code, protocol_code);
     return *this;
   }
 
   const UsbConfigDescriptor& config() const { return config_; }
 
  private:
   UsbConfigDescriptor config_;
 };
 
-void ExpectOpenAndThen(OpenDeviceError expected,
+void ExpectOpenAndThen(mojom::UsbOpenDeviceError expected,
                        const base::Closure& continuation,
-                       OpenDeviceError error) {
+                       mojom::UsbOpenDeviceError error) {
   EXPECT_EQ(expected, error);
   continuation.Run();
 }
 
 void ExpectResultAndThen(bool expected_result,
                          const base::Closure& continuation,
                          bool actual_result) {
   EXPECT_EQ(expected_result, actual_result);
   continuation.Run();
 }
 
 void ExpectTransferInAndThen(
-    TransferStatus expected_status,
+    mojom::UsbTransferStatus expected_status,
     const std::vector<uint8_t>& expected_bytes,
     const base::Closure& continuation,
-    TransferStatus actual_status,
+    mojom::UsbTransferStatus actual_status,
     const base::Optional<std::vector<uint8_t>>& actual_bytes) {
   EXPECT_EQ(expected_status, actual_status);
   ASSERT_TRUE(actual_bytes);
   ASSERT_EQ(expected_bytes.size(), actual_bytes->size());
   for (size_t i = 0; i < actual_bytes->size(); ++i) {
     EXPECT_EQ(expected_bytes[i], (*actual_bytes)[i])
         << "Contents differ at index: " << i;
   }
   continuation.Run();
 }
 
-void ExpectPacketsOutAndThen(const std::vector<uint32_t>& expected_packets,
-                             const base::Closure& continuation,
-                             std::vector<IsochronousPacketPtr> actual_packets) {
+void ExpectPacketsOutAndThen(
+    const std::vector<uint32_t>& expected_packets,
+    const base::Closure& continuation,
+    std::vector<UsbIsochronousPacketPtr> actual_packets) {
   ASSERT_EQ(expected_packets.size(), actual_packets.size());
   for (size_t i = 0; i < expected_packets.size(); ++i) {
     EXPECT_EQ(expected_packets[i], actual_packets[i]->transferred_length)
         << "Packet lengths differ at index: " << i;
-    EXPECT_EQ(TransferStatus::COMPLETED, actual_packets[i]->status)
+    EXPECT_EQ(mojom::UsbTransferStatus::COMPLETED, actual_packets[i]->status)
         << "Packet at index " << i << " not completed.";
   }
   continuation.Run();
 }
 
 void ExpectPacketsInAndThen(
     const std::vector<uint8_t>& expected_bytes,
     const std::vector<uint32_t>& expected_packets,
     const base::Closure& continuation,
     const base::Optional<std::vector<uint8_t>>& actual_bytes,
-    std::vector<IsochronousPacketPtr> actual_packets) {
+    std::vector<UsbIsochronousPacketPtr> actual_packets) {
   ASSERT_EQ(expected_packets.size(), actual_packets.size());
   for (size_t i = 0; i < expected_packets.size(); ++i) {
     EXPECT_EQ(expected_packets[i], actual_packets[i]->transferred_length)
         << "Packet lengths differ at index: " << i;
-    EXPECT_EQ(TransferStatus::COMPLETED, actual_packets[i]->status)
+    EXPECT_EQ(mojom::UsbTransferStatus::COMPLETED, actual_packets[i]->status)
         << "Packet at index " << i << " not completed.";
   }
   ASSERT_TRUE(actual_bytes);
   ASSERT_EQ(expected_bytes.size(), actual_bytes->size());
   for (size_t i = 0; i < actual_bytes->size(); ++i) {
     EXPECT_EQ(expected_bytes[i], (*actual_bytes)[i])
         << "Contents differ at index: " << i;
   }
   continuation.Run();
 }
 
-void ExpectTransferStatusAndThen(TransferStatus expected_status,
+void ExpectTransferStatusAndThen(mojom::UsbTransferStatus expected_status,
                                  const base::Closure& continuation,
-                                 TransferStatus actual_status) {
+                                 mojom::UsbTransferStatus actual_status) {
   EXPECT_EQ(expected_status, actual_status);
   continuation.Run();
 }
 
 class USBDeviceImplTest : public testing::Test {
  public:
   USBDeviceImplTest()
       : message_loop_(new base::MessageLoop),
         is_device_open_(false),
         allow_reset_(false) {}
 
   ~USBDeviceImplTest() override {}
 
   void TearDown() override { base::RunLoop().RunUntilIdle(); }
 
  protected:
   MockPermissionProvider& permission_provider() { return permission_provider_; }
   MockUsbDevice& mock_device() { return *mock_device_.get(); }
   bool is_device_open() const { return is_device_open_; }
   MockUsbDeviceHandle& mock_handle() { return *mock_handle_.get(); }
 
   void set_allow_reset(bool allow_reset) { allow_reset_ = allow_reset; }
 
   // Creates a mock device and binds a Device proxy to a Device service impl
   // wrapping the mock device.
-  DevicePtr GetMockDeviceProxy(uint16_t vendor_id,
-                               uint16_t product_id,
-                               const std::string& manufacturer,
-                               const std::string& product,
-                               const std::string& serial) {
+  UsbDevicePtr GetMockDeviceProxy(uint16_t vendor_id,
+                                  uint16_t product_id,
+                                  const std::string& manufacturer,
+                                  const std::string& product,
+                                  const std::string& serial) {
     mock_device_ =
         new MockUsbDevice(vendor_id, product_id, manufacturer, product, serial);
     mock_handle_ = new MockUsbDeviceHandle(mock_device_.get());
 
-    DevicePtr proxy;
+    UsbDevicePtr proxy;
     DeviceImpl::Create(mock_device_, permission_provider_.GetWeakPtr(),
                        mojo::MakeRequest(&proxy));
 
     // Set up mock handle calls to respond based on mock device configs
     // established by the test.
     ON_CALL(mock_device(), Open(_))
         .WillByDefault(Invoke(this, &USBDeviceImplTest::OpenMockHandle));
     ON_CALL(mock_handle(), Close())
         .WillByDefault(Invoke(this, &USBDeviceImplTest::CloseMockHandle));
     ON_CALL(mock_handle(), SetConfiguration(_, _))
@@ skipping 13 matching lines @@
         .WillByDefault(Invoke(this, &USBDeviceImplTest::GenericTransfer));
     ON_CALL(mock_handle(), IsochronousTransferIn(_, _, _, _))
         .WillByDefault(Invoke(this, &USBDeviceImplTest::IsochronousTransferIn));
     ON_CALL(mock_handle(), IsochronousTransferOut(_, _, _, _, _))
         .WillByDefault(
             Invoke(this, &USBDeviceImplTest::IsochronousTransferOut));
 
     return proxy;
   }
 
-  DevicePtr GetMockDeviceProxy() {
+  UsbDevicePtr GetMockDeviceProxy() {
     return GetMockDeviceProxy(0x1234, 0x5678, "ACME", "Frobinator", "ABCDEF");
   }
 
   void AddMockConfig(const ConfigBuilder& builder) {
     const UsbConfigDescriptor& config = builder.config();
     DCHECK(!base::ContainsKey(mock_configs_, config.configuration_value));
     mock_configs_.insert(std::make_pair(config.configuration_value, config));
     mock_device_->AddMockConfig(config);
   }
 
@@ skipping 210 matching lines @@
   std::set<uint8_t> claimed_interfaces_;
 
   MockPermissionProvider permission_provider_;
 
   DISALLOW_COPY_AND_ASSIGN(USBDeviceImplTest);
 };
 
 }  // namespace
 
 TEST_F(USBDeviceImplTest, Disconnect) {
-  DevicePtr device = GetMockDeviceProxy();
+  UsbDevicePtr device = GetMockDeviceProxy();
 
   base::RunLoop loop;
   device.set_connection_error_handler(loop.QuitClosure());
   mock_device().NotifyDeviceRemoved();
   loop.Run();
 }
 
 TEST_F(USBDeviceImplTest, Open) {
-  DevicePtr device = GetMockDeviceProxy();
+  UsbDevicePtr device = GetMockDeviceProxy();
 
   EXPECT_FALSE(is_device_open());
 
   EXPECT_CALL(mock_device(), Open(_));
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, mojom::UsbOpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::ALREADY_OPEN,
+    device->Open(base::Bind(&ExpectOpenAndThen,
+                            mojom::UsbOpenDeviceError::ALREADY_OPEN,
                             loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 TEST_F(USBDeviceImplTest, Close) {
-  DevicePtr device = GetMockDeviceProxy();
+  UsbDevicePtr device = GetMockDeviceProxy();
 
   EXPECT_FALSE(is_device_open());
 
   EXPECT_CALL(mock_device(), Open(_));
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, mojom::UsbOpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 
   {
     base::RunLoop loop;
     device->Close(loop.QuitClosure());
     loop.Run();
   }
 
   EXPECT_FALSE(is_device_open());
 }
 
 TEST_F(USBDeviceImplTest, SetInvalidConfiguration) {
-  DevicePtr device = GetMockDeviceProxy();
+  UsbDevicePtr device = GetMockDeviceProxy();
 
   EXPECT_CALL(mock_device(), Open(_));
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, mojom::UsbOpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), SetConfiguration(42, _));
   EXPECT_CALL(permission_provider(), HasConfigurationPermission(42, _));
 
   {
     // SetConfiguration should fail because 42 is not a valid mock
     // configuration.
     base::RunLoop loop;
     device->SetConfiguration(
         42, base::Bind(&ExpectResultAndThen, false, loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 TEST_F(USBDeviceImplTest, SetValidConfiguration) {
-  DevicePtr device = GetMockDeviceProxy();
+  UsbDevicePtr device = GetMockDeviceProxy();
 
   EXPECT_CALL(mock_device(), Open(_));
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, mojom::UsbOpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), SetConfiguration(42, _));
   EXPECT_CALL(permission_provider(), HasConfigurationPermission(42, _));
 
   AddMockConfig(ConfigBuilder(42));
 
   {
     // SetConfiguration should succeed because 42 is a valid mock configuration.
     base::RunLoop loop;
     device->SetConfiguration(
         42, base::Bind(&ExpectResultAndThen, true, loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 // Verify that the result of Reset() reflects the underlying UsbDeviceHandle's
 // ResetDevice() result.
 TEST_F(USBDeviceImplTest, Reset) {
-  DevicePtr device = GetMockDeviceProxy();
+  UsbDevicePtr device = GetMockDeviceProxy();
 
   EXPECT_CALL(mock_device(), Open(_));
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, mojom::UsbOpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), ResetDevice(_));
 
   set_allow_reset(true);
 
   {
     base::RunLoop loop;
     device->Reset(base::Bind(&ExpectResultAndThen, true, loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), ResetDevice(_));
 
   set_allow_reset(false);
 
   {
     base::RunLoop loop;
     device->Reset(base::Bind(&ExpectResultAndThen, false, loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 TEST_F(USBDeviceImplTest, ClaimAndReleaseInterface) {
-  DevicePtr device = GetMockDeviceProxy();
+  UsbDevicePtr device = GetMockDeviceProxy();
 
   EXPECT_CALL(mock_device(), Open(_));
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, mojom::UsbOpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
 
   // Now add a mock interface #1.
   AddMockConfig(ConfigBuilder(1).AddInterface(1, 0, 1, 2, 3));
 
   EXPECT_CALL(mock_handle(), SetConfiguration(1, _));
   EXPECT_CALL(permission_provider(), HasConfigurationPermission(1, _));
 
@@ skipping 39 matching lines @@
     base::RunLoop loop;
     device->ReleaseInterface(
         1, base::Bind(&ExpectResultAndThen, true, loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 TEST_F(USBDeviceImplTest, SetInterfaceAlternateSetting) {
-  DevicePtr device = GetMockDeviceProxy();
+  UsbDevicePtr device = GetMockDeviceProxy();
 
   EXPECT_CALL(mock_device(), Open(_));
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, mojom::UsbOpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
 
   AddMockConfig(ConfigBuilder(1)
                     .AddInterface(1, 0, 1, 2, 3)
                     .AddInterface(1, 42, 1, 2, 3)
                     .AddInterface(2, 0, 1, 2, 3));
 
   EXPECT_CALL(mock_handle(), SetInterfaceAlternateSetting(1, 42, _));
@@ skipping 11 matching lines @@
     base::RunLoop loop;
     device->SetInterfaceAlternateSetting(
         1, 100, base::Bind(&ExpectResultAndThen, false, loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 TEST_F(USBDeviceImplTest, ControlTransfer) {
-  DevicePtr device = GetMockDeviceProxy();
+  UsbDevicePtr device = GetMockDeviceProxy();
 
   EXPECT_CALL(mock_device(), Open(_));
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, mojom::UsbOpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
 
   AddMockConfig(ConfigBuilder(1).AddInterface(7, 0, 1, 2, 3));
 
   EXPECT_CALL(mock_handle(), SetConfiguration(1, _));
   EXPECT_CALL(permission_provider(), HasConfigurationPermission(1, _));
 
   {
     base::RunLoop loop;
     device->SetConfiguration(
         1, base::Bind(&ExpectResultAndThen, true, loop.QuitClosure()));
     loop.Run();
   }
 
   std::vector<uint8_t> fake_data;
   fake_data.push_back(41);
   fake_data.push_back(42);
   fake_data.push_back(43);
 
   AddMockInboundData(fake_data);
 
   EXPECT_CALL(mock_handle(),
               ControlTransfer(USB_DIRECTION_INBOUND, UsbDeviceHandle::STANDARD,
                               UsbDeviceHandle::DEVICE, 5, 6, 7, _, _, 0, _));
   EXPECT_CALL(permission_provider(), HasConfigurationPermission(1, _));
 
   {
-    auto params = ControlTransferParams::New();
-    params->type = ControlTransferType::STANDARD;
-    params->recipient = ControlTransferRecipient::DEVICE;
+    auto params = mojom::UsbControlTransferParams::New();
+    params->type = UsbControlTransferType::STANDARD;
+    params->recipient = UsbControlTransferRecipient::DEVICE;
     params->request = 5;
     params->value = 6;
     params->index = 7;
     base::RunLoop loop;
-    device->ControlTransferIn(
-        std::move(params), static_cast<uint32_t>(fake_data.size()), 0,
-        base::Bind(&ExpectTransferInAndThen, TransferStatus::COMPLETED,
-                   fake_data, loop.QuitClosure()));
+    device->ControlTransferIn(std::move(params),
+                              static_cast<uint32_t>(fake_data.size()), 0,
+                              base::Bind(&ExpectTransferInAndThen,
+                                         mojom::UsbTransferStatus::COMPLETED,
+                                         fake_data, loop.QuitClosure()));
     loop.Run();
   }
 
   AddMockOutboundData(fake_data);
 
   EXPECT_CALL(mock_handle(),
               ControlTransfer(USB_DIRECTION_OUTBOUND, UsbDeviceHandle::STANDARD,
                               UsbDeviceHandle::INTERFACE, 5, 6, 7, _, _, 0, _));
   EXPECT_CALL(permission_provider(), HasFunctionPermission(7, 1, _));
 
   {
-    auto params = ControlTransferParams::New();
-    params->type = ControlTransferType::STANDARD;
-    params->recipient = ControlTransferRecipient::INTERFACE;
+    auto params = mojom::UsbControlTransferParams::New();
+    params->type = UsbControlTransferType::STANDARD;
+    params->recipient = UsbControlTransferRecipient::INTERFACE;
     params->request = 5;
     params->value = 6;
     params->index = 7;
     base::RunLoop loop;
     device->ControlTransferOut(
         std::move(params), fake_data, 0,
-        base::Bind(&ExpectTransferStatusAndThen, TransferStatus::COMPLETED,
-                   loop.QuitClosure()));
+        base::Bind(&ExpectTransferStatusAndThen,
+                   mojom::UsbTransferStatus::COMPLETED, loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 TEST_F(USBDeviceImplTest, GenericTransfer) {
-  DevicePtr device = GetMockDeviceProxy();
+  UsbDevicePtr device = GetMockDeviceProxy();
 
   EXPECT_CALL(mock_device(), Open(_));
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, mojom::UsbOpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
 
   std::string message1 = "say hello please";
   std::vector<uint8_t> fake_outbound_data(message1.size());
   std::copy(message1.begin(), message1.end(), fake_outbound_data.begin());
 
   std::string message2 = "hello world!";
   std::vector<uint8_t> fake_inbound_data(message2.size());
   std::copy(message2.begin(), message2.end(), fake_inbound_data.begin());
 
   AddMockConfig(ConfigBuilder(1).AddInterface(7, 0, 1, 2, 3));
   AddMockOutboundData(fake_outbound_data);
   AddMockInboundData(fake_inbound_data);
 
   EXPECT_CALL(mock_handle(), GenericTransfer(USB_DIRECTION_OUTBOUND, 0x01, _,
                                              fake_outbound_data.size(), 0, _));
 
   {
     base::RunLoop loop;
     device->GenericTransferOut(
         1, fake_outbound_data, 0,
-        base::Bind(&ExpectTransferStatusAndThen, TransferStatus::COMPLETED,
-                   loop.QuitClosure()));
+        base::Bind(&ExpectTransferStatusAndThen,
+                   mojom::UsbTransferStatus::COMPLETED, loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), GenericTransfer(USB_DIRECTION_INBOUND, 0x81, _,
                                              fake_inbound_data.size(), 0, _));
 
   {
     base::RunLoop loop;
     device->GenericTransferIn(
         1, static_cast<uint32_t>(fake_inbound_data.size()), 0,
-        base::Bind(&ExpectTransferInAndThen, TransferStatus::COMPLETED,
-                   fake_inbound_data, loop.QuitClosure()));
+        base::Bind(&ExpectTransferInAndThen,
+                   mojom::UsbTransferStatus::COMPLETED, fake_inbound_data,
+                   loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 TEST_F(USBDeviceImplTest, IsochronousTransfer) {
-  DevicePtr device = GetMockDeviceProxy();
+  UsbDevicePtr device = GetMockDeviceProxy();
 
   EXPECT_CALL(mock_device(), Open(_));
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, mojom::UsbOpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
 
   std::vector<UsbDeviceHandle::IsochronousPacket> fake_packets(4);
   for (size_t i = 0; i < fake_packets.size(); ++i) {
     fake_packets[i].length = 8;
     fake_packets[i].transferred_length = 8;
     fake_packets[i].status = USB_TRANSFER_COMPLETED;
   }
@@ skipping 37 matching lines @@
         base::Bind(&ExpectPacketsInAndThen, fake_inbound_data,
                    expected_transferred_lengths, loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 }  // namespace usb
 }  // namespace device