[Media Router] Adds a pre-invocation hook to Media Router bindings.

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_interfaces',
@@ skipping 527 matching lines @@
   }
   MediaRouteProvider.prototype = Object.create(
       mediaRouterMojom.MediaRouteProvider.stubClass.prototype);
 
   /*
    * 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
+    // 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',
+      'onBeforeInvokeHandler'
     ];
     requiredHandlers.forEach(function(nextHandler) {
       if (handlers[nextHandler] === undefined) {
         console.error(nextHandler + ' handler not registered.');
       }
     });
   }
 
   /**
    * Starts querying for sinks capable of displaying the media source
    * designated by |sourceUrn|.  Results are returned by calling
    * OnSinksReceived.
    * @param {!string} sourceUrn
    */
   MediaRouteProvider.prototype.startObservingMediaSinks =
       function(sourceUrn) {
+    this.handlers_.onBeforeInvokeHandler();
     this.handlers_.startObservingMediaSinks(sourceUrn);
   };
 
   /**
    * Stops querying for sinks capable of displaying |sourceUrn|.
    * @param {!string} sourceUrn
    */
   MediaRouteProvider.prototype.stopObservingMediaSinks =
       function(sourceUrn) {
+    this.handlers_.onBeforeInvokeHandler();
     this.handlers_.stopObservingMediaSinks(sourceUrn);
   };
 
   /**
    * Requests that |sinkId| render the media referenced by |sourceUrn|. If the
    * request is from the Presentation API, then origin and tabId will
    * be populated.
    * @param {!string} sourceUrn Media source to render.
    * @param {!string} sinkId Media sink ID.
    * @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 {!TimeDelta} timeout If positive, the timeout duration for the
    *     request. Otherwise, the default duration will be used.
    * @param {!boolean} incognito If true, the route is being requested by
    *     an 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.createRoute =
       function(sourceUrn, sinkId, presentationId, origin, tabId,
-          timeout, incognito) {
+               timeout, incognito) {
+    this.handlers_.onBeforeInvokeHandler();
     return this.handlers_.createRoute(
         sourceUrn, sinkId, presentationId, origin, tabId,
         Math.floor(timeout.microseconds / 1000), incognito)
         .then(function(route) {
           return toSuccessRouteResponse_(route);
         },
         function(err) {
           return toErrorRouteResponse_(err);
         });
   };
@@ skipping 10 matching lines @@
    *     request. Otherwise, the default duration will be used.
    * @param {!boolean} incognito If true, the route is being requested by
    *     an 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.joinRoute =
       function(sourceUrn, presentationId, origin, tabId, timeout,
                incognito) {
+    this.handlers_.onBeforeInvokeHandler();
     return this.handlers_.joinRoute(
         sourceUrn, presentationId, origin, tabId,
         Math.floor(timeout.microseconds / 1000), incognito)
         .then(function(route) {
           return toSuccessRouteResponse_(route);
         },
         function(err) {
           return toErrorRouteResponse_(err);
         });
   };
@@ skipping 11 matching lines @@
    *     request. Otherwise, the default duration will be used.
    * @param {!boolean} incognito If true, the route is being requested by
    *     an 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.connectRouteByRouteId =
       function(sourceUrn, routeId, presentationId, origin, tabId,
                timeout, incognito) {
+    this.handlers_.onBeforeInvokeHandler();
     return this.handlers_.connectRouteByRouteId(
         sourceUrn, routeId, presentationId, origin, tabId,
         Math.floor(timeout.microseconds / 1000), incognito)
         .then(function(route) {
           return toSuccessRouteResponse_(route);
         },
         function(err) {
           return toErrorRouteResponse_(err);
         });
   };
 
   /**
    * Terminates the route specified by |routeId|.
    * @param {!string} routeId
    * @return {!Promise<!Object>} A Promise resolving to an object describing
    *    the result of the terminate operation, or rejecting with an error
    *    message and code if the operation failed.
    */
   MediaRouteProvider.prototype.terminateRoute = function(routeId) {
+    this.handlers_.onBeforeInvokeHandler();
     // TODO(crbug.com/627967): Remove code path that doesn't expect a Promise
     // in M56.
     var maybePromise = this.handlers_.terminateRoute(routeId);
     var successResult = {
         result_code: mediaRouterMojom.RouteRequestResultCode.OK
     };
     if (maybePromise) {
       return maybePromise.then(
         function() { return successResult; },
         function(err) { return toErrorRouteResponse_(err); }
       );
     } else {
       return Promise.resolve(successResult);
     }
   };
 
   /**
    * Posts a message to the route designated by |routeId|.
    * @param {!string} routeId
    * @param {!string} message
    * @return {!Promise.<boolean>} Resolved with true if the message was sent,
    *    or false on failure.
    */
   MediaRouteProvider.prototype.sendRouteMessage = function(
-      routeId, message) {
+    routeId, message) {
+    this.handlers_.onBeforeInvokeHandler();
     return this.handlers_.sendRouteMessage(routeId, message)
         .then(function() {
           return {'sent': true};
         }, function() {
           return {'sent': false};
         });
   };
 
   /**
    * Sends a binary message to the route designated by |routeId|.
    * @param {!string} routeId
    * @param {!Uint8Array} data
    * @return {!Promise.<boolean>} Resolved with true if the data was sent,
    *    or false on failure.
    */
   MediaRouteProvider.prototype.sendRouteBinaryMessage = function(
-      routeId, data) {
+    routeId, data) {
+    this.handlers_.onBeforeInvokeHandler();
     return this.handlers_.sendRouteBinaryMessage(routeId, data)
         .then(function() {
           return {'sent': true};
         }, function() {
           return {'sent': false};
         });
   };
 
   /**
    * Listen for messages from a route.
    * @param {!string} routeId
    */
   MediaRouteProvider.prototype.startListeningForRouteMessages = function(
       routeId) {
+    this.handlers_.onBeforeInvokeHandler();
     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 (crbug.com/626395).
    * @param {!string} routeId
    */
   MediaRouteProvider.prototype.listenForRouteMessagesOld = function(routeId) {
+    this.handlers_.onBeforeInvokeHandler();
     this.handlers_.listenForRouteMessages(routeId)
         .then(function(messages) {
           // 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));
   };
 
   /**
    * @param {!string} routeId
    */
   MediaRouteProvider.prototype.stopListeningForRouteMessages = function(
       routeId) {
+    this.handlers_.onBeforeInvokeHandler();
     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);
   };
 
   /**
    * Requests that the provider manager start sending information about active
    * media routes to the Media Router.
    * @param {!string} sourceUrn
    */
   MediaRouteProvider.prototype.startObservingMediaRoutes = function(sourceUrn) {
+    this.handlers_.onBeforeInvokeHandler();
     this.handlers_.startObservingMediaRoutes(sourceUrn);
   };
 
   /**
    * Requests that the provider manager stop sending information about active
    * media routes to the Media Router.
    * @param {!string} sourceUrn
    */
   MediaRouteProvider.prototype.stopObservingMediaRoutes = function(sourceUrn) {
+    this.handlers_.onBeforeInvokeHandler();
     this.handlers_.stopObservingMediaRoutes(sourceUrn);
   };
 
   /**
    * Enables mDNS device discovery.
    */
   MediaRouteProvider.prototype.enableMdnsDiscovery = function() {
+    this.handlers_.onBeforeInvokeHandler();
     this.handlers_.enableMdnsDiscovery();
   };
 
   /**
    * Requests that the provider manager update media sinks.
    * @param {!string} sourceUrn
    */
   MediaRouteProvider.prototype.updateMediaSinks = function(sourceUrn) {
+    this.handlers_.onBeforeInvokeHandler();
     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
    * that can be used immediately for route creation, its ID is returned.
    * Otherwise the empty string is returned.
    *
    * @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.
    * @return {!Promise.<!{sink_id: !string}>} A Promise resolving to either the
    *     sink ID of the sink found by the search that can be used for route
    *     creation, or the empty string if no route can be immediately created.
    */
   MediaRouteProvider.prototype.searchSinks = function(
       sinkId, sourceUrn, searchCriteria) {
     // 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': ''});
     }
+    this.handlers_.onBeforeInvokeHandler();
     return Promise.resolve({
       'sink_id': this.handlers_.searchSinks(sinkId, sourceUrn, searchCriteria)
     });
   };
 
   mediaRouter = new MediaRouter(connector.bindHandleToProxy(
       frameInterfaces.getInterface(mediaRouterMojom.MediaRouter.name),
       mediaRouterMojom.MediaRouter));
 
   return mediaRouter;
 });
-