Move device opening from DeviceManager to Device.

device/devices_app/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 "device/devices_app/usb/device_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/stl_util.h"
 #include "device/devices_app/usb/type_converters.h"
@@ skipping 21 matching lines @@
 }
 
 scoped_refptr<net::IOBuffer> CreateTransferBuffer(size_t size) {
   scoped_refptr<net::IOBuffer> buffer = new net::IOBuffer(
       std::max(static_cast<size_t>(1u), static_cast<size_t>(size)));
   return buffer;
 }
 
 }  // namespace
 
-DeviceImpl::DeviceImpl(scoped_refptr<UsbDeviceHandle> device_handle,
+DeviceImpl::DeviceImpl(scoped_refptr<UsbDevice> device,
                        mojo::InterfaceRequest<Device> request)
-    : binding_(this, request.Pass()),
-      device_handle_(device_handle),
-      weak_factory_(this) {
-}
+    : binding_(this, request.Pass()), device_(device), weak_factory_(this) {}
 
 DeviceImpl::~DeviceImpl() {
   CloseHandle();
 }
 
 void DeviceImpl::CloseHandle() {
   if (device_handle_)
     device_handle_->Close();
   device_handle_ = nullptr;
 }
 
+void DeviceImpl::OnOpen(const OpenCallback& callback,
+                        scoped_refptr<UsbDeviceHandle> handle) {
+  device_handle_ = handle;
+  callback.Run(handle ? OPEN_DEVICE_ERROR_OK : OPEN_DEVICE_ERROR_ACCESS_DENIED);
+}
+
 void DeviceImpl::OnTransferIn(const MojoTransferInCallback& callback,
                               UsbTransferStatus status,
                               scoped_refptr<net::IOBuffer> buffer,
                               size_t buffer_size) {
   mojo::Array<uint8_t> data;
   if (buffer) {
     // TODO(rockot/reillyg): We should change UsbDeviceHandle to use a
     // std::vector<uint8_t> instead of net::IOBuffer. Then we could move
     // instead of copy.
     std::vector<uint8_t> bytes(buffer_size);
@@ skipping 31 matching lines @@
 }
 
 void DeviceImpl::OnIsochronousTransferOut(
     const MojoTransferOutCallback& callback,
     UsbTransferStatus status,
     scoped_refptr<net::IOBuffer> buffer,
     size_t buffer_size) {
   callback.Run(mojo::ConvertTo<TransferStatus>(status));
 }
 
+void DeviceImpl::GetDeviceInfo(const GetDeviceInfoCallback& callback) {
+  callback.Run(DeviceInfo::From(*device_));
+}
+
+void DeviceImpl::GetConfiguration(const GetConfigurationCallback& callback) {
+  const UsbConfigDescriptor* config = device_->GetActiveConfiguration();
+  callback.Run(config ? ConfigurationInfo::From(*config) : nullptr);
+}
+
+void DeviceImpl::Open(const OpenCallback& callback) {
+  device_->Open(
+      base::Bind(&DeviceImpl::OnOpen, weak_factory_.GetWeakPtr(), callback));
+}
+
 void DeviceImpl::Close(const CloseCallback& callback) {
   CloseHandle();
   callback.Run();
 }
 
-void DeviceImpl::GetDeviceInfo(const GetDeviceInfoCallback& callback) {
-  if (!device_handle_) {
-    callback.Run(DeviceInfoPtr());
-    return;
-  }
-
-  // TODO(rockot/reillyg): Converting configuration info should be done in the
-  // TypeConverter, but GetConfiguration() is non-const so we do it here for
-  // now.
-  DeviceInfoPtr info = DeviceInfo::From(*device_handle_->GetDevice());
-  const std::vector<UsbConfigDescriptor>& configs =
-      device_handle_->GetDevice()->configurations();
-  info->configurations = mojo::Array<ConfigurationInfoPtr>::New(configs.size());
-  for (size_t i = 0; i < configs.size(); ++i) {
-    info->configurations[i] = ConfigurationInfo::From(configs[i]);
-  }
-  callback.Run(info.Pass());
-}
-
 void DeviceImpl::SetConfiguration(uint8_t value,
                                   const SetConfigurationCallback& callback) {
   if (!device_handle_) {
     callback.Run(false);
     return;
   }
 
   device_handle_->SetConfiguration(value, WrapMojoCallback(callback));
 }
 
@@ skipping 175 matching lines @@
   }
   device_handle_->IsochronousTransfer(
       USB_DIRECTION_OUTBOUND, endpoint_address, buffer, transfer_size,
       static_cast<uint32_t>(packets.size()), packet_size, timeout,
       base::Bind(&DeviceImpl::OnIsochronousTransferOut,
                  weak_factory_.GetWeakPtr(), callback));
 }
 
 }  // namespace usb
 }  // namespace device