Use complete USB DeviceInfo Mojo object to make permission decisions.

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 33 matching lines @@
   UsbService* usb_service = DeviceClient::Get()->GetUsbService();
   if (usb_service) {
     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) {
@@ skipping 140 matching lines @@
 void DeviceManagerImpl::GetDeviceChanges(
     const GetDeviceChangesCallback& callback) {
   device_change_callbacks_.push(callback);
   MaybeRunDeviceChangesCallback();
 }
 
 void DeviceManagerImpl::OpenDevice(
     const mojo::String& guid,
     mojo::InterfaceRequest<Device> device_request,
     const OpenDeviceCallback& callback) {
-  mojo::Array<mojo::String> requested_guids(1);
-  requested_guids[0] = guid;
+  auto has_permission_callback = base::Bind(
+      &DeviceManagerImpl::OnGotDeviceInfoForOpen, weak_factory_.GetWeakPtr(),
+      base::Passed(&device_request), callback);
+  service_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&GetDeviceOnServiceThread, guid, has_permission_callback,
+                 base::ThreadTaskRunnerHandle::Get()));
+}
+
+void DeviceManagerImpl::OnGotDeviceInfoForOpen(
+    mojo::InterfaceRequest<Device> device_request,
+    const OpenDeviceCallback& callback,
+    DeviceInfoPtr device_info) {
+  if (!device_info) {
+    callback.Run(OPEN_DEVICE_ERROR_NOT_FOUND);
+    return;
+  }
+
+  mojo::Array<DeviceInfoPtr> requested_devices(1);
+  requested_devices[0] = device_info.Pass();
   permission_provider_->HasDevicePermission(
-      requested_guids.Pass(),
+      requested_devices.Pass(),
       base::Bind(&DeviceManagerImpl::OnOpenDevicePermissionCheckComplete,
                  base::Unretained(this), base::Passed(&device_request),
                  callback));
 }
 
 void DeviceManagerImpl::OnOpenDevicePermissionCheckComplete(
     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);
     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()));
 }
 
 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;
-  mojo::Array<mojo::String> requested_guids(0);
+  mojo::Array<DeviceInfoPtr> requested_devices(0);
   for (const auto& device : devices) {
     if (filters.empty() || UsbDeviceFilter::MatchesAny(device, filters)) {
       device_map[device->guid()] = device;
-      requested_guids.push_back(device->guid());
+      requested_devices.push_back(DeviceInfo::From(*device));
     }
   }
 
   permission_provider_->HasDevicePermission(
-      requested_guids.Pass(),
+      requested_devices.Pass(),
       base::Bind(&FilterAndConvertDevicesAndThen, device_map, callback));
 }
 
 void DeviceManagerImpl::OnDeviceAdded(scoped_refptr<UsbDevice> device) {
   DCHECK(!ContainsKey(devices_removed_, device->guid()));
   devices_added_[device->guid()] = device;
   MaybeRunDeviceChangesCallback();
 }
 
 void DeviceManagerImpl::OnDeviceRemoved(scoped_refptr<UsbDevice> device) {
   if (devices_added_.erase(device->guid()) == 0)
     devices_removed_[device->guid()] = device;
   MaybeRunDeviceChangesCallback();
 }
 
 void DeviceManagerImpl::MaybeRunDeviceChangesCallback() {
   if (!permission_request_pending_ && !device_change_callbacks_.empty()) {
     DeviceMap devices_added;
     devices_added.swap(devices_added_);
     DeviceMap devices_removed;
     devices_removed.swap(devices_removed_);
 
-    mojo::Array<mojo::String> requested_guids(devices_added.size() +
-                                              devices_removed.size());
+    mojo::Array<DeviceInfoPtr> requested_devices(devices_added.size() +
+                                                 devices_removed.size());
     {
       size_t i = 0;
       for (const auto& map_entry : devices_added)
-        requested_guids[i++] = map_entry.first;
+        requested_devices[i++] = DeviceInfo::From(*map_entry.second);
       for (const auto& map_entry : devices_removed)
-        requested_guids[i++] = map_entry.first;
+        requested_devices[i++] = DeviceInfo::From(*map_entry.second);
     }
 
     permission_request_pending_ = true;
     permission_provider_->HasDevicePermission(
-        requested_guids.Pass(),
+        requested_devices.Pass(),
         base::Bind(&DeviceManagerImpl::OnEnumerationPermissionCheckComplete,
                    base::Unretained(this), devices_added, devices_removed));
   }
 }
 
 void DeviceManagerImpl::OnEnumerationPermissionCheckComplete(
     const DeviceMap& devices_added,
     const DeviceMap& devices_removed,
     mojo::Array<mojo::String> allowed_guids) {
   permission_request_pending_ = false;
@@ skipping 21 matching lines @@
     callback.Run(notification.Pass());
     device_change_callbacks_.pop();
   }
 
   if (devices_added_.size() > 0 || !devices_removed_.empty())
     MaybeRunDeviceChangesCallback();
 }
 
 }  // namespace usb
 }  // namespace device