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

third_party/protobuf/CHANGES.txt

-2015-08-26 version 3.0.0-beta-1 (C++/Java/Python/Ruby/Nano/Objective-C/C#/JavaSript)
+2016-05-16 version 3.0.0-beta-3 (C++/Java/Python/Ruby/Nano/Objective-C/C#/JavaScript)
   General
-  * Intorduced a new language implementaion: JavaScript.
+  * Supported Proto3 lite-runtime in C++/Java for mobile platforms.
+  * Any type now supports APIs to specify prefixes other than
+    type.googleapis.com
+  * Removed javanano_use_deprecated_package option; Nano will always has its own
+    ".nano" package.
+
+  C++ (Beta)
+  * Improved hash maps.
+      - Improved hash maps comments. In particular, please note that equal hash
+        maps will not necessarily have the same iteration order and
+        serialization.
+      - Added a new hash maps implementation that will become the default in a
+        later release.
+  * Arenas
+      - Several inlined methods in Arena were moved to out-of-line to improve
+        build performance and code size.
+      - Added SpaceAllocatedAndUsed() to report both space used and allocated
+      - Added convenient class UnsafeArenaAllocatedRepeatedPtrFieldBackInserter
+  * Any
+      - Allow custom type URL prefixes in Any packing.
+      - TextFormat now expand the Any type rather than printing bytes.
+  * Performance optimizations and various bug fixes.
+
+  Java (Beta)
+  * Introduced an ExperimentalApi annotation. Annotated APIs are experimental
+    and are subject to change in a backward incompatible way in future releases.
+  * Introduced zero-copy serialization as an ExperimentalApi
+      - Introduction of the `ByteOutput` interface. This is similar to
+        `OutputStream` but provides semantics for lazy writing (i.e. no
+        immediate copy required) of fields that are considered to be immutable.
+      - `ByteString` now supports writing to a `ByteOutput`, which will directly
+        expose the internals of the `ByteString` (i.e. `byte[]` or `ByteBuffer`)
+        to the `ByteOutput` without copying.
+      - `CodedOutputStream` now supports writing to a `ByteOutput`. `ByteString`
+        instances that are too large to fit in the internal buffer will be
+        (lazily) written to the `ByteOutput` directly.
+      - This allows applications using large `ByteString` fields to avoid
+        duplication of these fields entirely. Such an application can supply a
+        `ByteOutput` that chains together the chunks received from
+        `CodedOutputStream` before forwarding them onto the IO system.
+  * Other related changes to `CodedOutputStream`
+      - Additional use of `sun.misc.Unsafe` where possible to perform fast
+        access to `byte[]` and `ByteBuffer` values and avoiding unnecessary
+        range checking.
+      - `ByteBuffer`-backed `CodedOutputStream` now writes directly to the
+        `ByteBuffer` rather than to an intermediate array.
+  * Improved lite-runtime.
+      - Lite protos now implement deep equals/hashCode/toString
+      - Significantly improved the performance of Builder#mergeFrom() and
+        Builder#mergeDelimitedFrom()
+  * Various bug fixes and small feature enhancement.
+      - Fixed stack overflow when in hashCode() for infinite recursive oneofs.
+      - Fixed the lazy field parsing in lite to merge rather than overwrite.
+      - TextFormat now supports reporting line/column numbers on errors.
+      - Updated to add appropriate @Override for better compiler errors.
+
+  Python (Beta)
+  * Added JSON format for Any, Struct, Value and ListValue
+  * [ ] is now accepted for both repeated scalar fields and repeated message
+    fields in text format parser.
+  * Numerical field name is now supported in text format.
+  * Added DiscardUnknownFields API for python protobuf message.
+
+  Objective-C (Beta)
+  * Proto comments now come over as HeaderDoc comments in the generated sources
+    so Xcode can pick them up and display them.
+  * The library headers have been updated to use HeaderDoc comments so Xcode can
+    pick them up and display them.
+  * The per message and per field overhead in both generated code and runtime
+    object sizes was reduced.
+  * Generated code now include deprecated annotations when the proto file
+    included them.
+
+  C# (Beta)
+  In general: some changes are breaking, which require regenerating messages.
+  Most user-written code will not be impacted *except* for the renaming of enum
+  values.
+
+  * Allow custom type URL prefixes in `Any` packing, and ignore them when
+    unpacking
+  * `protoc` is now in a separate NuGet package (Google.Protobuf.Tools)
+  * New option: `internal_access` to generate internal classes
+  * Enum values are now PascalCased, and if there's a prefix which matches the
+    name of the enum, that is removed (so an enum `COLOR` with a value
+    `COLOR_BLUE` would generate a value of just `Blue`). An option
+    (`legacy_enum_values`) is temporarily available to disable this, but the
+    option will be removed for GA.
+  * `json_name` option is now honored
+  * If group tags are encountered when parsing, they are validated more
+    thoroughly (although we don't support actual groups)
+  * NuGet dependencies are better specified
+  * Breaking: `Preconditions` is renamed to `ProtoPreconditions`
+  * Breaking: `GeneratedCodeInfo` is renamed to `GeneratedClrTypeInfo`
+  * `JsonFormatter` now allows writing to a `TextWriter`
+  * New interface, `ICustomDiagnosticMessage` to allow more compact
+    representations from `ToString`
+  * `CodedInputStream` and `CodedOutputStream` now implement `IDisposable`,
+    which simply disposes of the streams they were constructed with
+  * Map fields no longer support null values (in line with other languages)
+  * Improvements in JSON formatting and parsing
+
+  Javascript (Alpha)
+  * Better support for "bytes" fields: bytes fields can be read as either a
+    base64 string or UInt8Array (in environments where TypedArray is supported).
+  * New support for CommonJS imports.  This should make it easier to use the
+    JavaScript support in Node.js and tools like WebPack.  See js/README.md for
+    more information.
+  * Some significant internal refactoring to simplify and modularize the code.
+
+  Ruby (Alpha)
+  * JSON serialization now properly uses camelCased names, with a runtime option
+    that will preserve original names from .proto files instead.
+  * Well-known types are now included in the distribution.
+  * Release now includes binary gems for Windows, Mac, and Linux instead of just
+    source gems.
+  * Bugfix for serializing oneofs.
+
+  C++/Java Lite (Alpha)
+    A new "lite" generator parameter was introduced in the protoc for C++ and
+    Java for Proto3 syntax messages. Example usage:
+
+     ./protoc --cpp_out=lite:$OUTPUT_PATH foo.proto
+
+    The protoc will treat the current input and all the transitive dependencies
+    as LITE. The same generator parameter must be used to generate the
+    dependencies.
+
+    In Proto3 syntax files, "optimized_for=LITE_RUNTIME" is no longer supported.
+
+
+2015-12-30 version 3.0.0-beta-2 (C++/Java/Python/Ruby/Nano/Objective-C/C#/JavaScript)
+  General
+  * Introduced a new language implementation: JavaScript.
   * Added a new field option "json_name". By default proto field names are
     converted to "lowerCamelCase" in proto3 JSON format. This option can be
     used to override this behavior and specify a different JSON name for the
     field.
   * Added conformance tests to ensure implementations are following proto3 JSON
     specification.
 
   C++ (Beta)
   * Various bug fixes and improvements to the JSON support utility:
       - Duplicate map keys in JSON are now rejected (i.e., translation will
@@ skipping 14 matching lines @@
       - Fixed a thread-safety bug.
       - Added a new option “preservingProtoFieldNames” to JsonFormat.
       - Added a new option “includingDefaultValueFields” to JsonFormat.
       - Updated the JSON utility to comply with proto3 JSON specification.
 
   Python (Beta)
   * Added proto3 JSON format utility. It includes support for all field types
     and a few well-known types except for Any and Struct.
   * Added runtime support for Any, Timestamp, Duration and FieldMask.
   * [ ] is now accepted for repeated scalar fields in text format parser.
+  * Map fields now have proper O(1) performance for lookup/insert/delete
+    when using the Python/C++ implementation. They were previously using O(n)
+    search-based algorithms because the C++ reflection interface didn't
+    support true map operations.
 
   Objective-C (Beta)
   * Various bug-fixes and code tweaks to pass more strict compiler warnings.
   * Now has conformance test coverage and is passing all tests.
 
   C# (Beta)
   * Various bug-fixes.
   * Code generation: Files generated in directories based on namespace.
   * Code generation: Include comments from .proto files in XML doc
     comments (naively)
@@ skipping 121 matching lines @@
   General
   * Introduced two new language implementations (Objective-C, C#) to proto3.
   * Explicit "optional" keyword are disallowed in proto3 syntax, as fields are
     optional by default.
   * Group fields are no longer supported in proto3 syntax.
   * Changed repeated primitive fields to use packed serialization by default in
     proto3 (implemented for C++, Java, Python in this release).  The user can
     still disable packed serialization by setting packed to false for now.
   * Added well-known type protos (any.proto, empty.proto, timestamp.proto,
     duration.proto, etc.). Users can import and use these protos just like
-    regular proto files. Addtional runtime support will be added for them in
+    regular proto files. Additional runtime support will be added for them in
     future releases (in the form of utility helper functions, or having them
     replaced by language specific types in generated code).
   * Added a "reserved" keyword in both proto2 and proto3 syntax. User can use
     this keyword to declare reserved field numbers and names to prevent them
     from being reused by other fields in the same message.
 
     To reserve field numbers, add a reserved declaration in your message:
 
       message TestMessage {
         reserved 2, 15, 9 to 11, 3;
@@ skipping 21 matching lines @@
     support, parsing and serialization. It’s  compatible with ARC and non-ARC
     usage. Besides, user can also access it via the swift bridging header.
 
     See objectivec/README.md for details.
 
   C#
     * C# protobufs are based on project
       https://github.com/jskeet/protobuf-csharp-port. The original project was
       frozen and all the new development will happen here.
     * Codegen plugin for C# was completely rewritten to C++ and is now an
-      intergral part of protoc.
+      integral part of protoc.
     * Some refactorings and cleanup has been applied to the C# runtime library.
     * Only proto2 is supported in C# at the moment, proto3 support is in
       progress and will likely bring significant breaking changes to the API.
 
     See csharp/README.md for details.
 
   C++
     * Added runtime support for Any type. To use Any in your proto file, first
       import the definition of Any:
 
@@ skipping 143 matching lines @@
          type called Any.
       4. Fix semantics for unknown enum values.
       5. Addition of maps.
       6. Addition of a small set of standard types for representation of time,
          dynamic data, etc.
       7. A well-defined encoding in JSON as an alternative to binary proto
          encoding.
 
     This release (v3.0.0-alpha-1) includes partial proto3 support for C++ and
     Java. Items 6 (well-known types) and 7 (JSON format) in the above feature
-    list are not impelmented.
+    list are not implemented.
 
     A new notion "syntax" is introduced to specify whether a .proto file
     uses proto2 or proto3:
 
       // foo.proto
       syntax = "proto3";
       message Bar {...}
 
     If omitted, the protocol compiler will generate a warning and "proto2" will
     be used as the default. This warning will be turned into an error in a
@@ skipping 80 matching lines @@
     memory and at most one field can be set at the same time. Use the
     oneof keyword to define a oneof like:
       message SampleMessage {
         oneof test_oneof {
           string name = 4;
           YourMessage sub_message = 9;
         }
       }
   * Files, services, enums, messages, methods and enum values can be marked
     as deprecated now.
-  * Added Support for list values, including lists of mesaages, when
+  * Added Support for list values, including lists of messages, when
     parsing text-formatted protos in C++ and Java.
       For example:  foo: [1, 2, 3]
 
   C++
   * Enhanced customization on TestFormat printing.
   * Added SwapFields() in reflection API to swap a subset of fields.
     Added SetAllocatedMessage() in reflection API.
   * Repeated primitive extensions are now packable. The
     [packed=true] option only affects serializers. Therefore, it is
     possible to switch a repeated extension field to packed format
@@ skipping 59 matching lines @@
     directly.
   * ByteString now supports more operations: substring(), prepend(), and
     append(). The implementation of ByteString uses a binary tree structure
     to support these operations efficiently.
   * New method findInitializationErrors() that lists all missing required
     fields.
   * Various code size and speed optimizations.
 
   Python
   * Added support for dynamic message creation. DescriptorDatabase,
-    DescriptorPool, and MessageFactory work like their C++ couterparts to
+    DescriptorPool, and MessageFactory work like their C++ counterparts to
     simplify Descriptor construction from *DescriptorProtos, and MessageFactory
     provides a message instance from a Descriptor.
   * Added pickle support for protobuf messages.
   * Unknown fields are now preserved after parsing.
   * Fixed bug where custom options were not correctly populated. Custom
     options can be accessed now.
   * Added EnumTypeWrapper that provides better accessibility to enum types.
   * Added ParseMessage(descriptor, bytes) to generate a new Message instance
     from a descriptor and a byte string.
 
 2011-05-01 version 2.4.1:
 
   C++
-  * Fixed the frendship problem for old compilers to make the library now gcc 3
+  * Fixed the friendship problem for old compilers to make the library now gcc 3
     compatible again.
   * Fixed vcprojects/extract_includes.bat to extract compiler/plugin.h.
 
   Java
   * Removed usages of JDK 1.6 only features to make the library now JDK 1.5
     compatible again.
   * Fixed a bug about negative enum values.
   * serialVersionUID is now defined in generated messages for java serializing.
   * Fixed protoc to use java.lang.Object, which makes "Object" now a valid
     message name again.
@@ skipping 246 matching lines @@
 
   Java
   * Fixed bug where Message.mergeFrom(Message) failed to merge extensions.
   * Message interface has new method toBuilder() which is equivalent to
     newBuilderForType().mergeFrom(this).
   * All enums now implement the ProtocolMessageEnum interface.
   * Setting a field to null now throws NullPointerException.
   * Fixed tendency for TextFormat's parsing to overflow the stack when
     parsing large string values.  The underlying problem is with Java's
     regex implementation (which unfortunately uses recursive backtracking
-    rather than building an NFA).  Worked around by making use of possesive
+    rather than building an NFA).  Worked around by making use of possessive
     quantifiers.
   * Generated service classes now also generate pure interfaces.  For a service
     Foo, Foo.Interface is a pure interface containing all of the service's
     defined methods.  Foo.newReflectiveService() can be called to wrap an
     instance of this interface in a class that implements the generic
     RpcService interface, which provides reflection support that is usually
     needed by RPC server implementations.
   * RPC interfaces now support blocking operation in addition to non-blocking.
     The protocol compiler generates separate blocking and non-blocking stubs
     which operate against separate blocking and non-blocking RPC interfaces.
     RPC implementations will have to implement the new interfaces in order to
     support blocking mode.
   * New I/O methods parseDelimitedFrom(), mergeDelimitedFrom(), and
-    writeDelimitedTo() read and write "delemited" messages from/to a stream,
+    writeDelimitedTo() read and write "delimited" messages from/to a stream,
     meaning that the message size precedes the data.  This way, you can write
     multiple messages to a stream without having to worry about delimiting
     them yourself.
   * Throw a more descriptive exception when build() is double-called.
   * Add a method to query whether CodedInputStream is at the end of the input
     stream.
   * Add a method to reset a CodedInputStream's size counter; useful when
     reading many messages with the same stream.
   * equals() and hashCode() now account for unknown fields.
 
@@ skipping 165 matching lines @@
     contain extra zeros.
   * Fix Python service CallMethod() implementation.
 
   Other
   * Improved readmes.
   * VIM syntax highlighting improvements.
 
 2008-07-07 version 2.0.0:
 
   * First public release.