Use Mojo enum types in the C++ USB interface

device/usb/webusb_descriptors.cc

 // Copyright 2015 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/webusb_descriptors.h"
 
 #include <stddef.h>
 
 #include <iterator>
 #include <map>
@@ skipping 174 matching lines @@
 
   callback.Run(std::move(allowed_origins), landing_page);
 }
 
 void OnReadUrlDescriptor(std::map<uint8_t, GURL>* url_map,
                          uint8_t index,
                          const base::Closure& callback,
                          UsbTransferStatus status,
                          scoped_refptr<net::IOBuffer> buffer,
                          size_t length) {
-  if (status != USB_TRANSFER_COMPLETED) {
+  if (status != UsbTransferStatus::COMPLETED) {
     USB_LOG(EVENT) << "Failed to read WebUSB URL descriptor: " << index;
     callback.Run();
     return;
   }
 
   GURL url;
   if (ParseWebUsbUrlDescriptor(
           std::vector<uint8_t>(buffer->data(), buffer->data() + length),
           &url)) {
     (*url_map)[index] = url;
   }
   callback.Run();
 }
 
 // Reads the descriptor with |index| from the device, adds the value to
 // |url_map| and then runs |callback|.
 void ReadUrlDescriptor(scoped_refptr<UsbDeviceHandle> device_handle,
                        uint8_t vendor_code,
                        std::map<uint8_t, GURL>* url_map,
                        uint8_t index,
                        const base::Closure& callback) {
   scoped_refptr<IOBufferWithSize> buffer = new IOBufferWithSize(255);
   device_handle->ControlTransfer(
-      USB_DIRECTION_INBOUND, UsbDeviceHandle::VENDOR, UsbDeviceHandle::DEVICE,
-      vendor_code, index, kGetUrlRequest, buffer, buffer->size(),
-      kControlTransferTimeout,
+      UsbTransferDirection::INBOUND, UsbControlTransferType::VENDOR,
+      UsbControlTransferRecipient::DEVICE, vendor_code, index, kGetUrlRequest,
+      buffer, buffer->size(), kControlTransferTimeout,
       base::Bind(&OnReadUrlDescriptor, url_map, index, callback));
 }
 
 // Reads URL descriptors from the device so that it can fill |allowed_origins|
 // with the GURLs matching the indicies already collected.
 void ReadUrlDescriptors(scoped_refptr<UsbDeviceHandle> device_handle,
                         uint8_t vendor_code,
                         uint8_t landing_page_id,
                         const ReadWebUsbDescriptorsCallback& callback,
                         std::unique_ptr<WebUsbAllowedOrigins> allowed_origins) {
@@ skipping 26 matching lines @@
   for (uint8_t index : to_request) {
     ReadUrlDescriptor(device_handle, vendor_code, url_map_ptr, index, barrier);
   }
 }
 
 void OnReadWebUsbAllowedOrigins(
     const ReadWebUsbAllowedOriginsCallback& callback,
     UsbTransferStatus status,
     scoped_refptr<net::IOBuffer> buffer,
     size_t length) {
-  if (status != USB_TRANSFER_COMPLETED) {
+  if (status != UsbTransferStatus::COMPLETED) {
     USB_LOG(EVENT) << "Failed to read WebUSB allowed origins.";
     callback.Run(nullptr);
     return;
   }
 
   std::unique_ptr<WebUsbAllowedOrigins> allowed_origins(
       new WebUsbAllowedOrigins());
   if (allowed_origins->Parse(
           std::vector<uint8_t>(buffer->data(), buffer->data() + length))) {
     callback.Run(std::move(allowed_origins));
   } else {
     callback.Run(nullptr);
   }
 }
 
 void OnReadWebUsbAllowedOriginsHeader(
     scoped_refptr<UsbDeviceHandle> device_handle,
     const ReadWebUsbAllowedOriginsCallback& callback,
     uint8_t vendor_code,
     UsbTransferStatus status,
     scoped_refptr<net::IOBuffer> buffer,
     size_t length) {
-  if (status != USB_TRANSFER_COMPLETED || length != 4) {
+  if (status != UsbTransferStatus::COMPLETED || length != 4) {
     USB_LOG(EVENT) << "Failed to read WebUSB allowed origins header.";
     callback.Run(nullptr);
     return;
   }
 
   const uint8_t* data = reinterpret_cast<uint8_t*>(buffer->data());
   uint16_t new_length = data[2] | (data[3] << 8);
   scoped_refptr<IOBufferWithSize> new_buffer = new IOBufferWithSize(new_length);
   device_handle->ControlTransfer(
-      USB_DIRECTION_INBOUND, UsbDeviceHandle::VENDOR, UsbDeviceHandle::DEVICE,
-      vendor_code, 0, kGetAllowedOriginsRequest, new_buffer, new_buffer->size(),
+      UsbTransferDirection::INBOUND, UsbControlTransferType::VENDOR,
+      UsbControlTransferRecipient::DEVICE, vendor_code, 0,
+      kGetAllowedOriginsRequest, new_buffer, new_buffer->size(),
       kControlTransferTimeout,
       base::Bind(&OnReadWebUsbAllowedOrigins, callback));
 }
 
 void ReadWebUsbAllowedOrigins(
     scoped_refptr<UsbDeviceHandle> device_handle,
     uint8_t vendor_code,
     const ReadWebUsbAllowedOriginsCallback& callback) {
   scoped_refptr<IOBufferWithSize> buffer = new IOBufferWithSize(4);
   device_handle->ControlTransfer(
-      USB_DIRECTION_INBOUND, UsbDeviceHandle::VENDOR, UsbDeviceHandle::DEVICE,
-      vendor_code, 0, kGetAllowedOriginsRequest, buffer, buffer->size(),
+      UsbTransferDirection::INBOUND, UsbControlTransferType::VENDOR,
+      UsbControlTransferRecipient::DEVICE, vendor_code, 0,
+      kGetAllowedOriginsRequest, buffer, buffer->size(),
       kControlTransferTimeout,
       base::Bind(&OnReadWebUsbAllowedOriginsHeader, device_handle, callback,
                  vendor_code));
 }
 
 void OnReadBosDescriptor(scoped_refptr<UsbDeviceHandle> device_handle,
                          const ReadWebUsbDescriptorsCallback& callback,
                          UsbTransferStatus status,
                          scoped_refptr<net::IOBuffer> buffer,
                          size_t length) {
-  if (status != USB_TRANSFER_COMPLETED) {
+  if (status != UsbTransferStatus::COMPLETED) {
     USB_LOG(EVENT) << "Failed to read BOS descriptor.";
     callback.Run(nullptr, GURL());
     return;
   }
 
   WebUsbPlatformCapabilityDescriptor descriptor;
   if (!descriptor.ParseFromBosDescriptor(
           std::vector<uint8_t>(buffer->data(), buffer->data() + length))) {
     callback.Run(nullptr, GURL());
     return;
   }
 
   ReadWebUsbAllowedOrigins(
       device_handle, descriptor.vendor_code,
       base::Bind(&ReadUrlDescriptors, device_handle, descriptor.vendor_code,
                  descriptor.landing_page_id, callback));
 }
 
 void OnReadBosDescriptorHeader(scoped_refptr<UsbDeviceHandle> device_handle,
                                const ReadWebUsbDescriptorsCallback& callback,
                                UsbTransferStatus status,
                                scoped_refptr<net::IOBuffer> buffer,
                                size_t length) {
-  if (status != USB_TRANSFER_COMPLETED || length != 5) {
+  if (status != UsbTransferStatus::COMPLETED || length != 5) {
     USB_LOG(EVENT) << "Failed to read BOS descriptor header.";
     callback.Run(nullptr, GURL());
     return;
   }
 
   const uint8_t* data = reinterpret_cast<uint8_t*>(buffer->data());
   uint16_t new_length = data[2] | (data[3] << 8);
   scoped_refptr<IOBufferWithSize> new_buffer = new IOBufferWithSize(new_length);
   device_handle->ControlTransfer(
-      USB_DIRECTION_INBOUND, UsbDeviceHandle::STANDARD, UsbDeviceHandle::DEVICE,
-      kGetDescriptorRequest, kBosDescriptorType << 8, 0, new_buffer,
-      new_buffer->size(), kControlTransferTimeout,
+      UsbTransferDirection::INBOUND, UsbControlTransferType::STANDARD,
+      UsbControlTransferRecipient::DEVICE, kGetDescriptorRequest,
+      kBosDescriptorType << 8, 0, new_buffer, new_buffer->size(),
+      kControlTransferTimeout,
       base::Bind(&OnReadBosDescriptor, device_handle, callback));
 }
 
 }  // namespace
 
 WebUsbFunctionSubset::WebUsbFunctionSubset() : first_interface(0) {}
 
 WebUsbFunctionSubset::WebUsbFunctionSubset(const WebUsbFunctionSubset& other) =
     default;
 
@@ skipping 189 matching lines @@
     return false;
   }
 
   return true;
 }
 
 void ReadWebUsbDescriptors(scoped_refptr<UsbDeviceHandle> device_handle,
                            const ReadWebUsbDescriptorsCallback& callback) {
   scoped_refptr<IOBufferWithSize> buffer = new IOBufferWithSize(5);
   device_handle->ControlTransfer(
-      USB_DIRECTION_INBOUND, UsbDeviceHandle::STANDARD, UsbDeviceHandle::DEVICE,
-      kGetDescriptorRequest, kBosDescriptorType << 8, 0, buffer, buffer->size(),
+      UsbTransferDirection::INBOUND, UsbControlTransferType::STANDARD,
+      UsbControlTransferRecipient::DEVICE, kGetDescriptorRequest,
+      kBosDescriptorType << 8, 0, buffer, buffer->size(),
       kControlTransferTimeout,
       base::Bind(&OnReadBosDescriptorHeader, device_handle, callback));
 }
 
 bool FindInWebUsbAllowedOrigins(
     const device::WebUsbAllowedOrigins* allowed_origins,
     const GURL& origin,
     base::Optional<uint8_t> config_value,
     base::Optional<uint8_t> first_interface) {
   if (!allowed_origins)
@@ skipping 15 matching lines @@
 
       if (base::ContainsValue(function.origins, origin))
         return true;
     }
   }
 
   return false;
 }
 
 }  // namespace device