Add JS bindings validation logic for non-nullable types

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",
   "mojo/public/js/bindings/buffer"
   ], function(unicode, buffer) {
 
   var kErrorUnsigned = "Passing negative value to unsigned";
@@ skipping 575 matching lines @@
   String.encodedSize = 8;
 
   String.decode = function(decoder) {
     return decoder.decodeStringPointer();
   };
 
   String.encode = function(encoder, val) {
     encoder.encodeStringPointer(val);
   };
 
+  function NullableString() {
+  }
+
+  NullableString.encodedSize = String.encodedSize;
+
+  NullableString.decode = String.decode;
+
+  NullableString.encode = String.encode;
 
   function Float() {
   }
 
   Float.encodedSize = 4;
 
   Float.decode = function(decoder) {
     return decoder.readFloat();
   };
 
@@ skipping 30 matching lines @@
 
   PointerTo.prototype.encode = function(encoder, val) {
     if (!val) {
       encoder.encodePointer(val);
       return;
     }
     var objectEncoder = encoder.createAndEncodeEncoder(this.cls.encodedSize);
     this.cls.encode(objectEncoder, val);
   };
 
+  function NullablePointerTo(cls) {
+    PointerTo.call(this, cls);
+  }
+
+  NullablePointerTo.prototype = Object.create(PointerTo.prototype);
+
   function ArrayOf(cls) {
     this.cls = cls;
   }
 
   ArrayOf.prototype.encodedSize = 8;
 
   ArrayOf.prototype.decode = function(decoder) {
     return decoder.decodeArrayPointer(this.cls);
   };
 
   ArrayOf.prototype.encode = function(encoder, val) {
     encoder.encodeArrayPointer(this.cls, val);
   };
 
+  function NullableArrayOf(cls) {
+    ArrayOf.call(this, cls);
+  }
+
+  NullableArrayOf.prototype = Object.create(ArrayOf.prototype);
+
   function Handle() {
   }
 
   Handle.encodedSize = 4;
 
   Handle.decode = function(decoder) {
     return decoder.decodeHandle();
   };
 
   Handle.encode = function(encoder, val) {
     encoder.encodeHandle(val);
   };
 
+  function NullableHandle() {
+  }
+
+  NullableHandle.encodedSize = Handle.encodedSize;
+
+  NullableHandle.decode = Handle.decode;
+
+  NullableHandle.encode = Handle.encode;
+
   var exports = {};
   exports.align = align;
   exports.isAligned = isAligned;
   exports.Message = Message;
   exports.MessageBuilder = MessageBuilder;
   exports.MessageWithRequestIDBuilder = MessageWithRequestIDBuilder;
   exports.MessageReader = MessageReader;
   exports.kArrayHeaderSize = kArrayHeaderSize;
   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.NullableString = NullableString;
   exports.PointerTo = PointerTo;
+  exports.NullablePointerTo = NullablePointerTo;
   exports.ArrayOf = ArrayOf;
+  exports.NullableArrayOf = NullableArrayOf;
   exports.PackedBool = PackedBool;
   exports.Handle = Handle;
+  exports.NullableHandle = NullableHandle;
   return exports;
 });