Mojo's C++ and JavaScript bindings should produce identical messages

mojo/public/bindings/js/codec.js

 // Copyright 2013 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(function() {
 
   // Memory -------------------------------------------------------------------
 
   function store8(memory, pointer, val) {
     memory[pointer] = val;
@@ skipping 63 matching lines @@
   };
 
   Buffer.prototype.grow = function(size) {
     var newMemory = new Uint8Array(size);
     var oldMemory = this.memory;
     for (var i = 0; i < oldMemory.length; ++i)
       newMemory[i] = oldMemory[i];
     this.memory = newMemory;
   };
 
+  Buffer.prototype.createViewOfAllocatedMemory = function() {
+    return new Uint8Array(this.memory.buffer, 0, this.next);
+  };
+
   // Constants ----------------------------------------------------------------
 
   var kArrayHeaderSize = 8;
   var kStructHeaderSize = 8;
   var kMessageHeaderSize = 8;
 
   // Decoder ------------------------------------------------------------------
 
   function Decoder(memory, handles, base) {
     this.memory = memory;
@@ skipping 111 matching lines @@
   Encoder.prototype.encodePointer = function(pointer) {
     if (!pointer)
       return this.write64(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.write64(offset);
   };
 
   Encoder.prototype.createAndEncodeEncoder = function(size) {
-    var pointer = this.buffer.alloc(size);
+    var pointer = this.buffer.alloc(align(size));
     this.encodePointer(pointer);
     return new Encoder(this.buffer, this.handles, pointer);
   };
 
   Encoder.prototype.encodeHandle = function(handle) {
     this.handles.push(handle);
     this.write32(this.handles.length - 1);
   };
 
   Encoder.prototype.encodeString = function(val) {
@@ skipping 44 matching lines @@
   // Message ------------------------------------------------------------------
 
   function Message(memory, handles) {
     this.memory = memory;
     this.handles = handles;
   }
 
   // MessageBuilder -----------------------------------------------------------
 
   function MessageBuilder(messageName, payloadSize) {
+    // Currently, we don't compute the payload size correctly ahead of time.
+    // Instead, we overwrite this field at the end.
     var numberOfBytes = kMessageHeaderSize + payloadSize;
     this.buffer = new Buffer(numberOfBytes);
     this.handles = [];
     var encoder = this.createEncoder(kMessageHeaderSize);
     encoder.write32(numberOfBytes);
     encoder.write32(messageName);
   }
 
   MessageBuilder.prototype.createEncoder = function(size) {
     var pointer = this.buffer.alloc(size);
     return new Encoder(this.buffer, this.handles, pointer);
   }
 
   MessageBuilder.prototype.encodeStruct = function(cls, val) {
     cls.encode(this.createEncoder(cls.encodedSize), val);
   };
 
   MessageBuilder.prototype.finish = function() {
-    var message = new Message(this.buffer.memory, this.handles);
+    // TODO(abarth): Rather than resizing the buffer at the end, we could
+    // compute the size we need ahead of time, like we do in C++.
+    var memory = this.buffer.createViewOfAllocatedMemory();
+    store32(memory, 0, memory.length);
+    var message = new Message(memory, this.handles);
     this.buffer = null;
     this.handles = null;
     this.encoder = null;
     return message;
   };
 
   // MessageReader ------------------------------------------------------------
 
   function MessageReader(message) {
     this.decoder = new Decoder(message.memory, message.handles, 0);
@@ skipping 95 matching lines @@
   exports.kStructHeaderSize = kStructHeaderSize;
   exports.kMessageHeaderSize = kMessageHeaderSize;
   exports.Uint8 = Uint8;
   exports.Uint16 = Uint16;
   exports.Uint32 = Uint32;
   exports.Uint64 = Uint64;
   exports.PointerTo = PointerTo;
   exports.Handle = Handle;
   return exports;
 });