Implement getConfiguration in WebUSBDeviceImpl.

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"
 #include "content/renderer/usb/type_converters.h"
 #include "device/devices_app/public/cpp/constants.h"
 #include "mojo/application/public/cpp/connect.h"
 #include "mojo/application/public/interfaces/shell.mojom.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/platform/modules/webusb/WebUSBDeviceInfo.h"
 #include "third_party/WebKit/public/platform/modules/webusb/WebUSBTransferInfo.h"
 
 namespace content {
 
 namespace {
 
 const char kClaimInterfaceFailed[] = "Unable to claim interface.";
 const char kClearHaltFailed[] = "Unable to clear endpoint.";
 const char kDeviceNoAccess[] = "Access denied.";
+const char kDeviceNotConfigured[] = "Device not configured.";
 const char kDeviceNotOpened[] = "Device not opened.";
 const char kDeviceUnavailable[] = "Device unavailable.";
 const char kDeviceResetFailed[] = "Unable to reset the device.";
 const char kReleaseInterfaceFailed[] = "Unable to release interface.";
 const char kSetConfigurationFailed[] = "Unable to set device configuration.";
 const char kSetInterfaceFailed[] = "Unable to set device interface.";
 const char kTransferFailed[] = "Transfer failed.";
 
 // Generic default rejection handler for any WebUSB callbacks type. Assumes
 // |CallbacksType| is a blink::WebCallbacks<T, const blink::WebUSBError&>
@@ skipping 47 matching lines @@
     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
+    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)
     scoped_callbacks->onSuccess();
   else
     RejectWithDeviceError(failure_message, scoped_callbacks.Pass());
@@ skipping 61 matching lines @@
 void WebUSBDeviceImpl::close(blink::WebUSBDeviceCloseCallbacks* callbacks) {
   auto scoped_callbacks = MakeScopedUSBCallbacks(callbacks);
   if (!device_) {
     RejectWithDeviceError(kDeviceNotOpened, scoped_callbacks.PassCallbacks());
   } else {
     device_->Close(
         base::Bind(&OnDeviceClosed, base::Passed(&scoped_callbacks)));
   }
 }
 
+void WebUSBDeviceImpl::getConfiguration(
+    blink::WebUSBDeviceGetConfigurationCallbacks* callbacks) {
+  auto scoped_callbacks = MakeScopedUSBCallbacks(callbacks);
+  if (!device_) {
+    RejectWithDeviceError(kDeviceNotOpened, scoped_callbacks.PassCallbacks());
+  } else {
+    device_->GetConfiguration(
+        base::Bind(&OnGetConfiguration, base::Passed(&scoped_callbacks)));
+  }
+}
+
 void WebUSBDeviceImpl::setConfiguration(
     uint8_t configuration_value,
     blink::WebUSBDeviceSetConfigurationCallbacks* callbacks) {
   auto scoped_callbacks = MakeScopedUSBCallbacks(callbacks);
   if (!device_) {
     RejectWithDeviceError(kDeviceNotOpened, scoped_callbacks.PassCallbacks());
   } else {
     device_->SetConfiguration(
         configuration_value,
         base::Bind(&HandlePassFailDeviceOperation,
@@ skipping 132 matching lines @@
   if (!device_) {
     RejectWithDeviceError(kDeviceNotOpened, scoped_callbacks.PassCallbacks());
   } else {
     device_->Reset(
         base::Bind(&HandlePassFailDeviceOperation,
                    base::Passed(&scoped_callbacks), kDeviceResetFailed));
   }
 }
 
 }  // namespace content