Use Mojo enum types in the C++ USB interface

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 289 matching lines @@
     callback.Run(allow_reset_);
   }
 
   void InboundTransfer(const UsbDeviceHandle::TransferCallback& callback) {
     ASSERT_GE(mock_inbound_data_.size(), 1u);
     const std::vector<uint8_t>& bytes = mock_inbound_data_.front();
     size_t length = bytes.size();
     scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(length);
     std::copy(bytes.begin(), bytes.end(), buffer->data());
     mock_inbound_data_.pop();
-    callback.Run(USB_TRANSFER_COMPLETED, buffer, length);
+    callback.Run(UsbTransferStatus::COMPLETED, buffer, length);
   }
 
   void OutboundTransfer(scoped_refptr<net::IOBuffer> buffer,
                         size_t length,
                         const UsbDeviceHandle::TransferCallback& callback) {
     ASSERT_GE(mock_outbound_data_.size(), 1u);
     const std::vector<uint8_t>& bytes = mock_outbound_data_.front();
     ASSERT_EQ(bytes.size(), length);
     for (size_t i = 0; i < length; ++i) {
       EXPECT_EQ(bytes[i], buffer->data()[i]) << "Contents differ at index: "
                                              << i;
     }
     mock_outbound_data_.pop();
-    callback.Run(USB_TRANSFER_COMPLETED, buffer, length);
+    callback.Run(UsbTransferStatus::COMPLETED, buffer, length);
   }
 
-  void ControlTransfer(UsbEndpointDirection direction,
-                       UsbDeviceHandle::TransferRequestType request_type,
-                       UsbDeviceHandle::TransferRecipient recipient,
+  void ControlTransfer(UsbTransferDirection direction,
+                       UsbControlTransferType request_type,
+                       UsbControlTransferRecipient recipient,
                        uint8_t request,
                        uint16_t value,
                        uint16_t index,
                        scoped_refptr<net::IOBuffer> buffer,
                        size_t length,
                        unsigned int timeout,
                        const UsbDeviceHandle::TransferCallback& callback) {
-    if (direction == USB_DIRECTION_INBOUND)
+    if (direction == UsbTransferDirection::INBOUND)
       InboundTransfer(callback);
     else
       OutboundTransfer(buffer, length, callback);
   }
 
-  void GenericTransfer(UsbEndpointDirection direction,
+  void GenericTransfer(UsbTransferDirection direction,
                        uint8_t endpoint,
                        scoped_refptr<net::IOBuffer> buffer,
                        size_t length,
                        unsigned int timeout,
                        const UsbDeviceHandle::TransferCallback& callback) {
-    if (direction == USB_DIRECTION_INBOUND)
+    if (direction == UsbTransferDirection::INBOUND)
       InboundTransfer(callback);
     else
       OutboundTransfer(buffer, length, callback);
   }
 
   void IsochronousTransferIn(
       uint8_t endpoint_number,
       const std::vector<uint32_t>& packet_lengths,
       unsigned int timeout,
       const UsbDeviceHandle::IsochronousTransferCallback& callback) {
@@ skipping 351 matching lines @@
   }
 
   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, _));
+              ControlTransfer(UsbTransferDirection::INBOUND,
+                              UsbControlTransferType::STANDARD,
+                              UsbControlTransferRecipient::DEVICE, 5, 6, 7, _,
+                              _, 0, _));
   EXPECT_CALL(permission_provider(), HasConfigurationPermission(1, _));
 
   {
     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,
                                          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, _));
+              ControlTransfer(UsbTransferDirection::OUTBOUND,
+                              UsbControlTransferType::STANDARD,
+                              UsbControlTransferRecipient::INTERFACE, 5, 6, 7,
+                              _, _, 0, _));
   EXPECT_CALL(permission_provider(), HasFunctionPermission(7, 1, _));
 
   {
     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;
@@ skipping 24 matching lines @@
   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, _));
+  EXPECT_CALL(mock_handle(),
+              GenericTransfer(UsbTransferDirection::OUTBOUND, 0x01, _,
+                              fake_outbound_data.size(), 0, _));
 
   {
     base::RunLoop loop;
     device->GenericTransferOut(
         1, fake_outbound_data, 0,
         base::Bind(&ExpectTransferStatusAndThen,
                    mojom::UsbTransferStatus::COMPLETED, loop.QuitClosure()));
     loop.Run();
   }
 
-  EXPECT_CALL(mock_handle(), GenericTransfer(USB_DIRECTION_INBOUND, 0x81, _,
-                                             fake_inbound_data.size(), 0, _));
+  EXPECT_CALL(mock_handle(),
+              GenericTransfer(UsbTransferDirection::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,
                    mojom::UsbTransferStatus::COMPLETED, fake_inbound_data,
                    loop.QuitClosure()));
     loop.Run();
   }
@@ skipping 10 matching lines @@
     base::RunLoop loop;
     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;
+    fake_packets[i].status = UsbTransferStatus::COMPLETED;
   }
   std::vector<uint32_t> fake_packet_lengths(4, 8);
 
   std::vector<uint32_t> expected_transferred_lengths(4, 8);
 
   std::string outbound_data = "aaaaaaaabbbbbbbbccccccccdddddddd";
   std::vector<uint8_t> fake_outbound_data(outbound_data.size());
   std::copy(outbound_data.begin(), outbound_data.end(),
             fake_outbound_data.begin());
 
@@ skipping 28 matching lines @@
         base::Bind(&ExpectPacketsInAndThen, fake_inbound_data,
                    expected_transferred_lengths, loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 }  // namespace usb
 }  // namespace device