Mojom API for establishing a JS to MPS connection.

      establish for the test app.

Bug: 889151
Test: Deployed to guado device and verified that a connection can be
Change-Id: I2704c373b30efb49b2932f30f24939c7f9dbb7b2
Reviewed-on: https://chromium-review.googlesource.com/c/1220728
Commit-Queue: Luke Sorenson <lasoren@chromium.org>
Reviewed-by: Rahul Chaturvedi <rkc@chromium.org>
Reviewed-by: Jacob Dufault <jdufault@chromium.org>
Reviewed-by: Dominick Ng <dominickn@chromium.org>
Reviewed-by: Ken Rockot <rockot@chromium.org>
Reviewed-by: Devlin <rdevlin.cronin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#596312}

chrome/browser/chrome_content_browser_manifest_overlay.json

@@ -90,6 +90,7 @@
           "chrome.mojom.OpenSearchDocumentDescriptionHandler",
           "chrome.mojom.PrerenderCanceler",
           "chromeos.ime.mojom.InputEngineManager",
+          "chromeos.media_perception.mojom.MediaPerception",
           "contextual_search.mojom.ContextualSearchJsApiService",
           "dom_distiller.mojom.DistillabilityService",
           "dom_distiller.mojom.DistillerJavaScriptService",

chrome/browser/extensions/BUILD.gn

@@ -977,6 +977,9 @@ jumbo_static_library("extensions") {
       "//ash/public/cpp",
       "//chromeos/components/proximity_auth",
       "//chromeos/services/ime/public/mojom",
+      "//chromeos/services/machine_learning/public/cpp",
+      "//chromeos/services/machine_learning/public/mojom",
+      "//chromeos/services/media_perception/public/mojom",
       "//components/arc",
       "//components/chrome_apps",
       "//components/constrained_window",

chrome/browser/extensions/api/media_perception_private/media_perception_api_delegate_chromeos.cc

@@ -12,6 +12,7 @@
 #include "chrome/browser/component_updater/cros_component_installer_chromeos.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/delegate_to_browser_gpu_service_accelerator_factory.h"
+#include "content/public/browser/render_frame_host.h"
 #include "content/public/common/service_manager_connection.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "services/service_manager/public/cpp/connector.h"
@@ -89,4 +90,19 @@ void MediaPerceptionAPIDelegateChromeOS::
   (*provider)->InjectGpuDependencies(std::move(accelerator_factory));
 }
 
+void MediaPerceptionAPIDelegateChromeOS::SetMediaPerceptionRequestHandler(
+    MediaPerceptionRequestHandler handler) {
+  handler_ = std::move(handler);
+}
+
+void MediaPerceptionAPIDelegateChromeOS::ForwardMediaPerceptionRequest(
+    chromeos::media_perception::mojom::MediaPerceptionRequest request,
+    content::RenderFrameHost* render_frame_host) {
+  if (!handler_) {
+    DLOG(ERROR) << "Got request but the handler is not set.";
+    return;
+  }
+  handler_.Run(std::move(request));
+}
+
 }  // namespace extensions

chrome/browser/extensions/api/media_perception_private/media_perception_api_delegate_chromeos.h

@@ -22,8 +22,15 @@ class MediaPerceptionAPIDelegateChromeOS
       LoadCrOSComponentCallback load_callback) override;
   void BindDeviceFactoryProviderToVideoCaptureService(
       video_capture::mojom::DeviceFactoryProviderPtr* provider) override;
+  void SetMediaPerceptionRequestHandler(
+      MediaPerceptionRequestHandler handler) override;
+  void ForwardMediaPerceptionRequest(
+      chromeos::media_perception::mojom::MediaPerceptionRequest request,
+      content::RenderFrameHost* render_frame_host) override;
 
  private:
+  MediaPerceptionRequestHandler handler_;
+
   DISALLOW_COPY_AND_ASSIGN(MediaPerceptionAPIDelegateChromeOS);
 };
 

chrome/browser/extensions/chrome_extensions_interface_registration.cc

@@ -20,7 +20,10 @@
 #include "chromeos/chromeos_features.h"
 #include "chromeos/services/ime/public/mojom/constants.mojom.h"
 #include "chromeos/services/ime/public/mojom/input_engine.mojom.h"
+#include "chromeos/services/media_perception/public/mojom/media_perception.mojom.h"
 #include "content/public/common/service_manager_connection.h"
+#include "extensions/browser/api/extensions_api_client.h"
+#include "extensions/browser/api/media_perception_private/media_perception_api_delegate.h"
 #include "services/service_manager/public/cpp/connector.h"
 #endif
 
@@ -65,6 +68,25 @@ void RegisterChromeInterfacesForExtension(
         &ForwardRequest<chromeos::ime::mojom::InputEngineManager>,
         chromeos::ime::mojom::kServiceName));
   }
+
+  if (extension->permissions_data()->HasAPIPermission(
+          APIPermission::kMediaPerceptionPrivate)) {
+    extensions::ExtensionsAPIClient* client =
+        extensions::ExtensionsAPIClient::Get();
+    extensions::MediaPerceptionAPIDelegate* delegate = nullptr;
+    if (client)
+      delegate = client->GetMediaPerceptionAPIDelegate();
+    if (delegate) {
+      // Note that it is safe to use base::Unretained here because |delegate| is
+      // owned by the |client|, which is instantiated by the
+      // ChromeExtensionsBrowserClient, which in turn is owned and lives as long
+      // as the BrowserProcessImpl.
+      registry->AddInterface(
+          base::BindRepeating(&extensions::MediaPerceptionAPIDelegate::
+                                  ForwardMediaPerceptionRequest,
+                              base::Unretained(delegate)));
+    }
+  }
 #endif
 }
 

chromeos/services/media_perception/public/mojom/BUILD.gn

@@ -6,7 +6,8 @@ import("//mojo/public/tools/bindings/mojom.gni")
 
 mojom("mojom") {
   sources = [
-    "connector.mojom",
+    "media_perception.mojom",
+    "media_perception_service.mojom",
   ]
 
   public_deps = [

chromeos/services/media_perception/public/mojom/connector.mojom → chromeos/services/media_perception/public/mojom/media_perception.mojom

@@ -4,11 +4,5 @@
 
 module chromeos.media_perception.mojom;
 
-import "services/video_capture/public/mojom/device_factory.mojom";
-
-interface Connector {
-  // Interface for a process running outside of Chrome to connect to the
-  // video capture service directly via a Mojo pipe set up through a
-  // DeviceFactory request.
-  ConnectToVideoCaptureService(video_capture.mojom.DeviceFactory& request);
+interface MediaPerception {
 };

chromeos/services/media_perception/public/mojom/media_perception_service.mojom

+// Copyright 2018 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.
+//
+// Next MinVersion: 1
+
+module chromeos.media_perception.mojom;
+
+import "chromeos/services/media_perception/public/mojom/media_perception.mojom";
+import "services/video_capture/public/mojom/device_factory.mojom";
+
+// Used to establish two-way communication between a client and the media
+// perception service.
+interface MediaPerceptionService {
+  GetController@0(MediaPerceptionController& request,
+                  MediaPerceptionControllerClient client);
+};
+
+interface MediaPerceptionController {
+  // Used by the client to establish a MediaPerception pipe.
+  ActivateMediaPerception@0(MediaPerception& request);
+};
+
+interface MediaPerceptionControllerClient {
+  // Interface for the service to connect to the Video Capture Service
+  // directly via a Mojo pipe set up through a DeviceFactory request.
+  ConnectToVideoCaptureService@0(video_capture.mojom.DeviceFactory& request);
+};
+

extensions/browser/api/BUILD.gn

@@ -145,6 +145,7 @@ source_set("api") {
       "//chromeos",
       "//chromeos:media_perception_proto",
       "//chromeos/services/media_perception/public/mojom",
+      "//chromeos/services/media_perception/public/mojom:mojom_js_data_deps",
     ]
   }
 }

extensions/browser/api/media_perception_private/media_perception_api_delegate.h

@@ -5,12 +5,21 @@
 #ifndef EXTENSIONS_BROWSER_API_MEDIA_PERCEPTION_PRIVATE_MEDIA_PERCEPTION_API_DELEGATE_H_
 #define EXTENSIONS_BROWSER_API_MEDIA_PERCEPTION_PRIVATE_MEDIA_PERCEPTION_API_DELEGATE_H_
 
+#include <memory>
+
 #include "base/callback.h"
 #include "base/files/file_path.h"
+#include "chromeos/services/media_perception/public/mojom/media_perception_service.mojom.h"
 #include "extensions/common/api/media_perception_private.h"
 #include "services/video_capture/public/mojom/device_factory.mojom.h"
 #include "services/video_capture/public/mojom/device_factory_provider.mojom.h"
 
+namespace content {
+
+class RenderFrameHost;
+
+}  //  namespace content
+
 namespace extensions {
 
 class MediaPerceptionAPIDelegate {
@@ -20,6 +29,9 @@ class MediaPerceptionAPIDelegate {
   using LoadCrOSComponentCallback =
       base::OnceCallback<void(bool success, const base::FilePath& mount_point)>;
 
+  using MediaPerceptionRequestHandler = base::RepeatingCallback<void(
+      chromeos::media_perception::mojom::MediaPerceptionRequest request)>;
+
   virtual ~MediaPerceptionAPIDelegate() {}
 
   // Provides an interface through which a media analytics Chrome OS component
@@ -34,6 +46,17 @@ class MediaPerceptionAPIDelegate {
   // |provider| is owned by the caller.
   virtual void BindDeviceFactoryProviderToVideoCaptureService(
       video_capture::mojom::DeviceFactoryProviderPtr* provider) = 0;
+
+  // Provides an interface to set a handler for an incoming
+  // MediaPerceptionRequest.
+  virtual void SetMediaPerceptionRequestHandler(
+      MediaPerceptionRequestHandler handler) = 0;
+
+  // Receives an incoming media perception request and forwards it to the
+  // request handler if set.
+  virtual void ForwardMediaPerceptionRequest(
+      chromeos::media_perception::mojom::MediaPerceptionRequest request,
+      content::RenderFrameHost* render_frame_host) = 0;
 };
 
 }  // namespace extensions

extensions/browser/api/media_perception_private/media_perception_api_manager.cc

@@ -18,41 +18,16 @@
 #include "extensions/browser/api/media_perception_private/media_perception_api_delegate.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_function.h"
-#include "mojo/public/cpp/bindings/strong_binding.h"
+#include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/interface_request.h"
 #include "mojo/public/cpp/platform/platform_channel.h"
 #include "mojo/public/cpp/system/invitation.h"
+#include "services/video_capture/public/mojom/device_factory_provider.mojom.h"
 
 namespace extensions {
 
 namespace {
 
-class ConnectorImpl : public chromeos::media_perception::mojom::Connector {
- public:
-  // delegate is owned by the ExtensionsAPIClient.
-  explicit ConnectorImpl(MediaPerceptionAPIDelegate* delegate)
-      : delegate_(delegate) {}
-  ~ConnectorImpl() override = default;
-
-  // media_perception::mojom::Connector override.
-  void ConnectToVideoCaptureService(
-      video_capture::mojom::DeviceFactoryRequest request) override {
-    DCHECK(delegate_) << "Delegate not set.";
-    delegate_->BindDeviceFactoryProviderToVideoCaptureService(
-        &device_factory_provider_);
-    device_factory_provider_->ConnectToDeviceFactory(std::move(request));
-  }
-
- private:
-  // Provides access to methods for talking to core Chrome code.
-  MediaPerceptionAPIDelegate* delegate_;
-
-  // Bound to the VideoCaptureService to establish the connection to the
-  // media analytics process.
-  video_capture::mojom::DeviceFactoryProviderPtr device_factory_provider_;
-
-  DISALLOW_COPY_AND_ASSIGN(ConnectorImpl);
-};
-
 extensions::api::media_perception_private::State GetStateForServiceError(
     const extensions::api::media_perception_private::ServiceError
         service_error) {
@@ -102,6 +77,46 @@ std::unique_ptr<std::string> ExtractVersionFromMountPoint(
 
 }  // namespace
 
+class MediaPerceptionAPIManager::MediaPerceptionControllerClient
+    : public chromeos::media_perception::mojom::
+          MediaPerceptionControllerClient {
+ public:
+  // delegate is owned by the ExtensionsAPIClient.
+  MediaPerceptionControllerClient(
+      MediaPerceptionAPIDelegate* delegate,
+      chromeos::media_perception::mojom::MediaPerceptionControllerClientRequest
+          request)
+      : delegate_(delegate), binding_(this, std::move(request)) {
+    DCHECK(delegate_) << "Delegate not set.";
+  }
+
+  ~MediaPerceptionControllerClient() override = default;
+
+  // media_perception::mojom::MediaPerceptionControllerClient:
+  void ConnectToVideoCaptureService(
+      video_capture::mojom::DeviceFactoryRequest request) override {
+    DCHECK(delegate_) << "Delegate not set.";
+    delegate_->BindDeviceFactoryProviderToVideoCaptureService(
+        &device_factory_provider_);
+    device_factory_provider_->ConnectToDeviceFactory(std::move(request));
+  }
+
+ private:
+  // Provides access to methods for talking to core Chrome code.
+  MediaPerceptionAPIDelegate* delegate_;
+
+  // Binding of the MediaPerceptionControllerClient to the message pipe.
+  mojo::Binding<
+      chromeos::media_perception::mojom::MediaPerceptionControllerClient>
+      binding_;
+
+  // Bound to the VideoCaptureService to establish the connection to the
+  // media analytics process.
+  video_capture::mojom::DeviceFactoryProviderPtr device_factory_provider_;
+
+  DISALLOW_COPY_AND_ASSIGN(MediaPerceptionControllerClient);
+};
+
 // static
 MediaPerceptionAPIManager* MediaPerceptionAPIManager::Get(
     content::BrowserContext* context) {
@@ -135,6 +150,12 @@ MediaPerceptionAPIManager::~MediaPerceptionAPIManager() {
   upstart_client->StopMediaAnalytics();
 }
 
+void MediaPerceptionAPIManager::ActivateMediaPerception(
+    chromeos::media_perception::mojom::MediaPerceptionRequest request) {
+  if (media_perception_controller_.is_bound())
+    media_perception_controller_->ActivateMediaPerception(std::move(request));
+}
+
 void MediaPerceptionAPIManager::SetMountPointNonEmptyForTesting() {
   mount_point_ = "non-empty-string";
 }
@@ -390,7 +411,7 @@ void MediaPerceptionAPIManager::SendMojoInvitation(
   MediaPerceptionAPIDelegate* delegate =
       ExtensionsAPIClient::Get()->GetMediaPerceptionAPIDelegate();
   if (!delegate) {
-    LOG(WARNING) << "Could not get MediaPerceptionAPIDelegate.";
+    DLOG(WARNING) << "Could not get MediaPerceptionAPIDelegate.";
     std::move(callback).Run(GetProcessStateForServiceError(
         extensions::api::media_perception_private::
             SERVICE_ERROR_MOJO_CONNECTION_FAILURE));
@@ -405,10 +426,10 @@ void MediaPerceptionAPIManager::SendMojoInvitation(
                                  base::kNullProcessHandle,
                                  channel.TakeLocalEndpoint());
 
-  auto connector = std::make_unique<ConnectorImpl>(delegate);
-  mojo::MakeStrongBinding(std::move(connector),
-                          chromeos::media_perception::mojom::ConnectorRequest(
-                              std::move(server_pipe)));
+  media_perception_service_ =
+      chromeos::media_perception::mojom::MediaPerceptionServicePtr(
+          chromeos::media_perception::mojom::MediaPerceptionServicePtrInfo(
+              std::move(server_pipe), 0));
 
   base::ScopedFD fd =
       channel.TakeRemoteEndpoint().TakePlatformHandle().TakeFD();
@@ -435,6 +456,46 @@ void MediaPerceptionAPIManager::OnBootstrapMojoConnection(
   extensions::api::media_perception_private::ProcessState state_started;
   state_started.status =
       extensions::api::media_perception_private::PROCESS_STATUS_STARTED;
+
+  // Check if the extensions api client is available in this context. Code path
+  // used for testing.
+  if (!ExtensionsAPIClient::Get()) {
+    DLOG(ERROR) << "Could not get ExtensionsAPIClient.";
+    std::move(callback).Run(std::move(state_started));
+    return;
+  }
+
+  MediaPerceptionAPIDelegate* delegate =
+      ExtensionsAPIClient::Get()->GetMediaPerceptionAPIDelegate();
+  if (!delegate) {
+    DLOG(WARNING) << "Could not get MediaPerceptionAPIDelegate.";
+    std::move(callback).Run(GetProcessStateForServiceError(
+        extensions::api::media_perception_private::
+            SERVICE_ERROR_MOJO_CONNECTION_FAILURE));
+    return;
+  }
+
+  if (!media_perception_service_.is_bound()) {
+    DLOG(WARNING) << "MediaPerceptionService interface not bound.";
+    std::move(callback).Run(GetProcessStateForServiceError(
+        extensions::api::media_perception_private::
+            SERVICE_ERROR_MOJO_CONNECTION_FAILURE));
+    return;
+  }
+
+  auto controller_request = mojo::MakeRequest(&media_perception_controller_);
+
+  chromeos::media_perception::mojom::MediaPerceptionControllerClientPtr
+      client_ptr;
+  media_perception_controller_client_ =
+      std::make_unique<MediaPerceptionControllerClient>(
+          delegate, mojo::MakeRequest(&client_ptr));
+  delegate->SetMediaPerceptionRequestHandler(
+      base::BindRepeating(&MediaPerceptionAPIManager::ActivateMediaPerception,
+                          weak_ptr_factory_.GetWeakPtr()));
+
+  media_perception_service_->GetController(std::move(controller_request),
+                                           std::move(client_ptr));
   std::move(callback).Run(std::move(state_started));
 }
 

extensions/browser/api/media_perception_private/media_perception_api_manager.h

@@ -12,10 +12,9 @@
 #include "base/scoped_observer.h"
 #include "chromeos/dbus/media_analytics_client.h"
 #include "chromeos/dbus/media_perception/media_perception.pb.h"
-#include "chromeos/services/media_perception/public/mojom/connector.mojom.h"
+#include "chromeos/services/media_perception/public/mojom/media_perception_service.mojom.h"
 #include "extensions/browser/browser_context_keyed_api_factory.h"
 #include "extensions/common/api/media_perception_private.h"
-#include "services/video_capture/public/mojom/device_factory_provider.mojom.h"
 
 namespace extensions {
 
@@ -47,6 +46,10 @@ class MediaPerceptionAPIManager
   static BrowserContextKeyedAPIFactory<MediaPerceptionAPIManager>*
   GetFactoryInstance();
 
+  // Handler for clients of the API requesting a MediaPerception Mojo interface.
+  void ActivateMediaPerception(
+      chromeos::media_perception::mojom::MediaPerceptionRequest request);
+
   // Public functions for MediaPerceptionPrivateAPI implementation.
   void SetAnalyticsComponent(
       const extensions::api::media_perception_private::Component& component,
@@ -67,6 +70,8 @@ class MediaPerceptionAPIManager
  private:
   friend class BrowserContextKeyedAPIFactory<MediaPerceptionAPIManager>;
 
+  class MediaPerceptionControllerClient;
+
   // BrowserContextKeyedAPI:
   static const char* service_name() { return "MediaPerceptionAPIManager"; }
 
@@ -142,6 +147,17 @@ class MediaPerceptionAPIManager
   // is set.
   std::string mount_point_;
 
+  // Pointer to the MediaPerceptionService interface for communicating with the
+  // service over Mojo.
+  chromeos::media_perception::mojom::MediaPerceptionServicePtr
+      media_perception_service_;
+
+  chromeos::media_perception::mojom::MediaPerceptionControllerPtr
+      media_perception_controller_;
+
+  std::unique_ptr<MediaPerceptionControllerClient>
+      media_perception_controller_client_;
+
   ScopedObserver<chromeos::MediaAnalyticsClient, MediaPerceptionAPIManager>
       scoped_observer_;
   base::WeakPtrFactory<MediaPerceptionAPIManager> weak_ptr_factory_;

extensions/browser/api/media_perception_private/media_perception_private_apitest.cc

@@ -49,7 +49,18 @@ class TestMediaPerceptionAPIDelegate : public MediaPerceptionAPIDelegate {
 
   void BindDeviceFactoryProviderToVideoCaptureService(
       video_capture::mojom::DeviceFactoryProviderPtr* provider) override {
-    LOG(ERROR) << "Not implemented.";
+    NOTIMPLEMENTED();
+  }
+
+  void SetMediaPerceptionRequestHandler(
+      MediaPerceptionRequestHandler handler) override {
+    NOTIMPLEMENTED();
+  }
+
+  void ForwardMediaPerceptionRequest(
+      chromeos::media_perception::mojom::MediaPerceptionRequest request,
+      content::RenderFrameHost* render_frame_host) override {
+    NOTIMPLEMENTED();
   }
 };
 

extensions/renderer/module_system.cc

@@ -122,7 +122,7 @@ bool ContextNeedsMojoBindings(ScriptContext* context) {
   //
   // Prefer to use Mojo from C++ if possible rather than adding to this list.
   static const char* const kApisRequiringMojo[] = {
-      "mimeHandlerPrivate", "mojoPrivate",
+      "mediaPerceptionPrivate", "mimeHandlerPrivate", "mojoPrivate",
   };
 
   for (const auto* api : kApisRequiringMojo) {