Use interface associations to check function permissions.

device/usb/usb_device_handle_impl.cc

 // Copyright 2014 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/usb_device_handle_impl.h"
 
 #include <algorithm>
 #include <numeric>
 #include <utility>
 #include <vector>
@@ skipping 738 matching lines @@
     GenericTransferInternal(endpoint_address, buffer, length, timeout,
                             task_runner_, callback);
   } else {
     task_runner_->PostTask(
         FROM_HERE, base::Bind(&UsbDeviceHandleImpl::GenericTransferInternal,
                               this, endpoint_address, buffer, length, timeout,
                               base::ThreadTaskRunnerHandle::Get(), callback));
   }
 }
 
-bool UsbDeviceHandleImpl::FindInterfaceByEndpoint(uint8_t endpoint_address,
-                                                  uint8_t* interface_number) {
+const UsbInterfaceDescriptor* UsbDeviceHandleImpl::FindInterfaceByEndpoint(
+    uint8_t endpoint_address) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const auto endpoint_it = endpoint_map_.find(endpoint_address);
-  if (endpoint_it != endpoint_map_.end()) {
-    *interface_number = endpoint_it->second.interface_number;
-    return true;
-  }
-  return false;
+  if (endpoint_it != endpoint_map_.end())
+    return endpoint_it->second.interface;
+  return nullptr;
 }
 
 UsbDeviceHandleImpl::UsbDeviceHandleImpl(
     scoped_refptr<UsbContext> context,
     scoped_refptr<UsbDeviceImpl> device,
     PlatformUsbDeviceHandle handle,
     scoped_refptr<base::SequencedTaskRunner> blocking_task_runner)
     : device_(device),
       handle_(handle),
       context_(context),
@@ skipping 123 matching lines @@
   const UsbConfigDescriptor* config = device_->GetActiveConfiguration();
   if (config) {
     for (const auto& map_entry : claimed_interfaces_) {
       int interface_number = map_entry.first;
       const scoped_refptr<InterfaceClaimer>& claimed_iface = map_entry.second;
 
       for (const UsbInterfaceDescriptor& iface : config->interfaces) {
         if (iface.interface_number == interface_number &&
             iface.alternate_setting == claimed_iface->alternate_setting()) {
           for (const UsbEndpointDescriptor& endpoint : iface.endpoints) {
-            endpoint_map_[endpoint.address] = {interface_number,
-                                               endpoint.transfer_type};
+            endpoint_map_[endpoint.address] = {&iface, &endpoint};
           }
           break;
         }
       }
     }
   }
 }
 
 scoped_refptr<UsbDeviceHandleImpl::InterfaceClaimer>
 UsbDeviceHandleImpl::GetClaimedInterfaceForEndpoint(uint8_t endpoint) {
   const auto endpoint_it = endpoint_map_.find(endpoint);
   if (endpoint_it != endpoint_map_.end())
-    return claimed_interfaces_[endpoint_it->second.interface_number];
+    return claimed_interfaces_[endpoint_it->second.interface->interface_number];
   return nullptr;
 }
 
 void UsbDeviceHandleImpl::ControlTransferInternal(
     UsbEndpointDirection direction,
     TransferRequestType request_type,
     TransferRecipient recipient,
     uint8_t request,
     uint16_t value,
     uint16_t index,
@@ skipping 115 matching lines @@
   }
 
   if (!base::IsValueInRangeForNumericType<int>(length)) {
     USB_LOG(DEBUG) << "Transfer too long.";
     RunTransferCallback(callback_task_runner, callback, USB_TRANSFER_ERROR,
                         buffer, 0);
     return;
   }
 
   scoped_ptr<Transfer> transfer;
-  UsbTransferType transfer_type = endpoint_it->second.transfer_type;
+  UsbTransferType transfer_type = endpoint_it->second.endpoint->transfer_type;
   if (transfer_type == USB_TRANSFER_BULK) {
     transfer = Transfer::CreateBulkTransfer(this, endpoint_address, buffer,
                                             static_cast<int>(length), timeout,
                                             callback_task_runner, callback);
   } else if (transfer_type == USB_TRANSFER_INTERRUPT) {
     transfer = Transfer::CreateInterruptTransfer(
         this, endpoint_address, buffer, static_cast<int>(length), timeout,
         callback_task_runner, callback);
   } else {
     USB_LOG(DEBUG) << "Endpoint " << static_cast<int>(endpoint_address)
@@ skipping 54 matching lines @@
     map_entry.second = nullptr;
     blocking_task_runner_->ReleaseSoon(FROM_HERE, interface_claimer);
   }
 
   // Cannot close device handle here. Need to wait for libusb_cancel_transfer to
   // finish.
   device_ = nullptr;
 }
 
 }  // namespace device