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 completer = new Completer();
   int numEvents = 0;
 
-  handle.enableWriteEvents();
   handle.listen((_) {
     numEvents++;
     handle.close();
   }, onDone: () {
     completer.complete(numEvents);
   });
+  handle.enableWriteEvents();

[siva, 2014/12/29 23:20:44]

Why does this have to be moved down?

[zra, 2014/12/30 16:29:33]

It doesn't have to be. enableWriteEvents() can go either before or after the
call to listen, and the effect will be the same. I moved it because
simpleAsyncAwaitTest already tests setting the signals before the listen call in
the constructor. It can't set the signals after the listen call as it is using
await for.

 
   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 handle = new MojoHandle(endpoint.handle, MojoHandleSignals.READWRITE);
 
   int numEvents = 0;
-  handle.enableWriteEvents();
-  await for (var signal in handle) {
+  await for (List<int> event in handle) {
     numEvents++;
     handle.close();
   }
   Expect.equals(1, numEvents);
 }
 
 
 ByteData byteDataOfString(String s) {
   return new ByteData.view((new Uint8List.fromList(s.codeUnits)).buffer);
 }
@@ skipping 21 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)) {
+  await for (List<int> event in handle) {
+    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)) {
+    } else if (mojoSignals.isWritable) {
       endpoint.write(byteDataOfString("Pong"));
       pongs++;
-      handle.disableWriteEvents();
+      handle.enableReadEvents();
     }
   }
   handle.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 handle = new MojoHandle(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 handle) {
+    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();
       }
       handle.enableWriteEvents();  // Now it is our turn to send.
-    } else if (MojoHandleSignals.isWritable(signal)) {
+    } else if (mojoSignals.isWritable) {
       if (pings < 10) {
         endpoint.write(byteDataOfString("Ping"));
         pings++;
       }
-      handle.disableWriteEvents();  // Don't send while waiting for reply.
+      handle.enableReadEvents();  // Don't send while waiting for reply.
     }
   }
   Expect.equals(10, pings);
   Expect.equals(10, pongs);
 }
 
 
 main() async {
   simpleTest();
   await simpleAsyncAwaitTest();
   await pingPongTest();
 }