Mojo JS bindings: code generator maps interface ptr and request to InterfacePtr and InterfaceReques…

mojo/public/js/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",
-  "mojo/public/js/buffer",
-], function(unicode, buffer) {
+], function(buffer, types, unicode) {
 
   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 776 matching lines @@
 
   function NullableHandle() {
   }
 
   NullableHandle.encodedSize = Handle.encodedSize;
 
   NullableHandle.decode = Handle.decode;
 
   NullableHandle.encode = Handle.encode;
 
-  function Interface() {
+  function Interface(cls) {
+    this.cls = cls;
   }
 
-  Interface.encodedSize = 8;
+  Interface.prototype.encodedSize = 8;
 
-  Interface.decode = function(decoder) {
-    var handle = decoder.decodeHandle();
-    // Ignore the version field for now.
-    decoder.readUint32();
-
-    return handle;
+  Interface.prototype.decode = function(decoder) {
+    var interfacePtrInfo = new types.InterfacePtrInfo(
+        decoder.decodeHandle(), decoder.readUint32());
+    var interfacePtr = new this.cls();
+    interfacePtr.ptr.bind(interfacePtrInfo);
+    return interfacePtr;
   };
 
-  Interface.encode = function(encoder, val) {
-    encoder.encodeHandle(val);
-    // Set the version field to 0 for now.
-    encoder.writeUint32(0);
+  Interface.prototype.encode = function(encoder, val) {
+    var interfacePtrInfo =
+        val ? val.ptr.passInterface() : new InterfacePtrInfo(null, 0);
+    encoder.encodeHandle(interfacePtrInfo.handle);
+    encoder.writeUint32(interfacePtrInfo.version);
   };
 
-  function NullableInterface() {
+  function NullableInterface(cls) {
+    Interface.call(this, cls);
   }
 
-  NullableInterface.encodedSize = Interface.encodedSize;
+  NullableInterface.prototype = Object.create(Interface.prototype);
 
-  NullableInterface.decode = Interface.decode;
+  function InterfaceRequest() {
+  }
 
-  NullableInterface.encode = Interface.encode;
+  InterfaceRequest.encodedSize = 4;
+
+  InterfaceRequest.decode = function(decoder) {
+    return new types.InterfaceRequest(decoder.decodeHandle());
+  };
+
+  InterfaceRequest.encode = function(encoder, val) {
+    encoder.encodeHandle(val ? val.handle : null);
+  };
+
+  function NullableInterfaceRequest() {
+  }
+
+  NullableInterfaceRequest.encodedSize = InterfaceRequest.encodedSize;
+
+  NullableInterfaceRequest.decode = InterfaceRequest.decode;
+
+  NullableInterfaceRequest.encode = InterfaceRequest.encode;
 
   function MapOf(keyClass, valueClass) {
     this.keyClass = keyClass;
     this.valueClass = valueClass;
   }
 
   MapOf.prototype.encodedSize = 8;
 
   MapOf.prototype.decode = function(decoder) {
     return decoder.decodeMapPointer(this.keyClass, this.valueClass);
@@ skipping 39 matching lines @@
   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;
 });