[Media Router] Export Mojom definitions in media_router_bindings.js.

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', [
     'content/public/renderer/frame_interfaces',
+    'chrome/browser/media/router/mojo/media_controller.mojom',
     'chrome/browser/media/router/mojo/media_router.mojom',
+    'chrome/browser/media/router/mojo/media_status.mojom',
     'extensions/common/mojo/keep_alive.mojom',
     'mojo/common/time.mojom',
     'mojo/public/js/bindings',
+    'net/interfaces/ip_address.mojom',
     'url/mojo/origin.mojom',
+    'url/mojo/url.mojom',
 ], function(frameInterfaces,
+            mediaControllerMojom,
             mediaRouterMojom,
+            mediaStatusMojom,
             keepAliveMojom,
             timeMojom,
             bindings,
-            originMojom) {
+            ipAddressMojom,
+            originMojom,
+            urlMojom) {
   'use strict';
 
   /**
    * Converts a media sink to a MediaSink Mojo object.
    * @param {!MediaSink} sink A media sink.
    * @return {!mediaRouterMojom.MediaSink} A Mojo MediaSink object.
    */
   function sinkToMojo_(sink) {
     return new mediaRouterMojom.MediaSink({
       'name': sink.friendlyName,
@@ skipping 219 matching lines @@
      * The bindings to bind the service delegate to the Mojo interface.
      * Object must remain in scope for the lifetime of the connection to
      * prevent the connection from closing automatically.
      * @type {!bindings.Binding}
      */
     this.mediaRouteProviderBinding_ = new bindings.Binding(
         mediaRouterMojom.MediaRouteProvider, this.mrpm_);
   }
 
   /**
+   * Returns definitions of Mojo core and generated Mojom classes that can be
+   * used directly by the component.
+   * @return {!Object}
+   * TODO(imcheng): We should export these along with MediaRouter. This requires
+   * us to modify the component to handle multiple exports. When that logic is
+   * baked in for a couple of milestones, we should be able to remove this
+   * method.
+   */
+  MediaRouter.prototype.getMojoExports = function() {
+    return {
+      Binding: bindings.Binding,
+      DialMediaSink: mediaRouterMojom.DialMediaSink,
+      CastMediaSink: mediaRouterMojom.CastMediaSink,
+      IPAddress: ipAddressMojom.IPAddress,
+      InterfacePtrController: bindings.InterfacePtrController,
+      InterfaceRequest: bindings.InterfaceRequest,
+      MediaController: mediaControllerMojom.MediaController,
+      MediaStatus: mediaStatusMojom.MediaStatus,
+      MediaStatusObserverPtr: mediaStatusMojom.MediaStatusObserverPtr,
+      Sink: mediaRouterMojom.MediaSink,
+      SinkExtraData: mediaRouterMojom.MediaSinkExtraData,
+      Url: urlMojom.Url,
+    };
+  };
+
+  /**
    * Registers the Media Router Provider Manager with the Media Router.
    * @return {!Promise<string>} Instance ID for the Media Router.
    */
   MediaRouter.prototype.start = function() {
     return this.service_.registerMediaRouteProvider(
         this.mediaRouteProviderBinding_.createInterfacePtrAndBind()).then(
             function(result) {
       return result.instance_id;
     }.bind(this));
   }
@@ skipping 242 matching lines @@
      * @type {function()}
      */
     this.enableMdnsDiscovery = null;
 
     /**
      * @type {function()}
      */
     this.updateMediaSinks = null;
 
     /**
-     * @type {function(!string, !string, !SinkSearchCriteria): !string}
+     * @type {function(string, string, !SinkSearchCriteria): string}
      */
     this.searchSinks = null;
+
+    /**
+     * @type {function(string, !bindings.InterfaceRequest): !Promise<boolean>}
+     */
+    this.createMediaRouteController = null;
+
+    /**
+     * @type {function(string, !mediaStatusMojom.MediaStatusObserverPtr)}
+     */
+    this.setMediaRouteStatusObserver = null;
   };
 
   /**
    * Routes calls from Media Router to the provider manager extension.
    * Registered with the MediaRouter stub.
    * @param {!MediaRouter} MediaRouter proxy to call into the
    * Media Router mojo interface.
    * @constructor
    */
   function MediaRouteProvider(mediaRouter) {
     /**
      * Object containing JS callbacks into Provider Manager code.
      * @type {!MediaRouterHandlers}
      */
     this.handlers_ = new MediaRouterHandlers();
 
     /**
      * Proxy class to the browser's Media Router Mojo service.
      * @type {!MediaRouter}
      */
     this.mediaRouter_ = mediaRouter;
   }
 
   /*
    * Sets the callback handler used to invoke methods in the provider manager.
    *
    * @param {!MediaRouterHandlers} handlers
    */
   MediaRouteProvider.prototype.setHandlers = function(handlers) {
     // TODO(mfoltz): Remove when component that supports this method is

[mark a. foltz, 2017/03/30 23:21:05]

We should do a pass through these bindings and remove obsolete backwards
compatibility code.
I can take this on :)

     // rolled out to all Chrome channels in M56.
     if (!handlers['onBeforeInvokeHandler'])
       handlers['onBeforeInvokeHandler'] = () => {};
     this.handlers_ = handlers;
     var requiredHandlers = [
       'stopObservingMediaRoutes',
       'startObservingMediaRoutes',
       'sendRouteMessage',
       'sendRouteBinaryMessage',
       'startListeningForRouteMessages',
       'stopListeningForRouteMessages',
       'detachRoute',
       'terminateRoute',
       'joinRoute',
       'createRoute',
       'stopObservingMediaSinks',
       'startObservingMediaRoutes',
       'connectRouteByRouteId',
       'enableMdnsDiscovery',
       'updateMediaSinks',
       'searchSinks',
+      'createMediaRouteController',
+      'setMediaRouteStatusObserver',
       'onBeforeInvokeHandler'
     ];
     requiredHandlers.forEach(function(nextHandler) {
       if (handlers[nextHandler] === undefined) {
         console.error(nextHandler + ' handler not registered.');
       }
     });
   }
 
   /**
@@ skipping 250 matching lines @@
     // to be missing this API.
     if (!this.handlers_.searchSinks) {
       return Promise.resolve({'sink_id': ''});
     }
     this.handlers_.onBeforeInvokeHandler();
     return Promise.resolve({
       'sink_id': this.handlers_.searchSinks(sinkId, sourceUrn, searchCriteria)
     });
   };
 
+
+  /**
+   * Creates a controller for the given route and binds the given
+   * InterfaceRequest to it.
+   * @param {string} routeId
+   * @param {!bindings.InterfaceRequest} controllerRequest
+   * @return {!Promise<!{success: boolean}>} Resolves to true if a controller
+   *     is created. Resolves to false if a controller cannot be created, or if
+   *     the controller is already bound.
+   */
+  MediaRouteProvider.prototype.createMediaRouteController = function(
+      routeId, controllerRequest) {
+    // TODO(imcheng): Remove this check when M59 is in stable.
+    if (!this.handlers_.createMediaRouteController) {
+      return Promise.resolve({success: false});
+    }
+
+    this.handlers_.onBeforeInvokeHandler();
+    this.handlers_.createMediaRouteController(routeId, controllerRequest)
+        .then(controller => {success: true},
+              e => {success: false});
+  }
+
+  /**
+   * Sets the MediaStatus oberver for a given route. MediaStatus updates are
+   * notified via the given observer interface.
+   * @param {string} routeId
+   * @param {!mediaStatusMojom.MediaStatusObserverPtr} observer
+   */
+  MediaRouteProvider.prototype.setMediaRouteStatusObserver = function(
+      routeId, observer) {
+    // TODO(imcheng): Remove this check when M59 is in stable.
+    if (!this.handlers_.setMediaRouteStatusObserver) {
+      return;
+    }
+    this.handlers_.onBeforeInvokeHandler();
+    this.handlers_.setMediaRouteStatusObserver(routeId, observer);
+  };
+
   mediaRouter = new MediaRouter(new mediaRouterMojom.MediaRouterPtr(
       frameInterfaces.getInterface(mediaRouterMojom.MediaRouter.name)));
 
   return mediaRouter;
 });