Mojo: Add String, Float, and Double types to codec.js.

mojo/public/js/bindings/codec.js

 // 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.
 
 define("mojo/public/js/bindings/codec", [
   "mojo/public/js/bindings/unicode"
 ], function(unicode) {
 
   var kErrorUnsigned = "Passing negative value to unsigned";
 
@@ skipping 211 matching lines @@
   Decoder.prototype.decodeArray = function(cls) {
     var numberOfBytes = this.readUint32();
     var numberOfElements = this.readUint32();
     var val = new Array(numberOfElements);
     for (var i = 0; i < numberOfElements; ++i) {
       val[i] = cls.decode(this);
     }
     return val;
   };
 
+  Decoder.prototype.decodeStruct = function(cls) {
+    return cls.decode(this);
+  };
+
   Decoder.prototype.decodeStructPointer = function(cls) {
     return cls.decode(this.decodeAndCreateDecoder());
   };
 
   Decoder.prototype.decodeArrayPointer = function(cls) {
     return this.decodeAndCreateDecoder().decodeArray(cls);
   };
 
   Decoder.prototype.decodeStringPointer = function() {
     return this.decodeAndCreateDecoder().decodeString();
@@ skipping 109 matching lines @@
   Encoder.prototype.encodeArray = function(cls, val) {
     var numberOfElements = val.length;
     var numberOfBytes = kArrayHeaderSize + cls.encodedSize * numberOfElements;
     this.writeUint32(numberOfBytes);
     this.writeUint32(numberOfElements);
     for (var i = 0; i < numberOfElements; ++i) {
       cls.encode(this, val[i]);
     }
   };
 
+  Encoder.prototype.encodeStruct = function(cls, val) {
+    return cls.encode(this, val);
+  };
+
   Encoder.prototype.encodeStructPointer = function(cls, val) {
     var encoder = this.createAndEncodeEncoder(cls.encodedSize);
     cls.encode(encoder, val);
   };
 
   Encoder.prototype.encodeArrayPointer = function(cls, val) {
     var encodedSize = kArrayHeaderSize + cls.encodedSize * val.length;
     var encoder = this.createAndEncodeEncoder(encodedSize);
     encoder.encodeArray(cls, val);
   };
@@ skipping 110 matching lines @@
 
   function Int8() {
   }
 
   Int8.encodedSize = 1;
 
   Int8.decode = function(decoder) {
     return decoder.readInt8();
   };
 
+  Int8.encode = function(encoder, val) {
+    encoder.writeInt8(val);
+  };
+
   Uint8.encode = function(encoder, val) {
     encoder.writeUint8(val);
   };
 
   function Uint8() {
   }
 
   Uint8.encodedSize = 1;
 
   Uint8.decode = function(decoder) {
@@ skipping 75 matching lines @@
   Uint64.encodedSize = 8;
 
   Uint64.decode = function(decoder) {
     return decoder.readUint64();
   };
 
   Uint64.encode = function(encoder, val) {
     encoder.writeUint64(val);
   };
 
-  // TODO(abarth): Add missing types:
-  // * String
+  function String() {
+  };
+
+  String.encodedSize = 8;
+
+  String.decode = function(decoder) {
+    return decoder.decodeStringPointer();
+  };
+
+  String.encode = function(encoder, val) {
+    encoder.encodeStringPointer(val);
+  };
+
 
   function Float() {
   }
 
   Float.encodedSize = 4;
 
   Float.decode = function(decoder) {
     return decoder.readFloat();
   };
 
@@ skipping 29 matching lines @@
     this.cls.encode(objectEncoder, val);
   };
 
   function ArrayOf(cls) {
     this.cls = cls;
   }
 
   ArrayOf.prototype.encodedSize = 8;
 
   ArrayOf.prototype.decode = function(decoder) {
-    return decoder.decodeArrayPointer(self.cls);
+    return decoder.decodeArrayPointer(this.cls);
   };
 
   ArrayOf.prototype.encode = function(encoder, val) {
-    encoder.encodeArrayPointer(self.cls, val);
+    encoder.encodeArrayPointer(this.cls, val);
   };
 
   function Handle() {
   }
 
   Handle.encodedSize = 4;
 
   Handle.decode = function(decoder) {
     return decoder.decodeHandle();
   };
@@ skipping 17 matching lines @@
   exports.Int8 = Int8;
   exports.Uint8 = Uint8;
   exports.Int16 = Int16;
   exports.Uint16 = Uint16;
   exports.Int32 = Int32;
   exports.Uint32 = Uint32;
   exports.Int64 = Int64;
   exports.Uint64 = Uint64;
   exports.Float = Float;
   exports.Double = Double;
+  exports.String = String;
   exports.PointerTo = PointerTo;
   exports.ArrayOf = ArrayOf;
   exports.Handle = Handle;
   return exports;
 });