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

mojo/dart/test/handle_watcher_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_core';
 import 'dart:typed_data';
 
 import 'package:mojo/dart/testing/expect.dart';
 
 void simpleTest() {
   var pipe = new MojoMessagePipe();
   Expect.isNotNull(pipe);
 
   var endpoint = pipe.endpoints[0];
   Expect.isTrue(endpoint.handle.isValid);
 
-  var handle = new MojoHandle(endpoint.handle);
+  var eventStream = new MojoEventStream(endpoint.handle);
   var completer = new Completer();
   int numEvents = 0;
 
-  handle.enableWriteEvents();
-  handle.listen((_) {
+  eventStream.listen((_) {
     numEvents++;
-    handle.close();
+    eventStream.close();
   }, onDone: () {
     completer.complete(numEvents);
   });
+  eventStream.enableWriteEvents();
 
   completer.future.then((int numEvents) {
     Expect.equals(1, numEvents);
   });
 }
 
 
 Future simpleAsyncAwaitTest() async {
   var pipe = new MojoMessagePipe();
   Expect.isNotNull(pipe);
 
   var endpoint = pipe.endpoints[0];
   Expect.isTrue(endpoint.handle.isValid);
 
-  var handle = new MojoHandle(endpoint.handle);
+  var eventStream =
+      new MojoEventStream(endpoint.handle, MojoHandleSignals.READWRITE);
 
   int numEvents = 0;
-  handle.enableWriteEvents();
-  await for (var signal in handle) {
+  await for (List<int> event in eventStream) {
     numEvents++;
-    handle.close();
+    eventStream.close();
   }
   Expect.equals(1, numEvents);
 }
 
 
 ByteData byteDataOfString(String s) {
   return new ByteData.view((new Uint8List.fromList(s.codeUnits)).buffer);
 }
 
 
@@ skipping 18 matching lines @@
 
   // Convert to a string and check.
   String msg = stringOfByteData(bytes);
   Expect.equals(expected, msg);
 }
 
 
 Future pingPongIsolate(MojoMessagePipeEndpoint endpoint) async {
   int pings = 0;
   int pongs = 0;
-  var handle = new MojoHandle(endpoint.handle);
-  await for (var signal in handle) {
-    if (MojoHandleSignals.isReadWrite(signal)) {
+  var eventStream = new MojoEventStream(endpoint.handle);
+  await for (List<int> event in eventStream) {
+    var mojoSignals = new MojoHandleSignals(event[1]);
+    if (mojoSignals.isReadWrite) {
       // We are either sending or receiving.
-      throw new Exception("Unexpected signal");
-    } else if (MojoHandleSignals.isReadable(signal)) {
+      throw new Exception("Unexpected event");
+    } else if (mojoSignals.isReadable) {
       expectStringFromEndpoint("Ping", endpoint);
       pings++;
-      handle.enableWriteEvents();
-    } else if (MojoHandleSignals.isWritable(signal)) {
+      eventStream.enableWriteEvents();
+    } else if (mojoSignals.isWritable) {
       endpoint.write(byteDataOfString("Pong"));
       pongs++;
-      handle.disableWriteEvents();
+      eventStream.enableReadEvents();
     }
   }
-  handle.close();
+  eventStream.close();
   Expect.equals(10, pings);
   Expect.equals(10, pongs);
 }
 
 
 Future pingPongTest() async {
   var pipe = new MojoMessagePipe();
   var isolate = await Isolate.spawn(pingPongIsolate, pipe.endpoints[0]);
   var endpoint = pipe.endpoints[1];
-  var handle = new MojoHandle(endpoint.handle);
+  var eventStream =
+      new MojoEventStream(endpoint.handle,  MojoHandleSignals.READWRITE);
 
   int pings = 0;
   int pongs = 0;
-  handle.enableWriteEvents();  // This side will send first.
-  await for (var signal in handle) {
-    if (MojoHandleSignals.isReadWrite(signal)) {
+  await for (List<int> event in eventStream) {
+    var mojoSignals = new MojoHandleSignals(event[1]);
+    if (mojoSignals.isReadWrite) {
       // We are either sending or receiving.
-      throw new Exception("Unexpected signal");
-    } else if (MojoHandleSignals.isReadable(signal)) {
+      throw new Exception("Unexpected event");
+    } else if (mojoSignals.isReadable) {
       expectStringFromEndpoint("Pong", endpoint);
       pongs++;
       if (pongs == 10) {
-        handle.close();
+        eventStream.close();
       }
-      handle.enableWriteEvents();  // Now it is our turn to send.
-    } else if (MojoHandleSignals.isWritable(signal)) {
+      eventStream.enableWriteEvents();  // Now it is our turn to send.
+    } else if (mojoSignals.isWritable) {
       if (pings < 10) {
         endpoint.write(byteDataOfString("Ping"));
         pings++;
       }
-      handle.disableWriteEvents();  // Don't send while waiting for reply.
+      eventStream.enableReadEvents();  // Don't send while waiting for reply.
     }
   }
   Expect.equals(10, pings);
   Expect.equals(10, pongs);
 }
 
 
 main() async {
   simpleTest();
   await simpleAsyncAwaitTest();
   await pingPongTest();
 }