Add associated interfaces & bindings.

mojo/public/js/new_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.
 
 (function() {
   var internal = mojo.internal;
 
   var kErrorUnsigned = "Passing negative value to unsigned";
   var kErrorArray = "Passing non Array for array type";
   var kErrorString = "Passing non String for string type";
@@ skipping 446 matching lines @@
   Message.prototype.expectsResponse = function() {
     return (this.getFlags() & kMessageExpectsResponse) != 0;
   };
 
   Message.prototype.setRequestID = function(requestID) {
     // TODO(darin): Verify that space was reserved for this field!
     this.buffer.setUint64(kMessageRequestIDOffset, requestID);
   };
 
 
-  // MessageBuilder -----------------------------------------------------------
+  // MessageV0Builder ---------------------------------------------------------
 
-  function MessageBuilder(messageName, payloadSize) {
+  function MessageV0Builder(messageName, payloadSize) {
     // Currently, we don't compute the payload size correctly ahead of time.
     // Instead, we resize the buffer at the end.
     var numberOfBytes = kMessageHeaderSize + payloadSize;
     this.buffer = new internal.Buffer(numberOfBytes);
     this.handles = [];
     var encoder = this.createEncoder(kMessageHeaderSize);
     encoder.writeUint32(kMessageHeaderSize);
     encoder.writeUint32(0);  // version.
     encoder.writeUint32(0);  // interface ID.
     encoder.writeUint32(messageName);
     encoder.writeUint32(0);  // flags.
     encoder.writeUint32(0);  // padding.
   }
 
-  MessageBuilder.prototype.createEncoder = function(size) {
+  MessageV0Builder.prototype.createEncoder = function(size) {
     var pointer = this.buffer.alloc(size);
     return new Encoder(this.buffer, this.handles, pointer);
   };
 
-  MessageBuilder.prototype.encodeStruct = function(cls, val) {
+  MessageV0Builder.prototype.encodeStruct = function(cls, val) {
     cls.encode(this.createEncoder(cls.encodedSize), val);
   };
 
-  MessageBuilder.prototype.finish = function() {
+  MessageV0Builder.prototype.finish = function() {
     // 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++.
     this.buffer.trim();
     var message = new Message(this.buffer, this.handles);
     this.buffer = null;
     this.handles = null;
     this.encoder = null;
     return message;
   };
 
-  // MessageWithRequestIDBuilder -----------------------------------------------
+  // MessageV1Builder -----------------------------------------------
 
-  function MessageWithRequestIDBuilder(messageName, payloadSize, flags,
+  function MessageV1Builder(messageName, payloadSize, flags,
                                        requestID) {
     // Currently, we don't compute the payload size correctly ahead of time.
     // Instead, we resize the buffer at the end.
     var numberOfBytes = kMessageWithRequestIDHeaderSize + payloadSize;
     this.buffer = new internal.Buffer(numberOfBytes);
     this.handles = [];
     var encoder = this.createEncoder(kMessageWithRequestIDHeaderSize);
     encoder.writeUint32(kMessageWithRequestIDHeaderSize);
     encoder.writeUint32(1);  // version.
     encoder.writeUint32(0);  // interface ID.
     encoder.writeUint32(messageName);
     encoder.writeUint32(flags);
     encoder.writeUint32(0);  // padding.
     encoder.writeUint64(requestID);
   }
 
-  MessageWithRequestIDBuilder.prototype =
-      Object.create(MessageBuilder.prototype);
+  MessageV1Builder.prototype =
+      Object.create(MessageV0Builder.prototype);
 
-  MessageWithRequestIDBuilder.prototype.constructor =
-      MessageWithRequestIDBuilder;
+  MessageV1Builder.prototype.constructor =
+      MessageV1Builder;
 
   // MessageReader ------------------------------------------------------------
 
   function MessageReader(message) {
     this.decoder = new Decoder(message.buffer, message.handles, 0);
     var messageHeaderSize = this.decoder.readUint32();
     this.payloadSize = message.buffer.byteLength - messageHeaderSize;
     var version = this.decoder.readUint32();
     var interface_id = this.decoder.readUint32();
     if (interface_id != 0) {
@@ skipping 332 matching lines @@
 
   function NullableMapOf(keyClass, valueClass) {
     MapOf.call(this, keyClass, valueClass);
   }
 
   NullableMapOf.prototype = Object.create(MapOf.prototype);
 
   internal.align = align;
   internal.isAligned = isAligned;
   internal.Message = Message;
-  internal.MessageBuilder = MessageBuilder;
-  internal.MessageWithRequestIDBuilder = MessageWithRequestIDBuilder;
+  internal.MessageV0Builder = MessageV0Builder;
+  internal.MessageV1Builder = MessageV1Builder;
   internal.MessageReader = MessageReader;
   internal.kArrayHeaderSize = kArrayHeaderSize;
   internal.kMapStructPayloadSize = kMapStructPayloadSize;
   internal.kStructHeaderSize = kStructHeaderSize;
   internal.kEncodedInvalidHandleValue = kEncodedInvalidHandleValue;
   internal.kMessageHeaderSize = kMessageHeaderSize;
   internal.kMessageWithRequestIDHeaderSize = kMessageWithRequestIDHeaderSize;
   internal.kMessageExpectsResponse = kMessageExpectsResponse;
   internal.kMessageIsResponse = kMessageIsResponse;
   internal.Int8 = Int8;
@@ skipping 16 matching lines @@
   internal.PackedBool = PackedBool;
   internal.Handle = Handle;
   internal.NullableHandle = NullableHandle;
   internal.Interface = Interface;
   internal.NullableInterface = NullableInterface;
   internal.InterfaceRequest = InterfaceRequest;
   internal.NullableInterfaceRequest = NullableInterfaceRequest;
   internal.MapOf = MapOf;
   internal.NullableMapOf = NullableMapOf;
 })();