Mojo JS bindings: simplify mojo.connectToService() usage - Part 1

mojo/apps/js/bindings/connection_unittests.js

 // Copyright 2013 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.
 
 // Mock out the support module to avoid depending on the message loop.
 define("mojo/public/js/bindings/support", ["timer"], function(timer) {
   var waitingCallbacks = [];
 
   function WaitCookie(id) {
     this.id = id;
@@ skipping 67 matching lines @@
     threading.quit();
   }.bind(this)).catch(function(e) {
     this.result = "FAIL: " + (e.stack || e);
     threading.quit();
   }.bind(this));
 
   function testClientServer() {
     var receivedFrobinate = false;
     var receivedDidFrobinate = false;
 
-    // ServiceImpl -------------------------------------------------------------
+    // ServiceImpl ------------------------------------------------------------
 
     function ServiceImpl(peer) {
       this.peer = peer;
     }
 
-    ServiceImpl.prototype = Object.create(sample_service.ServiceStub.prototype);
+    ServiceImpl.prototype = Object.create(
+        sample_service.Service.stubClass.prototype);
 
     ServiceImpl.prototype.frobinate = function(foo, baz, port) {
       receivedFrobinate = true;
 
       expect(foo.name).toBe("Example name");
       expect(baz).toBeTruthy();
       expect(core.close(port)).toBe(core.RESULT_OK);
 
       this.peer.didFrobinate(42);
     };
 
-    // ServiceImpl -------------------------------------------------------------
+    // ServiceClientImpl ------------------------------------------------------
 
     function ServiceClientImpl(peer) {
       this.peer = peer;
     }
 
     ServiceClientImpl.prototype =
-        Object.create(sample_service.ServiceClientStub.prototype);
+        Object.create(sample_service.ServiceClient.stubClass.prototype);
 
     ServiceClientImpl.prototype.didFrobinate = function(result) {
       receivedDidFrobinate = true;
 
       expect(result).toBe(42);
     };
 
     var pipe = core.createMessagePipe();
     var anotherPipe = core.createMessagePipe();
     var sourcePipe = core.createMessagePipe();
 
     var connection0 = new connection.Connection(
-        pipe.handle0, ServiceImpl, sample_service.ServiceClientProxy);
+        pipe.handle0, ServiceImpl, sample_service.ServiceClient.proxyClass);
 
     var connection1 = new connection.Connection(
-        pipe.handle1, ServiceClientImpl, sample_service.ServiceProxy);
+        pipe.handle1, ServiceClientImpl, sample_service.Service.proxyClass);
 
     var foo = new sample_service.Foo();
     foo.bar = new sample_service.Bar();
     foo.name = "Example name";
     foo.source = sourcePipe.handle0;
     connection1.remote.frobinate(foo, true, anotherPipe.handle0);
 
     mockSupport.pumpOnce(core.RESULT_OK);
 
     expect(receivedFrobinate).toBeTruthy();
@@ skipping 16 matching lines @@
 
     // The Connection object is responsible for closing these handles.
     expect(core.close(pipe.handle0)).toBe(core.RESULT_INVALID_ARGUMENT);
     expect(core.close(pipe.handle1)).toBe(core.RESULT_INVALID_ARGUMENT);
   }
 
   function testWriteToClosedPipe() {
     var pipe = core.createMessagePipe();
 
     var connection1 = new connection.Connection(
-        pipe.handle1, function() {}, sample_service.ServiceProxy);
+        pipe.handle1, function() {}, sample_service.Service.proxyClass);
 
     // Close the other end of the pipe.
     core.close(pipe.handle0);
 
     // Not observed yet because we haven't pumped events yet.
     expect(connection1.encounteredError()).toBeFalsy();
 
     var foo = new sample_service.Foo();
     foo.bar = new sample_service.Bar();
     // TODO(darin): crbug.com/357043: pass null in place of |foo| here.
@@ skipping 12 matching lines @@
 
   function testRequestResponse() {
 
     // ProviderImpl ------------------------------------------------------------
 
     function ProviderImpl(peer) {
       this.peer = peer;
     }
 
     ProviderImpl.prototype =
-        Object.create(sample_interfaces.ProviderStub.prototype);
+        Object.create(sample_interfaces.Provider.stubClass.prototype);
 
     ProviderImpl.prototype.echoString = function(a) {
       mockSupport.queuePump(core.RESULT_OK);
       return Promise.resolve({a: a});
     };
 
     ProviderImpl.prototype.echoStrings = function(a, b) {
       mockSupport.queuePump(core.RESULT_OK);
       return Promise.resolve({a: a, b: b});
     };
 
     // ProviderClientImpl ------------------------------------------------------
 
     function ProviderClientImpl(peer) {
       this.peer = peer;
     }
 
     ProviderClientImpl.prototype =
-        Object.create(sample_interfaces.ProviderClientStub.prototype);
+        Object.create(sample_interfaces.ProviderClient.stubClass.prototype);
 
     var pipe = core.createMessagePipe();
 
     var connection0 = new connection.Connection(
-        pipe.handle0, ProviderImpl, sample_interfaces.ProviderClientProxy);
+        pipe.handle0,
+        ProviderImpl,
+        sample_interfaces.ProviderClient.proxyClass);
 
     var connection1 = new connection.Connection(
-        pipe.handle1, ProviderClientImpl, sample_interfaces.ProviderProxy);
+        pipe.handle1,
+        ProviderClientImpl,
+        sample_interfaces.Provider.proxyClass);
 
     var origReadMessage = core.readMessage;
     // echoString
     mockSupport.queuePump(core.RESULT_OK);
     return connection1.remote.echoString("hello").then(function(response) {
       expect(response.a).toBe("hello");
     }).then(function() {
       // echoStrings
       mockSupport.queuePump(core.RESULT_OK);
       return connection1.remote.echoStrings("hello", "world");
@@ skipping 10 matching lines @@
     }).then(function() {
       throw Error("Expected echoString to fail.");
     }, function(error) {
       expect(error.message).toBe("Connection error: " + core.RESULT_UNKNOWN);
 
       // Clean up.
       core.readMessage = origReadMessage;
     });
   }
 });