Revert "third_party/protobuf: Update to HEAD (83d681ee2c)"

third_party/protobuf/js/map.js

Index: third_party/protobuf/js/map.js
diff --git a/third_party/protobuf/js/map.js b/third_party/protobuf/js/map.js
deleted file mode 100644
index 93f08e037681293ab37c1f12d0feaf75566af832..0000000000000000000000000000000000000000
--- a/third_party/protobuf/js/map.js
+++ /dev/null
@@ -1,519 +0,0 @@
-// 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.
-//     * Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following disclaimer
-// in the documentation and/or other materials provided with the
-// distribution.
-//     * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived from
-// this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-goog.provide('jspb.Map');
-
-goog.require('goog.asserts');
-
-goog.forwardDeclare('jspb.BinaryReader');
-goog.forwardDeclare('jspb.BinaryWriter');
-
-
-
-/**
- * Constructs a new Map. A Map is a container that is used to implement map
- * fields on message objects. It closely follows the ES6 Map API; however,
- * it is distinct because we do not want to depend on external polyfills or
- * on ES6 itself.
- *
- * This constructor should only be called from generated message code. It is not
- * intended for general use by library consumers.
- *
- * @template K, V
- *
- * @param {!Array<!Array<!Object>>} arr
- *
- * @param {?function(new:V)|function(new:V,?)=} opt_valueCtor
- *    The constructor for type V, if type V is a message type.
- *
- * @constructor
- * @struct
- */
-jspb.Map = function(arr, opt_valueCtor) {
-  /** @const @private */
-  this.arr_ = arr;
-  /** @const @private */
-  this.valueCtor_ = opt_valueCtor;
-
-  /** @type {!Object<string, !jspb.Map.Entry_<K,V>>} @private */
-  this.map_ = {};
-
-  /**
-   * Is `this.arr_ updated with respect to `this.map_`?
-   * @type {boolean}
-   */
-  this.arrClean = true;
-
-  if (this.arr_.length > 0) {
-    this.loadFromArray_();
-  }
-};
-
-
-/**
- * Load initial content from underlying array.
- * @private
- */
-jspb.Map.prototype.loadFromArray_ = function() {
-  for (var i = 0; i < this.arr_.length; i++) {
-    var record = this.arr_[i];
-    var key = record[0];
-    var value = record[1];
-    this.map_[key.toString()] = new jspb.Map.Entry_(key, value);
-  }
-  this.arrClean = true;
-};
-
-
-/**
- * Synchronize content to underlying array, if needed, and return it.
- * @return {!Array<!Array<!Object>>}
- */
-jspb.Map.prototype.toArray = function() {
-  if (this.arrClean) {
-    if (this.valueCtor_) {
-      // We need to recursively sync maps in submessages to their arrays.
-      var m = this.map_;
-      for (var p in m) {
-        if (Object.prototype.hasOwnProperty.call(m, p)) {
-          var valueWrapper = /** @type {?jspb.Message} */ (m[p].valueWrapper);
-          if (valueWrapper) {
-            valueWrapper.toArray();
-          }
-        }
-      }
-    }
-  } else {
-    // Delete all elements.
-    this.arr_.length = 0;
-    var strKeys = this.stringKeys_();
-    // Output keys in deterministic (sorted) order.
-    strKeys.sort();
-    for (var i = 0; i < strKeys.length; i++) {
-      var entry = this.map_[strKeys[i]];
-      var valueWrapper = /** @type {!Object} */ (entry.valueWrapper);
-      if (valueWrapper) {
-        valueWrapper.toArray();
-      }
-      this.arr_.push([entry.key, entry.value]);
-    }
-    this.arrClean = true;
-  }
-  return this.arr_;
-};
-
-
-/**
- * Returns the map formatted as an array of key-value pairs, suitable for the
- * toObject() form of a message.
- *
- * @param {boolean=} includeInstance Whether to include the JSPB instance for
- *    transitional soy proto support: http://goto/soy-param-migration
- * @param {!function((boolean|undefined),!V):!Object=} valueToObject
- *    The static toObject() method, if V is a message type.
- * @return {!Array<!Array<!Object>>}
- */
-jspb.Map.prototype.toObject = function(includeInstance, valueToObject) {
-  var rawArray = this.toArray();
-  var entries = [];
-  for (var i = 0; i < rawArray.length; i++) {
-    var entry = this.map_[rawArray[i][0].toString()];
-    this.wrapEntry_(entry);
-    var valueWrapper = /** @type {!V|undefined} */ (entry.valueWrapper);
-    if (valueWrapper) {
-      goog.asserts.assert(valueToObject);
-      entries.push([entry.key, valueToObject(includeInstance, valueWrapper)]);
-    } else {
-      entries.push([entry.key, entry.value]);
-    }
-  }
-  return entries;
-};
-
-
-/**
- * Returns a Map from the given array of key-value pairs when the values are of
- * message type. The values in the array must match the format returned by their
- * message type's toObject() method.
- *
- * @template K, V
- * @param {!Array<!Array<!Object>>} entries
- * @param {!function(new:V)|function(new:V,?)} valueCtor
- *    The constructor for type V.
- * @param {!function(!Object):V} valueFromObject
- *    The fromObject function for type V.
- * @return {!jspb.Map<K, V>}
- */
-jspb.Map.fromObject = function(entries, valueCtor, valueFromObject) {
-  var result = new jspb.Map([], valueCtor);
-  for (var i = 0; i < entries.length; i++) {
-    var key = entries[i][0];
-    var value = valueFromObject(entries[i][1]);
-    result.set(key, value);
-  }
-  return result;
-};
-
-
-/**
- * Helper: return an iterator over an array.
- * @template T
- * @param {!Array<T>} arr the array
- * @return {!Iterator<T>} an iterator
- * @private
- */
-jspb.Map.arrayIterator_ = function(arr) {
-  var idx = 0;
-  return /** @type {!Iterator} */ ({
-    next: function() {
-      if (idx < arr.length) {
-        return { done: false, value: arr[idx++] };
-      } else {
-        return { done: true };
-      }
-    }
-  });
-};
-
-
-/**
- * Returns the map's length (number of key/value pairs).
- * @return {number}
- */
-jspb.Map.prototype.getLength = function() {
-  return this.stringKeys_().length;
-};
-
-
-/**
- * Clears the map.
- */
-jspb.Map.prototype.clear = function() {
-  this.map_ = {};
-  this.arrClean = false;
-};
-
-
-/**
- * Deletes a particular key from the map.
- * N.B.: differs in name from ES6 Map's `delete` because IE8 does not support
- * reserved words as property names.
- * @this {jspb.Map}
- * @param {K} key
- * @return {boolean} Whether any entry with this key was deleted.
- */
-jspb.Map.prototype.del = function(key) {
-  var keyValue = key.toString();
-  var hadKey = this.map_.hasOwnProperty(keyValue);
-  delete this.map_[keyValue];
-  this.arrClean = false;
-  return hadKey;
-};
-
-
-/**
- * Returns an array of [key, value] pairs in the map.
- *
- * This is redundant compared to the plain entries() method, but we provide this
- * to help out Angular 1.x users.  Still evaluating whether this is the best
- * option.
- *
- * @return {!Array<!Array<K|V>>}
- */
-jspb.Map.prototype.getEntryList = function() {
-  var entries = [];
-  var strKeys = this.stringKeys_();
-  strKeys.sort();
-  for (var i = 0; i < strKeys.length; i++) {
-    var entry = this.map_[strKeys[i]];
-    entries.push([entry.key, entry.value]);
-  }
-  return entries;
-};
-
-
-/**
- * Returns an iterator over [key, value] pairs in the map.
- * Closure compiler sadly doesn't support tuples, ie. Iterator<[K,V]>.
- * @return {!Iterator<!Array<K|V>>}
- *     The iterator
- */
-jspb.Map.prototype.entries = function() {
-  var entries = [];
-  var strKeys = this.stringKeys_();
-  strKeys.sort();
-  for (var i = 0; i < strKeys.length; i++) {
-    var entry = this.map_[strKeys[i]];
-    entries.push([entry.key, this.wrapEntry_(entry)]);
-  }
-  return jspb.Map.arrayIterator_(entries);
-};
-
-
-/**
- * Returns an iterator over keys in the map.
- * @return {!Iterator<K>} The iterator
- */
-jspb.Map.prototype.keys = function() {
-  var keys = [];
-  var strKeys = this.stringKeys_();
-  strKeys.sort();
-  for (var i = 0; i < strKeys.length; i++) {
-    var entry = this.map_[strKeys[i]];
-    keys.push(entry.key);
-  }
-  return jspb.Map.arrayIterator_(keys);
-};
-
-
-/**
- * Returns an iterator over values in the map.
- * @return {!Iterator<V>} The iterator
- */
-jspb.Map.prototype.values = function() {
-  var values = [];
-  var strKeys = this.stringKeys_();
-  strKeys.sort();
-  for (var i = 0; i < strKeys.length; i++) {
-    var entry = this.map_[strKeys[i]];
-    values.push(this.wrapEntry_(entry));
-  }
-  return jspb.Map.arrayIterator_(values);
-};
-
-
-/**
- * Iterates over entries in the map, calling a function on each.
- * @template T
- * @param {function(this:T, V, K, ?jspb.Map<K, V>)} cb
- * @param {T=} opt_thisArg
- */
-jspb.Map.prototype.forEach = function(cb, opt_thisArg) {
-  var strKeys = this.stringKeys_();
-  strKeys.sort();
-  for (var i = 0; i < strKeys.length; i++) {
-    var entry = this.map_[strKeys[i]];
-    cb.call(opt_thisArg, this.wrapEntry_(entry), entry.key, this);
-  }
-};
-
-
-/**
- * Sets a key in the map to the given value.
- * @param {K} key The key
- * @param {V} value The value
- * @return {!jspb.Map<K,V>}
- */
-jspb.Map.prototype.set = function(key, value) {
-  var entry = new jspb.Map.Entry_(key);
-  if (this.valueCtor_) {
-    entry.valueWrapper = value;
-    // .toArray() on a message returns a reference to the underlying array
-    // rather than a copy.
-    entry.value = value.toArray();
-  } else {
-    entry.value = value;
-  }
-  this.map_[key.toString()] = entry;
-  this.arrClean = false;
-  return this;
-};
-
-
-/**
- * Helper: lazily construct a wrapper around an entry, if needed, and return the
- * user-visible type.
- * @param {!jspb.Map.Entry_<K,V>} entry
- * @return {V}
- * @private
- */
-jspb.Map.prototype.wrapEntry_ = function(entry) {
-  if (this.valueCtor_) {
-    if (!entry.valueWrapper) {
-      entry.valueWrapper = new this.valueCtor_(entry.value);
-    }
-    return /** @type {V} */ (entry.valueWrapper);
-  } else {
-    return entry.value;
-  }
-};
-
-
-/**
- * Gets the value corresponding to a key in the map.
- * @param {K} key
- * @return {V|undefined} The value, or `undefined` if key not present
- */
-jspb.Map.prototype.get = function(key) {
-  var keyValue = key.toString();
-  var entry = this.map_[keyValue];
-  if (entry) {
-    return this.wrapEntry_(entry);
-  } else {
-    return undefined;
-  }
-};
-
-
-/**
- * Determines whether the given key is present in the map.
- * @param {K} key
- * @return {boolean} `true` if the key is present
- */
-jspb.Map.prototype.has = function(key) {
-  var keyValue = key.toString();
-  return (keyValue in this.map_);
-};
-
-
-/**
- * Write this Map field in wire format to a BinaryWriter, using the given field
- * number.
- * @param {number} fieldNumber
- * @param {!jspb.BinaryWriter} writer
- * @param {!function(this:jspb.BinaryWriter,number,K)} keyWriterFn
- *     The method on BinaryWriter that writes type K to the stream.
- * @param {!function(this:jspb.BinaryWriter,number,V)|
- *          function(this:jspb.BinaryReader,V,?)} valueWriterFn
- *     The method on BinaryWriter that writes type V to the stream.  May be
- *     writeMessage, in which case the second callback arg form is used.
- * @param {function(V,!jspb.BinaryWriter)=} opt_valueWriterCallback
- *    The BinaryWriter serialization callback for type V, if V is a message
- *    type.
- */
-jspb.Map.prototype.serializeBinary = function(
-    fieldNumber, writer, keyWriterFn, valueWriterFn, opt_valueWriterCallback) {
-  var strKeys = this.stringKeys_();
-  strKeys.sort();
-  for (var i = 0; i < strKeys.length; i++) {
-    var entry = this.map_[strKeys[i]];
-    writer.beginSubMessage(fieldNumber);
-    keyWriterFn.call(writer, 1, entry.key);
-    if (this.valueCtor_) {
-      valueWriterFn.call(writer, 2, this.wrapEntry_(entry),
-                         opt_valueWriterCallback);
-    } else {
-      valueWriterFn.call(writer, 2, entry.value);
-    }
-    writer.endSubMessage();
-  }
-};
-
-
-/**
- * Read one key/value message from the given BinaryReader. Compatible as the
- * `reader` callback parameter to jspb.BinaryReader.readMessage, to be called
- * when a key/value pair submessage is encountered.
- * @template K, V
- * @param {!jspb.Map} map
- * @param {!jspb.BinaryReader} reader
- * @param {!function(this:jspb.BinaryReader):K} keyReaderFn
- *     The method on BinaryReader that reads type K from the stream.
- *
- * @param {!function(this:jspb.BinaryReader):V|
- *          function(this:jspb.BinaryReader,V,
- *                  function(V,!jspb.BinaryReader))} valueReaderFn
- *    The method on BinaryReader that reads type V from the stream. May be
- *    readMessage, in which case the second callback arg form is used.
- *
- * @param {?function(V,!jspb.BinaryReader)=} opt_valueReaderCallback
- *    The BinaryReader parsing callback for type V, if V is a message type.
- *
- */
-jspb.Map.deserializeBinary = function(map, reader, keyReaderFn, valueReaderFn,
-                                      opt_valueReaderCallback) {
-  var key = undefined;
-  var value = undefined;
-
-  while (reader.nextField()) {
-    if (reader.isEndGroup()) {
-      break;
-    }
-    var field = reader.getFieldNumber();
-    if (field == 1) {
-      // Key.
-      key = keyReaderFn.call(reader);
-    } else if (field == 2) {
-      // Value.
-      if (map.valueCtor_) {
-        value = new map.valueCtor_();
-        valueReaderFn.call(reader, value, opt_valueReaderCallback);
-      } else {
-        value = valueReaderFn.call(reader);
-      }
-    }
-  }
-
-  goog.asserts.assert(key != undefined);
-  goog.asserts.assert(value != undefined);
-  map.set(key, value);
-};
-
-
-/**
- * Helper: compute the list of all stringified keys in the underlying Object
- * map.
- * @return {!Array<string>}
- * @private
- */
-jspb.Map.prototype.stringKeys_ = function() {
-  var m = this.map_;
-  var ret = [];
-  for (var p in m) {
-    if (Object.prototype.hasOwnProperty.call(m, p)) {
-      ret.push(p);
-    }
-  }
-  return ret;
-};
-
-
-
-/**
- * @param {!K} key The entry's key.
- * @param {V=} opt_value The entry's value wrapper.
- * @constructor
- * @struct
- * @template K, V
- * @private
- */
-jspb.Map.Entry_ = function(key, opt_value) {
-  /** @const {K} */
-  this.key = key;
-
-  // The JSPB-serializable value.  For primitive types this will be of type V.
-  // For message types it will be an array.
-  /** @type {V} */
-  this.value = opt_value;
-
-  // Only used for submessage values.
-  /** @type {V} */
-  this.valueWrapper = undefined;
-};