Add associated interfaces & bindings.

mojo/public/js/bindings.js

 // Copyright 2014 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.
 
 define("mojo/public/js/bindings", [
   "mojo/public/js/core",
   "mojo/public/js/interface_types",
   "mojo/public/js/lib/interface_endpoint_client",
   "mojo/public/js/router",
 ], function(core, types, interfaceEndpointClient, router) {
@@ skipping 35 matching lines @@
 
     if (ptrInfoOrHandle instanceof types.InterfacePtrInfo) {
       this.version = ptrInfoOrHandle.version;
       this.handle_ = ptrInfoOrHandle.handle;
     } else {
       this.handle_ = ptrInfoOrHandle;
     }
   };
 
   InterfacePtrController.prototype.isBound = function() {
-    return this.router_ !== null || this.handle_ !== null;
+    return this.interfaceEndpointClient_ !== null || this.handle_ !== null;
   };
 
   // Although users could just discard the object, reset() closes the pipe
   // immediately.
   InterfacePtrController.prototype.reset = function() {
     this.version = 0;
     if (this.interfaceEndpointClient_) {
       this.interfaceEndpointClient_.close();
       this.interfaceEndpointClient_ = null;
     }
     if (this.router_) {
       this.router_.close();
       this.router_ = null;
 
       this.proxy_ = null;
     }
     if (this.handle_) {
       core.close(this.handle_);
       this.handle_ = null;
     }
   };
 
   InterfacePtrController.prototype.resetWithReason = function(reason) {
-    this.configureProxyIfNecessary_();
-    this.interfaceEndpointClient_.close(reason);
-    this.interfaceEndpointClient_ = null;
+    if (this.isBound()) {
+      this.configureProxyIfNecessary_();
+      this.interfaceEndpointClient_.close(reason);
+      this.interfaceEndpointClient_ = null;
+    }
     this.reset();
   };
 
   InterfacePtrController.prototype.setConnectionErrorHandler = function(
       callback) {
     if (!this.isBound())
       throw new Error("Cannot set connection error handler if not bound.");
 
     this.configureProxyIfNecessary_();
     this.interfaceEndpointClient_.setConnectionErrorHandler(callback);
@@ skipping 23 matching lines @@
 
   InterfacePtrController.prototype.waitForNextMessageForTesting = function() {
     this.configureProxyIfNecessary_();
     this.router_.waitForNextMessageForTesting();
   };
 
   InterfacePtrController.prototype.configureProxyIfNecessary_ = function() {
     if (!this.handle_)
       return;
 
-    this.router_ = new router.Router(this.handle_);
+    this.router_ = new router.Router(this.handle_, true);
     this.handle_ = null;
 
     this.interfaceEndpointClient_ = new InterfaceEndpointClient(
-        this.router_.createLocalEndpointHandle(types.kMasterInterfaceId),
-        this.router_);
+        this.router_.createLocalEndpointHandle(types.kMasterInterfaceId));
 
     this.interfaceEndpointClient_ .setPayloadValidators([
         this.interfaceType_.validateResponse]);
     this.proxy_ = new this.interfaceType_.proxyClass(
         this.interfaceEndpointClient_);
   };
 
   InterfacePtrController.prototype.queryVersion = function() {
     function onQueryVersion(version) {
       this.version = version;
@@ skipping 58 matching lines @@
     var handle = requestOrHandle instanceof types.InterfaceRequest ?
         requestOrHandle.handle : requestOrHandle;
     if (!core.isHandle(handle))
       return;
 
     this.router_ = new router.Router(handle);
 
     this.stub_ = new this.interfaceType_.stubClass(this.impl_);
     this.interfaceEndpointClient_ = new InterfaceEndpointClient(
         this.router_.createLocalEndpointHandle(types.kMasterInterfaceId),
-        this.router_, this.interfaceType_.kVersion);
-    this.interfaceEndpointClient_.setIncomingReceiver(this.stub_);
+        this.stub_, this.interfaceType_.kVersion);
+
     this.interfaceEndpointClient_ .setPayloadValidators([
         this.interfaceType_.validateRequest]);
   };
 
   Binding.prototype.close = function() {
     if (!this.isBound())
       return;
 
     if (this.interfaceEndpointClient_) {
       this.interfaceEndpointClient_.close();
       this.interfaceEndpointClient_ = null;
     }
 
     this.router_.close();
     this.router_ = null;
     this.stub_ = null;
   };
 
   Binding.prototype.closeWithReason = function(reason) {
     if (this.interfaceEndpointClient_) {
       this.interfaceEndpointClient_.close(reason);
       this.interfaceEndpointClient_ = null;
     }
     this.close();
   };
 
-  Binding.prototype.setConnectionErrorHandler
-      = function(callback) {
+  Binding.prototype.setConnectionErrorHandler = function(callback) {
     if (!this.isBound()) {
       throw new Error("Cannot set connection error handler if not bound.");
     }
     this.interfaceEndpointClient_.setConnectionErrorHandler(callback);
   };
 
   Binding.prototype.unbind = function() {
     if (!this.isBound())
       return new types.InterfaceRequest(null);
 
@@ skipping 63 matching lines @@
   var exports = {};
   exports.InterfacePtrInfo = types.InterfacePtrInfo;
   exports.InterfaceRequest = types.InterfaceRequest;
   exports.makeRequest = makeRequest;
   exports.InterfacePtrController = InterfacePtrController;
   exports.Binding = Binding;
   exports.BindingSet = BindingSet;
 
   return exports;
 });