Convert the PermissionProvider Mojo interface to plain C++.

This interface allows a separate Mojo service to provide permissions
management for a DeviceManager instance. This will be useful if USB
device handling is ever moved into a separate process but until then it
adds needless complexity to the implementation because access checks are
made asynchronous. Make it a normal C++ interface for now.

BUG=None

Review URL: https://codereview.chromium.org/1742333003

Cr-Commit-Position: refs/heads/master@{#379393}

4 files changed, 46 insertions, 73 deletions

diff --git a/chrome/browser/usb/usb_tab_helper.cc b/chrome/browser/usb/usb_tab_helper.cc
index 8e235e4..91977fd 100644
--- a/chrome/browser/usb/usb_tab_helper.cc
+++ b/chrome/browser/usb/usb_tab_helper.cc
@@ -38,11 +38,8 @@ void UsbTabHelper::CreateDeviceManager(
     RenderFrameHost* render_frame_host,
     mojo::InterfaceRequest<device::usb::DeviceManager> request) {
   DCHECK(WebContents::FromRenderFrameHost(render_frame_host) == web_contents());
-  device::usb::PermissionProviderPtr permission_provider;
-  GetPermissionProvider(render_frame_host,
-                        mojo::GetProxy(&permission_provider));
-  device::usb::DeviceManagerImpl::Create(std::move(permission_provider),
-                                         std::move(request));
+  device::usb::DeviceManagerImpl::Create(
+      GetPermissionProvider(render_frame_host), std::move(request));
 }
 
 #if !defined(OS_ANDROID)
@@ -73,15 +70,14 @@ FrameUsbServices* UsbTabHelper::GetFrameUsbService(
   return it->second.get();
 }
 
-void UsbTabHelper::GetPermissionProvider(
-    RenderFrameHost* render_frame_host,
-    mojo::InterfaceRequest<device::usb::PermissionProvider> request) {
+base::WeakPtr<device::usb::PermissionProvider>
+UsbTabHelper::GetPermissionProvider(RenderFrameHost* render_frame_host) {
   FrameUsbServices* frame_usb_services = GetFrameUsbService(render_frame_host);
   if (!frame_usb_services->permission_provider) {
     frame_usb_services->permission_provider.reset(
         new WebUSBPermissionProvider(render_frame_host));
   }
-  frame_usb_services->permission_provider->Bind(std::move(request));
+  return frame_usb_services->permission_provider->GetWeakPtr();
 }
 
 #if !defined(OS_ANDROID)
diff --git a/chrome/browser/usb/usb_tab_helper.h b/chrome/browser/usb/usb_tab_helper.h
index 277cf67..688f501 100644
--- a/chrome/browser/usb/usb_tab_helper.h
+++ b/chrome/browser/usb/usb_tab_helper.h
@@ -57,9 +57,8 @@ class UsbTabHelper : public content::WebContentsObserver,
   FrameUsbServices* GetFrameUsbService(
       content::RenderFrameHost* render_frame_host);
 
-  void GetPermissionProvider(
-      content::RenderFrameHost* render_frame_host,
-      mojo::InterfaceRequest<device::usb::PermissionProvider> request);
+  base::WeakPtr<device::usb::PermissionProvider> GetPermissionProvider(
+      content::RenderFrameHost* render_frame_host);
 
 #if !defined(OS_ANDROID)
   void GetPermissionBubble(
diff --git a/chrome/browser/usb/web_usb_permission_provider.cc b/chrome/browser/usb/web_usb_permission_provider.cc
index a037432..3e27881 100644
--- a/chrome/browser/usb/web_usb_permission_provider.cc
+++ b/chrome/browser/usb/web_usb_permission_provider.cc
@@ -13,7 +13,7 @@
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
-#include "device/core/device_client.h"
+#include "device/usb/public/interfaces/device.mojom.h"
 
 using content::WebContents;
 using device::usb::WebUsbDescriptorSet;
@@ -28,31 +28,26 @@ bool FindOriginInDescriptorSet(const WebUsbDescriptorSet* set,
                                const uint8_t* interface_number) {
   if (!set)
     return false;
-  for (size_t i = 0; i < set->origins.size(); ++i) {
+  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 device::usb::WebUsbConfigurationSubsetPtr& config =
-        set->configurations[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) {
+    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 device::usb::WebUsbFunctionSubsetPtr& function =
-          config->functions[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)
         continue;
-      for (size_t k = 0; k < function->origins.size(); ++k) {
+      for (size_t k = 0; k < function->origins.size(); ++k)
         if (origin.spec() == function->origins[k])
           return true;
-      }
     }
   }
   return false;
@@ -62,16 +57,20 @@ bool FindOriginInDescriptorSet(const WebUsbDescriptorSet* set,
 
 WebUSBPermissionProvider::WebUSBPermissionProvider(
     content::RenderFrameHost* render_frame_host)
-    : render_frame_host_(render_frame_host) {
+    : render_frame_host_(render_frame_host), weak_factory_(this) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(render_frame_host_);
 }
 
 WebUSBPermissionProvider::~WebUSBPermissionProvider() {}
 
-void WebUSBPermissionProvider::HasDevicePermission(
-    mojo::Array<device::usb::DeviceInfoPtr> requested_devices,
-    const HasDevicePermissionCallback& callback) {
+base::WeakPtr<device::usb::PermissionProvider>
+WebUSBPermissionProvider::GetWeakPtr() {
+  return weak_factory_.GetWeakPtr();
+}
+
+bool WebUSBPermissionProvider::HasDevicePermission(
+    const device::usb::DeviceInfo& device_info) const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   WebContents* web_contents =
       WebContents::FromRenderFrameHost(render_frame_host_);
@@ -84,44 +83,29 @@ void WebUSBPermissionProvider::HasDevicePermission(
   UsbChooserContext* chooser_context =
       UsbChooserContextFactory::GetForProfile(profile);
 
-  mojo::Array<mojo::String> allowed_guids;
-  for (size_t i = 0; i < requested_devices.size(); ++i) {
-    const device::usb::DeviceInfo& device = *requested_devices[i];
-    if (FindOriginInDescriptorSet(device.webusb_allowed_origins.get(),
-                                  requesting_origin, nullptr, nullptr) &&
-        chooser_context->HasDevicePermission(requesting_origin,
-                                             embedding_origin, device)) {
-      allowed_guids.push_back(device.guid);
-    }
-  }
-  callback.Run(std::move(allowed_guids));
+  return FindOriginInDescriptorSet(device_info.webusb_allowed_origins.get(),
+                                   requesting_origin, nullptr, nullptr) &&
+         chooser_context->HasDevicePermission(requesting_origin,
+                                              embedding_origin, device_info);
 }
 
-void WebUSBPermissionProvider::HasConfigurationPermission(
+bool WebUSBPermissionProvider::HasConfigurationPermission(
     uint8_t requested_configuration_value,
-    device::usb::DeviceInfoPtr device,
-    const HasInterfacePermissionCallback& callback) {
+    const device::usb::DeviceInfo& device_info) const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  callback.Run(FindOriginInDescriptorSet(
-      device->webusb_allowed_origins.get(),
+  return FindOriginInDescriptorSet(
+      device_info.webusb_allowed_origins.get(),
       render_frame_host_->GetLastCommittedURL().GetOrigin(),
-      &requested_configuration_value, nullptr));
+      &requested_configuration_value, nullptr);
 }
 
-void WebUSBPermissionProvider::HasInterfacePermission(
+bool WebUSBPermissionProvider::HasInterfacePermission(
     uint8_t requested_interface,
     uint8_t configuration_value,
-    device::usb::DeviceInfoPtr device,
-    const HasInterfacePermissionCallback& callback) {
+    const device::usb::DeviceInfo& device_info) const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  callback.Run(FindOriginInDescriptorSet(
-      device->webusb_allowed_origins.get(),
+  return FindOriginInDescriptorSet(
+      device_info.webusb_allowed_origins.get(),
       render_frame_host_->GetLastCommittedURL().GetOrigin(),
-      &configuration_value, &requested_interface));
-}
-
-void WebUSBPermissionProvider::Bind(
-    mojo::InterfaceRequest<device::usb::PermissionProvider> request) {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  bindings_.AddBinding(this, std::move(request));
+      &configuration_value, &requested_interface);
 }
diff --git a/chrome/browser/usb/web_usb_permission_provider.h b/chrome/browser/usb/web_usb_permission_provider.h
index 19b6f30..e52275b 100644
--- a/chrome/browser/usb/web_usb_permission_provider.h
+++ b/chrome/browser/usb/web_usb_permission_provider.h
@@ -7,10 +7,8 @@
 
 #include <stdint.h>
 
-#include "device/usb/public/interfaces/permission_provider.mojom.h"
-#include "mojo/public/cpp/bindings/array.h"
-#include "mojo/public/cpp/bindings/binding_set.h"
-#include "mojo/public/cpp/bindings/interface_request.h"
+#include "base/memory/weak_ptr.h"
+#include "device/usb/mojo/permission_provider.h"
 
 namespace content {
 class RenderFrameHost;
@@ -24,28 +22,24 @@ class WebUSBPermissionProvider : public device::usb::PermissionProvider {
  public:
   explicit WebUSBPermissionProvider(
       content::RenderFrameHost* render_frame_host);
-
   ~WebUSBPermissionProvider() override;
 
+  base::WeakPtr<PermissionProvider> GetWeakPtr();
+
   // device::usb::PermissionProvider implementation.
-  void HasDevicePermission(
-      mojo::Array<device::usb::DeviceInfoPtr> requested_devices,
-      const HasDevicePermissionCallback& callback) override;
-  void HasConfigurationPermission(
+  bool HasDevicePermission(
+      const device::usb::DeviceInfo& device_info) const override;
+  bool HasConfigurationPermission(
       uint8_t requested_configuration,
-      device::usb::DeviceInfoPtr device,
-      const HasInterfacePermissionCallback& callback) override;
-  void HasInterfacePermission(
+      const device::usb::DeviceInfo& device_info) const override;
+  bool HasInterfacePermission(
       uint8_t requested_interface,
       uint8_t configuration_value,
-      device::usb::DeviceInfoPtr device,
-      const HasInterfacePermissionCallback& callback) override;
-  void Bind(
-      mojo::InterfaceRequest<device::usb::PermissionProvider> request) override;
+      const device::usb::DeviceInfo& device_info) const override;
 
  private:
-  mojo::BindingSet<PermissionProvider> bindings_;
   content::RenderFrameHost* const render_frame_host_;
+  base::WeakPtrFactory<PermissionProvider> weak_factory_;
 };
 
 #endif  // CHROME_BROWSER_USB_WEB_USB_PERMISSION_PROVIDER_H_