Update third_party/protobuf to protobuf-v3.0.0-beta-3

third_party/protobuf/js/binary/decoder.js

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
 // https://developers.google.com/protocol-buffers/
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
@@ skipping 205 matching lines @@
  * @param {jspb.ByteSource=} opt_bytes The bytes we're reading from.
  * @param {number=} opt_start The optional offset to start reading at.
  * @param {number=} opt_length The optional length of the block to read -
  *     we'll throw an assertion if we go off the end of the block.
  * @constructor
  * @struct
  */
 jspb.BinaryDecoder = function(opt_bytes, opt_start, opt_length) {
   /**
    * Typed byte-wise view of the source buffer.
-   * @private {Uint8Array}
+   * @private {?Uint8Array}
    */
   this.bytes_ = null;
 
   /**
    * Start point of the block to read.
    * @private {number}
    */
   this.start_ = 0;
 
   /**
@@ skipping 91 matching lines @@
   this.bytes_ = null;
   this.start_ = 0;
   this.end_ = 0;
   this.cursor_ = 0;
   this.error_ = false;
 };
 
 
 /**
  * Returns the raw buffer.
- * @return {Uint8Array} The raw buffer.
+ * @return {?Uint8Array} The raw buffer.
  */
 jspb.BinaryDecoder.prototype.getBuffer = function() {
   return this.bytes_;
 };
 
 
 /**
  * Changes the block of bytes we're decoding.
  * @param {!jspb.ByteSource} data The bytes we're reading from.
  * @param {number=} opt_start The optional offset to start reading at.
@@ skipping 275 matching lines @@
  * @return {string} The decoded unsigned 32-bit varint as a string.
  */
 jspb.BinaryDecoder.prototype.readUnsignedVarint32String = function() {
   // 32-bit integers fit in JavaScript numbers without loss of precision, so
   // string variants of 32-bit varint readers can simply delegate then convert
   // to string.
   var value = this.readUnsignedVarint32();
   return value.toString();
 };
 
+
 /**
  * Reads a 32-bit signed variant and returns its value as a string.
  *
  * @return {string} The decoded signed 32-bit varint as a string.
  */
 jspb.BinaryDecoder.prototype.readSignedVarint32String = function() {
   // 32-bit integers fit in JavaScript numbers without loss of precision, so
   // string variants of 32-bit varint readers can simply delegate then convert
   // to string.
   var value = this.readSignedVarint32();
@@ skipping 299 matching lines @@
 jspb.BinaryDecoder.prototype.readStringWithLength = function() {
   var length = this.readUnsignedVarint32();
   return this.readString(length);
 };
 
 
 /**
  * Reads a block of raw bytes from the binary stream.
  *
  * @param {number} length The number of bytes to read.
- * @return {Uint8Array} The decoded block of bytes, or null if the length was
- *     invalid.
+ * @return {!Uint8Array} The decoded block of bytes, or an empty block if the
+ *     length was invalid.
  */
 jspb.BinaryDecoder.prototype.readBytes = function(length) {
   if (length < 0 ||
       this.cursor_ + length > this.bytes_.length) {
     this.error_ = true;
-    return null;
+    goog.asserts.fail('Invalid byte length!');
+    return new Uint8Array(0);
   }
 
   var result = this.bytes_.subarray(this.cursor_, this.cursor_ + length);
 
   this.cursor_ += length;
   goog.asserts.assert(this.cursor_ <= this.end_);
   return result;
 };
 
 
@@ skipping 25 matching lines @@
   var d = bytes[cursor + 3];
   var e = bytes[cursor + 4];
   var f = bytes[cursor + 5];
   var g = bytes[cursor + 6];
   var h = bytes[cursor + 7];
 
   this.cursor_ += 8;
 
   return String.fromCharCode(a, b, c, d, e, f, g, h);
 };