Use interface associations to check function permissions.

chrome/browser/usb/web_usb_permission_provider.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 "chrome/browser/usb/web_usb_permission_provider.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/command_line.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/usb/usb_chooser_context.h"
 #include "chrome/browser/usb/usb_chooser_context_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "device/usb/public/interfaces/device.mojom.h"
 
 using content::WebContents;
 using device::usb::WebUsbDescriptorSet;
 using device::usb::WebUsbConfigurationSubsetPtr;
 using device::usb::WebUsbFunctionSubsetPtr;
 
 namespace {
 
 bool FindOriginInDescriptorSet(const WebUsbDescriptorSet* set,
                                const GURL& origin,
                                const uint8_t* configuration_value,
-                               const uint8_t* interface_number) {
+                               const uint8_t* first_interface) {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableWebUsbSecurity))
     return true;
 
   if (!set)
     return false;
   for (size_t i = 0; i < set->origins.size(); ++i)
     if (origin.spec() == set->origins[i])
       return true;
   for (size_t i = 0; i < set->configurations.size(); ++i) {
     const WebUsbConfigurationSubsetPtr& config = set->configurations[i];
     if (configuration_value &&
         *configuration_value != config->configuration_value)
       continue;
     for (size_t j = 0; i < config->origins.size(); ++j)
       if (origin.spec() == config->origins[j])
         return true;
     for (size_t j = 0; j < config->functions.size(); ++j) {
       const WebUsbFunctionSubsetPtr& function = config->functions[j];
-      // TODO(reillyg): Implement support for Interface Association Descriptors
-      // so that this check will match associated interfaces.
-      if (interface_number && *interface_number != function->first_interface)
+      if (first_interface && *first_interface != function->first_interface)
         continue;
       for (size_t k = 0; k < function->origins.size(); ++k)
         if (origin.spec() == function->origins[k])
           return true;
     }
   }
   return false;
 }
 
 }  // namespace
@@ skipping 35 matching lines @@
 bool WebUSBPermissionProvider::HasConfigurationPermission(
     uint8_t requested_configuration_value,
     const device::usb::DeviceInfo& device_info) const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   return FindOriginInDescriptorSet(
       device_info.webusb_allowed_origins.get(),
       render_frame_host_->GetLastCommittedURL().GetOrigin(),
       &requested_configuration_value, nullptr);
 }
 
-bool WebUSBPermissionProvider::HasInterfacePermission(
-    uint8_t requested_interface,
+bool WebUSBPermissionProvider::HasFunctionPermission(
+    uint8_t requested_function,
     uint8_t configuration_value,
     const device::usb::DeviceInfo& device_info) const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   return FindOriginInDescriptorSet(
       device_info.webusb_allowed_origins.get(),
       render_frame_host_->GetLastCommittedURL().GetOrigin(),
-      &configuration_value, &requested_interface);
+      &configuration_value, &requested_function);
 }