Use Mojo enum types in the C++ USB interface

device/usb/mojo/device_impl.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 <algorithm>
 #include <memory>
@@ skipping 316 matching lines @@
                                    uint32_t timeout,
                                    const ControlTransferInCallback& callback) {
   if (!device_handle_) {
     callback.Run(mojom::UsbTransferStatus::TRANSFER_ERROR, base::nullopt);
     return;
   }
 
   if (HasControlTransferPermission(params->recipient, params->index)) {
     scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(length);
     device_handle_->ControlTransfer(
-        USB_DIRECTION_INBOUND,
-        mojo::ConvertTo<UsbDeviceHandle::TransferRequestType>(params->type),
-        mojo::ConvertTo<UsbDeviceHandle::TransferRecipient>(params->recipient),
+        UsbTransferDirection::INBOUND, params->type, params->recipient,
         params->request, params->value, params->index, buffer, length, timeout,
         base::Bind(&OnTransferIn, callback));
   } else {
     callback.Run(mojom::UsbTransferStatus::PERMISSION_DENIED, base::nullopt);
   }
 }
 
 void DeviceImpl::ControlTransferOut(
     UsbControlTransferParamsPtr params,
     const std::vector<uint8_t>& data,
     uint32_t timeout,
     const ControlTransferOutCallback& callback) {
   if (!device_handle_) {
     callback.Run(mojom::UsbTransferStatus::TRANSFER_ERROR);
     return;
   }
 
   if (HasControlTransferPermission(params->recipient, params->index)) {
     scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(data.size());
     std::copy(data.begin(), data.end(), buffer->data());
     device_handle_->ControlTransfer(
-        USB_DIRECTION_OUTBOUND,
-        mojo::ConvertTo<UsbDeviceHandle::TransferRequestType>(params->type),
-        mojo::ConvertTo<UsbDeviceHandle::TransferRecipient>(params->recipient),
+        UsbTransferDirection::OUTBOUND, params->type, params->recipient,
         params->request, params->value, params->index, buffer, data.size(),
         timeout, base::Bind(&OnTransferOut, callback));
   } else {
     callback.Run(mojom::UsbTransferStatus::PERMISSION_DENIED);
   }
 }
 
 void DeviceImpl::GenericTransferIn(uint8_t endpoint_number,
                                    uint32_t length,
                                    uint32_t timeout,
                                    const GenericTransferInCallback& callback) {
   if (!device_handle_) {
     callback.Run(mojom::UsbTransferStatus::TRANSFER_ERROR, base::nullopt);
     return;
   }
 
   uint8_t endpoint_address = endpoint_number | 0x80;
   scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(length);
-  device_handle_->GenericTransfer(USB_DIRECTION_INBOUND, endpoint_address,
-                                  buffer, length, timeout,
+  device_handle_->GenericTransfer(UsbTransferDirection::INBOUND,
+                                  endpoint_address, buffer, length, timeout,
                                   base::Bind(&OnTransferIn, callback));
 }
 
 void DeviceImpl::GenericTransferOut(
     uint8_t endpoint_number,
     const std::vector<uint8_t>& data,
     uint32_t timeout,
     const GenericTransferOutCallback& callback) {
   if (!device_handle_) {
     callback.Run(mojom::UsbTransferStatus::TRANSFER_ERROR);
     return;
   }
 
   uint8_t endpoint_address = endpoint_number;
   scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(data.size());
   std::copy(data.begin(), data.end(), buffer->data());
-  device_handle_->GenericTransfer(USB_DIRECTION_OUTBOUND, endpoint_address,
-                                  buffer, data.size(), timeout,
-                                  base::Bind(&OnTransferOut, callback));
+  device_handle_->GenericTransfer(
+      UsbTransferDirection::OUTBOUND, endpoint_address, buffer, data.size(),
+      timeout, base::Bind(&OnTransferOut, callback));
 }
 
 void DeviceImpl::IsochronousTransferIn(
     uint8_t endpoint_number,
     const std::vector<uint32_t>& packet_lengths,
     uint32_t timeout,
     const IsochronousTransferInCallback& callback) {
   if (!device_handle_) {
     callback.Run(base::nullopt,
                  BuildIsochronousPacketArray(
@@ skipping 27 matching lines @@
       base::Bind(&OnIsochronousTransferOut, callback));
 }
 
 void DeviceImpl::OnDeviceRemoved(scoped_refptr<device::UsbDevice> device) {
   DCHECK_EQ(device_, device);
   binding_->Close();
 }
 
 }  // namespace usb
 }  // namespace device