Change mojo enums to be scoped enums in the generated C++ bindings.

device/devices_app/usb/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/devices_app/usb/device_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <map>
 #include <queue>
@@ skipping 361 matching lines @@
 
 TEST_F(USBDeviceImplTest, Open) {
   DevicePtr device = GetMockDeviceProxy();
 
   EXPECT_FALSE(is_device_open());
 
   EXPECT_CALL(mock_device(), Open(_));
 
   base::RunLoop loop;
   device->Open(
-      base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK, loop.QuitClosure()));
+      base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK, loop.QuitClosure()));
   loop.Run();
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 TEST_F(USBDeviceImplTest, Close) {
   DevicePtr device = GetMockDeviceProxy();
 
   EXPECT_FALSE(is_device_open());
 
   EXPECT_CALL(mock_device(), Open(_));
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 
   {
     base::RunLoop loop;
     device->Close(loop.QuitClosure());
     loop.Run();
@@ skipping 15 matching lines @@
   loop.Run();
 }
 
 TEST_F(USBDeviceImplTest, SetInvalidConfiguration) {
   DevicePtr device = GetMockDeviceProxy();
 
   EXPECT_CALL(mock_device(), Open(_));
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), SetConfiguration(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();
 
   EXPECT_CALL(mock_device(), Open(_));
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), SetConfiguration(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();
 
   EXPECT_CALL(mock_device(), Open(_));
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), ResetDevice(_));
 
   set_allow_reset(true);
 
   {
     base::RunLoop loop;
@@ skipping 14 matching lines @@
   EXPECT_CALL(mock_handle(), Close());
 }
 
 TEST_F(USBDeviceImplTest, ClaimAndReleaseInterface) {
   DevicePtr device = GetMockDeviceProxy();
 
   EXPECT_CALL(mock_device(), Open(_));
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::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, _));
 
   {
@@ skipping 47 matching lines @@
   EXPECT_CALL(mock_handle(), Close());
 }
 
 TEST_F(USBDeviceImplTest, SetInterfaceAlternateSetting) {
   DevicePtr device = GetMockDeviceProxy();
 
   EXPECT_CALL(mock_device(), Open(_));
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::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 17 matching lines @@
   EXPECT_CALL(mock_handle(), Close());
 }
 
 TEST_F(USBDeviceImplTest, ControlTransfer) {
   DevicePtr device = GetMockDeviceProxy();
 
   EXPECT_CALL(mock_device(), Open(_));
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
 
   AddMockConfig(ConfigBuilder(1).AddInterface(7, 0, 1, 2, 3));
 
   EXPECT_CALL(mock_device(), GetActiveConfiguration());
   EXPECT_CALL(mock_handle(), SetConfiguration(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, _));
 
   {
     auto params = ControlTransferParams::New();
-    params->type = CONTROL_TRANSFER_TYPE_STANDARD;
-    params->recipient = CONTROL_TRANSFER_RECIPIENT_DEVICE;
+    params->type = ControlTransferType::STANDARD;
+    params->recipient = ControlTransferRecipient::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, TRANSFER_STATUS_COMPLETED,
+        base::Bind(&ExpectTransferInAndThen, TransferStatus::COMPLETED,
                    fake_data, loop.QuitClosure()));
     loop.Run();
   }
 
   AddMockOutboundData(fake_data);
 
   EXPECT_CALL(mock_device(), GetActiveConfiguration());
   EXPECT_CALL(mock_handle(),
               ControlTransfer(USB_DIRECTION_OUTBOUND, UsbDeviceHandle::STANDARD,
                               UsbDeviceHandle::INTERFACE, 5, 6, 7, _, _, 0, _));
 
   {
     auto params = ControlTransferParams::New();
-    params->type = CONTROL_TRANSFER_TYPE_STANDARD;
-    params->recipient = CONTROL_TRANSFER_RECIPIENT_INTERFACE;
+    params->type = ControlTransferType::STANDARD;
+    params->recipient = ControlTransferRecipient::INTERFACE;
     params->request = 5;
     params->value = 6;
     params->index = 7;
     base::RunLoop loop;
     device->ControlTransferOut(
         std::move(params), mojo::Array<uint8_t>::From(fake_data), 0,
-        base::Bind(&ExpectTransferStatusAndThen, TRANSFER_STATUS_COMPLETED,
+        base::Bind(&ExpectTransferStatusAndThen, TransferStatus::COMPLETED,
                    loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 TEST_F(USBDeviceImplTest, GenericTransfer) {
   DevicePtr device = GetMockDeviceProxy();
 
   EXPECT_CALL(mock_device(), Open(_));
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::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, mojo::Array<uint8_t>::From(fake_outbound_data), 0,
-        base::Bind(&ExpectTransferStatusAndThen, TRANSFER_STATUS_COMPLETED,
+        base::Bind(&ExpectTransferStatusAndThen, TransferStatus::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, TRANSFER_STATUS_COMPLETED,
+        base::Bind(&ExpectTransferInAndThen, TransferStatus::COMPLETED,
                    fake_inbound_data, loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 TEST_F(USBDeviceImplTest, IsochronousTransfer) {
   DevicePtr device = GetMockDeviceProxy();
 
   EXPECT_CALL(mock_device(), Open(_));
 
   {
     base::RunLoop loop;
-    device->Open(base::Bind(&ExpectOpenAndThen, OPEN_DEVICE_ERROR_OK,
+    device->Open(base::Bind(&ExpectOpenAndThen, OpenDeviceError::OK,
                             loop.QuitClosure()));
     loop.Run();
   }
 
   std::string outbound_packet_data = "aaaaaaaabbbbbbbbccccccccdddddddd";
   std::vector<uint8_t> fake_outbound_packets(outbound_packet_data.size());
   std::copy(outbound_packet_data.begin(), outbound_packet_data.end(),
             fake_outbound_packets.begin());
 
   std::string inbound_packet_data = "ddddddddccccccccbbbbbbbbaaaaaaaa";
@@ skipping 14 matching lines @@
     mojo::Array<mojo::Array<uint8_t>> packets =
         mojo::Array<mojo::Array<uint8_t>>::New(4);
     for (size_t i = 0; i < 4; ++i) {
       std::vector<uint8_t> bytes(8);
       std::copy(outbound_packet_data.begin() + i * 8,
                 outbound_packet_data.begin() + i * 8 + 8, bytes.begin());
       packets[i].Swap(&bytes);
     }
     device->IsochronousTransferOut(
         1, std::move(packets), 0,
-        base::Bind(&ExpectTransferStatusAndThen, TRANSFER_STATUS_COMPLETED,
+        base::Bind(&ExpectTransferStatusAndThen, TransferStatus::COMPLETED,
                    loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(),
               IsochronousTransfer(USB_DIRECTION_INBOUND, 0x81, _,
                                   fake_inbound_packets.size(), 4, 8, 0, _));
 
   {
     base::RunLoop loop;
     std::vector<std::vector<uint8_t>> packets(4);
     for (size_t i = 0; i < 4; ++i) {
       packets[i].resize(8);
       std::copy(inbound_packet_data.begin() + i * 8,
                 inbound_packet_data.begin() + i * 8 + 8, packets[i].begin());
     }
     device->IsochronousTransferIn(
-        1, 4, 8, 0, base::Bind(&ExpectPacketsAndThen, TRANSFER_STATUS_COMPLETED,
+        1, 4, 8, 0, base::Bind(&ExpectPacketsAndThen, TransferStatus::COMPLETED,
                                packets, loop.QuitClosure()));
     loop.Run();
   }
 
   EXPECT_CALL(mock_handle(), Close());
 }
 
 }  // namespace usb
 }  // namespace device