Integrate WebUSB with Feature Policy

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 124 matching lines @@
     if (permission_provider_)
       permission_provider_->DecrementConnectionCount();
   }
   device_handle_ = nullptr;
 }
 
 bool DeviceImpl::HasControlTransferPermission(
     UsbControlTransferRecipient recipient,
     uint16_t index) {
   DCHECK(device_handle_);
+
+  if (recipient != UsbControlTransferRecipient::INTERFACE &&
+      recipient != UsbControlTransferRecipient::ENDPOINT) {
+    return true;
+  }
+
   const UsbConfigDescriptor* config = device_->active_configuration();
-
-  if (!permission_provider_)
+  if (!config)
     return false;
 
-  if (recipient == UsbControlTransferRecipient::INTERFACE ||
-      recipient == UsbControlTransferRecipient::ENDPOINT) {
-    if (!config)
-      return false;
+  const UsbInterfaceDescriptor* interface = nullptr;
+  if (recipient == UsbControlTransferRecipient::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;
+  }
 
-    const UsbInterfaceDescriptor* interface = nullptr;
-    if (recipient == UsbControlTransferRecipient::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_->HasFunctionPermission(
-        interface->first_interface, config->configuration_value, device_);
-  } else if (config) {
-    return permission_provider_->HasConfigurationPermission(
-        config->configuration_value, device_);
-  } else {
-    // Client must already have device permission to have gotten this far.
-    return true;
-  }
+  return interface;

[iclelland, 2017/05/04 15:24:08]

Returning a pointer from a bool method seems wrong (though I can't find anything
specifically prohibiting it in the style guide)  -- Is it clearer to explicitly
return (interface != nullptr)?

At the very least, a comment saying that we're not actually trying to return the
interface itself might be helpful.

[Reilly Grant (use Gerrit), 2017/05/04 20:34:46]

Done.

 }
 
 // static
 void DeviceImpl::OnOpen(base::WeakPtr<DeviceImpl> self,
                         const OpenCallback& callback,
                         scoped_refptr<UsbDeviceHandle> handle) {
   if (!self) {
     handle->Close();
     return;
   }
 
   self->device_handle_ = std::move(handle);
   if (self->device_handle_ && self->permission_provider_)
     self->permission_provider_->IncrementConnectionCount();
   callback.Run(self->device_handle_ ? mojom::UsbOpenDeviceError::OK
                                     : mojom::UsbOpenDeviceError::ACCESS_DENIED);
 }
 
 void DeviceImpl::OnPermissionGrantedForOpen(const OpenCallback& callback,
                                             bool granted) {
-  if (granted && permission_provider_ &&
-      permission_provider_->HasDevicePermission(device_)) {
+  if (granted) {
     device_->Open(
         base::Bind(&DeviceImpl::OnOpen, weak_factory_.GetWeakPtr(), callback));
   } else {
     callback.Run(mojom::UsbOpenDeviceError::ACCESS_DENIED);
   }
 }
 
 void DeviceImpl::Open(const OpenCallback& callback) {
   if (device_handle_) {
     callback.Run(mojom::UsbOpenDeviceError::ALREADY_OPEN);
     return;
   }
 
   if (!device_->permission_granted()) {
     device_->RequestPermission(
         base::Bind(&DeviceImpl::OnPermissionGrantedForOpen,
                    weak_factory_.GetWeakPtr(), callback));
     return;
   }
 
-  if (permission_provider_ &&
-      permission_provider_->HasDevicePermission(device_)) {
-    device_->Open(
-        base::Bind(&DeviceImpl::OnOpen, weak_factory_.GetWeakPtr(), callback));
-  } else {
-    callback.Run(mojom::UsbOpenDeviceError::ACCESS_DENIED);
-  }
+  device_->Open(
+      base::Bind(&DeviceImpl::OnOpen, weak_factory_.GetWeakPtr(), callback));
 }
 
 void DeviceImpl::Close(const CloseCallback& callback) {
   CloseHandle();
   callback.Run();
 }
 
 void DeviceImpl::SetConfiguration(uint8_t value,
                                   const SetConfigurationCallback& callback) {
   if (!device_handle_) {
     callback.Run(false);
     return;
   }
 
-  if (permission_provider_ &&
-      permission_provider_->HasConfigurationPermission(value, device_)) {
-    device_handle_->SetConfiguration(value, callback);
-  } else {
-    callback.Run(false);
-  }
+  device_handle_->SetConfiguration(value, callback);
 }
 
 void DeviceImpl::ClaimInterface(uint8_t interface_number,
                                 const ClaimInterfaceCallback& callback) {
   if (!device_handle_) {
     callback.Run(false);
     return;
   }
 
   const UsbConfigDescriptor* config = device_->active_configuration();
   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_->HasFunctionPermission(interface_it->first_interface,
-                                                  config->configuration_value,
-                                                  device_)) {
-    device_handle_->ClaimInterface(interface_number, callback);
-  } else {
-    callback.Run(false);
-  }
+  device_handle_->ClaimInterface(interface_number, callback);
 }
 
 void DeviceImpl::ReleaseInterface(uint8_t interface_number,
                                   const ReleaseInterfaceCallback& callback) {
   if (!device_handle_) {
     callback.Run(false);
     return;
   }
 
   device_handle_->ReleaseInterface(interface_number, callback);
@@ skipping 145 matching lines @@
       base::Bind(&OnIsochronousTransferOut, callback));
 }
 
 void DeviceImpl::OnDeviceRemoved(scoped_refptr<device::UsbDevice> device) {
   DCHECK_EQ(device_, device);
   binding_->Close();
 }
 
 }  // namespace usb
 }  // namespace device