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

mojo/public/dart/src/codec.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.
 
 // TODO(zra): Rewrite MojoDecoder and MojoEncoder using Dart idioms, and make
 // corresponding changes to the bindings generation script.
 
 part of bindings;
 
 const int kAlignment = 8;
@@ skipping 51 matching lines @@
   if (typeOrInstance is Type) {
     return reflectClass(typeOrInstance).getField(#encodedSize).reflectee;
   } else {
     return typeOrInstance.encodedSize;
   }
 }
 
 
 class MojoDecoder {
   ByteData buffer;
-  List<core.RawMojoHandle> handles;
+  List<core.MojoHandle> handles;
   int base;
   int next;
 
   MojoDecoder(this.buffer, this.handles, this.base) {
     next = base;
   }
 
   void skip(int offset) {
     next += offset;
   }
@@ skipping 64 matching lines @@
     if (offset == 0) {
       return 0;
     }
     return offsetPointer + offset;
   }
 
   MojoDecoder decodeAndCreateDecoder(int offset) {
     return new MojoDecoder(buffer, handles, offset);
   }
 
-  core.RawMojoHandle decodeHandle() {
+  core.MojoHandle decodeHandle() {
     int handleIndex = readUint32();
     return (handleIndex == kEncodedInvalidHandleValue) ?
-           new core.RawMojoHandle(core.RawMojoHandle.INVALID) :
+           new core.MojoHandle(core.MojoHandle.INVALID) :
            handles[handleIndex];
   }
 
   String decodeString() {
     int numBytes = readUint32();
     int numElements = readUint32();
     int base = next;
     next += numElements;
     return stringOfUtf8(buffer.buffer.asUint8List(base, numElements));
   }
@@ skipping 62 matching lines @@
       return null;
     }
     MojoDecoder decoder = decodeAndCreateDecoder(pointer);
     return decoder.decodeMap(keyType, valType);
   }
 }
 
 
 class MojoEncoder {
   ByteData buffer;
-  List<core.RawMojoHandle> handles;
+  List<core.MojoHandle> handles;
   int base;
   int next;
   int extent;
 
   MojoEncoder(this.buffer, this.handles, this.base, this.extent) {
     next = base;
   }
 
   void skip(int offset) {
     next += offset;
@@ skipping 86 matching lines @@
     }
     return pointer;
   }
 
   MojoEncoder createAndEncodeEncoder(int size) {
     int pointer = alloc(align(size));
     encodePointer(pointer);
     return new MojoEncoder(buffer, handles, pointer, extent);
   }
 
-  void encodeHandle(core.RawMojoHandle handle) {
+  void encodeHandle(core.MojoHandle handle) {
     if (handle.isValid) {
       handles.add(handle);
       writeUint32(handles.length - 1);
     } else {
       writeUint32(kEncodedInvalidHandleValue);
     }
   }
 
   void encodeString(String val) {
     Uint8List utf8string = utf8OfString(val);
@@ skipping 98 matching lines @@
 
 
 const int kMessageNameOffset = kStructHeaderSize;
 const int kMessageFlagsOffset = kMessageNameOffset + 4;
 const int kMessageRequestIDOffset = kMessageFlagsOffset + 4;
 const int kMessageExpectsResponse = 1 << 0;
 const int kMessageIsResponse = 1 << 1;
 
 class Message {
   ByteData buffer;
-  List<core.RawMojoHandle> handles;
+  List<core.MojoHandle> handles;
 
   Message(this.buffer, this.handles);
 
-  int getHeaderNumBytes() => buffer.getUint32(kStructHeaderNumBytesOffset);
-  int getHeaderNumFields() => buffer.getUint32(kStructHeaderNumFieldsOffset);
-  int getName() => buffer.getUint32(kMessageNameOffset);
-  int getFlags() => buffer.getUint32(kMessageFlagsOffset);
-  bool isResponse() => (getFlags() & kMessageIsResponse) != 0;
-  bool expectsResponse() => (getFlags() & kMessageExpectsResponse) != 0;
-
-  void setRequestID(int id) {
-    buffer.setUint64(kMessageRequestIDOffset, id);
-  }
+  int get headerNumBytes =>
+      buffer.getUint32(kStructHeaderNumBytesOffset, Endianness.LITTLE_ENDIAN);
+  int get headerNumFields =>
+      buffer.getUint32(kStructHeaderNumFieldsOffset, Endianness.LITTLE_ENDIAN);
+  int get name =>
+      buffer.getUint32(kMessageNameOffset, Endianness.LITTLE_ENDIAN);
+  int get flags =>
+      buffer.getUint32(kMessageFlagsOffset, Endianness.LITTLE_ENDIAN);
+  int get requestID =>
+      buffer.getUint64(kMessageRequestIDOffset, Endianness.LITTLE_ENDIAN);
+      set requestID(int id) =>
+      buffer.setUint64(kMessageRequestIDOffset, id, Endianness.LITTLE_ENDIAN);
+  bool get isResponse => (flags & kMessageIsResponse) != 0;
+  bool get expectsResponse => (flags & kMessageExpectsResponse) != 0;
 }
 
 
 class MessageBuilder {
   MojoEncoder encoder;
-  List<core.RawMojoHandle> handles;
+  List<core.MojoHandle> handles;
 
   MessageBuilder._();
 
   MessageBuilder(int name, int payloadSize) {
     int numBytes = kMessageHeaderSize + payloadSize;
     var buffer = new ByteData(numBytes);
-    handles = <core.RawMojoHandle>[];
+    handles = <core.MojoHandle>[];
 
     encoder = new MojoEncoder(buffer, handles, 0, kMessageHeaderSize);
     encoder.writeUint32(kMessageHeaderSize);
     encoder.writeUint32(2);  // num_fields;
     encoder.writeUint32(name);
     encoder.writeUint32(0);  // flags.
   }
 
   MojoEncoder createEncoder(int size) {
     encoder = new MojoEncoder(encoder.buffer,
@@ skipping 20 matching lines @@
   }
 }
 
 
 class MessageWithRequestIDBuilder extends MessageBuilder {
   MessageWithRequestIDBuilder(
       int name, int payloadSize, int requestID, [int flags = 0])
       : super._() {
     int numBytes = kMessageWithRequestIDHeaderSize + payloadSize;
     var buffer = new ByteData(numBytes);
-    handles = <core.RawMojoHandle>[];
+    handles = <core.MojoHandle>[];
 
     encoder = new MojoEncoder(
         buffer, handles, 0, kMessageWithRequestIDHeaderSize);
     encoder.writeUint32(kMessageWithRequestIDHeaderSize);
     encoder.writeUint32(3);  // num_fields.
     encoder.writeUint32(name);
     encoder.writeUint32(flags);
     encoder.writeUint64(requestID);
   }
 }
@@ skipping 181 matching lines @@
 }
 
 
 class NullableArrayOf extends ArrayOf {
   NullableArrayOf(Object val, [int length = 0]) : super(val, length);
 }
 
 
 class Handle {
   static const int encodedSize = 4;
-  static core.RawMojoHandle decode(MojoDecoder decoder) =>
+  static core.MojoHandle decode(MojoDecoder decoder) =>
       decoder.decodeHandle();
-  static void encode(MojoEncoder encoder, core.RawMojoHandle val) {
+  static void encode(MojoEncoder encoder, core.MojoHandle val) {
     encoder.encodeHandle(val);
   }
 }
 
 
 class NullableHandle {
   static const int encodedSize = Handle.encodedSize;
   static const decode = Handle.decode;
   static const encode = Handle.encode;
 }
 
 
 class MapOf {
   Object key;
   Object val;
 
   MapOf(this.key, this.val);
 
   int encodedSize = 8;
   Map decode(MojoDecoder decoder) => decoder.decodeMapPointer(key, val);
   void encode(MojoEncoder encoder, Map map) {
     encoder.encodeMapPointer(key, val, map);
   }
 }
 
 
 class NullableMapOf extends MapOf {
   NullableMapOf(Object key, Object val) : super(key, val);
 }