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

device/devices_app/usb/device_impl.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/devices_app/usb/device_impl.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 77 matching lines @@
   if (allowed) {
     scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(length);
     device_handle->ControlTransfer(
         USB_DIRECTION_INBOUND,
         mojo::ConvertTo<UsbDeviceHandle::TransferRequestType>(params->type),
         mojo::ConvertTo<UsbDeviceHandle::TransferRecipient>(params->recipient),
         params->request, params->value, params->index, buffer, length, timeout,
         base::Bind(&OnTransferIn, base::Passed(&callback)));
   } else {
     mojo::Array<uint8_t> data;
-    callback->Run(TRANSFER_STATUS_PERMISSION_DENIED, std::move(data));
+    callback->Run(TransferStatus::PERMISSION_DENIED, std::move(data));
   }
 }
 
 void OnTransferOut(scoped_ptr<MojoTransferOutCallback> callback,
                    UsbTransferStatus status,
                    scoped_refptr<net::IOBuffer> buffer,
                    size_t buffer_size) {
   callback->Run(mojo::ConvertTo<TransferStatus>(status));
 }
 
 void OnControlTransferOutPermissionCheckComplete(
     scoped_refptr<UsbDeviceHandle> device_handle,
     ControlTransferParamsPtr params,
     mojo::Array<uint8_t> data,
     int timeout,
     scoped_ptr<Device::ControlTransferOutCallback> callback,
     bool allowed) {
   if (allowed) {
     scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(data.size());
     const std::vector<uint8_t>& storage = data.storage();
     std::copy(storage.begin(), storage.end(), buffer->data());
     device_handle->ControlTransfer(
         USB_DIRECTION_OUTBOUND,
         mojo::ConvertTo<UsbDeviceHandle::TransferRequestType>(params->type),
         mojo::ConvertTo<UsbDeviceHandle::TransferRecipient>(params->recipient),
         params->request, params->value, params->index, buffer, data.size(),
         timeout, base::Bind(&OnTransferOut, base::Passed(&callback)));
   } else {
-    callback->Run(TRANSFER_STATUS_PERMISSION_DENIED);
+    callback->Run(TransferStatus::PERMISSION_DENIED);
   }
 }
 
 void OnIsochronousTransferIn(
     scoped_ptr<Device::IsochronousTransferInCallback> callback,
     uint32_t packet_size,
     UsbTransferStatus status,
     scoped_refptr<net::IOBuffer> buffer,
     size_t buffer_size) {
   size_t num_packets = buffer_size / packet_size;
@@ skipping 44 matching lines @@
   device_handle_ = nullptr;
 }
 
 void DeviceImpl::HasControlTransferPermission(
     ControlTransferRecipient recipient,
     uint16_t index,
     const base::Callback<void(bool)>& callback) {
   DCHECK(device_handle_);
   const UsbConfigDescriptor* config = device_->GetActiveConfiguration();
 
-  if (recipient == CONTROL_TRANSFER_RECIPIENT_INTERFACE ||
-      recipient == CONTROL_TRANSFER_RECIPIENT_ENDPOINT) {
+  if (recipient == ControlTransferRecipient::INTERFACE ||
+      recipient == ControlTransferRecipient::ENDPOINT) {
     if (!config) {
       callback.Run(false);
       return;
     }
 
     uint8_t interface_number = index & 0xff;
-    if (recipient == CONTROL_TRANSFER_RECIPIENT_ENDPOINT) {
+    if (recipient == ControlTransferRecipient::ENDPOINT) {
       if (!device_handle_->FindInterfaceByEndpoint(index & 0xff,
                                                    &interface_number)) {
         callback.Run(false);
         return;
       }
     }
 
     permission_provider_->HasInterfacePermission(
         interface_number, config->configuration_value,
         DeviceInfo::From(*device_), callback);
   } else if (config) {
     permission_provider_->HasConfigurationPermission(
         config->configuration_value, DeviceInfo::From(*device_), callback);
   } else {
     // Client must already have device permission to have gotten this far.
     callback.Run(true);
   }
 }
 
 void DeviceImpl::OnOpen(const OpenCallback& callback,
                         scoped_refptr<UsbDeviceHandle> handle) {
   device_handle_ = handle;
-  callback.Run(handle ? OPEN_DEVICE_ERROR_OK : OPEN_DEVICE_ERROR_ACCESS_DENIED);
+  callback.Run(handle ? OpenDeviceError::OK : OpenDeviceError::ACCESS_DENIED);
 }
 
 void DeviceImpl::GetDeviceInfo(const GetDeviceInfoCallback& callback) {
   callback.Run(DeviceInfo::From(*device_));
 }
 
 void DeviceImpl::GetConfiguration(const GetConfigurationCallback& callback) {
   const UsbConfigDescriptor* config = device_->GetActiveConfiguration();
   callback.Run(config ? config->configuration_value : 0);
 }
@@ skipping 84 matching lines @@
   }
 
   device_handle_->ClearHalt(endpoint, WrapMojoCallback(callback));
 }
 
 void DeviceImpl::ControlTransferIn(ControlTransferParamsPtr params,
                                    uint32_t length,
                                    uint32_t timeout,
                                    const ControlTransferInCallback& callback) {
   if (!device_handle_) {
-    callback.Run(TRANSFER_STATUS_ERROR, mojo::Array<uint8_t>());
+    callback.Run(TransferStatus::TRANSFER_ERROR, mojo::Array<uint8_t>());
     return;
   }
 
   auto callback_ptr = make_scoped_ptr(new ControlTransferInCallback(callback));
   ControlTransferRecipient recipient = params->recipient;
   uint16_t index = params->index;
   HasControlTransferPermission(
       recipient, index,
       base::Bind(&OnControlTransferInPermissionCheckComplete, device_handle_,
                  base::Passed(&params), length, timeout,
                  base::Passed(&callback_ptr)));
 }
 
 void DeviceImpl::ControlTransferOut(
     ControlTransferParamsPtr params,
     mojo::Array<uint8_t> data,
     uint32_t timeout,
     const ControlTransferOutCallback& callback) {
   if (!device_handle_) {
-    callback.Run(TRANSFER_STATUS_ERROR);
+    callback.Run(TransferStatus::TRANSFER_ERROR);
     return;
   }
 
   auto callback_ptr = make_scoped_ptr(new ControlTransferOutCallback(callback));
   ControlTransferRecipient recipient = params->recipient;
   uint16_t index = params->index;
   HasControlTransferPermission(
       recipient, index,
       base::Bind(&OnControlTransferOutPermissionCheckComplete, device_handle_,
                  base::Passed(&params), base::Passed(&data), timeout,
                  base::Passed(&callback_ptr)));
 }
 
 void DeviceImpl::GenericTransferIn(uint8_t endpoint_number,
                                    uint32_t length,
                                    uint32_t timeout,
                                    const GenericTransferInCallback& callback) {
   if (!device_handle_) {
-    callback.Run(TRANSFER_STATUS_ERROR, mojo::Array<uint8_t>());
+    callback.Run(TransferStatus::TRANSFER_ERROR, mojo::Array<uint8_t>());
     return;
   }
 
   auto callback_ptr = make_scoped_ptr(new GenericTransferInCallback(callback));
   uint8_t endpoint_address = endpoint_number | 0x80;
   scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(length);
   device_handle_->GenericTransfer(
       USB_DIRECTION_INBOUND, endpoint_address, buffer, length, timeout,
       base::Bind(&OnTransferIn, base::Passed(&callback_ptr)));
 }
 
 void DeviceImpl::GenericTransferOut(
     uint8_t endpoint_number,
     mojo::Array<uint8_t> data,
     uint32_t timeout,
     const GenericTransferOutCallback& callback) {
   if (!device_handle_) {
-    callback.Run(TRANSFER_STATUS_ERROR);
+    callback.Run(TransferStatus::TRANSFER_ERROR);
     return;
   }
 
   auto callback_ptr = make_scoped_ptr(new GenericTransferOutCallback(callback));
   uint8_t endpoint_address = endpoint_number;
   scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(data.size());
   const std::vector<uint8_t>& storage = data.storage();
   std::copy(storage.begin(), storage.end(), buffer->data());
   device_handle_->GenericTransfer(
       USB_DIRECTION_OUTBOUND, endpoint_address, buffer, data.size(), timeout,
       base::Bind(&OnTransferOut, base::Passed(&callback_ptr)));
 }
 
 void DeviceImpl::IsochronousTransferIn(
     uint8_t endpoint_number,
     uint32_t num_packets,
     uint32_t packet_length,
     uint32_t timeout,
     const IsochronousTransferInCallback& callback) {
   if (!device_handle_) {
-    callback.Run(TRANSFER_STATUS_ERROR, mojo::Array<mojo::Array<uint8_t>>());
+    callback.Run(TransferStatus::TRANSFER_ERROR,
+                 mojo::Array<mojo::Array<uint8_t>>());
     return;
   }
 
   auto callback_ptr =
       make_scoped_ptr(new IsochronousTransferInCallback(callback));
   uint8_t endpoint_address = endpoint_number | 0x80;
   size_t transfer_size = static_cast<size_t>(num_packets) * packet_length;
   scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(transfer_size);
   device_handle_->IsochronousTransfer(
       USB_DIRECTION_INBOUND, endpoint_address, buffer, transfer_size,
       num_packets, packet_length, timeout,
       base::Bind(&OnIsochronousTransferIn, base::Passed(&callback_ptr),
                  packet_length));
 }
 
 void DeviceImpl::IsochronousTransferOut(
     uint8_t endpoint_number,
     mojo::Array<mojo::Array<uint8_t>> packets,
     uint32_t timeout,
     const IsochronousTransferOutCallback& callback) {
   if (!device_handle_) {
-    callback.Run(TRANSFER_STATUS_ERROR);
+    callback.Run(TransferStatus::TRANSFER_ERROR);
     return;
   }
 
   auto callback_ptr =
       make_scoped_ptr(new IsochronousTransferOutCallback(callback));
   uint8_t endpoint_address = endpoint_number;
   uint32_t packet_size = 0;
   for (size_t i = 0; i < packets.size(); ++i) {
     packet_size =
         std::max(packet_size, static_cast<uint32_t>(packets[i].size()));
   }
   size_t transfer_size = packet_size * packets.size();
   scoped_refptr<net::IOBuffer> buffer = CreateTransferBuffer(transfer_size);
   memset(buffer->data(), 0, transfer_size);
   for (size_t i = 0; i < packets.size(); ++i) {
     uint8_t* packet =
         reinterpret_cast<uint8_t*>(&buffer->data()[i * packet_size]);
     DCHECK_LE(packets[i].size(), static_cast<size_t>(packet_size));
     memcpy(packet, packets[i].storage().data(), packets[i].size());
   }
   device_handle_->IsochronousTransfer(
       USB_DIRECTION_OUTBOUND, endpoint_address, buffer, transfer_size,
       static_cast<uint32_t>(packets.size()), packet_size, timeout,
       base::Bind(&OnIsochronousTransferOut, base::Passed(&callback_ptr)));
 }
 
 }  // namespace usb
 }  // namespace device