Use Mojo enum types in the C++ USB interface

device/usb/usb_descriptors_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/usb_descriptors.h"
 
 #include <stdint.h>
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/strings/utf_string_conversions.h"
 #include "device/usb/mock_usb_device_handle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 
 namespace device {
 
 namespace {
 
 ACTION_P2(InvokeCallback, data, length) {
   size_t transferred_length = std::min(length, arg7);
   memcpy(arg6->data(), data, transferred_length);
-  arg9.Run(USB_TRANSFER_COMPLETED, arg6, transferred_length);
+  arg9.Run(UsbTransferStatus::COMPLETED, arg6, transferred_length);
 }
 
 void ExpectStringDescriptors(
     std::unique_ptr<std::map<uint8_t, base::string16>> string_map) {
   EXPECT_EQ(3u, string_map->size());
   EXPECT_EQ(base::ASCIIToUTF16("String 1"), (*string_map)[1]);
   EXPECT_EQ(base::ASCIIToUTF16("String 2"), (*string_map)[2]);
   EXPECT_EQ(base::ASCIIToUTF16("String 3"), (*string_map)[3]);
 }
 
@@ skipping 43 matching lines @@
   EXPECT_EQ(0, config.interfaces[0].interface_number);
   EXPECT_EQ(0, config.interfaces[0].alternate_setting);
   EXPECT_EQ(0x12, config.interfaces[0].interface_class);
   EXPECT_EQ(0x34, config.interfaces[0].interface_subclass);
   EXPECT_EQ(0x56, config.interfaces[0].interface_protocol);
   ASSERT_EQ(3u, config.interfaces[0].endpoints.size());
   EXPECT_EQ(0u, config.interfaces[0].extra_data.size());
   EXPECT_EQ(0, config.interfaces[0].first_interface);
   // Endpoint 1 IN
   EXPECT_EQ(0x81, config.interfaces[0].endpoints[0].address);
-  EXPECT_EQ(USB_DIRECTION_INBOUND, config.interfaces[0].endpoints[0].direction);
+  EXPECT_EQ(UsbTransferDirection::INBOUND,
+            config.interfaces[0].endpoints[0].direction);
   EXPECT_EQ(512, config.interfaces[0].endpoints[0].maximum_packet_size);
   EXPECT_EQ(USB_SYNCHRONIZATION_NONE,
             config.interfaces[0].endpoints[0].synchronization_type);
-  EXPECT_EQ(USB_TRANSFER_BULK, config.interfaces[0].endpoints[0].transfer_type);
+  EXPECT_EQ(UsbTransferType::BULK,
+            config.interfaces[0].endpoints[0].transfer_type);
   EXPECT_EQ(USB_USAGE_RESERVED, config.interfaces[0].endpoints[0].usage_type);
   EXPECT_EQ(0, config.interfaces[0].endpoints[0].polling_interval);
   EXPECT_EQ(0u, config.interfaces[0].endpoints[0].extra_data.size());
   // Endpoint 2 IN
   EXPECT_EQ(0x82, config.interfaces[0].endpoints[1].address);
-  EXPECT_EQ(USB_DIRECTION_INBOUND, config.interfaces[0].endpoints[1].direction);
+  EXPECT_EQ(UsbTransferDirection::INBOUND,
+            config.interfaces[0].endpoints[1].direction);
   EXPECT_EQ(512, config.interfaces[0].endpoints[1].maximum_packet_size);
   EXPECT_EQ(USB_SYNCHRONIZATION_NONE,
             config.interfaces[0].endpoints[1].synchronization_type);
-  EXPECT_EQ(USB_TRANSFER_INTERRUPT,
+  EXPECT_EQ(UsbTransferType::INTERRUPT,
             config.interfaces[0].endpoints[1].transfer_type);
   EXPECT_EQ(USB_USAGE_PERIODIC, config.interfaces[0].endpoints[1].usage_type);
   EXPECT_EQ(4, config.interfaces[0].endpoints[1].polling_interval);
   EXPECT_EQ(0u, config.interfaces[0].endpoints[1].extra_data.size());
   // Endpoint 3 OUT
   EXPECT_EQ(0x03, config.interfaces[0].endpoints[2].address);
-  EXPECT_EQ(USB_DIRECTION_OUTBOUND,
+  EXPECT_EQ(UsbTransferDirection::OUTBOUND,
             config.interfaces[0].endpoints[2].direction);
   EXPECT_EQ(512, config.interfaces[0].endpoints[2].maximum_packet_size);
   EXPECT_EQ(USB_SYNCHRONIZATION_NONE,
             config.interfaces[0].endpoints[2].synchronization_type);
-  EXPECT_EQ(USB_TRANSFER_INTERRUPT,
+  EXPECT_EQ(UsbTransferType::INTERRUPT,
             config.interfaces[0].endpoints[2].transfer_type);
   EXPECT_EQ(USB_USAGE_NOTIFICATION,
             config.interfaces[0].endpoints[2].usage_type);
   EXPECT_EQ(4, config.interfaces[0].endpoints[2].polling_interval);
   EXPECT_EQ(0u, config.interfaces[0].endpoints[2].extra_data.size());
   // Interface 1
   EXPECT_EQ(1, config.interfaces[1].interface_number);
   EXPECT_EQ(0, config.interfaces[1].alternate_setting);
   EXPECT_EQ(0x78, config.interfaces[1].interface_class);
   EXPECT_EQ(0x9A, config.interfaces[1].interface_subclass);
@@ skipping 24 matching lines @@
   EXPECT_EQ(0, config.interfaces[1].interface_number);
   EXPECT_EQ(1, config.interfaces[1].alternate_setting);
   EXPECT_EQ(0xCD, config.interfaces[1].interface_class);
   EXPECT_EQ(0xEF, config.interfaces[1].interface_subclass);
   EXPECT_EQ(0x01, config.interfaces[1].interface_protocol);
   ASSERT_EQ(2u, config.interfaces[1].endpoints.size());
   EXPECT_EQ(0u, config.interfaces[1].extra_data.size());
   EXPECT_EQ(0, config.interfaces[1].first_interface);
   // Endpoint 1 IN
   EXPECT_EQ(0x81, config.interfaces[1].endpoints[0].address);
-  EXPECT_EQ(USB_DIRECTION_INBOUND, config.interfaces[1].endpoints[0].direction);
+  EXPECT_EQ(UsbTransferDirection::INBOUND,
+            config.interfaces[1].endpoints[0].direction);
   EXPECT_EQ(1024, config.interfaces[1].endpoints[0].maximum_packet_size);
   EXPECT_EQ(USB_SYNCHRONIZATION_NONE,
             config.interfaces[1].endpoints[0].synchronization_type);
-  EXPECT_EQ(USB_TRANSFER_ISOCHRONOUS,
+  EXPECT_EQ(UsbTransferType::ISOCHRONOUS,
             config.interfaces[1].endpoints[0].transfer_type);
   EXPECT_EQ(USB_USAGE_DATA, config.interfaces[1].endpoints[0].usage_type);
   EXPECT_EQ(8, config.interfaces[1].endpoints[0].polling_interval);
   EXPECT_EQ(0u, config.interfaces[1].endpoints[0].extra_data.size());
   // Endpoint 2 OUT
   EXPECT_EQ(0x02, config.interfaces[1].endpoints[1].address);
-  EXPECT_EQ(USB_DIRECTION_OUTBOUND,
+  EXPECT_EQ(UsbTransferDirection::OUTBOUND,
             config.interfaces[1].endpoints[1].direction);
   EXPECT_EQ(1024, config.interfaces[1].endpoints[1].maximum_packet_size);
   EXPECT_EQ(USB_SYNCHRONIZATION_NONE,
             config.interfaces[1].endpoints[1].synchronization_type);
-  EXPECT_EQ(USB_TRANSFER_ISOCHRONOUS,
+  EXPECT_EQ(UsbTransferType::ISOCHRONOUS,
             config.interfaces[1].endpoints[1].transfer_type);
   EXPECT_EQ(USB_USAGE_FEEDBACK, config.interfaces[1].endpoints[1].usage_type);
   EXPECT_EQ(8, config.interfaces[1].endpoints[1].polling_interval);
   EXPECT_EQ(0u, config.interfaces[1].endpoints[1].extra_data.size());
 }
 
 void ExpectDeviceDescriptor(const UsbDeviceDescriptor& descriptor) {
   // Device
   EXPECT_EQ(0x0310, descriptor.usb_version);
   EXPECT_EQ(0xFF, descriptor.device_class);
@@ skipping 25 matching lines @@
 
   UsbDeviceDescriptor descriptor;
   ASSERT_TRUE(descriptor.Parse(buffer));
   ExpectDeviceDescriptor(descriptor);
 }
 
 TEST_F(UsbDescriptorsTest, ReadDescriptors) {
   scoped_refptr<MockUsbDeviceHandle> device_handle(
       new MockUsbDeviceHandle(nullptr));
   EXPECT_CALL(*device_handle,
-              ControlTransfer(USB_DIRECTION_INBOUND, UsbDeviceHandle::STANDARD,
-                              UsbDeviceHandle::DEVICE, 0x06, 0x0100, 0x0000, _,
-                              _, _, _))
+              ControlTransfer(UsbTransferDirection::INBOUND,
+                              UsbControlTransferType::STANDARD,
+                              UsbControlTransferRecipient::DEVICE, 0x06, 0x0100,
+                              0x0000, _, _, _, _))
       .WillOnce(InvokeCallback(kDeviceDescriptor, sizeof(kDeviceDescriptor)));
   EXPECT_CALL(*device_handle,
-              ControlTransfer(USB_DIRECTION_INBOUND, UsbDeviceHandle::STANDARD,
-                              UsbDeviceHandle::DEVICE, 0x06, 0x0200, 0x0000, _,
-                              _, _, _))
+              ControlTransfer(UsbTransferDirection::INBOUND,
+                              UsbControlTransferType::STANDARD,
+                              UsbControlTransferRecipient::DEVICE, 0x06, 0x0200,
+                              0x0000, _, _, _, _))
       .Times(2)
       .WillRepeatedly(
           InvokeCallback(kConfig1Descriptor, sizeof(kConfig1Descriptor)));
   EXPECT_CALL(*device_handle,
-              ControlTransfer(USB_DIRECTION_INBOUND, UsbDeviceHandle::STANDARD,
-                              UsbDeviceHandle::DEVICE, 0x06, 0x0201, 0x0000, _,
-                              _, _, _))
+              ControlTransfer(UsbTransferDirection::INBOUND,
+                              UsbControlTransferType::STANDARD,
+                              UsbControlTransferRecipient::DEVICE, 0x06, 0x0201,
+                              0x0000, _, _, _, _))
       .Times(2)
       .WillRepeatedly(
           InvokeCallback(kConfig2Descriptor, sizeof(kConfig2Descriptor)));
 
   ReadUsbDescriptors(device_handle, base::Bind(&OnReadDescriptors));
 }
 
 TEST_F(UsbDescriptorsTest, NoInterfaceAssociations) {
   UsbConfigDescriptor config(1, false, false, 0);
   config.interfaces.emplace_back(0, 0, 255, 255, 255);
@@ skipping 146 matching lines @@
   std::unique_ptr<std::map<uint8_t, base::string16>> string_map(
       new std::map<uint8_t, base::string16>());
   (*string_map)[1] = base::string16();
   (*string_map)[2] = base::string16();
   (*string_map)[3] = base::string16();
 
   scoped_refptr<MockUsbDeviceHandle> device_handle(
       new MockUsbDeviceHandle(nullptr));
   static const uint8_t kStringDescriptor0[] = {0x04, 0x03, 0x21, 0x43};
   EXPECT_CALL(*device_handle,
-              ControlTransfer(USB_DIRECTION_INBOUND, UsbDeviceHandle::STANDARD,
-                              UsbDeviceHandle::DEVICE, 0x06, 0x0300, 0x0000, _,
-                              _, _, _))
+              ControlTransfer(UsbTransferDirection::INBOUND,
+                              UsbControlTransferType::STANDARD,
+                              UsbControlTransferRecipient::DEVICE, 0x06, 0x0300,
+                              0x0000, _, _, _, _))
       .WillOnce(InvokeCallback(kStringDescriptor0, sizeof(kStringDescriptor0)));
   static const uint8_t kStringDescriptor1[] = {0x12, 0x03, 'S', 0, 't', 0,
                                                'r',  0,    'i', 0, 'n', 0,
                                                'g',  0,    ' ', 0, '1', 0};
   EXPECT_CALL(*device_handle,
-              ControlTransfer(USB_DIRECTION_INBOUND, UsbDeviceHandle::STANDARD,
-                              UsbDeviceHandle::DEVICE, 0x06, 0x0301, 0x4321, _,
-                              _, _, _))
+              ControlTransfer(UsbTransferDirection::INBOUND,
+                              UsbControlTransferType::STANDARD,
+                              UsbControlTransferRecipient::DEVICE, 0x06, 0x0301,
+                              0x4321, _, _, _, _))
       .WillOnce(InvokeCallback(kStringDescriptor1, sizeof(kStringDescriptor1)));
   static const uint8_t kStringDescriptor2[] = {0x12, 0x03, 'S', 0, 't', 0,
                                                'r',  0,    'i', 0, 'n', 0,
                                                'g',  0,    ' ', 0, '2', 0};
   EXPECT_CALL(*device_handle,
-              ControlTransfer(USB_DIRECTION_INBOUND, UsbDeviceHandle::STANDARD,
-                              UsbDeviceHandle::DEVICE, 0x06, 0x0302, 0x4321, _,
-                              _, _, _))
+              ControlTransfer(UsbTransferDirection::INBOUND,
+                              UsbControlTransferType::STANDARD,
+                              UsbControlTransferRecipient::DEVICE, 0x06, 0x0302,
+                              0x4321, _, _, _, _))
       .WillOnce(InvokeCallback(kStringDescriptor2, sizeof(kStringDescriptor2)));
   static const uint8_t kStringDescriptor3[] = {0x12, 0x03, 'S', 0, 't', 0,
                                                'r',  0,    'i', 0, 'n', 0,
                                                'g',  0,    ' ', 0, '3', 0};
   EXPECT_CALL(*device_handle,
-              ControlTransfer(USB_DIRECTION_INBOUND, UsbDeviceHandle::STANDARD,
-                              UsbDeviceHandle::DEVICE, 0x06, 0x0303, 0x4321, _,
-                              _, _, _))
+              ControlTransfer(UsbTransferDirection::INBOUND,
+                              UsbControlTransferType::STANDARD,
+                              UsbControlTransferRecipient::DEVICE, 0x06, 0x0303,
+                              0x4321, _, _, _, _))
       .WillOnce(InvokeCallback(kStringDescriptor3, sizeof(kStringDescriptor3)));
 
   ReadUsbStringDescriptors(device_handle, std::move(string_map),
                            base::Bind(&ExpectStringDescriptors));
 }
 
 }  // namespace
 
 }  // namespace device