Use USB mojo interfaces in WebUsbDetector.

This CL converted USB callings in WebUsbDetector to mojo interfaces
by introducing webusb_landing_page in UsbDeviceInfo.

Bug: 699790
Change-Id: I6352c35a7eb9090ef4d5cb3d2436b30216d76ec9
Reviewed-on: https://chromium-review.googlesource.com/c/1297747
Commit-Queue: Donna Wu <donna.wu@intel.com>
Reviewed-by: Reilly Grant <reillyg@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Cr-Commit-Position: refs/heads/master@{#604923}

chrome/browser/usb/usb_chooser_context.cc

@@ -14,7 +14,6 @@
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/usb/usb_blocklist.h"
 #include "content/public/common/service_manager_connection.h"
-#include "device/usb/mojo/device_manager_impl.h"
 #include "device/usb/public/mojom/device.mojom.h"
 #include "services/device/public/mojom/constants.mojom.h"
 #include "services/service_manager/public/cpp/connector.h"

chrome/browser/usb/usb_chooser_context.h

@@ -18,7 +18,6 @@
 #include "base/values.h"
 #include "chrome/browser/permissions/chooser_context_base.h"
 #include "chrome/browser/usb/usb_policy_allowed_devices.h"
-#include "device/usb/mojo/device_manager_impl.h"
 #include "device/usb/public/mojom/device_manager.mojom.h"
 #include "mojo/public/cpp/bindings/associated_binding.h"
 

chrome/browser/usb/web_usb_detector.cc

@@ -4,6 +4,7 @@
 
 #include "chrome/browser/usb/web_usb_detector.h"
 
+#include <string>
 #include <utility>
 
 #include "base/feature_list.h"
@@ -25,10 +26,11 @@
 #include "components/vector_icons/vector_icons.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/origin_util.h"
-#include "device/base/device_client.h"
+#include "content/public/common/service_manager_connection.h"
 #include "device/base/features.h"
-#include "device/usb/usb_device.h"
-#include "device/usb/usb_ids.h"
+#include "device/usb/public/mojom/device.mojom.h"
+#include "services/device/public/mojom/constants.mojom.h"
+#include "services/service_manager/public/cpp/connector.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/page_transition_types.h"
 #include "ui/base/window_open_disposition.h"
@@ -167,7 +169,7 @@ class WebUsbNotificationDelegate : public TabStripModelObserver,
 
 }  // namespace
 
-WebUsbDetector::WebUsbDetector() : observer_(this) {}
+WebUsbDetector::WebUsbDetector() : client_binding_(this) {}
 
 WebUsbDetector::~WebUsbDetector() {}
 
@@ -181,27 +183,42 @@ void WebUsbDetector::Initialize() {
 #endif  // defined(OS_WIN)
 
   SCOPED_UMA_HISTOGRAM_TIMER("WebUsb.DetectorInitialization");
-  device::UsbService* usb_service =
-      device::DeviceClient::Get()->GetUsbService();
-  if (!usb_service)
-    return;
-
-  observer_.Add(usb_service);
+  // Tests may set a fake manager.
+  if (!device_manager_) {
+    // Request UsbDeviceManagerPtr from DeviceService.
+    content::ServiceManagerConnection::GetForProcess()
+        ->GetConnector()
+        ->BindInterface(device::mojom::kServiceName,
+                        mojo::MakeRequest(&device_manager_));
+  }
+  DCHECK(device_manager_);
+  device_manager_.set_connection_error_handler(base::BindOnce(
+      &WebUsbDetector::OnDeviceManagerConnectionError, base::Unretained(this)));
+
+  // Listen for added/removed device events.
+  DCHECK(!client_binding_);
+  device::mojom::UsbDeviceManagerClientAssociatedPtrInfo client;
+  client_binding_.Bind(mojo::MakeRequest(&client));
+  device_manager_->SetClient(std::move(client));
 }
 
-void WebUsbDetector::OnDeviceAdded(scoped_refptr<device::UsbDevice> device) {
-  const base::string16& product_name = device->product_string();
+void WebUsbDetector::OnDeviceAdded(
+    device::mojom::UsbDeviceInfoPtr device_info) {
+  if (!device_info->product_name || !device_info->webusb_landing_page)
+    return;
+
+  const base::string16& product_name = *device_info->product_name;
   if (product_name.empty())
     return;
 
-  const GURL& landing_page = device->webusb_landing_page();
+  const GURL& landing_page = *device_info->webusb_landing_page;
   if (!landing_page.is_valid() || !content::IsOriginSecure(landing_page))
     return;
 
   if (landing_page == GetActiveTabURL())
     return;
 
-  std::string notification_id = device->guid();
+  std::string notification_id = device_info->guid;
 
   message_center::RichNotificationData rich_notification_data;
   message_center::Notification notification(
@@ -224,6 +241,23 @@ void WebUsbDetector::OnDeviceAdded(scoped_refptr<device::UsbDevice> device) {
   SystemNotificationHelper::GetInstance()->Display(notification);
 }
 
-void WebUsbDetector::OnDeviceRemoved(scoped_refptr<device::UsbDevice> device) {
-  SystemNotificationHelper::GetInstance()->Close(device->guid());
+void WebUsbDetector::OnDeviceRemoved(
+    device::mojom::UsbDeviceInfoPtr device_info) {
+  SystemNotificationHelper::GetInstance()->Close(device_info->guid);
+}
+
+void WebUsbDetector::OnDeviceManagerConnectionError() {
+  device_manager_.reset();
+  client_binding_.Close();
+
+  // Try to reconnect the device manager.
+  Initialize();
+}
+
+void WebUsbDetector::SetDeviceManagerForTesting(
+    device::mojom::UsbDeviceManagerPtr fake_device_manager) {
+  DCHECK(!device_manager_);
+  DCHECK(!client_binding_);
+  DCHECK(fake_device_manager);
+  device_manager_ = std::move(fake_device_manager);
 }

chrome/browser/usb/web_usb_detector.h

@@ -6,14 +6,10 @@
 #define CHROME_BROWSER_USB_WEB_USB_DETECTOR_H_
 
 #include "base/macros.h"
-#include "base/scoped_observer.h"
-#include "device/usb/usb_service.h"
+#include "device/usb/public/mojom/device_manager.mojom.h"
+#include "mojo/public/cpp/bindings/associated_binding.h"
 
-namespace device {
-class UsbDevice;
-}
-
-class WebUsbDetector : public device::UsbService::Observer {
+class WebUsbDetector : public device::mojom::UsbDeviceManagerClient {
  public:
   WebUsbDetector();
   ~WebUsbDetector() override;
@@ -21,12 +17,20 @@ class WebUsbDetector : public device::UsbService::Observer {
   // Initializes the WebUsbDetector.
   void Initialize();
 
+  void SetDeviceManagerForTesting(
+      device::mojom::UsbDeviceManagerPtr fake_device_manager);
+
  private:
-  // device::UsbService::observer:
-  void OnDeviceAdded(scoped_refptr<device::UsbDevice> device) override;
-  void OnDeviceRemoved(scoped_refptr<device::UsbDevice> device) override;
+  // device::mojom::UsbDeviceManagerClient implementation.
+  void OnDeviceAdded(device::mojom::UsbDeviceInfoPtr device_info) override;
+  void OnDeviceRemoved(device::mojom::UsbDeviceInfoPtr device_info) override;
+
+  void OnDeviceManagerConnectionError();
 
-  ScopedObserver<device::UsbService, device::UsbService::Observer> observer_;
+  // Connection to |device_manager_instance_|.
+  device::mojom::UsbDeviceManagerPtr device_manager_;
+  mojo::AssociatedBinding<device::mojom::UsbDeviceManagerClient>
+      client_binding_;
 
   DISALLOW_COPY_AND_ASSIGN(WebUsbDetector);
 };

device/usb/mojo/type_converters.cc

@@ -113,6 +113,7 @@ TypeConverter<device::mojom::UsbDeviceInfoPtr, device::UsbDevice>::Convert(
   info->manufacturer_name = device.manufacturer_string();
   info->product_name = device.product_string();
   info->serial_number = device.serial_number();
+  info->webusb_landing_page = device.webusb_landing_page();
   const device::UsbConfigDescriptor* config = device.active_configuration();
   info->active_configuration = config ? config->configuration_value : 0;
   info->configurations =

device/usb/public/cpp/BUILD.gn

@@ -33,5 +33,6 @@ static_library("test_support") {
   public_deps = [
     "//base",
     "//device/usb/public/mojom",
+    "//url:url",
   ]
 }

device/usb/public/cpp/fake_usb_device_info.cc

@@ -33,13 +33,27 @@ FakeUsbDeviceInfo::FakeUsbDeviceInfo(uint16_t vendor_id,
                                      uint16_t product_id,
                                      const std::string& manufacturer_string,
                                      const std::string& product_string,
-                                     const std::string& serial_number) {
+                                     const std::string& serial_number)
+    : FakeUsbDeviceInfo(vendor_id,
+                        product_id,
+                        manufacturer_string,
+                        product_string,
+                        serial_number,
+                        GURL()) {}
+
+FakeUsbDeviceInfo::FakeUsbDeviceInfo(uint16_t vendor_id,
+                                     uint16_t product_id,
+                                     const std::string& manufacturer_string,
+                                     const std::string& product_string,
+                                     const std::string& serial_number,
+                                     const GURL& webusb_landing_page) {
   SetDefault();
   device_info_.vendor_id = vendor_id;
   device_info_.product_id = product_id;
   device_info_.manufacturer_name = base::UTF8ToUTF16(manufacturer_string);
   device_info_.product_name = base::UTF8ToUTF16(product_string),
   device_info_.serial_number = base::UTF8ToUTF16(serial_number);
+  device_info_.webusb_landing_page = webusb_landing_page;
 }
 
 FakeUsbDeviceInfo::~FakeUsbDeviceInfo() = default;

device/usb/public/cpp/fake_usb_device_info.h

@@ -13,6 +13,7 @@
 #include "base/memory/weak_ptr.h"
 #include "device/usb/public/mojom/device.mojom.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
+#include "url/gurl.h"
 
 namespace device {
 
@@ -33,6 +34,12 @@ class FakeUsbDeviceInfo : public base::RefCounted<FakeUsbDeviceInfo> {
                     const std::string& manufacturer_string,
                     const std::string& product_string,
                     const std::string& serial_number);
+  FakeUsbDeviceInfo(uint16_t vendor_id,
+                    uint16_t product_id,
+                    const std::string& manufacturer_string,
+                    const std::string& product_string,
+                    const std::string& serial_number,
+                    const GURL& webusb_landing_page);
 
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);

device/usb/public/mojom/BUILD.gn

@@ -10,8 +10,9 @@ mojom("mojom") {
     "device_manager.mojom",
   ]
 
-  deps = [
+  public_deps = [
     "//mojo/public/mojom/base",
+    "//url/mojom:url_mojom_gurl",
   ]
 
   # USB Mojom interfaces are exposed publicly to layout tests which use

device/usb/public/mojom/device.mojom

@@ -5,6 +5,7 @@
 module device.mojom;
 
 import "mojo/public/mojom/base/string16.mojom";
+import "url/mojom/url.mojom";
 
 enum UsbOpenDeviceError {
   // Opening the device succeeded.
@@ -88,6 +89,7 @@ struct UsbDeviceInfo {
   mojo_base.mojom.String16? manufacturer_name;
   mojo_base.mojom.String16? product_name;
   mojo_base.mojom.String16? serial_number;
+  url.mojom.Url? webusb_landing_page;
   uint8 active_configuration;
   array<UsbConfigurationInfo> configurations;
 };

third_party/WebKit/LayoutTests/external/wpt/resources/chromium/url.mojom.js

+// 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.
+
+'use strict';
+
+(function() {
+  var mojomId = 'url/mojom/url.mojom';
+  if (mojo.internal.isMojomLoaded(mojomId)) {
+    console.warn('The following mojom is loaded multiple times: ' + mojomId);
+    return;
+  }
+  mojo.internal.markMojomLoaded(mojomId);
+  var bindings = mojo;
+  var associatedBindings = mojo;
+  var codec = mojo.internal;
+  var validator = mojo.internal;
+
+  var exports = mojo.internal.exposeNamespace('url.mojom');
+
+
+
+  function Url(values) {
+    this.initDefaults_();
+    this.initFields_(values);
+  }
+
+
+  Url.prototype.initDefaults_ = function() {
+    this.url = null;
+  };
+  Url.prototype.initFields_ = function(fields) {
+    for(var field in fields) {
+        if (this.hasOwnProperty(field))
+          this[field] = fields[field];
+    }
+  };
+
+  Url.validate = function(messageValidator, offset) {
+    var err;
+    err = messageValidator.validateStructHeader(offset, codec.kStructHeaderSize);
+    if (err !== validator.validationError.NONE)
+        return err;
+
+    var kVersionSizes = [
+      {version: 0, numBytes: 16}
+    ];
+    err = messageValidator.validateStructVersion(offset, kVersionSizes);
+    if (err !== validator.validationError.NONE)
+        return err;
+
+
+    // validate Url.url
+    err = messageValidator.validateStringPointer(offset + codec.kStructHeaderSize + 0, false)
+    if (err !== validator.validationError.NONE)
+        return err;
+
+    return validator.validationError.NONE;
+  };
+
+  Url.encodedSize = codec.kStructHeaderSize + 8;
+
+  Url.decode = function(decoder) {
+    var packed;
+    var val = new Url();
+    var numberOfBytes = decoder.readUint32();
+    var version = decoder.readUint32();
+    val.url = decoder.decodeStruct(codec.String);
+    return val;
+  };
+
+  Url.encode = function(encoder, val) {
+    var packed;
+    encoder.writeUint32(Url.encodedSize);
+    encoder.writeUint32(0);
+    encoder.encodeStruct(codec.String, val.url);
+  };
+  exports.Url = Url;
+})();

third_party/WebKit/LayoutTests/external/wpt/webusb/resources/usb-helpers.js

@@ -42,6 +42,7 @@ let loadChromiumResources = Promise.resolve().then(() => {
   [
     '/resources/chromium/mojo_bindings.js',
     '/resources/chromium/string16.mojom.js',
+    '/resources/chromium/url.mojom.js',
     '/resources/chromium/device.mojom.js',
     '/resources/chromium/device_manager.mojom.js',
     '/resources/chromium/web_usb_service.mojom.js',