Remove WebUSB descriptor data from device.mojom.

device/usb/mojo/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/usb/mojo/device_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 168 matching lines @@
                        [index](const UsbInterfaceDescriptor& this_iface) {
                          return this_iface.interface_number == (index & 0xff);
                        });
       if (interface_it != config->interfaces.end())
         interface = &*interface_it;
     }
     if (interface == nullptr)
       return false;
 
     return permission_provider_->HasFunctionPermission(
-        interface->first_interface, config->configuration_value, *device_info_);
+        interface->first_interface, config->configuration_value, device_);
   } else if (config) {
     return permission_provider_->HasConfigurationPermission(
-        config->configuration_value, *device_info_);
+        config->configuration_value, device_);
   } else {
     // Client must already have device permission to have gotten this far.
     return true;
   }
 }
 
 void DeviceImpl::OnOpen(const OpenCallback& callback,
                         scoped_refptr<UsbDeviceHandle> handle) {
   device_handle_ = handle;
   if (device_handle_ && permission_provider_)
@@ skipping 21 matching lines @@
 }
 
 void DeviceImpl::SetConfiguration(uint8_t value,
                                   const SetConfigurationCallback& callback) {
   if (!device_handle_) {
     callback.Run(false);
     return;
   }
 
   if (permission_provider_ &&
-      permission_provider_->HasConfigurationPermission(value, *device_info_)) {
+      permission_provider_->HasConfigurationPermission(value, device_)) {
     device_handle_->SetConfiguration(value, WrapMojoCallback(callback));
   } else {
     callback.Run(false);
   }
 }
 
 void DeviceImpl::ClaimInterface(uint8_t interface_number,
                                 const ClaimInterfaceCallback& callback) {
   if (!device_handle_) {
     callback.Run(false);
@@ skipping 12 matching lines @@
                      return interface.interface_number == interface_number;
                    });
   if (interface_it == config->interfaces.end()) {
     callback.Run(false);
     return;
   }
 
   if (permission_provider_ &&
       permission_provider_->HasFunctionPermission(interface_it->first_interface,
                                                   config->configuration_value,
-                                                  *device_info_)) {
+                                                  device_)) {
     device_handle_->ClaimInterface(interface_number,
                                    WrapMojoCallback(callback));
   } else {
     callback.Run(false);
   }
 }
 
 void DeviceImpl::ReleaseInterface(uint8_t interface_number,
                                   const ReleaseInterfaceCallback& callback) {
   if (!device_handle_) {
@@ skipping 172 matching lines @@
       base::Bind(&OnIsochronousTransferOut, base::Passed(&callback_ptr)));
 }
 
 void DeviceImpl::OnDeviceRemoved(scoped_refptr<UsbDevice> device) {
   DCHECK_EQ(device_, device);
   delete this;
 }
 
 }  // namespace usb
 }  // namespace device