Match WebUSB errors more closely to the specificiation.

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 "base/bind.h"
 #include "base/callback.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/child/scoped_web_callbacks.h"
@@ skipping 23 matching lines @@
 // Generic default rejection handler for any WebUSB callbacks type. Assumes
 // |CallbacksType| is a blink::WebCallbacks<T, const blink::WebUSBError&>
 // for any type |T|.
 template <typename CallbacksType>
 void RejectWithError(const blink::WebUSBError& error,
                      scoped_ptr<CallbacksType> callbacks) {
   callbacks->onError(error);
 }
 
 template <typename CallbacksType>
-void RejectWithDeviceError(const std::string& message,
-                           scoped_ptr<CallbacksType> callbacks) {
-  RejectWithError(blink::WebUSBError(blink::WebUSBError::Error::Device,
-                                     base::UTF8ToUTF16(message)),
-                  callbacks.Pass());
-}
-
-template <typename CallbacksType>
 void RejectWithTransferError(scoped_ptr<CallbacksType> callbacks) {
-  RejectWithError(blink::WebUSBError(blink::WebUSBError::Error::Transfer,
-                                     base::UTF8ToUTF16(kTransferFailed)),
+  RejectWithError(blink::WebUSBError(blink::WebUSBError::Error::Network,
+                                     base::ASCIIToUTF16(kTransferFailed)),
                   callbacks.Pass());
 }
 
 // Create a new ScopedWebCallbacks for WebUSB device callbacks, defaulting to
 // a "device unavailable" rejection.
 template <typename CallbacksType>
 ScopedWebCallbacks<CallbacksType> MakeScopedUSBCallbacks(
     CallbacksType* callbacks) {
   return make_scoped_web_callbacks(
       callbacks,
       base::Bind(&RejectWithError<CallbacksType>,
-                 blink::WebUSBError(blink::WebUSBError::Error::Device,
-                                    base::UTF8ToUTF16(kDeviceUnavailable))));
+                 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:
       scoped_callbacks->onSuccess();
       break;
     case device::usb::OPEN_DEVICE_ERROR_ACCESS_DENIED:
       scoped_callbacks->onError(blink::WebUSBError(
-          blink::WebUSBError::Error::Device,
-          base::UTF8ToUTF16(kDeviceNoAccess)));
+          blink::WebUSBError::Error::Security,
+          base::ASCIIToUTF16(kDeviceNoAccess)));
       break;
     default:
       NOTREACHED();
   }
 }
 
 void OnDeviceClosed(
     ScopedWebCallbacks<blink::WebUSBDeviceCloseCallbacks> callbacks) {
   callbacks.PassCallbacks()->onSuccess();
 }
 
 void OnGetConfiguration(
     ScopedWebCallbacks<blink::WebUSBDeviceGetConfigurationCallbacks> callbacks,
     uint8_t configuration_value) {
   auto scoped_callbacks = callbacks.PassCallbacks();
-  if (configuration_value == 0)
-    RejectWithDeviceError(kDeviceNotConfigured, scoped_callbacks.Pass());
-  else
+  if (configuration_value == 0) {
+    RejectWithError(blink::WebUSBError(blink::WebUSBError::Error::NotFound,
+                                       kDeviceNotConfigured),
+                    scoped_callbacks.Pass());
+  } else {
     scoped_callbacks->onSuccess(configuration_value);
+  }
 }
 
 void HandlePassFailDeviceOperation(
     ScopedWebCallbacks<blink::WebCallbacks<void, const blink::WebUSBError&>>
         callbacks,
     const std::string& failure_message,
     bool success) {
   auto scoped_callbacks = callbacks.PassCallbacks();
-  if (success)
+  if (success) {
     scoped_callbacks->onSuccess();
-  else
-    RejectWithDeviceError(failure_message, scoped_callbacks.Pass());
+  } else {
+    RejectWithError(blink::WebUSBError(blink::WebUSBError::Error::Network,
+                                       base::ASCIIToUTF16(failure_message)),
+                    scoped_callbacks.Pass());
+  }
 }
 
 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) {
     RejectWithTransferError(scoped_callbacks.Pass());
     return;
@@ skipping 175 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