Dart: Adds optional named arguments for creating bindings.

mojo/dart/test/interface_test.dart

 // 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.
 
 import 'dart:async';
 import 'dart:isolate';
 import 'dart:typed_data';
 import 'mojo:bindings' as bindings;
 import 'mojo:core' as core;
 
@@ skipping 60 matching lines @@
     var encoder0 = encoder.getStructEncoderAtOffset(kDefaultStructInfo);
     encoder0.encodeString(a, 8, false);
   }
 }
 
 
 const int kEchoString_name = 0;
 const int kEchoStringResponse_name = 1;
 
 class EchoStub extends bindings.Stub {
-  EchoStub(core.MojoMessagePipeEndpoint endpoint) : super(endpoint);
+  EchoStub(core.MojoMessagePipeEndpoint endpoint)
+      : super.fromEndpoint(endpoint);
 
   Future<EchoStringResponse> echoString(EchoString es) {
     var response = new EchoStringResponse();
     response.a = es.a;
     return new Future.value(response);
   }
 
   Future<bindings.Message> handleMessage(bindings.ServiceMessage message) {
     switch (message.header.type) {
       case kEchoString_name:
@@ skipping 11 matching lines @@
       default:
         throw new Exception("Unexpected case");
         break;
     }
     return null;
   }
 }
 
 
 class EchoProxy extends bindings.Proxy {
-  EchoProxy(core.MojoMessagePipeEndpoint endpoint) : super(endpoint);
+  EchoProxy(core.MojoMessagePipeEndpoint endpoint, {bool doListen: true,
+      Function onClosed})
+      : super.fromEndpoint(endpoint, doListen: doListen, onClosed: onClosed);
 
   Future<EchoStringResponse> echoString(String a) {
     // compose message.
     var es = new EchoString();
     es.a = a;
     return sendMessageWithRequestId(
         es,
         kEchoString_name,
         -1,
         bindings.MessageHeader.kMessageExpectsResponse);
   }
 
   void handleResponse(bindings.ServiceMessage message) {
     switch (message.header.type) {
       case kEchoStringResponse_name:
         var esr = EchoStringResponse.deserialize(message.payload);
         Completer c = completerMap[message.header.requestId];
         completerMap[message.header.requestId] = null;
         c.complete(esr);
         break;
       default:
         throw new Exception("Unexpected case");
         break;
     }
   }
 }
 
 
 void providerIsolate(core.MojoMessagePipeEndpoint endpoint) {
-  var provider = new EchoStub(endpoint);
-  provider.listen();
+  new EchoStub(endpoint);
 }
 
 
 Future<int> runTest() async {
   var testCompleter = new Completer();
 
   var pipe = new core.MojoMessagePipe();
   var proxy = new EchoProxy(pipe.endpoints[0]);
   await Isolate.spawn(providerIsolate, pipe.endpoints[1]);
 
@@ skipping 31 matching lines @@
 void closingProviderIsolate(core.MojoMessagePipeEndpoint endpoint) {
   var provider = new EchoStub(endpoint);
   provider.close();
 }
 
 
 Future<bool> runOnClosedTest() async {
   var testCompleter = new Completer();
 
   var pipe = new core.MojoMessagePipe();
-  var proxy = new EchoProxy(pipe.endpoints[0]);
-  await Isolate.spawn(closingProviderIsolate, pipe.endpoints[1]);
-  proxy.listen(onClosed: () {
+  var proxy = new EchoProxy(pipe.endpoints[0], onClosed: () {
     testCompleter.complete(true);
   });
-
+  await Isolate.spawn(closingProviderIsolate, pipe.endpoints[1]);
   return testCompleter.future.timeout(
       new Duration(seconds: 1),
       onTimeout: () => false);
 }
 
 
 main() async {
   Expect.equals(kEchoesCount, await runTest());
   await runAwaitTest();
   Expect.isTrue(await runOnClosedTest());
 }