Validate incoming JS Message Headers: test message parser

mojo/public/js/bindings/buffer.js

Index: mojo/public/js/bindings/buffer.js
diff --git a/mojo/public/js/bindings/buffer.js b/mojo/public/js/bindings/buffer.js
new file mode 100644
index 0000000000000000000000000000000000000000..3ad475b757753fd58c44380bacc0b14cca121193
--- /dev/null
+++ b/mojo/public/js/bindings/buffer.js
@@ -0,0 +1,169 @@
+// 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([], function () {

[abarth-chromium, 2014/07/23 02:13:51]

I think you can just omit [] when it's empty.

[hansmuller, 2014/07/23 18:06:35]

Done.

+
+  function Buffer(sizeOrArrayBuffer) {
+    if (sizeOrArrayBuffer instanceof ArrayBuffer)
+      this.arrayBuffer = sizeOrArrayBuffer;
+    else
+      this.arrayBuffer = new ArrayBuffer(sizeOrArrayBuffer);
+
+    this.dataView = new DataView(this.arrayBuffer);
+    this.byteLength = this.arrayBuffer.byteLength;

[yzshen1, 2014/07/23 07:26:55]

Maybe we could make a getter which simply reads the byteLength of arrayBuffer,
so that we don't have to worry about keeping them in sync (which is error
prone)?

[hansmuller, 2014/07/23 18:06:35]

Good point.

+    this.next = 0;
+  }
+
+  var kHostIsLittleEndian = (function () {

[yzshen1, 2014/07/23 07:26:55]

(Not familiar with JS style.)

Maybe we should order the code so that the helpers are at the top and Buffer
constructor/methods stay together?

[hansmuller, 2014/07/23 18:06:35]

OK.

+    var endianArrayBuffer = new ArrayBuffer(2);
+    var endianUint8Array = new Uint8Array(endianArrayBuffer);
+    var endianUint16Array = new Uint16Array(endianArrayBuffer);
+    endianUint16Array[0] = 1;
+    return endianUint8Array[0] == 1;
+  })();
+
+  var kHighWordMultiplier = 0x100000000;
+
+  function getInt64(dataView, byteOffset, value) {
+    var lo, hi;
+    if (kHostIsLittleEndian) {
+      lo = dataView.getUint32(byteOffset, kHostIsLittleEndian);
+      hi = dataView.getInt32(byteOffset + 4, kHostIsLittleEndian);
+    } else {
+      hi = dataView.getInt32(byteOffset, kHostIsLittleEndian);
+      lo = dataView.getUint32(byteOffset + 4, kHostIsLittleEndian);
+    }
+    return lo + hi * kHighWordMultiplier;
+  }
+
+  function getUint64(dataView, byteOffset, value) {
+    var lo, hi;
+    if (kHostIsLittleEndian) {
+      lo = dataView.getUint32(byteOffset, kHostIsLittleEndian);
+      hi = dataView.getUint32(byteOffset + 4, kHostIsLittleEndian);
+    } else {
+      hi = dataView.getUint32(byteOffset, kHostIsLittleEndian);
+      lo = dataView.getUint32(byteOffset + 4, kHostIsLittleEndian);
+    }
+    return lo + hi * kHighWordMultiplier;
+  }
+
+  function setInt64(dataView, byteOffset, value) {
+    var hi = Math.floor(value / kHighWordMultiplier);
+    if (kHostIsLittleEndian) {
+      dataView.setInt32(byteOffset, value, kHostIsLittleEndian);
+      dataView.setInt32(byteOffset + 4, hi, kHostIsLittleEndian);
+    } else {
+      dataView.setInt32(byteOffset, hi, kHostIsLittleEndian);
+      dataView.setInt32(byteOffset + 4, value, kHostIsLittleEndian);
+    }
+  }
+
+  function setUint64(dataView, byteOffset, value) {
+    var hi = (value / kHighWordMultiplier) | 0;
+    if (kHostIsLittleEndian) {
+      dataView.setInt32(byteOffset, value, kHostIsLittleEndian);
+      dataView.setInt32(byteOffset + 4, hi, kHostIsLittleEndian);
+    } else {
+      dataView.setInt32(byteOffset, hi, kHostIsLittleEndian);
+      dataView.setInt32(byteOffset + 4, value, kHostIsLittleEndian);
+    }
+  }
+
+  Buffer.prototype.alloc = function(size) {
+    var pointer = this.next;
+    this.next += size;
+    if (this.next > this.byteLength) {
+      var newSize = (1.5 * (this.byteLength + size)) | 0;
+      this.grow(newSize);
+    }
+    return pointer;
+  };
+
+  function copyArrayBuffer(dstArrayBuffer, srcArrayBuffer) {
+    (new Uint8Array(dstArrayBuffer)).set(new Uint8Array(srcArrayBuffer));
+  }
+
+  Buffer.prototype.grow = function(size) {
+    var newArrayBuffer = new ArrayBuffer(size);
+    copyArrayBuffer(newArrayBuffer, this.arrayBuffer);
+    this.arrayBuffer = newArrayBuffer;
+    this.dataView = new DataView(this.arrayBuffer);
+    this.byteLength = size;
+  };
+
+  Buffer.prototype.trim = function() {
+    this.arrayBuffer = this.arrayBuffer.slice(0, this.next);
+    this.dataView = new DataView(this.arrayBuffer);
+    this.byteLength = this.next;
+  };
+
+  Buffer.prototype.getUint8 = function(offset) {
+    return this.dataView.getUint8(offset);
+  }
+  Buffer.prototype.getUint16 = function(offset) {
+    return this.dataView.getUint16(offset, kHostIsLittleEndian);
+  }
+  Buffer.prototype.getUint32 = function(offset) {
+    return this.dataView.getUint32(offset, kHostIsLittleEndian);
+  }
+  Buffer.prototype.getUint64 = function(offset) {
+    return getUint64(this.dataView, offset, kHostIsLittleEndian);

[yzshen1, 2014/07/23 07:26:55]

Does it make sense to merge the impl of getUint64() into this method? It seems
that function is only used once.

(And do similar things for [gs]et(Ui|I)nt64)

[hansmuller, 2014/07/23 18:06:35]

Yes, that makes sense.

+  }
+
+  Buffer.prototype.getInt8 = function(offset) {
+    return this.dataView.getInt8(offset);
+  }
+  Buffer.prototype.getInt16 = function(offset) {
+    return this.dataView.getInt16(offset, kHostIsLittleEndian);
+  }
+  Buffer.prototype.getInt32 = function(offset) {
+    return this.dataView.getInt32(offset, kHostIsLittleEndian);
+  }
+  Buffer.prototype.getInt64 = function(offset) {
+    return getInt64(this.dataView, offset, kHostIsLittleEndian);
+  }
+
+  Buffer.prototype.getFloat32 = function(offset) {
+    return this.dataView.getFloat32(offset, kHostIsLittleEndian);
+  }
+  Buffer.prototype.getFloat64 = function(offset) {
+    return this.dataView.getFloat64(offset, kHostIsLittleEndian);
+  }
+
+  Buffer.prototype.setUint8 = function(offset, value) {
+    this.dataView.setUint8(offset, value);
+  }
+  Buffer.prototype.setUint16 = function(offset, value) {
+    this.dataView.setUint16(offset, value, kHostIsLittleEndian);
+  }
+  Buffer.prototype.setUint32 = function(offset, value) {
+    this.dataView.setUint32(offset, value, kHostIsLittleEndian);
+  }
+  Buffer.prototype.setUint64 = function(offset, value) {
+    setUint64(this.dataView, offset, value, kHostIsLittleEndian);
+  }
+
+  Buffer.prototype.setInt8 = function(offset, value) {
+    this.dataView.setInt8(offset, value);
+  }
+  Buffer.prototype.setInt16 = function(offset, value) {
+    this.dataView.setInt16(offset, value, kHostIsLittleEndian);
+  }
+  Buffer.prototype.setInt32 = function(offset, value) {
+    this.dataView.setInt32(offset, value, kHostIsLittleEndian);
+  }
+  Buffer.prototype.setInt64 = function(offset, value) {
+    setInt64(this.dataView, offset, value, kHostIsLittleEndian);
+  }
+
+  Buffer.prototype.setFloat32 = function(offset, value) {
+    this.dataView.setFloat32(offset, value, kHostIsLittleEndian);
+  }
+  Buffer.prototype.setFloat64 = function(offset, value) {
+    this.dataView.setFloat64(offset, value, kHostIsLittleEndian);
+  }
+
+  return Buffer;

[Matt Perry, 2014/07/23 00:39:38]

I think you should return a dictionary object that contains a Buffer value,
rather than the Buffer object directly.

[abarth-chromium, 2014/07/23 02:13:51]

+1

[hansmuller, 2014/07/23 18:06:35]

I didn't want user s of this module to have to write |new buffer.Buffer(...)| or
|var Buffer = buffer.Buffer; new Buffer(...)|. That said, I'll yield to the
consensus on this point and return a dictionary.

+});