Use Mojo enum types in the C++ USB interface

device/usb/usb_descriptors.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 "device/usb/usb_descriptors.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 79 matching lines @@
                << desc->configurations.size() << ".";
     callback.Run(nullptr);
   }
 }
 
 void OnReadConfigDescriptor(UsbDeviceDescriptor* desc,
                             const base::Closure& closure,
                             UsbTransferStatus status,
                             scoped_refptr<IOBuffer> buffer,
                             size_t length) {
-  if (status == USB_TRANSFER_COMPLETED) {
+  if (status == UsbTransferStatus::COMPLETED) {
     if (!desc->Parse(
             std::vector<uint8_t>(buffer->data(), buffer->data() + length))) {
       LOG(ERROR) << "Failed to parse configuration descriptor.";
     }
   } else {
     LOG(ERROR) << "Failed to read configuration descriptor.";
   }
   closure.Run();
 }
 
 void OnReadConfigDescriptorHeader(scoped_refptr<UsbDeviceHandle> device_handle,
                                   UsbDeviceDescriptor* desc,
                                   uint8_t index,
                                   const base::Closure& closure,
                                   UsbTransferStatus status,
                                   scoped_refptr<IOBuffer> header,
                                   size_t length) {
-  if (status == USB_TRANSFER_COMPLETED && length == 4) {
+  if (status == UsbTransferStatus::COMPLETED && length == 4) {
     const uint8_t* data = reinterpret_cast<const uint8_t*>(header->data());
     uint16_t total_length = data[2] | data[3] << 8;
     scoped_refptr<IOBuffer> buffer = new IOBuffer(total_length);
     device_handle->ControlTransfer(
-        USB_DIRECTION_INBOUND, UsbDeviceHandle::STANDARD,
-        UsbDeviceHandle::DEVICE, kGetDescriptorRequest,
+        UsbTransferDirection::INBOUND, UsbControlTransferType::STANDARD,
+        UsbControlTransferRecipient::DEVICE, kGetDescriptorRequest,
         kConfigurationDescriptorType << 8 | index, 0, buffer, total_length,
         kControlTransferTimeout,
         base::Bind(&OnReadConfigDescriptor, desc, closure));
   } else {
     LOG(ERROR) << "Failed to read length for configuration "
                << static_cast<int>(index) << ".";
     closure.Run();
   }
 }
 
 void OnReadDeviceDescriptor(
     scoped_refptr<UsbDeviceHandle> device_handle,
     const base::Callback<void(std::unique_ptr<UsbDeviceDescriptor>)>& callback,
     UsbTransferStatus status,
     scoped_refptr<IOBuffer> buffer,
     size_t length) {
-  if (status != USB_TRANSFER_COMPLETED) {
+  if (status != UsbTransferStatus::COMPLETED) {
     LOG(ERROR) << "Failed to read device descriptor.";
     callback.Run(nullptr);
     return;
   }
 
   std::unique_ptr<UsbDeviceDescriptor> desc(new UsbDeviceDescriptor());
   if (!desc->Parse(
           std::vector<uint8_t>(buffer->data(), buffer->data() + length))) {
     LOG(ERROR) << "Device descriptor parsing error.";
     callback.Run(nullptr);
     return;
   }
 
   if (desc->num_configurations == 0) {
     callback.Run(std::move(desc));
     return;
   }
 
   uint8_t num_configurations = desc->num_configurations;
   UsbDeviceDescriptor* desc_ptr = desc.get();
   base::Closure closure = base::BarrierClosure(
       num_configurations,
       base::Bind(OnDoneReadingConfigDescriptors, device_handle,
                  base::Passed(&desc), callback));
   for (uint8_t i = 0; i < num_configurations; ++i) {
     scoped_refptr<IOBufferWithSize> header = new IOBufferWithSize(4);
     device_handle->ControlTransfer(
-        USB_DIRECTION_INBOUND, UsbDeviceHandle::STANDARD,
-        UsbDeviceHandle::DEVICE, kGetDescriptorRequest,
+        UsbTransferDirection::INBOUND, UsbControlTransferType::STANDARD,
+        UsbControlTransferRecipient::DEVICE, kGetDescriptorRequest,
         kConfigurationDescriptorType << 8 | i, 0, header, header->size(),
         kControlTransferTimeout,
         base::Bind(&OnReadConfigDescriptorHeader, device_handle, desc_ptr, i,
                    closure));
   }
 }
 
 void StoreStringDescriptor(IndexMap::iterator it,
                            const base::Closure& callback,
                            const base::string16& string) {
   it->second = string;
   callback.Run();
 }
 
 void OnReadStringDescriptor(
     const base::Callback<void(const base::string16&)>& callback,
     UsbTransferStatus status,
     scoped_refptr<IOBuffer> buffer,
     size_t length) {
   base::string16 string;
-  if (status == USB_TRANSFER_COMPLETED &&
+  if (status == UsbTransferStatus::COMPLETED &&
       ParseUsbStringDescriptor(
           std::vector<uint8_t>(buffer->data(), buffer->data() + length),
           &string)) {
     callback.Run(string);
   } else {
     callback.Run(base::string16());
   }
 }
 
 void ReadStringDescriptor(
     scoped_refptr<UsbDeviceHandle> device_handle,
     uint8_t index,
     uint16_t language_id,
     const base::Callback<void(const base::string16&)>& callback) {
   scoped_refptr<IOBufferWithSize> buffer = new IOBufferWithSize(255);
   device_handle->ControlTransfer(
-      USB_DIRECTION_INBOUND, UsbDeviceHandle::STANDARD, UsbDeviceHandle::DEVICE,
-      kGetDescriptorRequest, kStringDescriptorType << 8 | index, language_id,
-      buffer, buffer->size(), kControlTransferTimeout,
-      base::Bind(&OnReadStringDescriptor, callback));
+      UsbTransferDirection::INBOUND, UsbControlTransferType::STANDARD,
+      UsbControlTransferRecipient::DEVICE, kGetDescriptorRequest,
+      kStringDescriptorType << 8 | index, language_id, buffer, buffer->size(),
+      kControlTransferTimeout, base::Bind(&OnReadStringDescriptor, callback));
 }
 
 void OnReadLanguageIds(scoped_refptr<UsbDeviceHandle> device_handle,
                        IndexMapPtr index_map,
                        const base::Callback<void(IndexMapPtr)>& callback,
                        const base::string16& languages) {
   // Default to English unless the device provides a language and then just pick
   // the first one.
   uint16_t language_id = languages.empty() ? 0x0409 : languages[0];
 
@@ skipping 25 matching lines @@
 UsbEndpointDescriptor::UsbEndpointDescriptor(uint8_t address,
                                              uint8_t attributes,
                                              uint16_t maximum_packet_size,
                                              uint8_t polling_interval)
     : address(address),
       maximum_packet_size(maximum_packet_size),
       polling_interval(polling_interval) {
   // These fields are defined in Table 9-24 of the USB 3.1 Specification.
   switch (address & 0x80) {
     case 0x00:
-      direction = USB_DIRECTION_OUTBOUND;
+      direction = UsbTransferDirection::OUTBOUND;
       break;
     case 0x80:
-      direction = USB_DIRECTION_INBOUND;
+      direction = UsbTransferDirection::INBOUND;
       break;
   }
   switch (attributes & 0x03) {
     case 0x00:
-      transfer_type = USB_TRANSFER_CONTROL;
+      transfer_type = UsbTransferType::CONTROL;
       break;
     case 0x01:
-      transfer_type = USB_TRANSFER_ISOCHRONOUS;
+      transfer_type = UsbTransferType::ISOCHRONOUS;
       break;
     case 0x02:
-      transfer_type = USB_TRANSFER_BULK;
+      transfer_type = UsbTransferType::BULK;
       break;
     case 0x03:
-      transfer_type = USB_TRANSFER_INTERRUPT;
+      transfer_type = UsbTransferType::INTERRUPT;
       break;
   }
   switch (attributes & 0x0F) {
     // Isochronous endpoints only.
     case 0x05:
       synchronization_type = USB_SYNCHRONIZATION_ASYNCHRONOUS;
       break;
     case 0x09:
       synchronization_type = USB_SYNCHRONIZATION_ADAPTIVE;
       break;
@@ skipping 208 matching lines @@
 
   return true;
 }
 
 void ReadUsbDescriptors(scoped_refptr<UsbDeviceHandle> device_handle,
                         const base::Callback<void(
                             std::unique_ptr<UsbDeviceDescriptor>)>& callback) {
   scoped_refptr<IOBufferWithSize> buffer =
       new IOBufferWithSize(kDeviceDescriptorLength);
   device_handle->ControlTransfer(
-      USB_DIRECTION_INBOUND, UsbDeviceHandle::STANDARD, UsbDeviceHandle::DEVICE,
-      kGetDescriptorRequest, kDeviceDescriptorType << 8, 0, buffer,
-      buffer->size(), kControlTransferTimeout,
+      UsbTransferDirection::INBOUND, UsbControlTransferType::STANDARD,
+      UsbControlTransferRecipient::DEVICE, kGetDescriptorRequest,
+      kDeviceDescriptorType << 8, 0, buffer, buffer->size(),
+      kControlTransferTimeout,
       base::Bind(&OnReadDeviceDescriptor, device_handle, callback));
 }
 
 bool ParseUsbStringDescriptor(const std::vector<uint8_t>& descriptor,
                               base::string16* output) {
   if (descriptor.size() < 2 || descriptor[1] != kStringDescriptorType)
     return false;
 
   // Let the device return a buffer larger than the actual string but prefer the
   // length reported inside the descriptor.
@@ skipping 19 matching lines @@
     callback.Run(std::move(index_map));
     return;
   }
 
   ReadStringDescriptor(device_handle, 0, 0,
                        base::Bind(&OnReadLanguageIds, device_handle,
                                   base::Passed(&index_map), callback));
 }
 
 }  // namespace device