Change mojo enums to be scoped enums in the generated C++ bindings.

content/renderer/usb/type_converters.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 "content/renderer/usb/type_converters.h"
 
 #include <stddef.h>
 
 #include "base/logging.h"
 
 namespace mojo {
 
 // static
 blink::WebUSBDevice::TransferDirection
 TypeConverter<blink::WebUSBDevice::TransferDirection,
               device::usb::TransferDirection>::
     Convert(const device::usb::TransferDirection& direction) {
   switch (direction) {
-    case device::usb::TRANSFER_DIRECTION_IN:
+    case device::usb::TransferDirection::INBOUND:
       return blink::WebUSBDevice::TransferDirection::In;
-    case device::usb::TRANSFER_DIRECTION_OUT:
+    case device::usb::TransferDirection::OUTBOUND:
       return blink::WebUSBDevice::TransferDirection::Out;
     default:
       NOTREACHED();
       return blink::WebUSBDevice::TransferDirection::In;
   }
 }
 
 // static
 device::usb::TransferDirection
 TypeConverter<device::usb::TransferDirection,
               blink::WebUSBDevice::TransferDirection>::
     Convert(const blink::WebUSBDevice::TransferDirection& direction) {
   switch (direction) {
     case blink::WebUSBDevice::TransferDirection::In:
-      return device::usb::TRANSFER_DIRECTION_IN;
+      return device::usb::TransferDirection::INBOUND;
     case blink::WebUSBDevice::TransferDirection::Out:
-      return device::usb::TRANSFER_DIRECTION_OUT;
+      return device::usb::TransferDirection::OUTBOUND;
     default:
       NOTREACHED();
-      return device::usb::TRANSFER_DIRECTION_IN;
+      return device::usb::TransferDirection::INBOUND;
   }
 }
 
 // static
 device::usb::ControlTransferType
 TypeConverter<device::usb::ControlTransferType,
               blink::WebUSBDevice::RequestType>::
     Convert(const blink::WebUSBDevice::RequestType& direction) {
   switch (direction) {
     case blink::WebUSBDevice::RequestType::Standard:
-      return device::usb::CONTROL_TRANSFER_TYPE_STANDARD;
+      return device::usb::ControlTransferType::STANDARD;
     case blink::WebUSBDevice::RequestType::Class:
-      return device::usb::CONTROL_TRANSFER_TYPE_CLASS;
+      return device::usb::ControlTransferType::CLASS;
     case blink::WebUSBDevice::RequestType::Vendor:
-      return device::usb::CONTROL_TRANSFER_TYPE_VENDOR;
+      return device::usb::ControlTransferType::VENDOR;
     default:
       NOTREACHED();
-      return device::usb::CONTROL_TRANSFER_TYPE_STANDARD;
+      return device::usb::ControlTransferType::STANDARD;
   }
 }
 
 // static
 device::usb::ControlTransferRecipient
 TypeConverter<device::usb::ControlTransferRecipient,
               blink::WebUSBDevice::RequestRecipient>::
     Convert(const blink::WebUSBDevice::RequestRecipient& direction) {
   switch (direction) {
     case blink::WebUSBDevice::RequestRecipient::Device:
-      return device::usb::CONTROL_TRANSFER_RECIPIENT_DEVICE;
+      return device::usb::ControlTransferRecipient::DEVICE;
     case blink::WebUSBDevice::RequestRecipient::Interface:
-      return device::usb::CONTROL_TRANSFER_RECIPIENT_INTERFACE;
+      return device::usb::ControlTransferRecipient::INTERFACE;
     case blink::WebUSBDevice::RequestRecipient::Endpoint:
-      return device::usb::CONTROL_TRANSFER_RECIPIENT_ENDPOINT;
+      return device::usb::ControlTransferRecipient::ENDPOINT;
     case blink::WebUSBDevice::RequestRecipient::Other:
-      return device::usb::CONTROL_TRANSFER_RECIPIENT_OTHER;
+      return device::usb::ControlTransferRecipient::OTHER;
     default:
       NOTREACHED();
-      return device::usb::CONTROL_TRANSFER_RECIPIENT_DEVICE;
+      return device::usb::ControlTransferRecipient::DEVICE;
   }
 }
 
 // static
 device::usb::ControlTransferParamsPtr
 TypeConverter<device::usb::ControlTransferParamsPtr,
               blink::WebUSBDevice::ControlTransferParameters>::
     Convert(const blink::WebUSBDevice::ControlTransferParameters& parameters) {
   device::usb::ControlTransferParamsPtr params =
       device::usb::ControlTransferParams::New();
   params->type =
       mojo::ConvertTo<device::usb::ControlTransferType>(parameters.type);
   params->recipient = mojo::ConvertTo<device::usb::ControlTransferRecipient>(
       parameters.recipient);
   params->request = parameters.request;
   params->value = parameters.value;
   params->index = parameters.index;
   return params;
 }
 
 // static
 blink::WebUSBDeviceInfo::Endpoint::Type TypeConverter<
     blink::WebUSBDeviceInfo::Endpoint::Type,
     device::usb::EndpointType>::Convert(const device::usb::EndpointType&
                                             endpoint_type) {
   switch (endpoint_type) {
-    case device::usb::ENDPOINT_TYPE_BULK:
+    case device::usb::EndpointType::BULK:
       return blink::WebUSBDeviceInfo::Endpoint::Type::Bulk;
-    case device::usb::ENDPOINT_TYPE_INTERRUPT:
+    case device::usb::EndpointType::INTERRUPT:
       return blink::WebUSBDeviceInfo::Endpoint::Type::Interrupt;
-    case device::usb::ENDPOINT_TYPE_ISOCHRONOUS:
+    case device::usb::EndpointType::ISOCHRONOUS:
       return blink::WebUSBDeviceInfo::Endpoint::Type::Isochronous;
     default:
       NOTREACHED();
       return blink::WebUSBDeviceInfo::Endpoint::Type::Bulk;
   }
 }
 
 // static
 blink::WebUSBDeviceInfo::Endpoint
 TypeConverter<blink::WebUSBDeviceInfo::Endpoint, device::usb::EndpointInfoPtr>::
@@ skipping 131 matching lines @@
   options->filters = mojo::Array<device::usb::DeviceFilterPtr>::New(
       web_options.filters.size());
   for (size_t i = 0; i < web_options.filters.size(); ++i) {
     options->filters[i] =
         device::usb::DeviceFilter::From(web_options.filters[i]);
   }
   return options;
 }
 
 }  // namespace mojo