Fix handling of null pointers in JS bindings.

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"
 ], function(unicode) {
 
   var kErrorUnsigned = "Passing negative value to unsigned";
 
@@ skipping 184 matching lines @@
   Decoder.prototype.decodePointer = function() {
     // TODO(abarth): To correctly decode a pointer, we need to know the real
     // base address of the array buffer.
     var offsetPointer = this.next;
     var offset = this.readUint64();
     if (!offset)
       return 0;
     return offsetPointer + offset;
   };
 
-  Decoder.prototype.decodeAndCreateDecoder = function() {
-    return new Decoder(this.buffer, this.handles, this.decodePointer());
+  Decoder.prototype.decodeAndCreateDecoder = function(pointer) {
+    return new Decoder(this.buffer, this.handles, pointer);
   };
 
   Decoder.prototype.decodeHandle = function() {
     return this.handles[this.readUint32()];
   };
 
   Decoder.prototype.decodeString = function() {
     var numberOfBytes = this.readUint32();
     var numberOfElements = this.readUint32();
     var base = this.next;
@@ skipping 10 matching lines @@
       val[i] = cls.decode(this);
     }
     return val;
   };
 
   Decoder.prototype.decodeStruct = function(cls) {
     return cls.decode(this);
   };
 
   Decoder.prototype.decodeStructPointer = function(cls) {
-    return cls.decode(this.decodeAndCreateDecoder());
+    var pointer = this.decodePointer();
+    if (!pointer) {
+      return null;
+    }

[Matt Perry, 2014/05/16 18:39:04]

I assume this mimics how its done on the C++ side?

[Tom Sepez, 2014/05/16 18:56:17]

It's not exactly analogous, because JS has to decode everything, but C only has
to decode pointers and handles. SO on the C side, the checks are in the decode
templates for the cases where it matter.

+    return cls.decode(this.decodeAndCreateDecoder(pointer));
   };
 
   Decoder.prototype.decodeArrayPointer = function(cls) {
-    return this.decodeAndCreateDecoder().decodeArray(cls);
+    var pointer = this.decodePointer();
+    if (!pointer) {
+      return null;
+    }
+    return this.decodeAndCreateDecoder(pointer).decodeArray(cls);
   };
 
   Decoder.prototype.decodeStringPointer = function() {
-    return this.decodeAndCreateDecoder().decodeString();
+    var pointer = this.decodePointer();
+    if (!pointer) {
+      return null;
+    }
+    return this.decodeAndCreateDecoder(pointer).decodeString();
   };
 
   // Encoder ------------------------------------------------------------------
 
   function Encoder(buffer, handles, base) {
     this.buffer = buffer;
     this.handles = handles;
     this.base = base;
     this.next = base;
   }
@@ skipping 104 matching lines @@
     for (var i = 0; i < numberOfElements; ++i) {
       cls.encode(this, val[i]);
     }
   };
 
   Encoder.prototype.encodeStruct = function(cls, val) {
     return cls.encode(this, val);
   };
 
   Encoder.prototype.encodeStructPointer = function(cls, val) {
+    if (!val) {
+      this.encodePointer(val);
+      return;
+    }
     var encoder = this.createAndEncodeEncoder(cls.encodedSize);
     cls.encode(encoder, val);
   };
 
   Encoder.prototype.encodeArrayPointer = function(cls, val) {
+    if (!val) {
+      this.encodePointer(val);
+      return;
+    }
     var encodedSize = kArrayHeaderSize + cls.encodedSize * val.length;
     var encoder = this.createAndEncodeEncoder(encodedSize);
     encoder.encodeArray(cls, val);
   };
 
   Encoder.prototype.encodeStringPointer = function(val) {
+    if (!val) {
+      this.encodePointer(val);
+      return;
+    }
     var encodedSize = kArrayHeaderSize + unicode.utf8Length(val);
     var encoder = this.createAndEncodeEncoder(encodedSize);
     encoder.encodeString(val);
   };
 
   // Message ------------------------------------------------------------------
 
   var kMessageExpectsResponse = 1 << 0;
   var kMessageIsResponse      = 1 << 1;
 
@@ skipping 244 matching lines @@
     encoder.writeDouble(val);
   };
 
   function PointerTo(cls) {
     this.cls = cls;
   }
 
   PointerTo.prototype.encodedSize = 8;
 
   PointerTo.prototype.decode = function(decoder) {
-    return this.cls.decode(decoder.decodeAndCreateDecoder());
+    var pointer = decoder.decodePointer();
+    if (!pointer) {
+      return null;
+    }
+    return this.cls.decode(decoder.decodeAndCreateDecoder(pointer));
   };
 
   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 ArrayOf(cls) {
     this.cls = cls;
   }
 
   ArrayOf.prototype.encodedSize = 8;
 
@@ skipping 39 matching lines @@
   exports.Int64 = Int64;
   exports.Uint64 = Uint64;
   exports.Float = Float;
   exports.Double = Double;
   exports.String = String;
   exports.PointerTo = PointerTo;
   exports.ArrayOf = ArrayOf;
   exports.Handle = Handle;
   return exports;
 });