[Media Router] Wiring for searching route providers for new sinks.

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',
@@ skipping 257 matching lines @@
    * @param {Array<string>=} opt_origins
    */
   MediaRouter.prototype.onSinksReceived = function(sourceUrn, sinks,
       opt_origins) {
     // TODO(imcheng): Make origins required in M52+.
     this.service_.onSinksReceived(sourceUrn, sinks.map(sinkToMojo_),
         opt_origins || []);
   };
 
   /**
+   * Called by the provider manager when a sink is found to notify the MR of the
+   * sink's ID. The actual sink will be returned through the normal sink list
+   * update process, so this helps the MR identify the search result in the
+   * list.
+   * @param {string} pseudoSinkId  ID of the pseudo sink that started the
+   *     search.
+   * @param {string} sinkId ID of the newly-found sink.
+   */
+  MediaRouter.prototype.onSearchSinkIdReceived = function(
+      pseudoSinkId, sinkId) {
+    this.service_.onSearchSinkIdReceived(pseudoSinkId, sinkId);
+  };
+
+  /**
    * Called by the provider manager to keep the extension from suspending
    * if it enters a state where suspension is undesirable (e.g. there is an
    * active MediaRoute.)
    * If keepAlive is true, the extension is kept alive.
    * If keepAlive is false, the extension is allowed to suspend.
    * @param {boolean} keepAlive
    */
   MediaRouter.prototype.setKeepAlive = function(keepAlive) {
     if (keepAlive === false && this.keepAlive_) {
       this.keepAlive_.close();
@@ skipping 188 matching lines @@
 
     /**
      * @type {function()}
      */
     this.enableMdnsDiscovery = null;
 
     /**
      * @type {function()}
      */
     this.updateMediaSinks = null;
+
+    /**
+     * @type {function(!string, !string, !SinkSearchCriteria, !string, !string,
+     *                 !number, !number, !boolean)}
+     */
+    this.searchSinksAndCreateRoute = 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) {
@@ skipping 30 matching lines @@
       'stopListeningForRouteMessages',
       'detachRoute',
       'terminateRoute',
       'joinRoute',
       'createRoute',
       'stopObservingMediaSinks',
       'startObservingMediaRoutes',
       'connectRouteByRouteId',
       'enableMdnsDiscovery',
       'updateMediaSinks',
+      'searchSinksAndCreateRoute',
     ];
     requiredHandlers.forEach(function(nextHandler) {
       if (handlers[nextHandler] === undefined) {
         console.error(nextHandler + ' handler not registered.');
       }
     });
   }
 
   /**
    * Starts querying for sinks capable of displaying the media source
@@ skipping 214 matching lines @@
   };
 
   /**
    * Requests that the provider manager update media sinks.
    * @param {!string} sourceUrn
    */
   MediaRouteProvider.prototype.updateMediaSinks = function(sourceUrn) {
     this.handlers_.updateMediaSinks(sourceUrn);
   };
 
+  /**
+   * Requests that the provider manager search its providers for a sink matching
+   * |searchCriteria| that is compatible with |sourceUrn|. If a sink is found, a
+   * route is created with the remaining parameters the same as createRoute().
+   * The route will be returned by this function as for createRoute() but the
+   * sink will be returned through the normal sink update process and its ID
+   * will be returned through onSearchSinkIdReceived().
+   * @param {string} sinkId Sink ID of the pseudo sink generating the request.
+   * @param {string} sourceUrn Media source to be used with the sink.
+   * @param {!SinkSearchCriteria} searchCriteria Search criteria for the route
+   *     providers.
+   * @param {!string} presentationId Presentation ID from the site
+   *     requesting presentation. TODO(mfoltz): Remove.
+   * @param {!string} origin Origin of site requesting presentation.
+   * @param {!number} tabId ID of tab requesting presentation.
+   * @param {!number} timeoutMillis If positive, the timeout duration for the
+   *     request, measured in seconds. Otherwise, the default duration will be
+   *     used.
+   * @param {!boolean} offTheRecord If true, the route is being requested by
+   *     an off the record (incognito) profile.
+   * @return {!Promise.<!Object>} A Promise resolving to an object describing
+   *     the newly created media route, or rejecting with an error message on
+   *     failure.
+   */
+  MediaRouteProvider.prototype.searchSinksAndCreateRoute = function(
+      sinkId, sourceUrn, searchCriteria, presentationId, origin, tabId,
+      timeoutMillis, offTheRecord) {
+    return this.handlers_
+        .searchSinksAndCreateRoute(
+            sinkId, sourceUrn, searchCriteria, presentationId, origin, tabId,
+            timeoutMillis, offTheRecord)
+        .then(
+            function(route) { return toSuccessRouteResponse_(route); },
+            function(err) { return toErrorRouteResponse_(err); });
+  };
+
   mediaRouter = new MediaRouter(connector.bindHandleToProxy(
       serviceProvider.connectToService(
           mediaRouterMojom.MediaRouter.name),
       mediaRouterMojom.MediaRouter));
 
   return mediaRouter;
 });