Remove WebUSB descriptor data from device.mojom.

device/usb/mojo/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/usb/mojo/device_manager_impl.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 57 matching lines @@
   MaybeRunDeviceChangesCallback();
 }
 
 void DeviceManagerImpl::GetDevice(
     const mojo::String& guid,
     mojo::InterfaceRequest<Device> device_request) {
   scoped_refptr<UsbDevice> device = usb_service_->GetDevice(guid);
   if (!device)
     return;
 
-  DeviceInfoPtr device_info = DeviceInfo::From(*device);
   if (permission_provider_ &&
-      permission_provider_->HasDevicePermission(*device_info)) {
-    new DeviceImpl(device, std::move(device_info), permission_provider_,
+      permission_provider_->HasDevicePermission(device)) {
+    new DeviceImpl(device, DeviceInfo::From(*device), permission_provider_,
                    std::move(device_request));
   }
 }
 
 void DeviceManagerImpl::OnGetDevices(
     EnumerationOptionsPtr options,
     const GetDevicesCallback& callback,
     const std::vector<scoped_refptr<UsbDevice>>& devices) {
   std::vector<UsbDeviceFilter> filters;
   if (options)
     filters = options->filters.To<std::vector<UsbDeviceFilter>>();
 
   mojo::Array<DeviceInfoPtr> device_infos;
   for (const auto& device : devices) {
     if (filters.empty() || UsbDeviceFilter::MatchesAny(device, filters)) {
-      DeviceInfoPtr device_info = DeviceInfo::From(*device);
       if (permission_provider_ &&
-          permission_provider_->HasDevicePermission(*device_info)) {
-        device_infos.push_back(std::move(device_info));
+          permission_provider_->HasDevicePermission(device)) {
+        device_infos.push_back(DeviceInfo::From(*device));
       }
     }
   }
 
   callback.Run(std::move(device_infos));
 }
 
 void DeviceManagerImpl::OnDeviceAdded(scoped_refptr<UsbDevice> device) {
-  DeviceInfoPtr device_info = DeviceInfo::From(*device);
   if (permission_provider_ &&
-      permission_provider_->HasDevicePermission(*device_info)) {
-    devices_added_[device->guid()] = std::move(device_info);
+      permission_provider_->HasDevicePermission(device)) {
+    devices_added_[device->guid()] = DeviceInfo::From(*device);
     MaybeRunDeviceChangesCallback();
   }
 }
 
 void DeviceManagerImpl::OnDeviceRemoved(scoped_refptr<UsbDevice> device) {
   if (devices_added_.erase(device->guid()) == 0) {
-    DeviceInfoPtr device_info = DeviceInfo::From(*device);
     if (permission_provider_ &&
-        permission_provider_->HasDevicePermission(*device_info)) {
-      devices_removed_.push_back(std::move(device_info));
+        permission_provider_->HasDevicePermission(device)) {
+      devices_removed_.push_back(DeviceInfo::From(*device));
       MaybeRunDeviceChangesCallback();
     }
   }
 }
 
 void DeviceManagerImpl::WillDestroyUsbService() {
   delete this;
 }
 
 void DeviceManagerImpl::MaybeRunDeviceChangesCallback() {
   if (!device_change_callbacks_.empty() &&
       !(devices_added_.empty() && devices_removed_.empty())) {
     DeviceChangeNotificationPtr notification = DeviceChangeNotification::New();
     notification->devices_added.SetToEmpty();
     notification->devices_removed.SetToEmpty();
     for (auto& map_entry : devices_added_)
       notification->devices_added.push_back(std::move(map_entry.second));
     devices_added_.clear();
     notification->devices_removed.Swap(&devices_removed_);
 
     device_change_callbacks_.front().Run(std::move(notification));
     device_change_callbacks_.pop();
   }
 }
 
 }  // namespace usb
 }  // namespace device