Dart: Simplifies the handle watcher. Various cleanups and bugfixes.

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:mojo_bindings' as bindings;
 import 'dart:mojo_core' as core;
 import 'dart:typed_data';
 
 import 'package:mojo/dart/testing/expect.dart';
 
+const int kEchoesCount = 100;
+
 class EchoString {
   String a = null;
 
   EchoString();
 
   static const int encodedSize = bindings.kStructHeaderSize + 8;
   static EchoString decode(bindings.MojoDecoder decoder) {
     var val = new EchoString();
     var numBytes = decoder.readUint32();
     var numFields = decoder.readUint32();
@@ skipping 14 matching lines @@
   static var encode = EchoString.encode;
 }
 
 
 const int kEchoString_name = 0;
 const int kEchoStringResponse_name = 1;
 
 class EchoInterface extends bindings.Interface {
   EchoInterface(core.MojoMessagePipeEndpoint endpoint) : super(endpoint);
 
-  EchoStringResponse echoString(EchoString es) {
+  Future<EchoStringResponse> echoString(EchoString es) {
     var response = new EchoStringResponse();
     response.a = es.a;
-    return response;
+    return new Future.value(response);
   }
 
-  bindings.Message handleMessage(bindings.MessageReader reader) {
+  Future<bindings.Message> handleMessage(bindings.MessageReader reader) {
     switch (reader.name) {
       case kEchoString_name:
         var es = reader.decodeStruct(EchoString);
-        var response = echoString(es);
-        return buildResponseWithID(EchoStringResponse,
-                                   kEchoStringResponse_name,
-                                   reader.requestID,
-                                   bindings.kMessageIsResponse,
-                                   response);
+        return echoString(es).then((response) {
+          if (response != null) {
+            return buildResponseWithID(EchoStringResponse,
+                                       kEchoStringResponse_name,
+                                       reader.requestID,
+                                       bindings.kMessageIsResponse,
+                                       response);
+          }
+        });
         break;
       default:
         throw new Exception("Unexpected case");
         break;
     }
     return null;
   }
 }
 
 
 class EchoClient extends bindings.Client {
   EchoClient(core.MojoMessagePipeEndpoint endpoint) : super(endpoint);
 
   Future<EchoStringResponse> echoString(String a) {
     // compose message.
     var es = new EchoString();
     es.a = a;
     return enqueueMessageWithRequestID(EchoString,
                                        kEchoString_name,
-                                       0,
+                                       -1,
                                        bindings.kMessageExpectsResponse,
                                        es);
   }
 
   void handleResponse(bindings.MessageReader reader) {
     switch (reader.name) {
       case kEchoStringResponse_name:
         var esr = reader.decodeStruct(EchoStringResponse);
-        Completer c = completerQueue.removeAt(0);
+        Completer c = completerMap[reader.requestID];
+        completerMap[reader.requestID] = null;
         c.complete(esr);
         break;
       default:
         throw new Exception("Unexpected case");
         break;
     }
   }
 }
 
 
 void providerIsolate(core.MojoMessagePipeEndpoint endpoint) {
   var provider = new EchoInterface(endpoint);
   provider.listen();
 }
 
 
 Future<bool> runTest() async {
   var testCompleter = new Completer();
 
   var pipe = new core.MojoMessagePipe();
   var client = new EchoClient(pipe.endpoints[0]);
   await Isolate.spawn(providerIsolate, pipe.endpoints[1]);
 
-  int n = 100;
+  int n = kEchoesCount;
   int count = 0;
   client.open();
   for (int i = 0; i < n; i++) {
     client.echoString("hello").then((response) {
       Expect.equals("hello", response.a);
       count++;
       if (i == (n - 1)) {
         client.close();
         testCompleter.complete(count);
       }
     });
   }
 
   return testCompleter.future;
 }
 
 
 Future runAwaitTest() async {
   var pipe = new core.MojoMessagePipe();
   var client = new EchoClient(pipe.endpoints[0]);
   await Isolate.spawn(providerIsolate, pipe.endpoints[1]);
 
-  int n = 100;
+  int n = kEchoesCount;
   client.open();
   for (int i = 0; i < n; i++) {
     var response = await client.echoString("Hello");
     Expect.equals("Hello", response.a);
   }
   client.close();
 }
 
 
 main() async {
-  Expect.equals(100, await runTest());
+  Expect.equals(kEchoesCount, await runTest());
   await runAwaitTest();
 }