Revert of Mojo JS bindings: switch most usage of "connection"/"router" module to "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',
     'chrome/browser/media/router/mojo/media_router.mojom',
     'extensions/common/mojo/keep_alive.mojom',
     'mojo/common/time.mojom',
-    'mojo/public/js/bindings',
-], function(frameInterfaces,
+    'mojo/public/js/connection',
+    'mojo/public/js/router',
+], function(bindings,
+            core,
+            frameInterfaces,
             mediaRouterMojom,
             keepAliveMojom,
             timeMojom,
-            bindings) {
+            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.
    */
   function sinkToMojo_(sink) {
     return new mediaRouterMojom.MediaSink({
       'name': sink.friendlyName,
@@ skipping 146 matching lines @@
   function toErrorRouteResponse_(error) {
     return {
         error_text: error.message,
         result_code: getRouteRequestResultCode_(error)
     };
   }
 
   /**
    * Creates a new MediaRouter.
    * Converts a route struct to its Mojo form.
-   * @param {!mediaRouterMojom.MediaRouterPtr} service
+   * @param {!MediaRouterService} service
    * @constructor
    */
   function MediaRouter(service) {
     /**
      * The Mojo service proxy. Allows extension code to call methods that reside
      * in the browser.
-     * @type {!mediaRouterMojom.MediaRouterPtr}
+     * @type {!MediaRouterService}
      */
     this.service_ = service;
 
     /**
      * The provider manager service delegate. Its methods are called by the
      * browser-resident Mojo service.
      * @type {!MediaRouter}
      */
     this.mrpm_ = new MediaRouteProvider(this);
 
@@ skipping 72 matching lines @@
   /**
    * 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_.ptr.reset();
+      this.keepAlive_.close();
       this.keepAlive_ = null;
     } else if (keepAlive === true && !this.keepAlive_) {
-      this.keepAlive_ = new keepAliveMojom.KeepAlivePtr(
+      this.keepAlive_ = new routerModule.Router(
           frameInterfaces.getInterface(keepAliveMojom.KeepAlive.name));
     }
   };
 
   /**
    * Called by the provider manager to send an issue from a media route
    * provider to the Media Router, to show the user.
    * @param {!Object} issue The issue object.
    */
   MediaRouter.prototype.onIssue = function(issue) {
@@ skipping 187 matching lines @@
   };
 
   /**
    * 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) {
+    mediaRouterMojom.MediaRouteProvider.stubClass.call(this);
+
     /**
      * 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;
   }
+  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'])
@@ skipping 279 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)
     });
   };
 
-  mediaRouter = new MediaRouter(new mediaRouterMojom.MediaRouterPtr(
-      frameInterfaces.getInterface(mediaRouterMojom.MediaRouter.name)));
+  mediaRouter = new MediaRouter(connector.bindHandleToProxy(
+      frameInterfaces.getInterface(mediaRouterMojom.MediaRouter.name),
+      mediaRouterMojom.MediaRouter));
 
   return mediaRouter;
 });