Use Mojo enum types in the C++ USB interface

device/usb/usb_device_handle_win.cc

 // Copyright 2017 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_win.h"
 
 #include <usbioctl.h>
 #include <usbspec.h>
 #include <winioctl.h>
 #include <winusb.h>
@@ skipping 140 matching lines @@
 
 void UsbDeviceHandleWin::ClearHalt(uint8_t endpoint,
                                    const ResultCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!device_) {
     callback.Run(false);
     return;
   }
 }
 
-void UsbDeviceHandleWin::ControlTransfer(UsbEndpointDirection direction,
-                                         TransferRequestType request_type,
-                                         TransferRecipient recipient,
+void UsbDeviceHandleWin::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 TransferCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!device_) {
     task_runner_->PostTask(
-        FROM_HERE, base::Bind(callback, USB_TRANSFER_DISCONNECT, nullptr, 0));
+        FROM_HERE,
+        base::Bind(callback, UsbTransferStatus::DISCONNECT, nullptr, 0));
     return;
   }
 
   if (hub_handle_.IsValid()) {

[mcasas, 2017/04/17 17:15:15]

nit: this method would be clear with early-returns, i.e.:

  if (!hub_handle_.IsValid()) {
    task_runner_->PostTask(... TRANSFER_ERROR...);
    return;
  }
  if ( !INBOUND || !STANDARD || !DEVICE ...) {
    task_runner_->PostTask(... TRANSFER_ERROR...);
    return;  
  }

( Or perhaps merging all these conditions)  
Maybe not in this CL, up to you.

[Reilly Grant (use Gerrit), 2017/04/17 19:20:48]

I have a follow-up CL that adds more logic to this function and I will consider
these changes there.

-    if (direction == USB_DIRECTION_INBOUND &&
-        request_type == TransferRequestType::STANDARD &&
-        recipient == TransferRecipient::DEVICE &&
+    if (direction == UsbTransferDirection::INBOUND &&
+        request_type == UsbControlTransferType::STANDARD &&
+        recipient == UsbControlTransferRecipient::DEVICE &&
         request == USB_REQUEST_GET_DESCRIPTOR) {
       if ((value >> 8) == USB_DEVICE_DESCRIPTOR_TYPE) {
         auto* node_connection_info = new USB_NODE_CONNECTION_INFORMATION_EX;
         node_connection_info->ConnectionIndex = device_->port_number();
 
         Request* request = MakeRequest(hub_handle_.Get());
         request->MaybeStartWatching(
             DeviceIoControl(hub_handle_.Get(),
                             IOCTL_USB_GET_NODE_CONNECTION_INFORMATION_EX,
                             node_connection_info, sizeof(*node_connection_info),
@@ skipping 25 matching lines @@
                             request->overlapped()),
             base::Bind(&UsbDeviceHandleWin::GotDescriptorFromNodeConnection,
                        weak_factory_.GetWeakPtr(), callback, request_buffer,
                        buffer, length));
         return;
       }
     }
 
     // Unsupported transfer for hub.
     task_runner_->PostTask(
-        FROM_HERE, base::Bind(callback, USB_TRANSFER_ERROR, nullptr, 0));
+        FROM_HERE,
+        base::Bind(callback, UsbTransferStatus::TRANSFER_ERROR, nullptr, 0));
     return;
   }
 
   // Regular control transfers unimplemented.
-  task_runner_->PostTask(FROM_HERE,
-                         base::Bind(callback, USB_TRANSFER_ERROR, nullptr, 0));
+  task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(callback, UsbTransferStatus::TRANSFER_ERROR, nullptr, 0));
 }
 
 void UsbDeviceHandleWin::IsochronousTransferIn(
     uint8_t endpoint_number,
     const std::vector<uint32_t>& packet_lengths,
     unsigned int timeout,
     const IsochronousTransferCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void UsbDeviceHandleWin::IsochronousTransferOut(
     uint8_t endpoint_number,
     scoped_refptr<net::IOBuffer> buffer,
     const std::vector<uint32_t>& packet_lengths,
     unsigned int timeout,
     const IsochronousTransferCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
-void UsbDeviceHandleWin::GenericTransfer(UsbEndpointDirection direction,
+void UsbDeviceHandleWin::GenericTransfer(UsbTransferDirection direction,
                                          uint8_t endpoint_number,
                                          scoped_refptr<net::IOBuffer> buffer,
                                          size_t length,
                                          unsigned int timeout,
                                          const TransferCallback& callback) {
   // This one must be callable from any thread.
 }
 
 const UsbInterfaceDescriptor* UsbDeviceHandleWin::FindInterfaceByEndpoint(
     uint8_t endpoint_address) {
@@ skipping 38 matching lines @@
     DWORD win32_result,
     size_t bytes_transferred) {
   USB_NODE_CONNECTION_INFORMATION_EX* node_connection_info =
       static_cast<USB_NODE_CONNECTION_INFORMATION_EX*>(
           node_connection_info_ptr);
   std::unique_ptr<Request> request = UnlinkRequest(request_ptr);
 
   if (win32_result != ERROR_SUCCESS) {
     SetLastError(win32_result);
     USB_PLOG(ERROR) << "Failed to get node connection information";
-    callback.Run(USB_TRANSFER_ERROR, nullptr, 0);
+    callback.Run(UsbTransferStatus::TRANSFER_ERROR, nullptr, 0);
     return;
   }
 
   DCHECK_EQ(bytes_transferred, sizeof(USB_NODE_CONNECTION_INFORMATION_EX));
   bytes_transferred = std::min(sizeof(USB_DEVICE_DESCRIPTOR), buffer_length);
   memcpy(buffer->data(), &node_connection_info->DeviceDescriptor,
          bytes_transferred);
-  callback.Run(USB_TRANSFER_COMPLETED, buffer, bytes_transferred);
+  callback.Run(UsbTransferStatus::COMPLETED, buffer, bytes_transferred);
 }
 
 void UsbDeviceHandleWin::GotDescriptorFromNodeConnection(
     const TransferCallback& callback,
     scoped_refptr<net::IOBuffer> request_buffer,
     scoped_refptr<net::IOBuffer> original_buffer,
     size_t original_buffer_length,
     Request* request_ptr,
     DWORD win32_result,
     size_t bytes_transferred) {
   std::unique_ptr<Request> request = UnlinkRequest(request_ptr);
 
   if (win32_result != ERROR_SUCCESS) {
     SetLastError(win32_result);
     USB_PLOG(ERROR) << "Failed to read descriptor from node connection";
-    callback.Run(USB_TRANSFER_ERROR, nullptr, 0);
+    callback.Run(UsbTransferStatus::TRANSFER_ERROR, nullptr, 0);
     return;
   }
 
   DCHECK_GE(bytes_transferred, sizeof(USB_DESCRIPTOR_REQUEST));
   bytes_transferred -= sizeof(USB_DESCRIPTOR_REQUEST);
   memcpy(original_buffer->data(),
          request_buffer->data() + sizeof(USB_DESCRIPTOR_REQUEST),
          bytes_transferred);
-  callback.Run(USB_TRANSFER_COMPLETED, original_buffer, bytes_transferred);
+  callback.Run(UsbTransferStatus::COMPLETED, original_buffer,
+               bytes_transferred);
 }
 
 }  // namespace device