Use Mojo enum types in the C++ USB interface

device/usb/usb_device_handle_impl.cc

Index: device/usb/usb_device_handle_impl.cc
diff --git a/device/usb/usb_device_handle_impl.cc b/device/usb/usb_device_handle_impl.cc
index d8b28a923100fe6b534060c5b84149c8d81b51f0..ee398ed4cca0d81414c9609f7294450132c2d889 100644
--- a/device/usb/usb_device_handle_impl.cc
+++ b/device/usb/usb_device_handle_impl.cc
@@ -35,49 +35,48 @@ void HandleTransferCompletion(PlatformUsbTransferHandle transfer);
 
 namespace {
 
-uint8_t ConvertTransferDirection(UsbEndpointDirection direction) {
+uint8_t ConvertTransferDirection(UsbTransferDirection direction) {
   switch (direction) {
-    case USB_DIRECTION_INBOUND:
+    case UsbTransferDirection::INBOUND:
       return LIBUSB_ENDPOINT_IN;
-    case USB_DIRECTION_OUTBOUND:
+    case UsbTransferDirection::OUTBOUND:
       return LIBUSB_ENDPOINT_OUT;
-    default:
-      NOTREACHED();
-      return LIBUSB_ENDPOINT_IN;
   }
+  NOTREACHED();
+  return 0;
 }
 
-uint8_t CreateRequestType(UsbEndpointDirection direction,
-                          UsbDeviceHandle::TransferRequestType request_type,
-                          UsbDeviceHandle::TransferRecipient recipient) {
+uint8_t CreateRequestType(UsbTransferDirection direction,
+                          UsbControlTransferType request_type,
+                          UsbControlTransferRecipient recipient) {
   uint8_t result = ConvertTransferDirection(direction);
 
   switch (request_type) {
-    case UsbDeviceHandle::STANDARD:
+    case UsbControlTransferType::STANDARD:
       result |= LIBUSB_REQUEST_TYPE_STANDARD;
       break;
-    case UsbDeviceHandle::CLASS:
+    case UsbControlTransferType::CLASS:
       result |= LIBUSB_REQUEST_TYPE_CLASS;
       break;
-    case UsbDeviceHandle::VENDOR:
+    case UsbControlTransferType::VENDOR:
       result |= LIBUSB_REQUEST_TYPE_VENDOR;
       break;
-    case UsbDeviceHandle::RESERVED:
+    case UsbControlTransferType::RESERVED:
       result |= LIBUSB_REQUEST_TYPE_RESERVED;
       break;
   }
 
   switch (recipient) {
-    case UsbDeviceHandle::DEVICE:
+    case UsbControlTransferRecipient::DEVICE:
       result |= LIBUSB_RECIPIENT_DEVICE;
       break;
-    case UsbDeviceHandle::INTERFACE:
+    case UsbControlTransferRecipient::INTERFACE:
       result |= LIBUSB_RECIPIENT_INTERFACE;
       break;
-    case UsbDeviceHandle::ENDPOINT:
+    case UsbControlTransferRecipient::ENDPOINT:
       result |= LIBUSB_RECIPIENT_ENDPOINT;
       break;
-    case UsbDeviceHandle::OTHER:
+    case UsbControlTransferRecipient::OTHER:
       result |= LIBUSB_RECIPIENT_OTHER;
       break;
   }
@@ -89,23 +88,22 @@ static UsbTransferStatus ConvertTransferStatus(
     const libusb_transfer_status status) {
   switch (status) {
     case LIBUSB_TRANSFER_COMPLETED:
-      return USB_TRANSFER_COMPLETED;
+      return UsbTransferStatus::COMPLETED;
     case LIBUSB_TRANSFER_ERROR:
-      return USB_TRANSFER_ERROR;
+      return UsbTransferStatus::TRANSFER_ERROR;
     case LIBUSB_TRANSFER_TIMED_OUT:
-      return USB_TRANSFER_TIMEOUT;
+      return UsbTransferStatus::TIMEOUT;
     case LIBUSB_TRANSFER_STALL:
-      return USB_TRANSFER_STALLED;
+      return UsbTransferStatus::STALLED;
     case LIBUSB_TRANSFER_NO_DEVICE:
-      return USB_TRANSFER_DISCONNECT;
+      return UsbTransferStatus::DISCONNECT;
     case LIBUSB_TRANSFER_OVERFLOW:
-      return USB_TRANSFER_OVERFLOW;
+      return UsbTransferStatus::BABBLE;
     case LIBUSB_TRANSFER_CANCELLED:
-      return USB_TRANSFER_CANCELLED;
-    default:
-      NOTREACHED();
-      return USB_TRANSFER_ERROR;
+      return UsbTransferStatus::CANCELLED;
   }
+  NOTREACHED();
+  return UsbTransferStatus::TRANSFER_ERROR;
 }
 
 static void RunTransferCallback(
@@ -298,7 +296,7 @@ UsbDeviceHandleImpl::Transfer::CreateControlTransfer(
     scoped_refptr<base::TaskRunner> callback_task_runner,
     const TransferCallback& callback) {
   std::unique_ptr<Transfer> transfer(new Transfer(
-      device_handle, nullptr, USB_TRANSFER_CONTROL, buffer,
+      device_handle, nullptr, UsbTransferType::CONTROL, buffer,
       length + LIBUSB_CONTROL_SETUP_SIZE, callback_task_runner, callback));
 
   transfer->platform_transfer_ = libusb_alloc_transfer(0);
@@ -330,7 +328,7 @@ UsbDeviceHandleImpl::Transfer::CreateBulkTransfer(
     const TransferCallback& callback) {
   std::unique_ptr<Transfer> transfer(new Transfer(
       device_handle, device_handle->GetClaimedInterfaceForEndpoint(endpoint),
-      USB_TRANSFER_BULK, buffer, length, callback_task_runner, callback));
+      UsbTransferType::BULK, buffer, length, callback_task_runner, callback));
 
   transfer->platform_transfer_ = libusb_alloc_transfer(0);
   if (!transfer->platform_transfer_) {
@@ -359,7 +357,8 @@ UsbDeviceHandleImpl::Transfer::CreateInterruptTransfer(
     const TransferCallback& callback) {
   std::unique_ptr<Transfer> transfer(new Transfer(
       device_handle, device_handle->GetClaimedInterfaceForEndpoint(endpoint),
-      USB_TRANSFER_INTERRUPT, buffer, length, callback_task_runner, callback));
+      UsbTransferType::INTERRUPT, buffer, length, callback_task_runner,
+      callback));
 
   transfer->platform_transfer_ = libusb_alloc_transfer(0);
   if (!transfer->platform_transfer_) {
@@ -433,7 +432,7 @@ UsbDeviceHandleImpl::Transfer::Transfer(
     scoped_refptr<net::IOBuffer> buffer,
     scoped_refptr<base::TaskRunner> callback_task_runner,
     const IsochronousTransferCallback& callback)
-    : transfer_type_(USB_TRANSFER_ISOCHRONOUS),
+    : transfer_type_(UsbTransferType::ISOCHRONOUS),
       device_handle_(device_handle),
       buffer_(buffer),
       claimed_interface_(claimed_interface),
@@ -453,7 +452,7 @@ void UsbDeviceHandleImpl::Transfer::Submit() {
   if (rv != LIBUSB_SUCCESS) {
     USB_LOG(EVENT) << "Failed to submit transfer: "
                    << ConvertPlatformUsbErrorToString(rv);
-    TransferComplete(USB_TRANSFER_ERROR, 0);
+    TransferComplete(UsbTransferStatus::TRANSFER_ERROR, 0);
   }
 }
 
@@ -475,7 +474,7 @@ void UsbDeviceHandleImpl::Transfer::ProcessCompletion() {
       << "data too big for our buffer (libusb failure?)";
 
   switch (transfer_type_) {
-    case USB_TRANSFER_CONTROL:
+    case UsbTransferType::CONTROL:
       // If the transfer is a control transfer we do not expose the control
       // setup header to the caller. This logic strips off the header if
       // present before invoking the callback provided with the transfer.
@@ -495,13 +494,13 @@ void UsbDeviceHandleImpl::Transfer::ProcessCompletion() {
       }
     // Fall through!
 
-    case USB_TRANSFER_BULK:
-    case USB_TRANSFER_INTERRUPT:
+    case UsbTransferType::BULK:
+    case UsbTransferType::INTERRUPT:
       TransferComplete(ConvertTransferStatus(platform_transfer_->status),
                        actual_length);
       break;
 
-    case USB_TRANSFER_ISOCHRONOUS:
+    case UsbTransferType::ISOCHRONOUS:
       IsochronousTransferComplete();
       break;
 
@@ -523,7 +522,7 @@ void LIBUSB_CALL UsbDeviceHandleImpl::Transfer::PlatformCallback(
 void UsbDeviceHandleImpl::Transfer::TransferComplete(UsbTransferStatus status,
                                                      size_t bytes_transferred) {
   base::Closure closure;
-  if (transfer_type_ == USB_TRANSFER_ISOCHRONOUS) {
+  if (transfer_type_ == UsbTransferType::ISOCHRONOUS) {
     DCHECK_NE(LIBUSB_TRANSFER_COMPLETED, platform_transfer_->status);
     std::vector<IsochronousPacket> packets(platform_transfer_->num_iso_packets);
     for (size_t i = 0; i < packets.size(); ++i) {
@@ -697,9 +696,9 @@ void UsbDeviceHandleImpl::ClearHalt(uint8_t endpoint,
                             this, endpoint, callback));
 }
 
-void UsbDeviceHandleImpl::ControlTransfer(UsbEndpointDirection direction,
-                                          TransferRequestType request_type,
-                                          TransferRecipient recipient,
+void UsbDeviceHandleImpl::ControlTransfer(UsbTransferDirection direction,
+                                          UsbControlTransferType request_type,
+                                          UsbControlTransferRecipient recipient,
                                           uint8_t request,
                                           uint16_t value,
                                           uint16_t index,
@@ -726,7 +725,7 @@ void UsbDeviceHandleImpl::IsochronousTransferIn(
     unsigned int timeout,
     const IsochronousTransferCallback& callback) {
   uint8_t endpoint_address =
-      ConvertTransferDirection(USB_DIRECTION_INBOUND) | endpoint_number;
+      ConvertTransferDirection(UsbTransferDirection::INBOUND) | endpoint_number;
   if (task_runner_->BelongsToCurrentThread()) {
     IsochronousTransferInInternal(endpoint_address, packet_lengths, timeout,
                                   task_runner_, callback);
@@ -746,7 +745,8 @@ void UsbDeviceHandleImpl::IsochronousTransferOut(
     unsigned int timeout,
     const IsochronousTransferCallback& callback) {
   uint8_t endpoint_address =
-      ConvertTransferDirection(USB_DIRECTION_OUTBOUND) | endpoint_number;
+      ConvertTransferDirection(UsbTransferDirection::OUTBOUND) |
+      endpoint_number;
   if (task_runner_->BelongsToCurrentThread()) {
     IsochronousTransferOutInternal(endpoint_address, buffer, packet_lengths,
                                    timeout, task_runner_, callback);
@@ -759,7 +759,7 @@ void UsbDeviceHandleImpl::IsochronousTransferOut(
   }
 }
 
-void UsbDeviceHandleImpl::GenericTransfer(UsbEndpointDirection direction,
+void UsbDeviceHandleImpl::GenericTransfer(UsbTransferDirection direction,
                                           uint8_t endpoint_number,
                                           scoped_refptr<net::IOBuffer> buffer,
                                           size_t length,
@@ -969,9 +969,9 @@ UsbDeviceHandleImpl::GetClaimedInterfaceForEndpoint(uint8_t endpoint) {
 }
 
 void UsbDeviceHandleImpl::ControlTransferInternal(
-    UsbEndpointDirection direction,
-    TransferRequestType request_type,
-    TransferRecipient recipient,
+    UsbTransferDirection direction,
+    UsbControlTransferType request_type,
+    UsbControlTransferRecipient recipient,
     uint8_t request,
     uint16_t value,
     uint16_t index,
@@ -983,15 +983,15 @@ void UsbDeviceHandleImpl::ControlTransferInternal(
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!device_) {
-    RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_DISCONNECT,
-                        buffer, 0);
+    RunTransferCallback(callback_task_runner, callback,
+                        UsbTransferStatus::DISCONNECT, buffer, 0);
     return;
   }
 
   if (!base::IsValueInRangeForNumericType<uint16_t>(length)) {
     USB_LOG(USER) << "Transfer too long.";
-    RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_ERROR,
-                        buffer, 0);
+    RunTransferCallback(callback_task_runner, callback,
+                        UsbTransferStatus::TRANSFER_ERROR, buffer, 0);
     return;
   }
 
@@ -999,8 +999,8 @@ void UsbDeviceHandleImpl::ControlTransferInternal(
   scoped_refptr<net::IOBuffer> resized_buffer =
       new net::IOBufferWithSize(resized_length);
   if (!resized_buffer.get()) {
-    RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_ERROR,
-                        buffer, 0);
+    RunTransferCallback(callback_task_runner, callback,
+                        UsbTransferStatus::TRANSFER_ERROR, buffer, 0);
     return;
   }
   memcpy(resized_buffer->data() + LIBUSB_CONTROL_SETUP_SIZE, buffer->data(),
@@ -1011,8 +1011,8 @@ void UsbDeviceHandleImpl::ControlTransferInternal(
       value, index, static_cast<uint16_t>(length), resized_buffer, timeout,
       callback_task_runner, callback);
   if (!transfer) {
-    RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_ERROR,
-                        buffer, 0);
+    RunTransferCallback(callback_task_runner, callback,
+                        UsbTransferStatus::TRANSFER_ERROR, buffer, 0);
     return;
   }
 
@@ -1029,7 +1029,8 @@ void UsbDeviceHandleImpl::IsochronousTransferInInternal(
 
   if (!device_) {
     ReportIsochronousTransferError(callback_task_runner, callback,
-                                   packet_lengths, USB_TRANSFER_DISCONNECT);
+                                   packet_lengths,
+                                   UsbTransferStatus::DISCONNECT);
     return;
   }
 
@@ -1054,7 +1055,8 @@ void UsbDeviceHandleImpl::IsochronousTransferOutInternal(
 
   if (!device_) {
     ReportIsochronousTransferError(callback_task_runner, callback,
-                                   packet_lengths, USB_TRANSFER_DISCONNECT);
+                                   packet_lengths,
+                                   UsbTransferStatus::DISCONNECT);
     return;
   }
 
@@ -1077,8 +1079,8 @@ void UsbDeviceHandleImpl::GenericTransferInternal(
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!device_) {
-    RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_DISCONNECT,
-                        buffer, 0);
+    RunTransferCallback(callback_task_runner, callback,
+                        UsbTransferStatus::DISCONNECT, buffer, 0);
     return;
   }
 
@@ -1087,33 +1089,33 @@ void UsbDeviceHandleImpl::GenericTransferInternal(
     USB_LOG(DEBUG) << "Failed to submit transfer because endpoint "
                    << static_cast<int>(endpoint_address)
                    << " not part of a claimed interface.";
-    RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_ERROR,
-                        buffer, 0);
+    RunTransferCallback(callback_task_runner, callback,
+                        UsbTransferStatus::TRANSFER_ERROR, buffer, 0);
     return;
   }
 
   if (!base::IsValueInRangeForNumericType<int>(length)) {
     USB_LOG(DEBUG) << "Transfer too long.";
-    RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_ERROR,
-                        buffer, 0);
+    RunTransferCallback(callback_task_runner, callback,
+                        UsbTransferStatus::TRANSFER_ERROR, buffer, 0);
     return;
   }
 
   std::unique_ptr<Transfer> transfer;
   UsbTransferType transfer_type = endpoint_it->second.endpoint->transfer_type;
-  if (transfer_type == USB_TRANSFER_BULK) {
+  if (transfer_type == UsbTransferType::BULK) {
     transfer = Transfer::CreateBulkTransfer(this, endpoint_address, buffer,
                                             static_cast<int>(length), timeout,
                                             callback_task_runner, callback);
-  } else if (transfer_type == USB_TRANSFER_INTERRUPT) {
+  } else if (transfer_type == UsbTransferType::INTERRUPT) {
     transfer = Transfer::CreateInterruptTransfer(
         this, endpoint_address, buffer, static_cast<int>(length), timeout,
         callback_task_runner, callback);
   } else {
     USB_LOG(DEBUG) << "Endpoint " << static_cast<int>(endpoint_address)
                    << " is not a bulk or interrupt endpoint.";
-    RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_ERROR,
-                        buffer, 0);
+    RunTransferCallback(callback_task_runner, callback,
+                        UsbTransferStatus::TRANSFER_ERROR, buffer, 0);
     return;
   }