Mojo JS: Attempt to simplify bindTo* related code.

mojo/public/js/connection.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/connection", [
   "mojo/public/js/bindings",
   "mojo/public/js/connector",
   "mojo/public/js/core",
   "mojo/public/js/router",
 ], function(bindings, connector, core, router) {
@@ skipping 130 matching lines @@
     if (!core.isHandle(handle))
       throw new Error("Not a handle " + handle);
 
     var stub = new localInterface.stubClass;
     var router = new Router(handle);
     var connection = new BaseConnection(stub, undefined, router);
     StubBindings(stub).connection = connection;
     return stub;
   }
 
+  /**
+   * Creates a messape pipe and links one end of the pipe to the given object.
+   * @param {!Object} obj The object to create a handle for. Must be a subclass
+   *     of an auto-generated stub class.
+   * @return {!MojoHandle} The other (not yet connected) end of the message
+   *     pipe.
+   */
+  function createHandleForImpl(obj) {

[yzshen1, 2016/05/27 18:32:46]

I like this method!

I feel that createMessagePipeAndBindImpl() may be more clear. Because
createHandleForImpl() sounds like the handle returned is for the impl, but
actually it is for the opposite side.

WDYT?

[dpapad, 2016/05/27 20:36:56]

Done.
As a side note, there is a similar (but not identical) bindImpl() method a few
lines above. I think in follow up cleanups perhaps we can migrate all callers
(if any) to use the newer method, and rename the newer method to simply
bindImpl(). In any case I would prefer to leave such cleanups for later, such
that I can simplify the chrome://plugins page now, which will be used as a
reference example for future migrations.

[yzshen1, 2016/05/27 20:58:13]

Ah, I didn't notice that one! Then in order to make things more consistent,
maybe this one could be named bindStubDerivedImpl()?

Sorry. :)

[dpapad, 2016/05/27 21:16:09]

No problem. Done.

After looking further into the existing bindImpl(), it seems quite odd from an
API perspective. It essentially returns two values, the newly created "stub"
object, and handle1 from the newly created pipe. The "stub" object is returned
via a callback that is passed as a param to bindImpl(), whereas the handle is
returned via a normal "return" statement. It could simply return an object as
follows.
return {handle: pipe.handle1, stub: stub};

Either way, when I find time for some more cleanups, I'll find all call sites of
all bind*() public methods to possibly come up with a reduced and simpler set of
bind*() methods.

+    var pipe = core.createMessagePipe();
+    var router = new Router(pipe.handle0);
+    var connection = new BaseConnection(obj, undefined, router);
+    obj.connection = connection;
+    return pipe.handle1;
+  }
+
   var exports = {};
   exports.Connection = Connection;
   exports.TestConnection = TestConnection;
 
   exports.bindProxy = bindProxy;
   exports.bindImpl = bindImpl;
   exports.bindHandleToProxy = bindHandleToProxy;
   exports.bindHandleToStub = bindHandleToStub;
+  exports.createHandleForImpl = createHandleForImpl;
   return exports;
 });