Dart: Removes all but native calls and the handle watcher from the snapshot.

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:typed_data';
-import 'dart:mojo.core';
 
 import 'package:mojo/dart/testing/expect.dart';
+import 'package:mojo/public/dart/core.dart';
 
 void simpleTest() {
   var pipe = new MojoMessagePipe();
   Expect.isNotNull(pipe);
 
   var endpoint = pipe.endpoints[0];
   Expect.isTrue(endpoint.handle.isValid);
 
   var eventStream = new MojoEventStream(endpoint.handle);
   var completer = new Completer();
   int numEvents = 0;
 
   eventStream.listen((_) {
     numEvents++;
     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 eventStream =
       new MojoEventStream(endpoint.handle, MojoHandleSignals.READWRITE);
 
   int numEvents = 0;
   await for (List<int> event in eventStream) {
     numEvents++;
     eventStream.close();
   }
   Expect.equals(1, numEvents);
 }
 
-
 ByteData byteDataOfString(String s) {
   return new ByteData.view((new Uint8List.fromList(s.codeUnits)).buffer);
 }
 
-
 String stringOfByteData(ByteData bytes) {
   return new String.fromCharCodes(bytes.buffer.asUint8List().toList());
 }
 
-
-void expectStringFromEndpoint(String expected,
-                              MojoMessagePipeEndpoint endpoint) {
+void expectStringFromEndpoint(
+    String expected, MojoMessagePipeEndpoint endpoint) {
   // Query how many bytes are available.
   var result = endpoint.query();
   Expect.isNotNull(result);
   int size = result.bytesRead;
   Expect.isTrue(size > 0);
 
   // Read the data.
   ByteData bytes = new ByteData(size);
   result = endpoint.read(bytes);
   Expect.isNotNull(result);
   Expect.equals(size, result.bytesRead);
 
   // 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 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 event");
     } else if (mojoSignals.isReadable) {
       expectStringFromEndpoint("Ping", endpoint);
       pings++;
       eventStream.enableWriteEvents();
     } else if (mojoSignals.isWritable) {
       endpoint.write(byteDataOfString("Pong"));
       pongs++;
       eventStream.enableReadEvents();
     }
   }
   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 eventStream =
-      new MojoEventStream(endpoint.handle,  MojoHandleSignals.READWRITE);
+      new MojoEventStream(endpoint.handle, MojoHandleSignals.READWRITE);
 
   int pings = 0;
   int pongs = 0;
   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 event");
     } else if (mojoSignals.isReadable) {
       expectStringFromEndpoint("Pong", endpoint);
       pongs++;
       if (pongs == 10) {
         eventStream.close();
       }
-      eventStream.enableWriteEvents();  // Now it is our turn to send.
+      eventStream.enableWriteEvents(); // Now it is our turn to send.
     } else if (mojoSignals.isWritable) {
       if (pings < 10) {
         endpoint.write(byteDataOfString("Ping"));
         pings++;
       }
-      eventStream.enableReadEvents();  // 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();
 }