[Media Router] Replace route messaging API.

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 394 matching lines @@
    * @param {string} reason
    * @param {string} message
    */
   MediaRouter.prototype.onPresentationConnectionClosed =
       function(routeId, reason, message) {
     this.service_.onPresentationConnectionClosed(
         routeId, presentationConnectionCloseReasonToMojo_(reason), message);
   };
 
   /**
+   * @param {string} routeId
+   * @param {!Array<!RouteMessage>} mesages
+   */
+  MediaRouter.prototype.onRouteMessagesReceived = function(routeId, messages) {
+    this.service_.onRouteMessagesReceived(
+        routeId, messages.map(messageToMojo_));
+  };
+
+  /**
    * Object containing callbacks set by the provider manager.
    *
    * @constructor
    * @struct
    */
   function MediaRouterHandlers() {
     /**
      * @type {function(!string, !string, !string, !string, !number)}
      */
     this.createRoute = null;
@@ skipping 22 matching lines @@
      * @type {function(string, string): Promise}
      */
     this.sendRouteMessage = null;
 
     /**
      * @type {function(string, Uint8Array): Promise}
      */
     this.sendRouteBinaryMessage = null;
 
     /**
+     * TODO(imcheng): Remove in M55.

[apacible, 2016/07/07 15:57:44]

I'm likely missing context here -- what's special about M55?

Can you also file a bug for this so it isn't forgotten?

[imcheng, 2016/07/07 18:00:58]

My intention is for this patch to make it to M53. Generally speaking it should
be safe to remove backwards compatibility support two releases later, which
would be M55. I added a crbug and linked it here.

      * @type {function(string):
      *     Promise.<{messages: Array.<RouteMessage>, error: boolean}>}
      */
     this.listenForRouteMessages = null;
 
     /**
      * @type {function(string)}
      */
+    this.startlisteningForRouteMessages = null;
+
+    /**
+     * @type {function(string)}
+     */
     this.stopListeningForRouteMessages = null;
 
     /**
      * @type {function(string)}
      */
     this.detachRoute = null;
 
     /**
      * @type {function()}
      */
@@ skipping 55 matching lines @@
    *
    * @param {!MediaRouterHandlers} handlers
    */
   MediaRouteProvider.prototype.setHandlers = function(handlers) {
     this.handlers_ = handlers;
     var requiredHandlers = [
       'stopObservingMediaRoutes',
       'startObservingMediaRoutes',
       'sendRouteMessage',
       'sendRouteBinaryMessage',
-      'listenForRouteMessages',
+      'startListeningForRouteMessages',
       'stopListeningForRouteMessages',
       'detachRoute',
       'terminateRoute',
       'joinRoute',
       'createRoute',
       'stopObservingMediaSinks',
       'startObservingMediaRoutes',
       'connectRouteByRouteId',
       'enableMdnsDiscovery',
       'updateMediaSinks',
@@ skipping 157 matching lines @@
       routeId, data) {
     return this.handlers_.sendRouteBinaryMessage(routeId, data)
         .then(function() {
           return {'sent': true};
         }, function() {
           return {'sent': false};
         });
   };
 
   /**
-   * Listen for next batch of messages from one of the routeIds.
+   * Listen for messages from a route.
    * @param {!string} routeId
-   * @return {!Promise.<{messages: Array.<RouteMessage>, error: boolean}>}
-   *     Resolved with a list of messages, and a boolean indicating if an error
-   *     occurred.
    */
-  MediaRouteProvider.prototype.listenForRouteMessages = function(routeId) {
-    return this.handlers_.listenForRouteMessages(routeId)
+  MediaRouteProvider.prototype.startListeningForRouteMessages = function(
+      routeId) {
+    if (this.handlers_.startListeningForRouteMessages) {
+      this.handlers_.startListeningForRouteMessages(routeId);
+    } else {
+      // Old API.
+      this.listenForRouteMessagesOld(routeId);
+    }
+  };
+
+
+  /**
+   * A hack to adapt new MR messaging API to old extension messaging API.
+   * TODO(imcheng): Remove in M55.
+   * @param {!string} routeId
+   */
+  MediaRouteProvider.prototype.listenForRouteMessagesOld = function(routeId) {
+    this.handlers_.listenForRouteMessages(routeId)
         .then(function(messages) {
-          return {'messages': messages.map(messageToMojo_), 'error': false};
-        }, function() {
-          return {'messages': [], 'error': true};
-        });
+          // If messages is empty, then stopListeningForRouteMessages has been
+          // called. We don't need to send it back to MR.
+          if (messages.length > 0) {
+            // Send the messages back to MR, and listen for next batch of
+            // messages.
+            this.mediaRouter_.onRouteMessagesReceived(routeId, messages);
+            this.listenForRouteMessagesOld(routeId);
+          }
+        }.bind(this), function() {
+          // Ignore rejections.
+        }.bind(this));
   };
 
   /**
-   * If there is an outstanding |listenForRouteMessages| promise for
-   * |routeId|, resolve that promise with an empty array.
    * @param {!string} routeId
    */
   MediaRouteProvider.prototype.stopListeningForRouteMessages = function(
       routeId) {
-    return this.handlers_.stopListeningForRouteMessages(routeId);
+    this.handlers_.stopListeningForRouteMessages(routeId);
   };
 
   /**
    * Indicates that the presentation connection that was connected to |routeId|
    * is no longer connected to it.
    * @param {!string} routeId
    */
   MediaRouteProvider.prototype.detachRoute = function(
       routeId) {
     this.handlers_.detachRoute(routeId);
@@ skipping 59 matching lines @@
   };
 
   mediaRouter = new MediaRouter(connector.bindHandleToProxy(
       serviceProvider.connectToService(
           mediaRouterMojom.MediaRouter.name),
       mediaRouterMojom.MediaRouter));
 
   return mediaRouter;
 });