Move device opening from DeviceManager to Device.

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 kDeviceNotFound[] = "Device not found.";
 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 32 matching lines @@
 }
 
 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_NOT_FOUND:
-      scoped_callbacks->onError(blink::WebUSBError(
-          blink::WebUSBError::Error::Device,
-          base::UTF8ToUTF16(kDeviceNotFound)));
-      break;
     case device::usb::OPEN_DEVICE_ERROR_ACCESS_DENIED:
       scoped_callbacks->onError(blink::WebUSBError(
           blink::WebUSBError::Error::Device,
           base::UTF8ToUTF16(kDeviceNoAccess)));
       break;
     default:
       NOTREACHED();
   }
 }
 
@@ skipping 51 matching lines @@
   }
 
   // TODO(rockot): Device::ControlTransferOut should expose the number of bytes
   // actually transferred so we can send it from here.
   info->bytesWritten = bytes_written;
   scoped_callbacks->onSuccess(adoptWebPtr(info.release()));
 }
 
 }  // namespace
 
-WebUSBDeviceImpl::WebUSBDeviceImpl(device::usb::DeviceManagerPtr device_manager,
+WebUSBDeviceImpl::WebUSBDeviceImpl(device::usb::DevicePtr device,
                                    const blink::WebUSBDeviceInfo& device_info)
-    : device_manager_(device_manager.Pass()),
-      device_info_(device_info),
-      weak_factory_(this) {}
+    : device_(device.Pass()), device_info_(device_info), weak_factory_(this) {}
 
 WebUSBDeviceImpl::~WebUSBDeviceImpl() {}
 
 const blink::WebUSBDeviceInfo& WebUSBDeviceImpl::info() const {
   return device_info_;
 }
 
 void WebUSBDeviceImpl::open(blink::WebUSBDeviceOpenCallbacks* callbacks) {
   auto scoped_callbacks = MakeScopedUSBCallbacks(callbacks);
-  device_manager_->OpenDevice(
-      device_info_.guid.utf8(),
-      mojo::GetProxy(&device_),
-      base::Bind(&OnOpenDevice, base::Passed(&scoped_callbacks)));
+  device_->Open(base::Bind(&OnOpenDevice, base::Passed(&scoped_callbacks)));
 }
 
 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)));
   }
@@ skipping 144 matching lines @@
   if (!device_) {
     RejectWithDeviceError(kDeviceNotOpened, scoped_callbacks.PassCallbacks());
   } else {
     device_->Reset(
         base::Bind(&HandlePassFailDeviceOperation,
                    base::Passed(&scoped_callbacks), kDeviceResetFailed));
   }
 }
 
 }  // namespace content