media::mojom::Remoter and CastRemotingConnector/Sender

extensions/renderer/resources/media_router_bindings.js

 // 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.
 
 var mediaRouter;
 
 define('media_router_bindings', [
     'mojo/public/js/bindings',
     'mojo/public/js/core',
     'content/public/renderer/frame_service_registry',
+    'chrome/browser/media/router/mojo/media_remoter.mojom',
     'chrome/browser/media/router/mojo/media_router.mojom',
     'extensions/common/mojo/keep_alive.mojom',
     'mojo/public/js/connection',
     'mojo/public/js/router',
 ], function(bindings,
             core,
             serviceProvider,
+            mediaRemoterMojom,
             mediaRouterMojom,
             keepAliveMojom,
             connector,
             routerModule) {
   'use strict';
 
   /**
    * Converts a media sink to a MediaSink Mojo object.
    * @param {!MediaSink} sink A media sink.
    * @return {!mediaRouterMojom.MediaSink} A Mojo MediaSink object.
@@ skipping 386 matching lines @@
   /**
    * @param {string} routeId
    * @param {!Array<!RouteMessage>} mesages
    */
   MediaRouter.prototype.onRouteMessagesReceived = function(routeId, messages) {
     this.service_.onRouteMessagesReceived(
         routeId, messages.map(messageToMojo_));
   };
 
   /**
+   * Creates a MediaRemotingSession that manages content remoting from the given
+   * media source. Only one session can be created for the same source; and an
+   * attempt to create a second before MediaRemotingSession.Terminate() is
+   * called will cause a null handle to be returned.
+   * @param {!string} sourceUrn
+   * @param {!MediaRemotingProvider} provider
+   * @return {!Promise<MediaRemotingSession>} A proxy interface to the remote
+   * MediaRemotingSession. On failure, the proxy is not bound.
+   */
+  MediaRouter.prototype.createRemotingSession =
+      function(sourceUrn, provider) {
+        return this.service_.createRemotingSession(sourceUrn, provider).then(
+            function(result) {
+              return connector.bindHandleToProxy(
+                  result.remoting_session,
+                  mediaRemoterMojom.MediaRemotingSession);
+            });
+      };
+
+  /**
    * Object containing callbacks set by the provider manager.
    *
    * @constructor
    * @struct
    */
   function MediaRouterHandlers() {
     /**
      * @type {function(!string, !string, !string, !string, !number)}
      */
     this.createRoute = null;
@@ skipping 401 matching lines @@
     // TODO(btolsch): Remove this check when we no longer expect old extensions
     // to be missing this API.
     if (!this.handlers_.searchSinks) {
       return Promise.resolve({'sink_id': ''});
     }
     return Promise.resolve({
       'sink_id': this.handlers_.searchSinks(sinkId, sourceUrn, searchCriteria)
     });
   };
 
+  /**
+   * Routes calls from the MediaRemotingSession in the browser process to the
+   * provider manager extension.
+   * @param {!object} Delegate that provides the MediaRemotingProvider
+   * implementation, which itself contains state relative to a specific
+   * MediaRemotingSession.
+   * @constructor
+   */
+  function MediaRemotingProvider(delegate) {
+    mediaRemoterMojom.MediaRemotingProvider.stubClass.call(this);
+
+    this.delegate_ = delegate;
+    const requiredMethods = [
+      'startMediaServices',
+      'stopMediaServices',
+      'sendMessageToRemote',
+      'onSessionTerminated',
+    ];
+    requiredMethods.forEach(function(name) {
+      if (!delegate || !(delegate[name] instanceof Function)) {
+        console.error(name + ' method not implemented.');
+      }
+    });
+  };
+  MediaRemotingProvider.prototype = Object.create(
+      mediaRemoterMojom.MediaRemotingProvider.stubClass.prototype);
+
+  /**
+   * Notifies the provider that remote media services have started.
+   */
+  MediaRemotingProvider.prototype.startMediaServices() {
+    this.delegate_.startMediaServices();
+  }
+
+  /**
+   * Notifies the provider that remote media services have stopped.
+   * @param{?string=} errorReason If specified, a human-readable string
+   * indicating remoting was stopped due to an error; otherwise, it is stopping
+   * normally.
+   */
+  MediaRemotingProvider.prototype.stopMediaServices(errorReason) {
+    this.delegate_.stopMediaServices(errorReason);
+  }
+
+  /**
+   * Forwards a message, via the provider, to the remote's media services.
+   * @param{!Object} message An array of byte values (can be any type of object
+   * that supports array-like operations, such as: string, Array, TypedArray).
+   */
+  MediaRemotingProvider.prototype.sendMessageToRemote(message) {
+    this.delegate_.sendMessageToRemote(message);
+  }
+
+  /**
+   * Notifies the provider that the MediaRemotingSession has been terminated.
+   * @param{?string=} errorReason If specified, a human-readable string
+   * indicating that the session was terminated due to an error; otherwise, it
+   * is terminating normally.
+   */
+  MediaRemotingProvider.prototype.onSessionTerminated(errorReason) {
+    this.delegate_.onSessionTerminated(errorReason);
+  }
+
   mediaRouter = new MediaRouter(connector.bindHandleToProxy(
       serviceProvider.connectToService(
           mediaRouterMojom.MediaRouter.name),
       mediaRouterMojom.MediaRouter));
 
   return mediaRouter;
 });
-