Mojo JS Bindings: Eliminate foo$ Stub and Proxy class members

examples/js/README.md

 JavaScript Mojo Example Applications
 =====================
 
 hello.js, world.js - A minimal application that connects to another.
 
 wget.js - Uses the network service to load a URL.
 
 cube.js - A JS version of examples/sample_app.
 
 --- Running Mojo Applications --- 
@@ skipping 17 matching lines @@
 and loading the "main" JS module and all of the modules the main module
 depends on. 
 
 This is the overall structure of a JS Mojo application:
 
   #!mojo:js_content_handler
 
   define("main", ["mojo/services/public/js/application", 
     <list of other modules that this application depends on>
 ],
-    function(appModule, <one parameter per dependent module>) {
-      class MyApplication extends appModule.Application {
+    function(application, <one parameter per dependent module>) {
+      class MyApplication extends application.Application {
         constructor(appShell, url) {
           super(appShell, url); // Initializes this.shell, this.url.
           // MyApplication initializations here. 
         }
 
         initialize(args) {
         }
 
         acceptConnection(url, serviceProvider) {
         }
@@ skipping 47 matching lines @@
 another application.
 
 The JS bindings for a Mojo interface's API are delivered as a JS module whose
 name is based on the '.mojom' file's path. For example, to use the Mojo network
 service you need the JS module based on network_service.mojom:
 
   define("main", [
     "mojo/services/network/public/interfaces/network_service.mojom",
     "mojo/services/public/js/application",
   ]
-    function(netModule, appModule) {
-      class MyApplication extends appModule.Application {
+    function(net, application) {
+      class MyApplication extends application.Application {
         initialize(args) {
           var netService = this.shell.connectToService(
-              "mojo:network_service", netModule.NetworkService);
+              "mojo:network_service", net.NetworkService);
           // Use netService's NetworkService methods.
         }
         ...
       }
 
       return MyApplication;
     });
 
 The first connectToService() parameter is the Mojo URL for the network service
 application and the second is the JS "interface" object for NetworkService. The
@@ skipping 168 matching lines @@
 
   [Client=Foo] // Redundant but always implicitly true.
   interface Bar {
   }
 
   interface I {
     provideFoo(Foo foo);
     requestFoo(Foo& foo); // effectively: provideFoo(Bar bar)
   } 
 
--- In General
+-- Stubs and Proxies
+
+TODO: briefly introduce message pipes. 
+TODO: explain what stubs and proxies are, explain what's meant by "local" and "remote". 
+TODO: explain the StubBindings and ProxyBindings functions.
+TODO: support creating a proxy from a handle new MyProxy(someHandle);
+TODO: explain the Connection object and how it relates to this stuff.
 
 From a user's point of view, the bindings are in terms of the (remote)
-proxy class and the (local) stub class's implementation delegate
-(internally, that's the stub class's delegate$ property).  The
-bindings will add/use a local$ property on proxy objects which points
-to the stub class's implementation delegate. They also manage remote$
-property on the implementation delegate whose value is the proxy.
+proxy class and the (local) stub class. Properties are added to instances
+of these classes using functions called StubBindings and ProxyBindings.
 
-All that implies:
-
-fooImpl.remote$.local$ == fooImpl (the stub class's delegate)
-fooProxy.local$.remote$ == fooProxy
 
 
 -- Callers
 
 Assuming that we have a proxy for interface I, iProxy.
 
 An iProxy.provideFoo() call implies that we have an implementation of
 Foo, and want a proxy for Bar (Foo's client).
 
-  var myFooImpl;
-  provideFoo(myFooImpl);
-  myFooImpl.remote$; // A Bar proxy initialized by provideFoo(), undefined if Foo has no client.
+  var barProxy;
+  iProxy.provideFoo(function(remote) {
+    barProxy = remote;
+    return myFooImpl;
+  });
 
 An iProxy.requestFoo() call implies that we have an implementation of
 Bar and want a proxy for Foo (Bar's client).
 
-  var myBarImpl; // If Foo has no client then this is just {}.
-  requestFoo(myBarImpl);
-  myBarImpl.remote$; // A Foo proxy initialized by requestFoo.
+  var fooProxy;
+  iProxy.requestFoo(function(remote) {
+    fooProxy = remote;
+    return myBarImpl;
+  });
+
+In the requestFoo() case, if no client were defined for Bar the function
+parameter need not return anything.
 
 The wget.js example includes a request for the URLLoader service.
 
 -- Callees
 
 An implementation of provideFoo(Foo foo) implies that we have an
 implementation of Bar (Foo's client) and want a proxy to the Foo
 that has been passed to us.
 
   void provideFoo(fooProxy) {
-    fooProxy.local$ = myBarImpl; // sets myFooImpl.remote$ = fooProxy
+    ProxyBindings(fooProxy).setLocalDelegate(myMyBarImpl);
   }
 
 An implementation of requestFoo(Foo& foo) implies that we have an
 implementation of Foo and want a proxy for the Bar (Foo's client)
 that's been passed to us.
 
   void requestFoo(barProxy) {
-    barProxy.local$ = myFooImpl; // sets myFooImpl.remote$ = barProxy
+    ProxyBindings(barProxy).setLocallocalDelegate(myFooImpl);
   }