Add support for Float/Double types for JS Mojo bindings.

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 160 matching lines @@
     return result;
   };
 
   Decoder.prototype.readUint64 = function() {
     var result = getUint64(
         this.buffer.dataView, this.next, kHostIsLittleEndian);
     this.next += 8;
     return result;
   };
 
-  Decoder.prototype.readFloat32 = function() {
-    var result = this.buffer.dataView.readFloat32(
+  Decoder.prototype.readFloat = function() {
+    var result = this.buffer.dataView.getFloat32(
         this.next, kHostIsLittleEndian);
     this.next += 4;
     return result;
   };
 
-  Decoder.prototype.readFloat64 = function() {
-    var result = this.buffer.dataView.readFloat64(
+  Decoder.prototype.readDouble = function() {
+    var result = this.buffer.dataView.getFloat64(
         this.next, kHostIsLittleEndian);
     this.next += 8;
     return result;
   };
 
   Decoder.prototype.decodePointer = function() {
     // TODO(abarth): To correctly decode a pointer, we need to know the real
     // base address of the array buffer.
     var offsetPointer = this.next;
     var offset = this.readUint64();
@@ skipping 101 matching lines @@
   };
 
   Encoder.prototype.writeUint64 = function(val) {
     if (val < 0) {
       throw new Error(kErrorUnsigned);
     }
     setUint64(this.buffer.dataView, this.next, val);
     this.next += 8;
   };
 
-  Encoder.prototype.writeFloat32 = function(val) {
-    this.buffer.dataView.setFloat32(val, kHostIsLittleEndian);
+  Encoder.prototype.writeFloat = function(val) {
+    this.buffer.dataView.setFloat32(this.next, val, kHostIsLittleEndian);
     this.next += 4;
   };
 
-  Encoder.prototype.writeFloat64 = function(val) {
-    this.buffer.dataView.setFloat64(val, kHostIsLittleEndian);
+  Encoder.prototype.writeDouble = function(val) {
+    this.buffer.dataView.setFloat64(this.next, val, kHostIsLittleEndian);
     this.next += 8;
   };
 
   Encoder.prototype.encodePointer = function(pointer) {
     if (!pointer)
       return this.writeUint64(0);
     // TODO(abarth): To correctly encode a pointer, we need to know the real
     // base address of the array buffer.
     var offset = pointer - this.next;
     this.writeUint64(offset);
@@ skipping 223 matching lines @@
 
   Uint32.decode = function(decoder) {
     return decoder.readUint32();
   };
 
   Uint32.encode = function(encoder, val) {
     encoder.writeUint32(val);
   };
 
   function Int64() {
-  };
+  }
 
   Int64.encodedSize = 8;
 
   Int64.decode = function(decoder) {
     return decoder.readInt64();
   };
 
   Int64.encode = function(encoder, val) {
     encoder.writeInt64(val);
   };
 
   function Uint64() {
-  };
+  }
 
   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 Float() {
+  }
+
+  Float.encodedSize = 4;
+
+  Float.decode = function(decoder) {
+    return decoder.readFloat();
+  };
+
+  Float.encode = function(encoder, val) {
+    encoder.writeFloat(val);
+  };
+
+  function Double() {
+  }
+
+  Double.encodedSize = 8;
+
+  Double.decode = function(decoder) {
+    return decoder.readDouble();
+  };
+
+  Double.encode = function(encoder, val) {
+    encoder.writeDouble(val);
+  };
+
   function PointerTo(cls) {
     this.cls = cls;
-  };
-
-  // TODO(abarth): Add missing types:
-  // * String
-  // * Float
-  // * Double
-  // * Signed integers
+  }
 
   PointerTo.prototype.encodedSize = 8;
 
   PointerTo.prototype.decode = function(decoder) {
     return this.cls.decode(decoder.decodeAndCreateDecoder());
   };
 
   PointerTo.prototype.encode = function(encoder, val) {
     var objectEncoder = encoder.createAndEncodeEncoder(this.cls.encodedSize);
     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);
   };
 
   ArrayOf.prototype.encode = function(encoder, val) {
     encoder.encodeArrayPointer(self.cls, val);
   };
@@ skipping 24 matching lines @@
   exports.kMessageExpectsResponse = kMessageExpectsResponse;
   exports.kMessageIsResponse = kMessageIsResponse;
   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.PointerTo = PointerTo;
   exports.ArrayOf = ArrayOf;
   exports.Handle = Handle;
   return exports;
 });