Update mojo sdk to rev cc531b32182099a5a034a99daff35ed5d38a61c8

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 137 matching lines @@
       return 0;
     }
     return offsetPointer + offset;
   }
 
   MojoDecoder decodeAndCreateDecoder(int offset) {
     return new MojoDecoder(buffer, handles, offset);
   }
 
   core.RawMojoHandle decodeHandle() {
-    return handles[readUint32()];
+    int handleIndex = readUint32();
+    return (handleIndex == kEncodedInvalidHandleValue) ?
+           new core.RawMojoHandle(core.RawMojoHandle.INVALID) :
+           handles[handleIndex];
   }
 
   String decodeString() {
     int numBytes = readUint32();
     int numElements = readUint32();
     int base = next;
     next += numElements;
     return stringOfUtf8(buffer.buffer.asUint8List(base, numElements));
   }
 
@@ skipping 147 matching lines @@
     if (pointer == null) {
       writeUint64(0);
       return;
     }
     int offset = pointer - next;
     writeUint64(offset);
   }
 
   void grow(int new_size) {
     Uint8List new_buffer = new Uint8List(new_size);
-    new_buffer.setRange(0, next, buffer.buffer.asUint8List());
+    new_buffer.setRange(0, buffer.lengthInBytes, buffer.buffer.asUint8List());
     buffer = new_buffer.buffer.asByteData();
   }
 
   int alloc(int size_request) {
     int pointer = extent;
     extent += size_request;
     if (extent > buffer.lengthInBytes) {
       int new_size = buffer.lengthInBytes + size_request;
       new_size += new_size ~/ 2;
       grow(new_size);
     }
     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) {
-    handles.add(handle);
-    writeUint32(handles.length - 1);
+    if (handle.isValid) {
+      handles.add(handle);
+      writeUint32(handles.length - 1);
+    } else {
+      writeUint32(kEncodedInvalidHandleValue);
+    }
   }
 
   void encodeString(String val) {
     Uint8List utf8string = utf8OfString(val);
     int numElements = utf8string.lengthInBytes;
     int numBytes = kArrayHeaderSize + numElements;
     writeUint32(numBytes);
     writeUint32(numElements);
     buffer.buffer.asUint8List().setRange(next, next + numElements, utf8string);
     next += numElements;
@@ skipping 374 matching lines @@
     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);
+}