Cleanups in the Mojo package.

mojo/dart/unittests/embedder_tests/core_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:convert';
 import 'dart:io';
 import 'dart:typed_data';
 
 import 'package:_mojo_for_test_only/expect.dart';
 import 'package:mojo/core.dart';
 
 invalidHandleTest() {
-  MojoHandle invalidHandle = new MojoHandle(MojoHandle.INVALID);
+  MojoHandle invalidHandle = new MojoHandle(MojoHandle.invalidHandle);
 
   // Close.
   int result = invalidHandle.close();
   Expect.isTrue(result == MojoResult.kInvalidArgument);
 
   // Wait.
   MojoWaitResult mwr =
       invalidHandle.wait(MojoHandleSignals.kReadWrite, 1000000);
   Expect.isTrue(mwr.result == MojoResult.kInvalidArgument);
 
   MojoWaitManyResult mwmr = MojoHandle.waitMany([invalidHandle.h],
-      [MojoHandleSignals.kReadWrite], MojoHandle.DEADLINE_INDEFINITE);
+      [MojoHandleSignals.kReadWrite], MojoHandle.deadlineIndefinite);
   Expect.isTrue(mwmr.result == MojoResult.kInvalidArgument);
 
   // Message pipe.
   MojoMessagePipe pipe = new MojoMessagePipe();
   Expect.isNotNull(pipe);
   ByteData bd = new ByteData(10);
   pipe.endpoints[0].handle.close();
   pipe.endpoints[1].handle.close();
   result = pipe.endpoints[0].write(bd);
   Expect.isTrue(result == MojoResult.kInvalidArgument);
 
   MojoMessagePipeReadResult readResult = pipe.endpoints[0].read(bd);
   Expect.isTrue(pipe.endpoints[0].status == MojoResult.kInvalidArgument);
 
   // Data pipe.
   MojoDataPipe dataPipe = new MojoDataPipe();
   Expect.isNotNull(dataPipe);
   dataPipe.producer.handle.close();
   dataPipe.consumer.handle.close();
 
   int bytesWritten = dataPipe.producer.write(bd);
   Expect.isTrue(dataPipe.producer.status == MojoResult.kInvalidArgument);
 
-  ByteData writeData = dataPipe.producer.beginWrite(10);
+  ByteData writeData = dataPipe.producer.beginWrite();
   Expect.isNull(writeData);
   Expect.isTrue(dataPipe.producer.status == MojoResult.kInvalidArgument);
   dataPipe.producer.endWrite(10);
   Expect.isTrue(dataPipe.producer.status == MojoResult.kInvalidArgument);
 
   int read = dataPipe.consumer.read(bd);
   Expect.isTrue(dataPipe.consumer.status == MojoResult.kInvalidArgument);
 
-  ByteData readData = dataPipe.consumer.beginRead(10);
+  ByteData readData = dataPipe.consumer.beginRead();
   Expect.isNull(readData);
   Expect.isTrue(dataPipe.consumer.status == MojoResult.kInvalidArgument);
   dataPipe.consumer.endRead(10);
   Expect.isTrue(dataPipe.consumer.status == MojoResult.kInvalidArgument);
 
   // Shared buffer.
   MojoSharedBuffer sharedBuffer = new MojoSharedBuffer.create(10);
   Expect.isNotNull(sharedBuffer);
   sharedBuffer.close();
   MojoSharedBuffer duplicate = new MojoSharedBuffer.duplicate(sharedBuffer);
@@ skipping 33 matching lines @@
 
   // Write end1.
   String hello = "hello";
   ByteData helloData =
       new ByteData.view((new Uint8List.fromList(hello.codeUnits)).buffer);
   int result = end1.write(helloData);
   Expect.isTrue(result == MojoResult.kOk);
 
   // end0 should now be readable.
   MojoWaitManyResult mwmr = MojoHandle.waitMany([end0.handle.h],
-      [MojoHandleSignals.kReadable], MojoHandle.DEADLINE_INDEFINITE);
+      [MojoHandleSignals.kReadable], MojoHandle.deadlineIndefinite);
   Expect.isTrue(mwmr.result == MojoResult.kOk);
 
   // Read from end0.
   MojoMessagePipeReadResult readResult = end0.read(data);
   Expect.isNotNull(readResult);
   Expect.isTrue(readResult.status == MojoResult.kOk);
   Expect.equals(readResult.bytesRead, helloData.lengthInBytes);
   Expect.equals(readResult.handlesRead, 0);
 
   String hello_result = new String.fromCharCodes(
@@ skipping 31 matching lines @@
   // Consumer should not be readable.
   MojoWaitResult mwr = consumer.handle.wait(MojoHandleSignals.kReadable, 0);
   Expect.isTrue(mwr.result == MojoResult.kDeadlineExceeded);
 
   // Producer should be writable.
   mwr = producer.handle.wait(MojoHandleSignals.kWritable, 0);
   Expect.isTrue(mwr.result == MojoResult.kOk);
 
   // Try to read from consumer.
   ByteData buffer = new ByteData(20);
-  consumer.read(buffer, buffer.lengthInBytes, MojoDataPipeConsumer.FLAG_NONE);
+  consumer.read(buffer, buffer.lengthInBytes, MojoDataPipeConsumer.flagNone);
   Expect.isTrue(consumer.status == MojoResult.kShouldWait);
 
   // Try to begin a two-phase read from consumer.
-  ByteData b = consumer.beginRead(20, MojoDataPipeConsumer.FLAG_NONE);
+  ByteData b = consumer.beginRead(MojoDataPipeConsumer.flagNone);
   Expect.isNull(b);
   Expect.isTrue(consumer.status == MojoResult.kShouldWait);
 
   // Write to producer.
   String hello = "hello ";
   ByteData helloData =
       new ByteData.view((new Uint8List.fromList(hello.codeUnits)).buffer);
   int written = producer.write(
-      helloData, helloData.lengthInBytes, MojoDataPipeProducer.FLAG_NONE);
+      helloData, helloData.lengthInBytes, MojoDataPipeProducer.flagNone);
   Expect.isTrue(producer.status == MojoResult.kOk);
   Expect.equals(written, helloData.lengthInBytes);
 
   // Now that we have written, the consumer should be readable.
   MojoWaitManyResult mwmr = MojoHandle.waitMany([consumer.handle.h],
-      [MojoHandleSignals.kReadable], MojoHandle.DEADLINE_INDEFINITE);
+      [MojoHandleSignals.kReadable], MojoHandle.deadlineIndefinite);
   Expect.isTrue(mwr.result == MojoResult.kOk);
 
   // Do a two-phase write to the producer.
-  ByteData twoPhaseWrite =
-      producer.beginWrite(20, MojoDataPipeProducer.FLAG_NONE);
+  ByteData twoPhaseWrite = producer.beginWrite(MojoDataPipeProducer.flagNone);
   Expect.isTrue(producer.status == MojoResult.kOk);
   Expect.isNotNull(twoPhaseWrite);
   Expect.isTrue(twoPhaseWrite.lengthInBytes >= 20);
 
   String world = "world";
   twoPhaseWrite.buffer.asUint8List().setAll(0, world.codeUnits);
   producer.endWrite(Uint8List.BYTES_PER_ELEMENT * world.codeUnits.length);
   Expect.isTrue(producer.status == MojoResult.kOk);
 
   // Read one character from consumer.
-  int read = consumer.read(buffer, 1, MojoDataPipeConsumer.FLAG_NONE);
+  int read = consumer.read(buffer, 1, MojoDataPipeConsumer.flagNone);
   Expect.isTrue(consumer.status == MojoResult.kOk);
   Expect.equals(read, 1);
 
   // Close the producer.
   int result = producer.handle.close();
   Expect.isTrue(result == MojoResult.kOk);
 
   // Consumer should still be readable.
   mwr = consumer.handle.wait(MojoHandleSignals.kReadable, 0);
   Expect.isTrue(mwr.result == MojoResult.kOk);
 
   // Get the number of remaining bytes.
-  int remaining = consumer.read(null, 0, MojoDataPipeConsumer.FLAG_QUERY);
+  int remaining = consumer.read(null, 0, MojoDataPipeConsumer.flagQuery);
   Expect.isTrue(consumer.status == MojoResult.kOk);
   Expect.equals(remaining, "hello world".length - 1);
 
   // Do a two-phase read.
-  ByteData twoPhaseRead =
-      consumer.beginRead(remaining, MojoDataPipeConsumer.FLAG_NONE);
+  ByteData twoPhaseRead = consumer.beginRead(MojoDataPipeConsumer.flagNone);
   Expect.isTrue(consumer.status == MojoResult.kOk);
   Expect.isNotNull(twoPhaseRead);
   Expect.isTrue(twoPhaseRead.lengthInBytes <= remaining);
 
   Uint8List uint8_list = buffer.buffer.asUint8List();
   uint8_list.setAll(1, twoPhaseRead.buffer.asUint8List());
   uint8_list = uint8_list.sublist(0, 1 + twoPhaseRead.lengthInBytes);
 
   consumer.endRead(twoPhaseRead.lengthInBytes);
   Expect.isTrue(consumer.status == MojoResult.kOk);
@@ skipping 100 matching lines @@
 
 main() async {
   invalidHandleTest();
   basicMessagePipeTest();
   basicDataPipeTest();
   basicSharedBufferTest();
   await fillerDrainerTest();
   utilsTest();
   processTest();
 }