Use Mojo enum types in the C++ USB interface

device/usb/usb_device_handle_usbfs.cc

 // Copyright 2016 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_usbfs.h"
 
 #if defined(OS_ANDROID) && __ANDROID_API__ < 21
 #include <linux/usb_ch9.h>
 #else
 #include <linux/usb/ch9.h>
@@ skipping 14 matching lines @@
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/device_event_log/device_event_log.h"
 #include "device/usb/usb_device_linux.h"
 #include "net/base/io_buffer.h"
 
 namespace device {
 
 namespace {
 
-uint8_t ConvertEndpointDirection(UsbEndpointDirection direction) {
+uint8_t ConvertEndpointDirection(UsbTransferDirection direction) {
   switch (direction) {
-    case USB_DIRECTION_INBOUND:
+    case UsbTransferDirection::INBOUND:
       return USB_DIR_IN;
-    case USB_DIRECTION_OUTBOUND:
+    case UsbTransferDirection::OUTBOUND:
       return USB_DIR_OUT;
   }
   NOTREACHED();
   return 0;
 }
 
-uint8_t ConvertRequestType(UsbDeviceHandle::TransferRequestType request_type) {
+uint8_t ConvertRequestType(UsbControlTransferType request_type) {
   switch (request_type) {
-    case UsbDeviceHandle::STANDARD:
+    case UsbControlTransferType::STANDARD:
       return USB_TYPE_STANDARD;
-    case UsbDeviceHandle::CLASS:
+    case UsbControlTransferType::CLASS:
       return USB_TYPE_CLASS;
-    case UsbDeviceHandle::VENDOR:
+    case UsbControlTransferType::VENDOR:
       return USB_TYPE_VENDOR;
-    case UsbDeviceHandle::RESERVED:
+    case UsbControlTransferType::RESERVED:
       return USB_TYPE_RESERVED;
   }
   NOTREACHED();
   return 0;
 }
 
-uint8_t ConvertRecipient(UsbDeviceHandle::TransferRecipient recipient) {
+uint8_t ConvertRecipient(UsbControlTransferRecipient recipient) {
   switch (recipient) {
-    case UsbDeviceHandle::DEVICE:
+    case UsbControlTransferRecipient::DEVICE:
       return USB_RECIP_DEVICE;
-    case UsbDeviceHandle::INTERFACE:
+    case UsbControlTransferRecipient::INTERFACE:
       return USB_RECIP_INTERFACE;
-    case UsbDeviceHandle::ENDPOINT:
+    case UsbControlTransferRecipient::ENDPOINT:
       return USB_RECIP_ENDPOINT;
-    case UsbDeviceHandle::OTHER:
+    case UsbControlTransferRecipient::OTHER:
       return USB_RECIP_OTHER;
   }
   NOTREACHED();
   return 0;
 }
 
 scoped_refptr<net::IOBuffer> BuildControlTransferBuffer(
-    UsbEndpointDirection direction,
-    UsbDeviceHandle::TransferRequestType request_type,
-    UsbDeviceHandle::TransferRecipient recipient,
+    UsbTransferDirection direction,
+    UsbControlTransferType request_type,
+    UsbControlTransferRecipient recipient,
     uint8_t request,
     uint16_t value,
     uint16_t index,
     scoped_refptr<net::IOBuffer> original_buffer,
     size_t length) {
   scoped_refptr<net::IOBuffer> new_buffer(
       new net::IOBuffer(length + sizeof(usb_ctrlrequest)));
   usb_ctrlrequest* setup =
       reinterpret_cast<usb_ctrlrequest*>(new_buffer->data());
   setup->bRequestType = ConvertEndpointDirection(direction) |
                         ConvertRequestType(request_type) |
                         ConvertRecipient(recipient);
   setup->bRequest = request;
   setup->wValue = value;
   setup->wIndex = index;
   setup->wLength = length;
   memcpy(new_buffer->data() + sizeof(usb_ctrlrequest), original_buffer->data(),
          length);
   return new_buffer;
 }
 
 uint8_t ConvertTransferType(UsbTransferType type) {
   switch (type) {
-    case USB_TRANSFER_CONTROL:
+    case UsbTransferType::CONTROL:
       return USBDEVFS_URB_TYPE_CONTROL;
-    case USB_TRANSFER_ISOCHRONOUS:
+    case UsbTransferType::ISOCHRONOUS:
       return USBDEVFS_URB_TYPE_ISO;
-    case USB_TRANSFER_BULK:
+    case UsbTransferType::BULK:
       return USBDEVFS_URB_TYPE_BULK;
-    case USB_TRANSFER_INTERRUPT:
+    case UsbTransferType::INTERRUPT:
       return USBDEVFS_URB_TYPE_INTERRUPT;
   }
   NOTREACHED();
   return 0;
 }
 
 UsbTransferStatus ConvertTransferResult(int rc) {
   switch (rc) {
     case 0:
-      return USB_TRANSFER_COMPLETED;
+      return UsbTransferStatus::COMPLETED;
     case EPIPE:
-      return USB_TRANSFER_STALLED;
+      return UsbTransferStatus::STALLED;
     case ENODEV:
     case ESHUTDOWN:
     case EPROTO:
-      return USB_TRANSFER_DISCONNECT;
+      return UsbTransferStatus::DISCONNECT;
     default:
       // TODO(reillyg): Add a specific error message whenever one of the cases
       // above fails to match.
       USB_LOG(ERROR) << "Unknown system error: "
                      << logging::SystemErrorCodeToString(rc);
-      return USB_TRANSFER_ERROR;
+      return UsbTransferStatus::TRANSFER_ERROR;
   }
 }
 
 }  // namespace
 
 class UsbDeviceHandleUsbfs::FileThreadHelper {
  public:
   FileThreadHelper(base::ScopedFD fd,
                    scoped_refptr<UsbDeviceHandleUsbfs> device_handle,
                    scoped_refptr<base::SequencedTaskRunner> task_runner);
@@ skipping 288 matching lines @@
   if (!device_)
     return;  // Already closed.
 
   // On the |task_runner_| thread check |device_| to see if the handle is
   // closed. On the |blocking_task_runner_| thread check |fd_.is_valid()| to
   // see if the handle is closed.
   device_->HandleClosed(this);
   device_ = nullptr;
 
   for (const auto& transfer : transfers_)
-    CancelTransfer(transfer.get(), USB_TRANSFER_CANCELLED);
+    CancelTransfer(transfer.get(), UsbTransferStatus::CANCELLED);
 
   // Releases |helper_|.
   blocking_task_runner_->PostTask(
       FROM_HERE, base::Bind(&UsbDeviceHandleUsbfs::CloseBlocking, this));
 }
 
 void UsbDeviceHandleUsbfs::SetConfiguration(int configuration_value,
                                             const ResultCallback& callback) {
   if (!device_) {
     task_runner_->PostTask(FROM_HERE, base::Bind(callback, false));
@@ skipping 93 matching lines @@
 
   // USBDEVFS_CLEAR_HALT is synchronous because it issues a CLEAR_FEATURE
   // request to the device so it must be performed on a thread where it is okay
   // to block.
   blocking_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&UsbDeviceHandleUsbfs::FileThreadHelper::ClearHalt,
                  base::Unretained(helper_.get()), endpoint_address, callback));
 }
 
-void UsbDeviceHandleUsbfs::ControlTransfer(UsbEndpointDirection direction,
-                                           TransferRequestType request_type,
-                                           TransferRecipient recipient,
-                                           uint8_t request,
-                                           uint16_t value,
-                                           uint16_t index,
-                                           scoped_refptr<net::IOBuffer> buffer,
-                                           size_t length,
-                                           unsigned int timeout,
-                                           const TransferCallback& callback) {
+void UsbDeviceHandleUsbfs::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) {
   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;
   }
 
   std::unique_ptr<Transfer> transfer(new (0)
                                          Transfer(buffer, callback, nullptr));
   transfer->control_transfer_buffer =
       BuildControlTransferBuffer(direction, request_type, recipient, request,
                                  value, index, buffer, length);
   transfer->urb.type = USBDEVFS_URB_TYPE_CONTROL;
   transfer->urb.endpoint = 0;
@@ skipping 33 matching lines @@
     const std::vector<uint32_t>& packet_lengths,
     unsigned int timeout,
     const IsochronousTransferCallback& callback) {
   uint8_t endpoint_address = USB_DIR_OUT | endpoint_number;
   size_t total_length =
       std::accumulate(packet_lengths.begin(), packet_lengths.end(), 0u);
   IsochronousTransferInternal(endpoint_address, buffer, total_length,
                               packet_lengths, timeout, callback);
 }
 
-void UsbDeviceHandleUsbfs::GenericTransfer(UsbEndpointDirection direction,
+void UsbDeviceHandleUsbfs::GenericTransfer(UsbTransferDirection direction,
                                            uint8_t endpoint_number,
                                            scoped_refptr<net::IOBuffer> buffer,
                                            size_t length,
                                            unsigned int timeout,
                                            const TransferCallback& callback) {
   if (task_runner_->BelongsToCurrentThread()) {
     GenericTransferInternal(direction, endpoint_number, buffer, length, timeout,
                             callback, task_runner_);
   } else {
     task_runner_->PostTask(
@@ skipping 51 matching lines @@
 }
 
 void UsbDeviceHandleUsbfs::IsochronousTransferInternal(
     uint8_t endpoint_address,
     scoped_refptr<net::IOBuffer> buffer,
     size_t total_length,
     const std::vector<uint32_t>& packet_lengths,
     unsigned int timeout,
     const IsochronousTransferCallback& callback) {
   if (!device_) {
-    ReportIsochronousError(packet_lengths, callback, USB_TRANSFER_DISCONNECT);
+    ReportIsochronousError(packet_lengths, callback,
+                           UsbTransferStatus::DISCONNECT);
     return;
   }
 
   auto it = endpoints_.find(endpoint_address);
   if (it == endpoints_.end()) {
     USB_LOG(USER) << "Endpoint address " << static_cast<int>(endpoint_address)
                   << " is not part of a claimed interface.";
-    ReportIsochronousError(packet_lengths, callback, USB_TRANSFER_ERROR);
+    ReportIsochronousError(packet_lengths, callback,
+                           UsbTransferStatus::TRANSFER_ERROR);
     return;
   }
 
   std::unique_ptr<Transfer> transfer(new (packet_lengths.size())
                                          Transfer(buffer, callback));
   transfer->urb.type = USBDEVFS_URB_TYPE_ISO;
   transfer->urb.endpoint = endpoint_address;
   transfer->urb.buffer_length = total_length;
 
   for (size_t i = 0; i < packet_lengths.size(); ++i)
     transfer->urb.iso_frame_desc[i].length = packet_lengths[i];
 
   // USBDEVFS_SUBMITURB appears to be non-blocking as completion is reported
   // by USBDEVFS_REAPURBNDELAY. This code assumes a recent kernel that can
   // accept arbitrarily large transfer requests, hopefully also using a scatter-
   // gather list.
   int rc = HANDLE_EINTR(ioctl(fd_, USBDEVFS_SUBMITURB, &transfer->urb));
   if (rc) {
     rc = logging::GetLastSystemErrorCode();
     USB_PLOG(DEBUG) << "Failed to submit transfer";
     ReportIsochronousError(packet_lengths, callback, ConvertTransferResult(rc));
   } else {
     SetUpTimeoutCallback(transfer.get(), timeout);
     transfers_.push_back(std::move(transfer));
   }
 }
 
 void UsbDeviceHandleUsbfs::GenericTransferInternal(
-    UsbEndpointDirection direction,
+    UsbTransferDirection direction,
     uint8_t endpoint_number,
     scoped_refptr<net::IOBuffer> buffer,
     size_t length,
     unsigned int timeout,
     const TransferCallback& callback,
     scoped_refptr<base::SingleThreadTaskRunner> callback_runner) {
   if (!device_) {
     callback_runner->PostTask(
-        FROM_HERE, base::Bind(callback, USB_TRANSFER_DISCONNECT, nullptr, 0));
+        FROM_HERE,
+        base::Bind(callback, UsbTransferStatus::DISCONNECT, nullptr, 0));
     return;
   }
 
   uint8_t endpoint_address =
       ConvertEndpointDirection(direction) | endpoint_number;
   auto it = endpoints_.find(endpoint_address);
   if (it == endpoints_.end()) {
     USB_LOG(USER) << "Endpoint address " << static_cast<int>(endpoint_address)
                   << " is not part of a claimed interface.";
     callback_runner->PostTask(
-        FROM_HERE, base::Bind(callback, USB_TRANSFER_ERROR, nullptr, 0));
+        FROM_HERE,
+        base::Bind(callback, UsbTransferStatus::TRANSFER_ERROR, nullptr, 0));
     return;
   }
 
   std::unique_ptr<Transfer> transfer(
       new (0) Transfer(buffer, callback, callback_runner));
   transfer->urb.endpoint = endpoint_address;
   transfer->urb.buffer_length = length;
   transfer->urb.type = ConvertTransferType(it->second.type);
 
   // USBDEVFS_SUBMITURB appears to be non-blocking as completion is reported
@@ skipping 100 matching lines @@
     packets[i].status = status;
   }
   task_runner_->PostTask(FROM_HERE, base::Bind(callback, nullptr, packets));
 }
 
 void UsbDeviceHandleUsbfs::SetUpTimeoutCallback(Transfer* transfer,
                                                 unsigned int timeout) {
   if (timeout > 0) {
     transfer->timeout_closure.Reset(
         base::Bind(&UsbDeviceHandleUsbfs::CancelTransfer, this, transfer,
-                   USB_TRANSFER_TIMEOUT));
+                   UsbTransferStatus::TIMEOUT));
     task_runner_->PostDelayedTask(FROM_HERE,
                                   transfer->timeout_closure.callback(),
                                   base::TimeDelta::FromMilliseconds(timeout));
   }
 }
 
 std::unique_ptr<UsbDeviceHandleUsbfs::Transfer>
 UsbDeviceHandleUsbfs::RemoveFromTransferList(Transfer* transfer_ptr) {
   auto it = std::find_if(
       transfers_.begin(), transfers_.end(),
@@ skipping 34 matching lines @@
 }
 
 
 void UsbDeviceHandleUsbfs::UrbDiscarded(Transfer* transfer) {
   transfer->discarded = true;
   if (transfer->reaped)
     RemoveFromTransferList(transfer);
 }
 
 }  // namespace device