Use Mojo enum types in the C++ USB interface

extensions/browser/api/usb/usb_api.cc

 // Copyright 2014 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 "extensions/browser/api/usb/usb_api.h"
 
 #include <algorithm>
 #include <memory>
 #include <numeric>
 #include <set>
@@ skipping 33 matching lines @@
 namespace GetConfiguration = usb::GetConfiguration;
 namespace ListInterfaces = usb::ListInterfaces;
 namespace OpenDevice = usb::OpenDevice;
 namespace ReleaseInterface = usb::ReleaseInterface;
 namespace RequestAccess = usb::RequestAccess;
 namespace ResetDevice = usb::ResetDevice;
 namespace SetInterfaceAlternateSetting = usb::SetInterfaceAlternateSetting;
 
 using content::BrowserThread;
 using device::UsbConfigDescriptor;
+using device::UsbControlTransferRecipient;
+using device::UsbControlTransferType;
 using device::UsbDevice;
 using device::UsbDeviceFilter;
 using device::UsbDeviceHandle;
 using device::UsbEndpointDescriptor;
-using device::UsbEndpointDirection;
 using device::UsbInterfaceDescriptor;
 using device::UsbService;
 using device::UsbSynchronizationType;
+using device::UsbTransferDirection;
 using device::UsbTransferStatus;
 using device::UsbTransferType;
 using device::UsbUsageType;
 using std::string;
 using std::vector;
 using usb::ConfigDescriptor;
 using usb::ControlTransferInfo;
 using usb::ConnectionHandle;
 using usb::Device;
 using usb::Direction;
@@ skipping 48 matching lines @@
 const char kErrorInvalidTimeout[] =
     "Transfer timeout must be greater than or equal to 0.";
 const char kErrorResetDevice[] =
     "Error resetting the device. The device has been closed.";
 
 const size_t kMaxTransferLength = 100 * 1024 * 1024;
 const int kMaxPackets = 4 * 1024 * 1024;
 const int kMaxPacketLength = 64 * 1024;
 
 bool ConvertDirectionFromApi(const Direction& input,
-                             UsbEndpointDirection* output) {
+                             UsbTransferDirection* output) {
   switch (input) {
     case usb::DIRECTION_IN:
-      *output = device::USB_DIRECTION_INBOUND;
+      *output = UsbTransferDirection::INBOUND;
       return true;
     case usb::DIRECTION_OUT:
-      *output = device::USB_DIRECTION_OUTBOUND;
+      *output = UsbTransferDirection::OUTBOUND;
       return true;
     default:
       NOTREACHED();
       return false;
   }
 }
 
 bool ConvertRequestTypeFromApi(const RequestType& input,
-                               UsbDeviceHandle::TransferRequestType* output) {
+                               UsbControlTransferType* output) {
   switch (input) {
     case usb::REQUEST_TYPE_STANDARD:
-      *output = UsbDeviceHandle::STANDARD;
+      *output = UsbControlTransferType::STANDARD;
       return true;
     case usb::REQUEST_TYPE_CLASS:
-      *output = UsbDeviceHandle::CLASS;
+      *output = UsbControlTransferType::CLASS;
       return true;
     case usb::REQUEST_TYPE_VENDOR:
-      *output = UsbDeviceHandle::VENDOR;
+      *output = UsbControlTransferType::VENDOR;
       return true;
     case usb::REQUEST_TYPE_RESERVED:
-      *output = UsbDeviceHandle::RESERVED;
+      *output = UsbControlTransferType::RESERVED;
       return true;
     default:
       NOTREACHED();
       return false;
   }
 }
 
 bool ConvertRecipientFromApi(const Recipient& input,
-                             UsbDeviceHandle::TransferRecipient* output) {
+                             UsbControlTransferRecipient* output) {
   switch (input) {
     case usb::RECIPIENT_DEVICE:
-      *output = UsbDeviceHandle::DEVICE;
+      *output = UsbControlTransferRecipient::DEVICE;
       return true;
     case usb::RECIPIENT_INTERFACE:
-      *output = UsbDeviceHandle::INTERFACE;
+      *output = UsbControlTransferRecipient::INTERFACE;
       return true;
     case usb::RECIPIENT_ENDPOINT:
-      *output = UsbDeviceHandle::ENDPOINT;
+      *output = UsbControlTransferRecipient::ENDPOINT;
       return true;
     case usb::RECIPIENT_OTHER:
-      *output = UsbDeviceHandle::OTHER;
+      *output = UsbControlTransferRecipient::OTHER;
       return true;
     default:
       NOTREACHED();
       return false;
   }
 }
 
 template <class T>
 bool GetTransferSize(const T& input, size_t* output) {
   if (input.direction == usb::DIRECTION_IN) {
     const int* length = input.length.get();
     if (length && *length >= 0 &&
         static_cast<size_t>(*length) < kMaxTransferLength) {
       *output = *length;
       return true;
     }
   } else if (input.direction == usb::DIRECTION_OUT) {
     if (input.data.get()) {
       *output = input.data->size();
       return true;
     }
   }
   return false;
 }
 
 template <class T>
 scoped_refptr<net::IOBuffer> CreateBufferForTransfer(
     const T& input,
-    UsbEndpointDirection direction,
+    UsbTransferDirection direction,
     size_t size) {
   if (size >= kMaxTransferLength)
     return NULL;
 
   // Allocate a |size|-bytes buffer, or a one-byte buffer if |size| is 0. This
   // is due to an impedance mismatch between IOBuffer and URBs. An IOBuffer
   // cannot represent a zero-length buffer, while an URB can.
   scoped_refptr<net::IOBuffer> buffer =
       new net::IOBuffer(std::max(static_cast<size_t>(1), size));
 
-  if (direction == device::USB_DIRECTION_INBOUND) {
+  if (direction == UsbTransferDirection::INBOUND) {
     return buffer;
-  } else if (direction == device::USB_DIRECTION_OUTBOUND) {
+  } else if (direction == UsbTransferDirection::OUTBOUND) {
     if (input.data.get() && size <= input.data->size()) {
       memcpy(buffer->data(), input.data->data(), size);
       return buffer;
     }
   }
   NOTREACHED();
   return NULL;
 }
 
 const char* ConvertTransferStatusToApi(const UsbTransferStatus status) {
   switch (status) {
-    case device::USB_TRANSFER_COMPLETED:
+    case UsbTransferStatus::COMPLETED:
       return "";
-    case device::USB_TRANSFER_ERROR:
+    case UsbTransferStatus::TRANSFER_ERROR:
       return kErrorGeneric;
-    case device::USB_TRANSFER_TIMEOUT:
+    case UsbTransferStatus::TIMEOUT:
       return kErrorTimeout;
-    case device::USB_TRANSFER_CANCELLED:
+    case UsbTransferStatus::CANCELLED:
       return kErrorCancelled;
-    case device::USB_TRANSFER_STALLED:
+    case UsbTransferStatus::STALLED:
       return kErrorStalled;
-    case device::USB_TRANSFER_DISCONNECT:
+    case UsbTransferStatus::DISCONNECT:
       return kErrorDisconnect;
-    case device::USB_TRANSFER_OVERFLOW:
+    case UsbTransferStatus::BABBLE:
       return kErrorOverflow;
-    case device::USB_TRANSFER_LENGTH_SHORT:
+    case UsbTransferStatus::SHORT_PACKET:
       return kErrorTransferLength;
     default:
       NOTREACHED();
       return "";
   }
 }
 
 std::unique_ptr<base::Value> PopulateConnectionHandle(int handle,
                                                       int vendor_id,
                                                       int product_id) {
   ConnectionHandle result;
   result.handle = handle;
   result.vendor_id = vendor_id;
   result.product_id = product_id;
   return result.ToValue();
 }
 
 TransferType ConvertTransferTypeToApi(const UsbTransferType& input) {
   switch (input) {
-    case device::USB_TRANSFER_CONTROL:
+    case UsbTransferType::CONTROL:
       return usb::TRANSFER_TYPE_CONTROL;
-    case device::USB_TRANSFER_INTERRUPT:
+    case UsbTransferType::INTERRUPT:
       return usb::TRANSFER_TYPE_INTERRUPT;
-    case device::USB_TRANSFER_ISOCHRONOUS:
+    case UsbTransferType::ISOCHRONOUS:
       return usb::TRANSFER_TYPE_ISOCHRONOUS;
-    case device::USB_TRANSFER_BULK:
+    case UsbTransferType::BULK:
       return usb::TRANSFER_TYPE_BULK;
     default:
       NOTREACHED();
       return usb::TRANSFER_TYPE_NONE;
   }
 }
 
-Direction ConvertDirectionToApi(const UsbEndpointDirection& input) {
+Direction ConvertDirectionToApi(const UsbTransferDirection& input) {
   switch (input) {
-    case device::USB_DIRECTION_INBOUND:
+    case UsbTransferDirection::INBOUND:
       return usb::DIRECTION_IN;
-    case device::USB_DIRECTION_OUTBOUND:
+    case UsbTransferDirection::OUTBOUND:
       return usb::DIRECTION_OUT;
     default:
       NOTREACHED();
       return usb::DIRECTION_NONE;
   }
 }
 
 SynchronizationType ConvertSynchronizationTypeToApi(
     const UsbSynchronizationType& input) {
   switch (input) {
@@ skipping 161 matching lines @@
 }
 
 UsbTransferFunction::~UsbTransferFunction() {
 }
 
 void UsbTransferFunction::OnCompleted(UsbTransferStatus status,
                                       scoped_refptr<net::IOBuffer> data,
                                       size_t length) {
   std::unique_ptr<base::DictionaryValue> transfer_info(
       new base::DictionaryValue());
-  transfer_info->SetInteger(kResultCodeKey, status);
+  transfer_info->SetInteger(kResultCodeKey, static_cast<int>(status));
 
   if (data) {
     transfer_info->Set(
         kDataKey, base::Value::CreateWithCopiedBuffer(data->data(), length));
   } else {
     transfer_info->Set(kDataKey, new base::Value(base::Value::Type::BINARY));
   }
 
-  if (status == device::USB_TRANSFER_COMPLETED) {
+  if (status == UsbTransferStatus::COMPLETED) {
     Respond(OneArgument(std::move(transfer_info)));
   } else {
     std::unique_ptr<base::ListValue> error_args(new base::ListValue());
     error_args->Append(std::move(transfer_info));
     // Using ErrorWithArguments is discouraged but required to provide the
     // detailed transfer info as the transfer may have partially succeeded.
     Respond(ErrorWithArguments(std::move(error_args),
                                ConvertTransferStatusToApi(status)));
   }
 }
@@ skipping 523 matching lines @@
       ControlTransfer::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
     return RespondNow(Error(kErrorNoConnection));
   }
 
   const ControlTransferInfo& transfer = parameters->transfer_info;
-  UsbEndpointDirection direction = device::USB_DIRECTION_INBOUND;
-  UsbDeviceHandle::TransferRequestType request_type;
-  UsbDeviceHandle::TransferRecipient recipient;
+  UsbTransferDirection direction = UsbTransferDirection::INBOUND;
+  UsbControlTransferType request_type;
+  UsbControlTransferRecipient recipient;
   size_t size = 0;
 
   if (!ConvertDirectionFromApi(transfer.direction, &direction)) {
     return RespondNow(Error(kErrorConvertDirection));
   }
 
   if (!ConvertRequestTypeFromApi(transfer.request_type, &request_type)) {
     return RespondNow(Error(kErrorConvertRequestType));
   }
 
@@ skipping 34 matching lines @@
       BulkTransfer::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
     return RespondNow(Error(kErrorNoConnection));
   }
 
   const GenericTransferInfo& transfer = parameters->transfer_info;
-  UsbEndpointDirection direction = device::USB_DIRECTION_INBOUND;
+  UsbTransferDirection direction = UsbTransferDirection::INBOUND;
   size_t size = 0;
 
   if (!ConvertDirectionFromApi(transfer.direction, &direction)) {
     return RespondNow(Error(kErrorConvertDirection));
   }
 
   if (!GetTransferSize(transfer, &size)) {
     return RespondNow(Error(kErrorInvalidTransferLength));
   }
 
@@ skipping 25 matching lines @@
       InterruptTransfer::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
     return RespondNow(Error(kErrorNoConnection));
   }
 
   const GenericTransferInfo& transfer = parameters->transfer_info;
-  UsbEndpointDirection direction = device::USB_DIRECTION_INBOUND;
+  UsbTransferDirection direction = UsbTransferDirection::INBOUND;
   size_t size = 0;
 
   if (!ConvertDirectionFromApi(transfer.direction, &direction)) {
     return RespondNow(Error(kErrorConvertDirection));
   }
 
   if (!GetTransferSize(transfer, &size)) {
     return RespondNow(Error(kErrorInvalidTransferLength));
   }
 
@@ skipping 27 matching lines @@
 
   scoped_refptr<UsbDeviceHandle> device_handle =
       GetDeviceHandle(parameters->handle);
   if (!device_handle.get()) {
     return RespondNow(Error(kErrorNoConnection));
   }
 
   const IsochronousTransferInfo& transfer = parameters->transfer_info;
   const GenericTransferInfo& generic_transfer = transfer.transfer_info;
   size_t size = 0;
-  UsbEndpointDirection direction = device::USB_DIRECTION_INBOUND;
+  UsbTransferDirection direction = UsbTransferDirection::INBOUND;
 
   if (!ConvertDirectionFromApi(generic_transfer.direction, &direction))
     return RespondNow(Error(kErrorConvertDirection));
 
   if (!GetTransferSize(generic_transfer, &size))
     return RespondNow(Error(kErrorInvalidTransferLength));
 
   if (transfer.packets < 0 || transfer.packets >= kMaxPackets)
     return RespondNow(Error(kErrorInvalidNumberOfPackets));
   size_t packets = transfer.packets;
 
   if (transfer.packet_length < 0 ||
       transfer.packet_length >= kMaxPacketLength) {
     return RespondNow(Error(kErrorInvalidPacketLength));
   }
 
   size_t total_length = packets * transfer.packet_length;
   if (packets > size || total_length > size)
     return RespondNow(Error(kErrorTransferLength));
   std::vector<uint32_t> packet_lengths(packets, transfer.packet_length);
 
   int timeout = generic_transfer.timeout ? *generic_transfer.timeout : 0;
   if (timeout < 0)
     return RespondNow(Error(kErrorInvalidTimeout));
 
-  if (direction == device::USB_DIRECTION_INBOUND) {
+  if (direction == UsbTransferDirection::INBOUND) {
     device_handle->IsochronousTransferIn(
         generic_transfer.endpoint, packet_lengths, timeout,
         base::Bind(&UsbIsochronousTransferFunction::OnCompleted, this));
   } else {
     scoped_refptr<net::IOBuffer> buffer = CreateBufferForTransfer(
         generic_transfer, direction, transfer.packets * transfer.packet_length);
     if (!buffer.get())
       return RespondNow(Error(kErrorMalformedParameters));
 
     device_handle->IsochronousTransferOut(
         generic_transfer.endpoint, buffer.get(), packet_lengths, timeout,
         base::Bind(&UsbIsochronousTransferFunction::OnCompleted, this));
   }
   return RespondLater();
 }
 
 void UsbIsochronousTransferFunction::OnCompleted(
     scoped_refptr<net::IOBuffer> data,
     const std::vector<UsbDeviceHandle::IsochronousPacket>& packets) {
   size_t length = std::accumulate(
       packets.begin(), packets.end(), 0,
       [](const size_t& a, const UsbDeviceHandle::IsochronousPacket& packet) {
         return a + packet.transferred_length;
       });
   std::vector<char> buffer;
   buffer.reserve(length);
 
-  UsbTransferStatus status = device::USB_TRANSFER_COMPLETED;
+  UsbTransferStatus status = UsbTransferStatus::COMPLETED;
   const char* data_ptr = data ? data->data() : nullptr;
   for (const auto& packet : packets) {
     // Capture the error status of the first unsuccessful packet.
-    if (status == device::USB_TRANSFER_COMPLETED &&
-        packet.status != device::USB_TRANSFER_COMPLETED) {
+    if (status == UsbTransferStatus::COMPLETED &&
+        packet.status != UsbTransferStatus::COMPLETED) {
       status = packet.status;
     }
 
     if (data) {
       buffer.insert(buffer.end(), data_ptr,
                     data_ptr + packet.transferred_length);
       data_ptr += packet.length;
     }
   }
 
   std::unique_ptr<base::DictionaryValue> transfer_info(
       new base::DictionaryValue());
-  transfer_info->SetInteger(kResultCodeKey, status);
+  transfer_info->SetInteger(kResultCodeKey, static_cast<int>(status));
   transfer_info->Set(kDataKey, new base::Value(std::move(buffer)));
-  if (status == device::USB_TRANSFER_COMPLETED) {
+  if (status == UsbTransferStatus::COMPLETED) {
     Respond(OneArgument(std::move(transfer_info)));
   } else {
     std::unique_ptr<base::ListValue> error_args(new base::ListValue());
     error_args->Append(std::move(transfer_info));
     // Using ErrorWithArguments is discouraged but required to provide the
     // detailed transfer info as the transfer may have partially succeeded.
     Respond(ErrorWithArguments(std::move(error_args),
                                ConvertTransferStatusToApi(status)));
   }
 }
@@ skipping 32 matching lines @@
 
     std::unique_ptr<base::ListValue> error_args(new base::ListValue());
     error_args->AppendBoolean(false);
     // Using ErrorWithArguments is discouraged but required to maintain
     // compatibility with existing applications.
     Respond(ErrorWithArguments(std::move(error_args), kErrorResetDevice));
   }
 }
 
 }  // namespace extensions