Track USB device configuration state in Blink.

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"
 #include "base/strings/utf_string_conversions.h"
 #include "content/child/mojo/type_converters.h"
 #include "content/child/scoped_web_callbacks.h"
 #include "content/renderer/usb/type_converters.h"
 #include "mojo/shell/public/cpp/connect.h"
 #include "mojo/shell/public/interfaces/connector.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 kDeviceAlreadyOpen[] = "Device has already been opened.";
 const char kDeviceNoAccess[] = "Access denied.";
-const char kDeviceNotConfigured[] = "Device not configured.";
 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&>
 // for any type |T|.
@@ skipping 43 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) {
-    RejectWithError(blink::WebUSBError(blink::WebUSBError::Error::NotFound,
-                                       kDeviceNotConfigured),
-                    std::move(scoped_callbacks));
-  } 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 {
     RejectWithError(blink::WebUSBError(blink::WebUSBError::Error::Network,
@@ skipping 135 matching lines @@
     device_->Open(base::Bind(&OnOpenDevice, base::Passed(&scoped_callbacks)));
 }
 
 void WebUSBDeviceImpl::close(blink::WebUSBDeviceCloseCallbacks* callbacks) {
   auto scoped_callbacks = MakeScopedUSBCallbacks(callbacks);
   if (device_)
     device_->Close(
         base::Bind(&OnDeviceClosed, base::Passed(&scoped_callbacks)));
 }
 
-void WebUSBDeviceImpl::getConfiguration(
-    blink::WebUSBDeviceGetConfigurationCallbacks* callbacks) {
-  auto scoped_callbacks = MakeScopedUSBCallbacks(callbacks);
-  if (device_)
-    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_)
     device_->SetConfiguration(
         configuration_value,
         base::Bind(&HandlePassFailDeviceOperation,
                    base::Passed(&scoped_callbacks), kSetConfigurationFailed));
 }
@@ skipping 151 matching lines @@
 
 void WebUSBDeviceImpl::reset(blink::WebUSBDeviceResetCallbacks* callbacks) {
   auto scoped_callbacks = MakeScopedUSBCallbacks(callbacks);
   if (device_)
     device_->Reset(base::Bind(&HandlePassFailDeviceOperation,
                               base::Passed(&scoped_callbacks),
                               kDeviceResetFailed));
 }
 
 }  // namespace content