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

content/renderer/usb/web_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 "content/renderer/usb/web_usb_device_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 48 matching lines @@
       base::Bind(&RejectWithError<CallbacksType>,
                  blink::WebUSBError(blink::WebUSBError::Error::NotFound,
                                     base::ASCIIToUTF16(kDeviceUnavailable))));
 }
 
 void OnOpenDevice(
     ScopedWebCallbacks<blink::WebUSBDeviceOpenCallbacks> callbacks,
     device::usb::OpenDeviceError error) {
   auto scoped_callbacks = callbacks.PassCallbacks();
   switch(error) {
-    case device::usb::OPEN_DEVICE_ERROR_OK:
+    case device::usb::OpenDeviceError::OK:
       scoped_callbacks->onSuccess();
       break;
-    case device::usb::OPEN_DEVICE_ERROR_ACCESS_DENIED:
+    case device::usb::OpenDeviceError::ACCESS_DENIED:
       scoped_callbacks->onError(blink::WebUSBError(
           blink::WebUSBError::Error::Security,
           base::ASCIIToUTF16(kDeviceNoAccess)));
       break;
     default:
       NOTREACHED();
   }
 }
 
 void OnDeviceClosed(
@@ skipping 27 matching lines @@
                                        base::ASCIIToUTF16(failure_message)),
                     std::move(scoped_callbacks));
   }
 }
 
 void OnTransferIn(
     ScopedWebCallbacks<blink::WebUSBDeviceControlTransferCallbacks> callbacks,
     device::usb::TransferStatus status,
     mojo::Array<uint8_t> data) {
   auto scoped_callbacks = callbacks.PassCallbacks();
-  if (status != device::usb::TRANSFER_STATUS_COMPLETED) {
+  if (status != device::usb::TransferStatus::COMPLETED) {
     RejectWithTransferError(std::move(scoped_callbacks));
     return;
   }
   scoped_ptr<blink::WebUSBTransferInfo> info(new blink::WebUSBTransferInfo());
   info->status = blink::WebUSBTransferInfo::Status::Ok;
   info->data.assign(data);
   scoped_callbacks->onSuccess(adoptWebPtr(info.release()));
 }
 
 void OnTransferOut(
     ScopedWebCallbacks<blink::WebUSBDeviceControlTransferCallbacks> callbacks,
     size_t bytes_written,
     device::usb::TransferStatus status) {
   auto scoped_callbacks = callbacks.PassCallbacks();
   scoped_ptr<blink::WebUSBTransferInfo> info(new blink::WebUSBTransferInfo());
   switch (status) {
-    case device::usb::TRANSFER_STATUS_COMPLETED:
+    case device::usb::TransferStatus::COMPLETED:
       info->status = blink::WebUSBTransferInfo::Status::Ok;
       break;
-    case device::usb::TRANSFER_STATUS_STALLED:
+    case device::usb::TransferStatus::STALLED:
       info->status = blink::WebUSBTransferInfo::Status::Stall;
       break;
-    case device::usb::TRANSFER_STATUS_BABBLE:
+    case device::usb::TransferStatus::BABBLE:
       info->status = blink::WebUSBTransferInfo::Status::Babble;
       break;
     default:
       RejectWithTransferError(std::move(scoped_callbacks));
       return;
   }
 
   // TODO(rockot): Device::ControlTransferOut should expose the number of bytes
   // actually transferred so we can send it from here.
   info->bytesWritten = bytes_written;
@@ skipping 146 matching lines @@
 }
 
 void WebUSBDeviceImpl::reset(blink::WebUSBDeviceResetCallbacks* callbacks) {
   auto scoped_callbacks = MakeScopedUSBCallbacks(callbacks);
   device_->Reset(base::Bind(&HandlePassFailDeviceOperation,
                             base::Passed(&scoped_callbacks),
                             kDeviceResetFailed));
 }
 
 }  // namespace content