[webhid] Add WebContents::IsConnectedToHidDevice

IsConnectedToHidDevice returns true if any frame in the
WebContents is connected to a HID device. This will enable a
tab indicator icon to be displayed when a tab has an open HID
connection.

HidService monitors the number of open HID connections for a
frame and notifies WebContentsImpl when the count transitions
between zero and one.

BUG=1007539

Change-Id: I4b7020af97bcb50e2b26e5865519bcd5f77c63a4
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1823727
Reviewed-by: John Abd-El-Malek <jam@chromium.org>
Reviewed-by: Reilly Grant <reillyg@chromium.org>
Commit-Queue: Matt Reynolds <mattreynolds@chromium.org>
Cr-Commit-Position: refs/heads/master@{#711979}

content/browser/hid/hid_service.cc

@@ -8,6 +8,7 @@
 
 #include "base/bind.h"
 #include "base/callback.h"
+#include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/hid_chooser.h"
 #include "content/public/browser/hid_delegate.h"
@@ -20,9 +21,16 @@ namespace content {
 
 HidService::HidService(RenderFrameHost* render_frame_host,
                        mojo::PendingReceiver<blink::mojom::HidService> receiver)
-    : FrameServiceBase(render_frame_host, std::move(receiver)) {}
+    : FrameServiceBase(render_frame_host, std::move(receiver)) {
+  watchers_.set_disconnect_handler(base::BindRepeating(
+      &HidService::OnWatcherConnectionError, base::Unretained(this)));
+}
 
-HidService::~HidService() = default;
+HidService::~HidService() {
+  // The remaining watchers will be closed from this end.
+  if (!watchers_.empty())
+    DecrementActiveFrameCount();
+}
 
 // static
 void HidService::Create(
@@ -76,19 +84,35 @@ void HidService::Connect(
     const std::string& device_guid,
     mojo::PendingRemote<device::mojom::HidConnectionClient> client,
     ConnectCallback callback) {
+  if (watchers_.empty()) {
+    auto* web_contents_impl = static_cast<WebContentsImpl*>(
+        WebContents::FromRenderFrameHost(render_frame_host()));
+    web_contents_impl->IncrementHidActiveFrameCount();
+  }
+
+  mojo::PendingRemote<device::mojom::HidConnectionWatcher> watcher;
+  watchers_.Add(this, watcher.InitWithNewPipeAndPassReceiver());
   GetContentClient()
       ->browser()
       ->GetHidDelegate()
       ->GetHidManager(web_contents())
       ->Connect(
-          device_guid, std::move(client),
-          // TODO(mattreynolds): Bind |this| as a HidConnectionWatcher and
-          // track the number of active watchers.
-          /*watcher=*/mojo::NullRemote(),
+          device_guid, std::move(client), std::move(watcher),
           base::BindOnce(&HidService::FinishConnect, weak_factory_.GetWeakPtr(),
                          std::move(callback)));
 }
 
+void HidService::OnWatcherConnectionError() {
+  if (watchers_.empty())
+    DecrementActiveFrameCount();
+}
+
+void HidService::DecrementActiveFrameCount() {
+  auto* web_contents_impl = static_cast<WebContentsImpl*>(
+      WebContents::FromRenderFrameHost(render_frame_host()));
+  web_contents_impl->DecrementHidActiveFrameCount();
+}
+
 void HidService::FinishGetDevices(
     GetDevicesCallback callback,
     std::vector<device::mojom::HidDeviceInfoPtr> devices) {

content/browser/hid/hid_service.h

@@ -14,6 +14,7 @@
 #include "content/public/browser/frame_service_base.h"
 #include "mojo/public/cpp/bindings/pending_receiver.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
+#include "mojo/public/cpp/bindings/receiver_set.h"
 #include "services/device/public/mojom/hid.mojom.h"
 #include "third_party/blink/public/mojom/hid/hid.mojom.h"
 
@@ -24,7 +25,8 @@ class RenderFrameHost;
 
 // HidService provides an implementation of the HidService mojom interface. This
 // interface is used by Blink to implement the WebHID API.
-class HidService : public content::FrameServiceBase<blink::mojom::HidService> {
+class HidService : public content::FrameServiceBase<blink::mojom::HidService>,
+                   public device::mojom::HidConnectionWatcher {
  public:
   static void Create(RenderFrameHost*,
                      mojo::PendingReceiver<blink::mojom::HidService>);
@@ -41,6 +43,9 @@ class HidService : public content::FrameServiceBase<blink::mojom::HidService> {
   HidService(RenderFrameHost*, mojo::PendingReceiver<blink::mojom::HidService>);
   ~HidService() override;
 
+  void OnWatcherConnectionError();
+  void DecrementActiveFrameCount();
+
   void FinishGetDevices(GetDevicesCallback callback,
                         std::vector<device::mojom::HidDeviceInfoPtr> devices);
   void FinishRequestDevice(RequestDeviceCallback callback,
@@ -52,6 +57,10 @@ class HidService : public content::FrameServiceBase<blink::mojom::HidService> {
   // The last shown HID chooser UI.
   std::unique_ptr<HidChooser> chooser_;
 
+  // Each pipe here watches a connection created by Connect() in order to notify
+  // the WebContentsImpl when an active connection indicator should be shown.
+  mojo::ReceiverSet<device::mojom::HidConnectionWatcher> watchers_;
+
   base::WeakPtrFactory<HidService> weak_factory_{this};
 
   DISALLOW_COPY_AND_ASSIGN(HidService);

content/browser/hid/hid_service_unittest.cc

@@ -177,6 +177,8 @@ TEST_F(HidServiceTest, OpenAndCloseHidConnection) {
   connection_client()->Bind(
       hid_connection_client.InitWithNewPipeAndPassReceiver());
 
+  EXPECT_FALSE(contents()->IsConnectedToHidDevice());
+
   base::RunLoop run_loop;
   mojo::PendingRemote<device::mojom::HidConnection> connection;
   service->Connect(
@@ -190,7 +192,16 @@ TEST_F(HidServiceTest, OpenAndCloseHidConnection) {
   run_loop.Run();
   EXPECT_TRUE(connection);
 
+  EXPECT_TRUE(contents()->IsConnectedToHidDevice());
+
+  // Destroying |connection| will also disconnect the watcher.
   connection.reset();
+
+  // Allow the watcher's disconnect handler to run. This will update the
+  // WebContents active frame count.
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_FALSE(contents()->IsConnectedToHidDevice());
 }
 
 }  // namespace content

content/browser/web_contents/web_contents_impl.cc

@@ -1532,6 +1532,10 @@ bool WebContentsImpl::IsConnectedToSerialPort() {
   return serial_active_frame_count_ > 0;
 }
 
+bool WebContentsImpl::IsConnectedToHidDevice() {
+  return hid_active_frame_count_ > 0;
+}
+
 bool WebContentsImpl::HasNativeFileSystemHandles() {
   return native_file_system_handle_count_ > 0;
 }
@@ -6925,6 +6929,33 @@ void WebContentsImpl::DecrementSerialActiveFrameCount() {
     NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
 }
 
+void WebContentsImpl::IncrementHidActiveFrameCount() {
+  // Trying to invalidate the tab state while being destroyed could result in a
+  // use after free.
+  if (IsBeingDestroyed())
+    return;
+
+  // Notify for UI updates if the active frame count transitions from zero to
+  // non-zero.
+  hid_active_frame_count_++;
+  if (hid_active_frame_count_ == 1)
+    NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
+}
+
+void WebContentsImpl::DecrementHidActiveFrameCount() {
+  // Trying to invalidate the tab state while being destroyed could result in a
+  // use after free.
+  if (IsBeingDestroyed())
+    return;
+
+  // Notify for UI updates if the active frame count transitions from non-zero
+  // to zero.
+  DCHECK_NE(0u, hid_active_frame_count_);
+  hid_active_frame_count_--;
+  if (hid_active_frame_count_ == 0)
+    NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
+}
+
 void WebContentsImpl::IncrementNativeFileSystemHandleCount() {
   // Trying to invalidate the tab state while being destroyed could result in a
   // use after free.

content/browser/web_contents/web_contents_impl.h

@@ -358,6 +358,7 @@ class CONTENT_EXPORT WebContentsImpl : public WebContents,
   bool IsCurrentlyAudible() override;
   bool IsConnectedToBluetoothDevice() override;
   bool IsConnectedToSerialPort() override;
+  bool IsConnectedToHidDevice() override;
   bool HasNativeFileSystemHandles() override;
   bool HasNativeFileSystemDirectoryHandles() override;
   std::vector<base::FilePath> GetNativeFileSystemDirectoryHandles() override;
@@ -997,6 +998,11 @@ class CONTENT_EXPORT WebContentsImpl : public WebContents,
   void IncrementSerialActiveFrameCount();
   void DecrementSerialActiveFrameCount();
 
+  // Modify the counter of frames in this WebContents actively using HID
+  // devices.
+  void IncrementHidActiveFrameCount();
+  void DecrementHidActiveFrameCount();
+
   // Modify the counter of native file system handles for this WebContents.
   void IncrementNativeFileSystemHandleCount();
   void DecrementNativeFileSystemHandleCount();
@@ -1811,6 +1817,7 @@ class CONTENT_EXPORT WebContentsImpl : public WebContents,
 
   size_t bluetooth_connected_device_count_ = 0;
   size_t serial_active_frame_count_ = 0;
+  size_t hid_active_frame_count_ = 0;
 
   size_t native_file_system_handle_count_ = 0;
   std::map<base::FilePath, size_t> native_file_system_directory_handles_;

content/public/browser/web_contents.h

@@ -508,6 +508,10 @@ class WebContents : public PageNavigator,
   // port.
   virtual bool IsConnectedToSerialPort() = 0;
 
+  // Indicates whether any frame in the WebContents is connected to a HID
+  // device.
+  virtual bool IsConnectedToHidDevice() = 0;
+
   // Indicates whether any frame in the WebContents has native file system
   // handles.
   virtual bool HasNativeFileSystemHandles() = 0;