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 126 matching lines @@
   }
   device_handle_ = nullptr;
 }
 
 bool DeviceImpl::HasControlTransferPermission(
     UsbControlTransferRecipient recipient,
     uint16_t index) {
   DCHECK(device_handle_);
   const UsbConfigDescriptor* config = device_->active_configuration();
 
-  if (!permission_provider_)
-    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;
     }
     if (interface == nullptr)
       return false;
 
-    return permission_provider_->HasFunctionPermission(
-        interface->first_interface, config->configuration_value, device_);
+    return true;

[iclelland.google, 2017/05/02 14:42:52]

Drive-by: I'm not really looking at this part of the CL, but all of these
'return true' statements look redundant.

[Reilly Grant (use Gerrit), 2017/05/02 19:29:05]

Done.

   } else if (config) {
-    return permission_provider_->HasConfigurationPermission(
-        config->configuration_value, device_);
+    return true;
   } else {
     // Client must already have device permission to have gotten this far.
     return true;
   }
 }
 
 // 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) {

[lunalu1, 2017/05/03 15:01:21]

If I recall correctly, you don't need bracket here for else statement.
Can we do something similar to DeviceImpl::SetConfiguration:

if (granted) {
    device_->Open(
        base::Bind(&DeviceImpl::OnOpen, weak_factory_.GetWeakPtr(), callback));
    return;
}
callback.Run(mojom::UsbOpenDeviceError::ACCESS_DENIED);

[Reilly Grant (use Gerrit), 2017/05/04 01:16:50]

Done, though I put the error case first which is more common.

     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