Update //third_party/protobuf to version 3.

third_party/protobuf/src/google/protobuf/unittest.proto

 // Protocol Buffers - Google's data interchange format
 // Copyright 2008 Google Inc.  All rights reserved.
-// http://code.google.com/p/protobuf/
+// 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
@@ skipping 13 matching lines @@
 // 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.
 
 // Author: kenton@google.com (Kenton Varda)
 //  Based on original Protocol Buffers design by
 //  Sanjay Ghemawat, Jeff Dean, and others.
 //
 // A proto file we will use for unit testing.
 
+syntax = "proto2";
 
 // Some generic_services option(s) added automatically.
 // See:  http://go/proto2-generic-services-default
 option cc_generic_services = true;     // auto-added
 option java_generic_services = true;   // auto-added
 option py_generic_services = true;     // auto-added
+option cc_enable_arenas = true;
 
 import "google/protobuf/unittest_import.proto";
 
 // We don't put this in a package within proto2 because we need to make sure
 // that the generated code doesn't depend on being in the proto2 namespace.
 // In test_util.h we do "using namespace unittest = protobuf_unittest".
 package protobuf_unittest;
 
 // Protos optimized for SPEED use a strict superset of the generated code
 // of equivalent ones optimized for CODE_SIZE, so we should optimize all our
 // tests for speed unless explicitly testing code size optimization.
 option optimize_for = SPEED;
 
 option java_outer_classname = "UnittestProto";
 
 // This proto includes every type of field in both singular and repeated
 // forms.
 message TestAllTypes {
   message NestedMessage {
     // The field name "b" fails to compile in proto1 because it conflicts with
     // a local variable named "b" in one of the generated methods.  Doh.
     // This file needs to compile in proto1 to test backwards-compatibility.
     optional int32 bb = 1;
   }
 
   enum NestedEnum {
     FOO = 1;
     BAR = 2;
     BAZ = 3;
+    NEG = -1;  // Intentionally negative.
   }
 
   // Singular
   optional    int32 optional_int32    =  1;
   optional    int64 optional_int64    =  2;
   optional   uint32 optional_uint32   =  3;
   optional   uint64 optional_uint64   =  4;
   optional   sint32 optional_sint32   =  5;
   optional   sint64 optional_sint64   =  6;
   optional  fixed32 optional_fixed32  =  7;
@@ skipping 78 matching lines @@
   optional   string default_string   = 74 [default = "hello"];
   optional    bytes default_bytes    = 75 [default = "world"];
 
   optional NestedEnum  default_nested_enum  = 81 [default = BAR        ];
   optional ForeignEnum default_foreign_enum = 82 [default = FOREIGN_BAR];
   optional protobuf_unittest_import.ImportEnum
       default_import_enum = 83 [default = IMPORT_BAR];
 
   optional string default_string_piece = 84 [ctype=STRING_PIECE,default="abc"];
   optional string default_cord = 85 [ctype=CORD,default="123"];
+
+  // For oneof test
+  oneof oneof_field {
+    uint32 oneof_uint32 = 111;
+    NestedMessage oneof_nested_message = 112;
+    string oneof_string = 113;
+    bytes oneof_bytes = 114;
+  }
+}
+
+// This proto includes a recusively nested message.
+message NestedTestAllTypes {
+  optional NestedTestAllTypes child = 1;
+  optional TestAllTypes payload = 2;
+  repeated NestedTestAllTypes repeated_child = 3;
 }
 
 message TestDeprecatedFields {
   optional int32 deprecated_int32 = 1 [deprecated=true];
 }
 
 // Define these after TestAllTypes to make sure the compiler can handle
 // that.
 message ForeignMessage {
   optional int32 c = 1;
 }
 
 enum ForeignEnum {
   FOREIGN_FOO = 4;
   FOREIGN_BAR = 5;
   FOREIGN_BAZ = 6;
 }
 
+message TestReservedFields {
+  reserved 2, 15, 9 to 11;
+  reserved "bar", "baz";
+}
+
 message TestAllExtensions {
   extensions 1 to max;
 }
 
 extend TestAllExtensions {
   // Singular
   optional    int32 optional_int32_extension    =  1;
   optional    int64 optional_int64_extension    =  2;
   optional   uint32 optional_uint32_extension   =  3;
   optional   uint64 optional_uint64_extension   =  4;
@@ skipping 89 matching lines @@
   optional TestAllTypes.NestedEnum
     default_nested_enum_extension = 81 [default = BAR];
   optional ForeignEnum
     default_foreign_enum_extension = 82 [default = FOREIGN_BAR];
   optional protobuf_unittest_import.ImportEnum
     default_import_enum_extension = 83 [default = IMPORT_BAR];
 
   optional string default_string_piece_extension = 84 [ctype=STRING_PIECE,
                                                        default="abc"];
   optional string default_cord_extension = 85 [ctype=CORD, default="123"];
+
+  // For oneof test
+  optional uint32 oneof_uint32_extension = 111;
+  optional TestAllTypes.NestedMessage oneof_nested_message_extension = 112;
+  optional string oneof_string_extension = 113;
+  optional bytes oneof_bytes_extension = 114;
 }
 
 message TestNestedExtension {
   extend TestAllExtensions {
     // Check for bug where string extensions declared in tested scope did not
     // compile.
     optional string test = 1002 [default="test"];
+    // Used to test if generated extension name is correct when there are
+    // underscores.
+    optional string nested_string_extension = 1003;
   }
 }
 
 // We have separate messages for testing required fields because it's
 // annoying to have to fill in required fields in TestProto in order to
 // do anything with it.  Note that we don't need to test every type of
 // required filed because the code output is basically identical to
 // optional fields for all types.
 message TestRequired {
   required int32 a = 1;
@@ skipping 84 matching lines @@
 message TestMutualRecursionA {
   optional TestMutualRecursionB bb = 1;
 }
 
 message TestMutualRecursionB {
   optional TestMutualRecursionA a = 1;
   optional int32 optional_int32 = 2;
 }
 
 // Test that groups have disjoint field numbers from their siblings and
-// parents.  This is NOT possible in proto1; only proto2.  When attempting
+// parents.  This is NOT possible in proto1; only google.protobuf.  When attempting
 // to compile with proto1, this will emit an error; so we only include it
 // in protobuf_unittest_proto.
 message TestDupFieldNumber {                        // NO_PROTO1
   optional int32 a = 1;                             // NO_PROTO1
   optional group Foo = 2 { optional int32 a = 1; }  // NO_PROTO1
   optional group Bar = 3 { optional int32 a = 1; }  // NO_PROTO1
 }                                                   // NO_PROTO1
 
 // Additional messages for testing lazy fields.
 message TestEagerMessage {
   optional TestAllTypes sub_message = 1 [lazy=false];
 }
 message TestLazyMessage {
   optional TestAllTypes sub_message = 1 [lazy=true];
 }
 
 // Needed for a Python test.
 message TestNestedMessageHasBits {
   message NestedMessage {
     repeated int32 nestedmessage_repeated_int32 = 1;
     repeated ForeignMessage nestedmessage_repeated_foreignmessage = 2;
   }
   optional NestedMessage optional_nested_message = 1;
 }
 
 
 // Test an enum that has multiple values with the same number.
 enum TestEnumWithDupValue {
   option allow_alias = true;
+
   FOO1 = 1;
   BAR1 = 2;
   BAZ = 3;
   FOO2 = 1;
   BAR2 = 2;
 }
 
 // Test an enum with large, unordered values.
 enum TestSparseEnum {
   SPARSE_A = 123;
@@ skipping 25 matching lines @@
 
 
 // We list fields out of order, to ensure that we're using field number and not
 // field index to determine serialization order.
 message TestFieldOrderings {
   optional string my_string = 11;
   extensions 2 to 10;
   optional int64 my_int = 1;
   extensions 12 to 100;
   optional float my_float = 101;
+  message NestedMessage {
+    optional int64 oo = 2;
+    // The field name "b" fails to compile in proto1 because it conflicts with
+    // a local variable named "b" in one of the generated methods.  Doh.
+    // This file needs to compile in proto1 to test backwards-compatibility.
+    optional int32 bb = 1;
+  }
+
+  optional NestedMessage optional_nested_message  = 200;
 }
 
 
 extend TestFieldOrderings {
   optional string my_extension_string = 50;
   optional int32 my_extension_int = 5;
 }
 
 
 message TestExtremeDefaultValues {
@@ skipping 35 matching lines @@
   // literals.
   optional string cpp_trigraph = 20 [default = "? \? ?? \?? \??? ??/ ?\?-"];
 
   // String defaults containing the character '\000'
   optional string string_with_zero       = 23 [default = "hel\000lo"];
   optional  bytes bytes_with_zero        = 24 [default = "wor\000ld"];
   optional string string_piece_with_zero = 25 [ctype=STRING_PIECE,
                                                default="ab\000c"];
   optional string cord_with_zero         = 26 [ctype=CORD,
                                                default="12\0003"];
+  optional string replacement_string     = 27 [default="${unknown}"];
 }
 
 message SparseEnumMessage {
   optional TestSparseEnum sparse_enum = 1;
 }
 
 // Test String and Bytes: string is for valid UTF-8 strings
 message OneString {
   optional string data = 1;
 }
 
 message MoreString {
   repeated string data = 1;
 }
 
 message OneBytes {
   optional bytes data = 1;
 }
 
 message MoreBytes {
   repeated bytes data = 1;
 }
 
+// Test int32, uint32, int64, uint64, and bool are all compatible
+message Int32Message {
+  optional int32 data = 1;
+}
+
+message Uint32Message {
+  optional uint32 data = 1;
+}
+
+message Int64Message {
+  optional int64 data = 1;
+}
+
+message Uint64Message {
+  optional uint64 data = 1;
+}
+
+message BoolMessage {
+  optional bool data = 1;
+}
+
+// Test oneofs.
+message TestOneof {
+  oneof foo {
+    int32 foo_int = 1;
+    string foo_string = 2;
+    TestAllTypes foo_message = 3;
+    group FooGroup = 4 {
+      optional int32 a = 5;
+      optional string b = 6;
+    }
+  }
+}
+
+message TestOneofBackwardsCompatible {
+  optional int32 foo_int = 1;
+  optional string foo_string = 2;
+  optional TestAllTypes foo_message = 3;
+  optional group FooGroup = 4 {
+    optional int32 a = 5;
+    optional string b = 6;
+  }
+}
+
+message TestOneof2 {
+  oneof foo {
+    int32 foo_int = 1;
+    string foo_string = 2;
+    string foo_cord = 3 [ctype=CORD];
+    string foo_string_piece = 4 [ctype=STRING_PIECE];
+    bytes foo_bytes = 5;
+    NestedEnum foo_enum = 6;
+    NestedMessage foo_message = 7;
+    group FooGroup = 8 {
+      optional int32 a = 9;
+      optional string b = 10;
+    }
+    NestedMessage foo_lazy_message = 11 [lazy=true];
+  }
+
+  oneof bar {
+    int32 bar_int = 12 [default = 5];
+    string bar_string = 13 [default = "STRING"];
+    string bar_cord = 14 [ctype=CORD, default = "CORD"];
+    string bar_string_piece = 15 [ctype=STRING_PIECE, default = "SPIECE"];
+    bytes bar_bytes = 16 [default = "BYTES"];
+    NestedEnum bar_enum = 17 [default = BAR];
+  }
+
+  optional int32 baz_int = 18;
+  optional string baz_string = 19 [default = "BAZ"];
+
+  message NestedMessage {
+    optional int64 qux_int = 1;
+    repeated int32 corge_int = 2;
+  }
+
+  enum NestedEnum {
+    FOO = 1;
+    BAR = 2;
+    BAZ = 3;
+  }
+}
+
+message TestRequiredOneof {
+  oneof foo {
+    int32 foo_int = 1;
+    string foo_string = 2;
+    NestedMessage foo_message = 3;
+  }
+  message NestedMessage {
+    required double required_double = 1;
+  }
+}
 
 // Test messages for packed fields
 
 message TestPackedTypes {
   repeated    int32 packed_int32    =  90 [packed = true];
   repeated    int64 packed_int64    =  91 [packed = true];
   repeated   uint32 packed_uint32   =  92 [packed = true];
   repeated   uint64 packed_uint64   =  93 [packed = true];
   repeated   sint32 packed_sint32   =  94 [packed = true];
   repeated   sint64 packed_sint64   =  95 [packed = true];
@@ skipping 40 matching lines @@
   repeated  fixed32 packed_fixed32_extension  =  96 [packed = true];
   repeated  fixed64 packed_fixed64_extension  =  97 [packed = true];
   repeated sfixed32 packed_sfixed32_extension =  98 [packed = true];
   repeated sfixed64 packed_sfixed64_extension =  99 [packed = true];
   repeated    float packed_float_extension    = 100 [packed = true];
   repeated   double packed_double_extension   = 101 [packed = true];
   repeated     bool packed_bool_extension     = 102 [packed = true];
   repeated ForeignEnum packed_enum_extension  = 103 [packed = true];
 }
 
+message TestUnpackedExtensions {
+  extensions 1 to max;
+}
+
+extend TestUnpackedExtensions {
+  repeated    int32 unpacked_int32_extension    =  90 [packed = false];
+  repeated    int64 unpacked_int64_extension    =  91 [packed = false];
+  repeated   uint32 unpacked_uint32_extension   =  92 [packed = false];
+  repeated   uint64 unpacked_uint64_extension   =  93 [packed = false];
+  repeated   sint32 unpacked_sint32_extension   =  94 [packed = false];
+  repeated   sint64 unpacked_sint64_extension   =  95 [packed = false];
+  repeated  fixed32 unpacked_fixed32_extension  =  96 [packed = false];
+  repeated  fixed64 unpacked_fixed64_extension  =  97 [packed = false];
+  repeated sfixed32 unpacked_sfixed32_extension =  98 [packed = false];
+  repeated sfixed64 unpacked_sfixed64_extension =  99 [packed = false];
+  repeated    float unpacked_float_extension    = 100 [packed = false];
+  repeated   double unpacked_double_extension   = 101 [packed = false];
+  repeated     bool unpacked_bool_extension     = 102 [packed = false];
+  repeated ForeignEnum unpacked_enum_extension  = 103 [packed = false];
+}
+
 // Used by ExtensionSetTest/DynamicExtensions.  The test actually builds
 // a set of extensions to TestAllExtensions dynamically, based on the fields
 // of this message type.
 message TestDynamicExtensions {
   enum DynamicEnumType {
     DYNAMIC_FOO = 2200;
     DYNAMIC_BAR = 2201;
     DYNAMIC_BAZ = 2202;
   }
   message DynamicMessageType {
@@ skipping 79 matching lines @@
 message FooServerMessage{}
 
 service TestService {
   rpc Foo(FooRequest) returns (FooResponse);
   rpc Bar(BarRequest) returns (BarResponse);
 }
 
 
 message BarRequest  {}
 message BarResponse {}
+