Mojo JS bindings: change module loading solution.

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.
 
-define("mojo/public/js/codec", [
-  "mojo/public/js/buffer",
-  "mojo/public/js/interface_types",
-  "mojo/public/js/unicode",
-], function(buffer, types, unicode) {
+(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";
   var kErrorMap = "Passing non Map for map type";
 
   // Memory -------------------------------------------------------------------
 
   var kAlignment = 8;
 
@@ skipping 111 matching lines @@
 
   Decoder.prototype.decodeHandle = function() {
     return this.handles[this.readUint32()] || null;
   };
 
   Decoder.prototype.decodeString = function() {
     var numberOfBytes = this.readUint32();
     var numberOfElements = this.readUint32();
     var base = this.next;
     this.next += numberOfElements;
-    return unicode.decodeUtf8String(
+    return internal.decodeUtf8String(
         new Uint8Array(this.buffer.arrayBuffer, base, numberOfElements));
   };
 
   Decoder.prototype.decodeArray = function(cls) {
     var numberOfBytes = this.readUint32();
     var numberOfElements = this.readUint32();
     var val = new Array(numberOfElements);
     if (cls === PackedBool) {
       var byte;
       for (var i = 0; i < numberOfElements; ++i) {
@@ skipping 155 matching lines @@
     if (handle) {
       this.handles.push(handle);
       this.writeUint32(this.handles.length - 1);
     } else {
       this.writeUint32(kEncodedInvalidHandleValue);
     }
   };
 
   Encoder.prototype.encodeString = function(val) {
     var base = this.next + kArrayHeaderSize;
-    var numberOfElements = unicode.encodeUtf8String(
+    var numberOfElements = internal.encodeUtf8String(
         val, new Uint8Array(this.buffer.arrayBuffer, base));
     var numberOfBytes = kArrayHeaderSize + numberOfElements;
     this.writeUint32(numberOfBytes);
     this.writeUint32(numberOfElements);
     this.next += numberOfElements;
   };
 
   Encoder.prototype.encodeArray =
       function(cls, val, numberOfElements, encodedSize) {
     if (numberOfElements === undefined)
@@ skipping 54 matching lines @@
   Encoder.prototype.encodeStringPointer = function(val) {
     if (val == null) {
       // Also handles undefined, since undefined == null.
       this.encodePointer(val);
       return;
     }
     // Only accepts string primivites, not String Objects like new String("foo")
     if (typeof(val) !== "string") {
       throw new Error(kErrorString);
     }
-    var encodedSize = kArrayHeaderSize + unicode.utf8Length(val);
+    var encodedSize = kArrayHeaderSize + internal.utf8Length(val);
     var encoder = this.createAndEncodeEncoder(encodedSize);
     encoder.encodeString(val);
   };
 
   Encoder.prototype.encodeMap = function(keyClass, valueClass, val) {
     var keys = new Array(val.size);
     var values = new Array(val.size);
     var i = 0;
     val.forEach(function(value, key) {
       values[i] = value;
@@ skipping 63 matching lines @@
     this.buffer.setUint64(kMessageRequestIDOffset, requestID);
   };
 
 
   // MessageBuilder -----------------------------------------------------------
 
   function MessageBuilder(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 buffer.Buffer(numberOfBytes);
+    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.
   }
 
@@ skipping 17 matching lines @@
     return message;
   };
 
   // MessageWithRequestIDBuilder -----------------------------------------------
 
   function MessageWithRequestIDBuilder(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 buffer.Buffer(numberOfBytes);
+    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);
   }
@@ skipping 282 matching lines @@
 
   NullableHandle.encode = Handle.encode;
 
   function Interface(cls) {
     this.cls = cls;
   }
 
   Interface.prototype.encodedSize = 8;
 
   Interface.prototype.decode = function(decoder) {
-    var interfacePtrInfo = new types.InterfacePtrInfo(
+    var interfacePtrInfo = new mojo.InterfacePtrInfo(
         decoder.decodeHandle(), decoder.readUint32());
     var interfacePtr = new this.cls();
     interfacePtr.ptr.bind(interfacePtrInfo);
     return interfacePtr;
   };
 
   Interface.prototype.encode = function(encoder, val) {
     var interfacePtrInfo =
-        val ? val.ptr.passInterface() : new types.InterfacePtrInfo(null, 0);
+        val ? val.ptr.passInterface() : new mojo.InterfacePtrInfo(null, 0);
     encoder.encodeHandle(interfacePtrInfo.handle);
     encoder.writeUint32(interfacePtrInfo.version);
   };
 
   function NullableInterface(cls) {
     Interface.call(this, cls);
   }
 
   NullableInterface.prototype = Object.create(Interface.prototype);
 
   function InterfaceRequest() {
   }
 
   InterfaceRequest.encodedSize = 4;
 
   InterfaceRequest.decode = function(decoder) {
-    return new types.InterfaceRequest(decoder.decodeHandle());
+    return new mojo.InterfaceRequest(decoder.decodeHandle());
   };
 
   InterfaceRequest.encode = function(encoder, val) {
     encoder.encodeHandle(val ? val.handle : null);
   };
 
   function NullableInterfaceRequest() {
   }
 
   NullableInterfaceRequest.encodedSize = InterfaceRequest.encodedSize;
@@ skipping 16 matching lines @@
   MapOf.prototype.encode = function(encoder, val) {
     encoder.encodeMapPointer(this.keyClass, this.valueClass, val);
   };
 
   function NullableMapOf(keyClass, valueClass) {
     MapOf.call(this, keyClass, valueClass);
   }
 
   NullableMapOf.prototype = Object.create(MapOf.prototype);
 
-  var exports = {};
-  exports.align = align;
-  exports.isAligned = isAligned;
-  exports.Message = Message;
-  exports.MessageBuilder = MessageBuilder;
-  exports.MessageWithRequestIDBuilder = MessageWithRequestIDBuilder;
-  exports.MessageReader = MessageReader;
-  exports.kArrayHeaderSize = kArrayHeaderSize;
-  exports.kMapStructPayloadSize = kMapStructPayloadSize;
-  exports.kStructHeaderSize = kStructHeaderSize;
-  exports.kEncodedInvalidHandleValue = kEncodedInvalidHandleValue;
-  exports.kMessageHeaderSize = kMessageHeaderSize;
-  exports.kMessageWithRequestIDHeaderSize = kMessageWithRequestIDHeaderSize;
-  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.String = String;
-  exports.Enum = Enum;
-  exports.NullableString = NullableString;
-  exports.PointerTo = PointerTo;
-  exports.NullablePointerTo = NullablePointerTo;
-  exports.ArrayOf = ArrayOf;
-  exports.NullableArrayOf = NullableArrayOf;
-  exports.PackedBool = PackedBool;
-  exports.Handle = Handle;
-  exports.NullableHandle = NullableHandle;
-  exports.Interface = Interface;
-  exports.NullableInterface = NullableInterface;
-  exports.InterfaceRequest = InterfaceRequest;
-  exports.NullableInterfaceRequest = NullableInterfaceRequest;
-  exports.MapOf = MapOf;
-  exports.NullableMapOf = NullableMapOf;
-  return exports;
-});
+  internal.align = align;
+  internal.isAligned = isAligned;
+  internal.Message = Message;
+  internal.MessageBuilder = MessageBuilder;
+  internal.MessageWithRequestIDBuilder = MessageWithRequestIDBuilder;
+  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;
+  internal.Uint8 = Uint8;
+  internal.Int16 = Int16;
+  internal.Uint16 = Uint16;
+  internal.Int32 = Int32;
+  internal.Uint32 = Uint32;
+  internal.Int64 = Int64;
+  internal.Uint64 = Uint64;
+  internal.Float = Float;
+  internal.Double = Double;
+  internal.String = String;
+  internal.Enum = Enum;
+  internal.NullableString = NullableString;
+  internal.PointerTo = PointerTo;
+  internal.NullablePointerTo = NullablePointerTo;
+  internal.ArrayOf = ArrayOf;
+  internal.NullableArrayOf = NullableArrayOf;
+  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;
+})();