Update mojo sdk to rev f6c8ec07c01deebc13178d516225fd12695c3dc2

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;
 const int kArrayHeaderSize = 8;
 const int kStructHeaderSize = 8;
 const int kMessageHeaderSize = 16;
 const int kMessageWithRequestIDHeaderSize = 24;
 const int kMapStructPayloadSize = 16;
 const int kStructHeaderNumBytesOffset = 0;
 const int kStructHeaderNumFieldsOffset = 4;
@@ skipping 541 matching lines @@
     if (num_fields >= 3) {
       requestID = decoder.readUint64();
     }
     decoder.skip(messageHeaderSize - decoder.next);
   }
 
   Object decodeStruct(Object t) => _callDecode(t, decoder);
 }
 
 
-abstract class MojoType<T> {
-  static const int encodedSize = 0;
-  static T decode(MojoDecoder decoder) { return null; }
-  static void encode(MojoEncoder encoder, T val) {}
-}
-
-
 class PackedBool {}
 
 
-class Int8 implements MojoType<int> {
+class Int8 {
   static const int encodedSize = 1;
   static int decode(MojoDecoder decoder) => decoder.readInt8();
   static void encode(MojoEncoder encoder, int val) {
     encoder.writeInt8(val);
   }
 }
 
 
-class Uint8 implements MojoType<int> {
+class Uint8 {
   static const int encodedSize = 1;
   static int decode(MojoDecoder decoder) => decoder.readUint8();
   static void encode(MojoEncoder encoder, int val) {
     encoder.writeUint8(val);
   }
 }
 
 
-class Int16 implements MojoType<int> {
+class Int16 {
   static const int encodedSize = 2;
   static int decode(MojoDecoder decoder) => decoder.readInt16();
   static void encode(MojoEncoder encoder, int val) {
     encoder.writeInt16(val);
   }
 }
 
 
-class Uint16 implements MojoType<int> {
+class Uint16 {
   static const int encodedSize = 2;
   static int decode(MojoDecoder decoder) => decoder.readUint16();
   static void encode(MojoEncoder encoder, int val) {
     encoder.writeUint16(val);
   }
 }
 
 
-class Int32 implements MojoType<int> {
+class Int32 {
   static const int encodedSize = 4;
   static int decode(MojoDecoder decoder) => decoder.readInt32();
   static void encode(MojoEncoder encoder, int val) {
     encoder.writeInt32(val);
   }
 }
 
 
-class Uint32 implements MojoType<int> {
+class Uint32 {
   static const int encodedSize = 4;
   static int decode(MojoDecoder decoder) => decoder.readUint32();
   static void encode(MojoEncoder encoder, int val) {
     encoder.writeUint32(val);
   }
 }
 
 
-class Int64 implements MojoType<int> {
+class Int64 {
   static const int encodedSize = 8;
   static int decode(MojoDecoder decoder) => decoder.readInt64();
   static void encode(MojoEncoder encoder, int val) {
     encoder.writeInt64(val);
   }
 }
 
 
-class Uint64 implements MojoType<int> {
+class Uint64 {
   static const int encodedSize = 8;
   static int decode(MojoDecoder decoder) => decoder.readUint64();
   static void encode(MojoEncoder encoder, int val) {
     encoder.writeUint64(val);
   }
 }
 
 
-class MojoString implements MojoType<String> {
+class MojoString {
   static const int encodedSize = 8;
   static String decode(MojoDecoder decoder) => decoder.decodeStringPointer();
   static void encode(MojoEncoder encoder, String val) {
     encoder.encodeStringPointer(val);
   }
 }
 
 
-class NullableMojoString implements MojoType<String> {
+class NullableMojoString {
   static const int encodedSize = MojoString.encodedSize;
   static var decode = MojoString.decode;
   static var encode = MojoString.encode;
 }
 
 
-class Float implements MojoType<double> {
+class Float {
   static const int encodedSize = 4;
   static double decode(MojoDecoder decoder) => decoder.readFloat();
   static void encode(MojoEncoder encoder, double val) {
     encoder.writeFloat(val);
   }
 }
 
 
-class Double implements MojoType<double> {
+class Double {
   static const int encodedSize = 8;
   static double decode(MojoDecoder decoder) => decoder.readDouble();
   static void encode(MojoEncoder encoder, double val) {
     encoder.writeDouble(val);
   }
 }
 
 
 class PointerTo {
   Object val;
@@ skipping 39 matching lines @@
     encoder.encodeArrayPointer(this.val, val);
   }
 }
 
 
 class NullableArrayOf extends ArrayOf {
   NullableArrayOf(Object val, [int length = 0]) : super(val, length);
 }
 
 
-class Handle implements MojoType<core.RawMojoHandle> {
+class Handle {
   static const int encodedSize = 4;
-  static core.RawMojoHandle decode(MojoDecoder decoder) => decoder.decodeHandle();
+  static core.RawMojoHandle decode(MojoDecoder decoder) =>
+      decoder.decodeHandle();
   static void encode(MojoEncoder encoder, core.RawMojoHandle val) {
     encoder.encodeHandle(val);
   }
 }
 
 
-class NullableHandle implements MojoType<int> {
+class NullableHandle {
   static const int encodedSize = Handle.encodedSize;
   static const decode = Handle.decode;
   static const encode = Handle.encode;
 }