Use Mojo enum types in the C++ USB interface

device/usb/usb_device_handle_unittest.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 "device/usb/usb_device_handle.h"
 
 #include <stddef.h>
 
 #include <memory>
 
@@ skipping 129 matching lines @@
   EXPECT_TRUE(interface);
   EXPECT_EQ(0, interface->interface_number);
   interface = handle->FindInterfaceByEndpoint(0x01);
   EXPECT_TRUE(interface);
   EXPECT_EQ(0, interface->interface_number);
   EXPECT_FALSE(handle->FindInterfaceByEndpoint(0x82));
   EXPECT_FALSE(handle->FindInterfaceByEndpoint(0x02));
 
   scoped_refptr<net::IOBufferWithSize> in_buffer(new net::IOBufferWithSize(64));
   TestCompletionCallback in_completion;
-  handle->GenericTransfer(USB_DIRECTION_INBOUND, 0x81, in_buffer.get(),
+  handle->GenericTransfer(UsbTransferDirection::INBOUND, 0x81, in_buffer.get(),
                           in_buffer->size(),
                           5000,  // 5 second timeout
                           in_completion.callback());
 
   scoped_refptr<net::IOBufferWithSize> out_buffer(
       new net::IOBufferWithSize(in_buffer->size()));
   TestCompletionCallback out_completion;
   for (int i = 0; i < out_buffer->size(); ++i) {
     out_buffer->data()[i] = i;
   }
 
-  handle->GenericTransfer(USB_DIRECTION_OUTBOUND, 0x01, out_buffer.get(),
-                          out_buffer->size(),
+  handle->GenericTransfer(UsbTransferDirection::OUTBOUND, 0x01,
+                          out_buffer.get(), out_buffer->size(),
                           5000,  // 5 second timeout
                           out_completion.callback());
   out_completion.WaitForResult();
-  ASSERT_EQ(USB_TRANSFER_COMPLETED, out_completion.status());
+  ASSERT_EQ(UsbTransferStatus::COMPLETED, out_completion.status());
   EXPECT_EQ(static_cast<size_t>(out_buffer->size()),
             out_completion.transferred());
 
   in_completion.WaitForResult();
-  ASSERT_EQ(USB_TRANSFER_COMPLETED, in_completion.status());
+  ASSERT_EQ(UsbTransferStatus::COMPLETED, in_completion.status());
   EXPECT_EQ(static_cast<size_t>(in_buffer->size()),
             in_completion.transferred());
   for (size_t i = 0; i < in_completion.transferred(); ++i) {
     EXPECT_EQ(out_buffer->data()[i], in_buffer->data()[i])
         << "Mismatch at index " << i << ".";
   }
 
   TestResultCallback release_interface;
   handle->ReleaseInterface(0, release_interface.callback());
   ASSERT_TRUE(release_interface.WaitForResult());
@@ skipping 26 matching lines @@
       handle->FindInterfaceByEndpoint(0x82);
   EXPECT_TRUE(interface);
   EXPECT_EQ(1, interface->interface_number);
   interface = handle->FindInterfaceByEndpoint(0x02);
   EXPECT_TRUE(interface);
   EXPECT_EQ(1, interface->interface_number);
 
   scoped_refptr<net::IOBufferWithSize> in_buffer(
       new net::IOBufferWithSize(512));
   TestCompletionCallback in_completion;
-  handle->GenericTransfer(USB_DIRECTION_INBOUND, 0x82, in_buffer.get(),
+  handle->GenericTransfer(UsbTransferDirection::INBOUND, 0x82, in_buffer.get(),
                           in_buffer->size(),
                           5000,  // 5 second timeout
                           in_completion.callback());
 
   scoped_refptr<net::IOBufferWithSize> out_buffer(
       new net::IOBufferWithSize(in_buffer->size()));
   TestCompletionCallback out_completion;
   for (int i = 0; i < out_buffer->size(); ++i) {
     out_buffer->data()[i] = i;
   }
 
-  handle->GenericTransfer(USB_DIRECTION_OUTBOUND, 0x02, out_buffer.get(),
-                          out_buffer->size(),
+  handle->GenericTransfer(UsbTransferDirection::OUTBOUND, 0x02,
+                          out_buffer.get(), out_buffer->size(),
                           5000,  // 5 second timeout
                           out_completion.callback());
   out_completion.WaitForResult();
-  ASSERT_EQ(USB_TRANSFER_COMPLETED, out_completion.status());
+  ASSERT_EQ(UsbTransferStatus::COMPLETED, out_completion.status());
   EXPECT_EQ(static_cast<size_t>(out_buffer->size()),
             out_completion.transferred());
 
   in_completion.WaitForResult();
-  ASSERT_EQ(USB_TRANSFER_COMPLETED, in_completion.status());
+  ASSERT_EQ(UsbTransferStatus::COMPLETED, in_completion.status());
   EXPECT_EQ(static_cast<size_t>(in_buffer->size()),
             in_completion.transferred());
   for (size_t i = 0; i < in_completion.transferred(); ++i) {
     EXPECT_EQ(out_buffer->data()[i], in_buffer->data()[i])
         << "Mismatch at index " << i << ".";
   }
 
   TestResultCallback release_interface;
   handle->ReleaseInterface(1, release_interface.callback());
   ASSERT_TRUE(release_interface.WaitForResult());
 
   handle->Close();
 }
 
 TEST_F(UsbDeviceHandleTest, ControlTransfer) {
   if (!UsbTestGadget::IsTestEnabled())
     return;
 
   std::unique_ptr<UsbTestGadget> gadget =
       UsbTestGadget::Claim(io_thread_->task_runner());
   ASSERT_TRUE(gadget.get());
 
   TestOpenCallback open_device;
   gadget->GetDevice()->Open(open_device.callback());
   scoped_refptr<UsbDeviceHandle> handle = open_device.WaitForResult();
   ASSERT_TRUE(handle.get());
 
   scoped_refptr<net::IOBufferWithSize> buffer(new net::IOBufferWithSize(255));
   TestCompletionCallback completion;
-  handle->ControlTransfer(USB_DIRECTION_INBOUND, UsbDeviceHandle::STANDARD,
-                          UsbDeviceHandle::DEVICE, 0x06, 0x0301, 0x0409, buffer,
-                          buffer->size(), 0, completion.callback());
+  handle->ControlTransfer(
+      UsbTransferDirection::INBOUND, UsbControlTransferType::STANDARD,
+      UsbControlTransferRecipient::DEVICE, 0x06, 0x0301, 0x0409, buffer,
+      buffer->size(), 0, completion.callback());
   completion.WaitForResult();
-  ASSERT_EQ(USB_TRANSFER_COMPLETED, completion.status());
+  ASSERT_EQ(UsbTransferStatus::COMPLETED, completion.status());
   const char expected_str[] = "\x18\x03G\0o\0o\0g\0l\0e\0 \0I\0n\0c\0.\0";
   EXPECT_EQ(sizeof(expected_str) - 1, completion.transferred());
   for (size_t i = 0; i < completion.transferred(); ++i) {
     EXPECT_EQ(expected_str[i], buffer->data()[i]) << "Mismatch at index " << i
                                                   << ".";
   }
 
   handle->Close();
 }
 
@@ skipping 41 matching lines @@
   gadget->GetDevice()->Open(open_device.callback());
   scoped_refptr<UsbDeviceHandle> handle = open_device.WaitForResult();
   ASSERT_TRUE(handle.get());
 
   TestResultCallback claim_interface;
   handle->ClaimInterface(1, claim_interface.callback());
   ASSERT_TRUE(claim_interface.WaitForResult());
 
   scoped_refptr<net::IOBufferWithSize> buffer(new net::IOBufferWithSize(512));
   TestCompletionCallback completion;
-  handle->GenericTransfer(USB_DIRECTION_INBOUND, 0x82, buffer.get(),
+  handle->GenericTransfer(UsbTransferDirection::INBOUND, 0x82, buffer.get(),
                           buffer->size(),
                           5000,  // 5 second timeout
                           completion.callback());
 
   handle->Close();
   completion.WaitForResult();
-  ASSERT_EQ(USB_TRANSFER_CANCELLED, completion.status());
+  ASSERT_EQ(UsbTransferStatus::CANCELLED, completion.status());
 }
 
 TEST_F(UsbDeviceHandleTest, CancelOnDisconnect) {
   if (!UsbTestGadget::IsTestEnabled()) {
     return;
   }
 
   std::unique_ptr<UsbTestGadget> gadget =
       UsbTestGadget::Claim(io_thread_->task_runner());
   ASSERT_TRUE(gadget.get());
   ASSERT_TRUE(gadget->SetType(UsbTestGadget::ECHO));
 
   TestOpenCallback open_device;
   gadget->GetDevice()->Open(open_device.callback());
   scoped_refptr<UsbDeviceHandle> handle = open_device.WaitForResult();
   ASSERT_TRUE(handle.get());
 
   TestResultCallback claim_interface;
   handle->ClaimInterface(1, claim_interface.callback());
   ASSERT_TRUE(claim_interface.WaitForResult());
 
   scoped_refptr<net::IOBufferWithSize> buffer(new net::IOBufferWithSize(512));
   TestCompletionCallback completion;
-  handle->GenericTransfer(USB_DIRECTION_INBOUND, 0x82, buffer.get(),
+  handle->GenericTransfer(UsbTransferDirection::INBOUND, 0x82, buffer.get(),
                           buffer->size(),
                           5000,  // 5 second timeout
                           completion.callback());
 
   ASSERT_TRUE(gadget->Disconnect());
   completion.WaitForResult();
-  ASSERT_EQ(USB_TRANSFER_DISCONNECT, completion.status());
+  ASSERT_EQ(UsbTransferStatus::DISCONNECT, completion.status());
 
   handle->Close();
 }
 
 TEST_F(UsbDeviceHandleTest, Timeout) {
   if (!UsbTestGadget::IsTestEnabled()) {
     return;
   }
 
   std::unique_ptr<UsbTestGadget> gadget =
       UsbTestGadget::Claim(io_thread_->task_runner());
   ASSERT_TRUE(gadget.get());
   ASSERT_TRUE(gadget->SetType(UsbTestGadget::ECHO));
 
   TestOpenCallback open_device;
   gadget->GetDevice()->Open(open_device.callback());
   scoped_refptr<UsbDeviceHandle> handle = open_device.WaitForResult();
   ASSERT_TRUE(handle.get());
 
   TestResultCallback claim_interface;
   handle->ClaimInterface(1, claim_interface.callback());
   ASSERT_TRUE(claim_interface.WaitForResult());
 
   scoped_refptr<net::IOBufferWithSize> buffer(new net::IOBufferWithSize(512));
   TestCompletionCallback completion;
-  handle->GenericTransfer(USB_DIRECTION_INBOUND, 0x82, buffer.get(),
+  handle->GenericTransfer(UsbTransferDirection::INBOUND, 0x82, buffer.get(),
                           buffer->size(),
                           10,  // 10 millisecond timeout
                           completion.callback());
 
   completion.WaitForResult();
-  ASSERT_EQ(USB_TRANSFER_TIMEOUT, completion.status());
+  ASSERT_EQ(UsbTransferStatus::TIMEOUT, completion.status());
 
   handle->Close();
 }
 
 }  // namespace
 
 }  // namespace device