Move device opening from DeviceManager to Device.

device/devices_app/usb/device_manager_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_manager_impl.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 35 matching lines @@
     usb_service->GetDevices(base::Bind(&OnGetDevicesOnServiceThread, callback,
                                        callback_task_runner));
   } else {
     callback_task_runner->PostTask(FROM_HERE,
                                    base::Bind(callback, DeviceList()));
   }
 }
 
 void GetDeviceOnServiceThread(
     const mojo::String& guid,
-    const base::Callback<void(DeviceInfoPtr)>& callback,
-    scoped_refptr<base::TaskRunner> callback_task_runner) {
-  DeviceInfoPtr device_info;
-  DCHECK(DeviceClient::Get());
-  UsbService* usb_service = DeviceClient::Get()->GetUsbService();
-  if (usb_service) {
-    scoped_refptr<UsbDevice> device = usb_service->GetDevice(guid);
-    if (device)
-      device_info = DeviceInfo::From(*device);
-  }
-
-  callback_task_runner->PostTask(
-      FROM_HERE, base::Bind(callback, base::Passed(&device_info)));
-}
-
-void RunOpenDeviceCallback(const DeviceManager::OpenDeviceCallback& callback,
-                           OpenDeviceError error) {
-  callback.Run(error);
-}
-
-void OnOpenDeviceOnServiceThread(
-    mojo::InterfaceRequest<Device> device_request,
-    const DeviceManager::OpenDeviceCallback& callback,
-    scoped_refptr<base::TaskRunner> callback_task_runner,
-    scoped_refptr<UsbDeviceHandle> device_handle) {
-  if (!device_handle) {
-    callback_task_runner->PostTask(FROM_HERE,
-                                   base::Bind(&RunOpenDeviceCallback, callback,
-                                              OPEN_DEVICE_ERROR_ACCESS_DENIED));
-    return;
-  }
-
-  // Owned by its MessagePipe.
-  new DeviceImpl(device_handle, device_request.Pass());
-
-  callback_task_runner->PostTask(
-      FROM_HERE,
-      base::Bind(&RunOpenDeviceCallback, callback, OPEN_DEVICE_ERROR_OK));
-}
-
-void OpenDeviceOnServiceThread(
-    const std::string& guid,
-    mojo::InterfaceRequest<Device> device_request,
-    const DeviceManager::OpenDeviceCallback& callback,
+    const base::Callback<void(scoped_refptr<UsbDevice>)>& callback,
     scoped_refptr<base::TaskRunner> callback_task_runner) {
   DCHECK(DeviceClient::Get());
+  scoped_refptr<UsbDevice> device;
   UsbService* usb_service = DeviceClient::Get()->GetUsbService();
-  if (!usb_service) {
-    callback_task_runner->PostTask(FROM_HERE,
-                                   base::Bind(&RunOpenDeviceCallback, callback,
-                                              OPEN_DEVICE_ERROR_NOT_FOUND));
-    return;
-  }
-  scoped_refptr<UsbDevice> device = usb_service->GetDevice(guid);
-  if (!device) {
-    callback_task_runner->PostTask(FROM_HERE,
-                                   base::Bind(&RunOpenDeviceCallback, callback,
-                                              OPEN_DEVICE_ERROR_NOT_FOUND));
-    return;
-  }
-  device->Open(base::Bind(&OnOpenDeviceOnServiceThread,
-                          base::Passed(&device_request), callback,
-                          callback_task_runner));
+  if (usb_service)
+    device = usb_service->GetDevice(guid);
+  callback_task_runner->PostTask(FROM_HERE, base::Bind(callback, device));
 }
 
 void FilterAndConvertDevicesAndThen(
     const DeviceMap& devices,
     const DeviceManagerImpl::GetDevicesCallback& callback,
     mojo::Array<mojo::String> allowed_guids) {
   mojo::Array<DeviceInfoPtr> allowed_devices(allowed_guids.size());
   for (size_t i = 0; i < allowed_guids.size(); ++i) {
     const auto it = devices.find(allowed_guids[i]);
     DCHECK(it != devices.end());
@@ skipping 88 matching lines @@
       FROM_HERE, base::Bind(&GetDevicesOnServiceThread, get_devices_callback,
                             base::ThreadTaskRunnerHandle::Get()));
 }
 
 void DeviceManagerImpl::GetDeviceChanges(
     const GetDeviceChangesCallback& callback) {
   device_change_callbacks_.push(callback);
   MaybeRunDeviceChangesCallback();
 }
 
-void DeviceManagerImpl::OpenDevice(
+void DeviceManagerImpl::GetDevice(
     const mojo::String& guid,
-    mojo::InterfaceRequest<Device> device_request,
-    const OpenDeviceCallback& callback) {
-  auto has_permission_callback = base::Bind(
-      &DeviceManagerImpl::OnGotDeviceInfoForOpen, weak_factory_.GetWeakPtr(),
-      base::Passed(&device_request), callback);
+    mojo::InterfaceRequest<Device> device_request) {
+  auto get_device_callback =
+      base::Bind(&DeviceManagerImpl::OnGetDevice, weak_factory_.GetWeakPtr(),
+                 base::Passed(&device_request));
   service_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&GetDeviceOnServiceThread, guid, has_permission_callback,
+      base::Bind(&GetDeviceOnServiceThread, guid, get_device_callback,
                  base::ThreadTaskRunnerHandle::Get()));
 }
 
-void DeviceManagerImpl::OnGotDeviceInfoForOpen(
+void DeviceManagerImpl::OnGetDevice(
     mojo::InterfaceRequest<Device> device_request,
-    const OpenDeviceCallback& callback,
-    DeviceInfoPtr device_info) {
-  if (!device_info) {
-    callback.Run(OPEN_DEVICE_ERROR_NOT_FOUND);
+    scoped_refptr<UsbDevice> device) {
+  if (!device)
     return;
-  }
 
   mojo::Array<DeviceInfoPtr> requested_devices(1);
-  requested_devices[0] = device_info.Pass();
+  requested_devices[0] = DeviceInfo::From(*device);
   permission_provider_->HasDevicePermission(
       requested_devices.Pass(),
-      base::Bind(&DeviceManagerImpl::OnOpenDevicePermissionCheckComplete,
-                 base::Unretained(this), base::Passed(&device_request),
-                 callback));
+      base::Bind(&DeviceManagerImpl::OnGetDevicePermissionCheckComplete,
+                 base::Unretained(this), device,
+                 base::Passed(&device_request)));
 }
 
-void DeviceManagerImpl::OnOpenDevicePermissionCheckComplete(
+void DeviceManagerImpl::OnGetDevicePermissionCheckComplete(
+    scoped_refptr<UsbDevice> device,
     mojo::InterfaceRequest<Device> device_request,
-    const OpenDeviceCallback& callback,
     mojo::Array<mojo::String> allowed_guids) {
-  if (allowed_guids.size() == 0) {
-    callback.Run(OPEN_DEVICE_ERROR_ACCESS_DENIED);
+  if (allowed_guids.size() == 0)
     return;
-  }
 
   DCHECK(allowed_guids.size() == 1);
-  service_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&OpenDeviceOnServiceThread, allowed_guids[0],
-                            base::Passed(&device_request), callback,
-                            base::ThreadTaskRunnerHandle::Get()));
+  new DeviceImpl(device, device_request.Pass());
 }
 
 void DeviceManagerImpl::OnGetDevices(EnumerationOptionsPtr options,
                                      const GetDevicesCallback& callback,
                                      const DeviceList& devices) {
   std::vector<UsbDeviceFilter> filters;
   if (options)
     filters = options->filters.To<std::vector<UsbDeviceFilter>>();
 
   std::map<std::string, scoped_refptr<UsbDevice>> device_map;
@@ skipping 76 matching lines @@
     callback.Run(notification.Pass());
     device_change_callbacks_.pop();
   }
 
   if (devices_added_.size() > 0 || !devices_removed_.empty())
     MaybeRunDeviceChangesCallback();
 }
 
 }  // namespace usb
 }  // namespace device