Use interface associations to check function permissions.

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 <numeric>
@@ skipping 147 matching lines @@
   const UsbConfigDescriptor* config = device_->GetActiveConfiguration();
 
   if (!permission_provider_)
     return false;
 
   if (recipient == ControlTransferRecipient::INTERFACE ||
       recipient == ControlTransferRecipient::ENDPOINT) {
     if (!config)
       return false;
 
-    uint8_t interface_number = index & 0xff;
-    if (recipient == ControlTransferRecipient::ENDPOINT &&
-        !device_handle_->FindInterfaceByEndpoint(index & 0xff,
-                                                 &interface_number)) {
+    const UsbInterfaceDescriptor* interface = nullptr;
+    if (recipient == ControlTransferRecipient::ENDPOINT) {
+      interface = device_handle_->FindInterfaceByEndpoint(index & 0xff);
+    } else {
+      auto interface_it =
+          std::find_if(config->interfaces.begin(), config->interfaces.end(),
+                       [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_->HasInterfacePermission(
-        interface_number, config->configuration_value, *device_info_);
+    return permission_provider_->HasFunctionPermission(
+        interface->first_interface, config->configuration_value, *device_info_);
   } else if (config) {
     return permission_provider_->HasConfigurationPermission(
         config->configuration_value, *device_info_);
   } else {
     // Client must already have device permission to have gotten this far.
     return true;
   }
 }
 
 void DeviceImpl::OnOpen(const OpenCallback& callback,
@@ skipping 42 matching lines @@
     callback.Run(false);
     return;
   }
 
   const UsbConfigDescriptor* config = device_->GetActiveConfiguration();
   if (!config) {
     callback.Run(false);
     return;
   }
 
+  auto interface_it =
+      std::find_if(config->interfaces.begin(), config->interfaces.end(),
+                   [interface_number](const UsbInterfaceDescriptor& interface) {
+                     return interface.interface_number == interface_number;
+                   });
+  if (interface_it == config->interfaces.end()) {
+    callback.Run(false);
+    return;
+  }
+
   if (permission_provider_ &&
-      permission_provider_->HasInterfacePermission(
-          interface_number, config->configuration_value, *device_info_)) {
+      permission_provider_->HasFunctionPermission(interface_it->first_interface,
+                                                  config->configuration_value,
+                                                  *device_info_)) {
     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 171 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