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

third_party/protobuf/src/google/protobuf/map_entry.h

 // 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 65 matching lines @@
 
   const Descriptor* descriptor_;
   const Reflection* reflection_;
 };
 
 // MapEntry is the returned google::protobuf::Message when calling AddMessage of
 // google::protobuf::Reflection. In order to let it work with generated message
 // reflection, its in-memory type is the same as generated message with the same
 // fields. However, in order to decide the in-memory type of key/value, we need
 // to know both their cpp type in generated api and proto type. In
-// implementation, all in-memory types have related wire format functions to
+// implmentation, all in-memory types have related wire format functions to
 // support except ArenaStringPtr. Therefore, we need to define another type with
 // supporting wire format functions. Since this type is only used as return type
 // of MapEntry accessors, it's named MapEntry accessor type.
 //
 // cpp type:               the type visible to users in public API.
 // proto type:             WireFormatLite::FieldType of the field.
 // in-memory type:         type of the data member used to stored this field.
 // MapEntry accessor type: type used in MapEntry getters/mutators to access the
 //                         field.
 //
@@ skipping 54 matching lines @@
   inline ValueMapEntryAccessorType* mutable_value() {
     return entry_lite_.mutable_value();
   }
 
   // implements Message =============================================
 
   bool MergePartialFromCodedStream(::google::protobuf::io::CodedInputStream* input) {
     return entry_lite_.MergePartialFromCodedStream(input);
   }
 
-  size_t ByteSizeLong() const {
-    return entry_lite_.ByteSizeLong();
+  int ByteSize() const {
+    return entry_lite_.ByteSize();
   }
 
   void SerializeWithCachedSizes(::google::protobuf::io::CodedOutputStream* output) const {
     entry_lite_.SerializeWithCachedSizes(output);
   }
 
-  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(bool deterministic,
-                                                   ::google::protobuf::uint8* output) const {
-    return entry_lite_.InternalSerializeWithCachedSizesToArray(deterministic,
-                                                               output);
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const {
+    return entry_lite_.SerializeWithCachedSizesToArray(output);
   }
 
   int GetCachedSize() const {
     return entry_lite_.GetCachedSize();
   }
 
   bool IsInitialized() const {
     return entry_lite_.IsInitialized();
   }
 
@@ skipping 54 matching lines @@
   Arena* GetArena() const {
     return entry_lite_.GetArena();
   }
 
   // Create default MapEntry instance for given descriptor. Descriptor has to be
   // given when creating default MapEntry instance because different map field
   // may have the same type and MapEntry class. The given descriptor is needed
   // to distinguish instances of the same MapEntry class.
   static MapEntry* CreateDefaultInstance(const Descriptor* descriptor) {
     MapEntry* entry = new MapEntry;
-    ReflectionSchema schema = {
-        entry,
-        offsets_,
-        has_bits_,
+    const Reflection* reflection = new GeneratedMessageReflection(
+        descriptor, entry, offsets_,
         GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MapEntry, entry_lite_._has_bits_),
-        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MapEntry, _internal_metadata_),
-        -1,
-        NULL,
-        -1,
-        sizeof(MapEntry)};
-    const Reflection* reflection = new GeneratedMessageReflection(
-        descriptor, schema, DescriptorPool::generated_pool(),
-        MessageFactory::generated_factory());
+        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MapEntry, _unknown_fields_), -1,
+        DescriptorPool::generated_pool(),
+        ::google::protobuf::MessageFactory::generated_factory(),
+        sizeof(MapEntry),
+        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MapEntry, _internal_metadata_));
     entry->descriptor_ = descriptor;
     entry->reflection_ = reflection;
     entry->set_default_instance(entry);
     entry->InitAsDefaultInstance();
     RegisterMapEntryDefaultInstance(entry);
     return entry;
   }
 
  private:
   MapEntry()
       : _internal_metadata_(NULL), default_instance_(NULL), entry_lite_() {}
 
   explicit MapEntry(Arena* arena)
       : _internal_metadata_(arena),
         default_instance_(NULL),
         entry_lite_(arena) {}
 
   inline Arena* GetArenaNoVirtual() const {
     return entry_lite_.GetArenaNoVirtual();
   }
 
   void set_default_instance(MapEntry* default_instance) {
     default_instance_ = default_instance;
     entry_lite_.set_default_instance(&default_instance->entry_lite_);
   }
 
-  static uint32 offsets_[2];
-  static uint32 has_bits_[2];
+  static int offsets_[2];
+  UnknownFieldSet _unknown_fields_;
   InternalMetadataWithArena _internal_metadata_;
   MapEntry* default_instance_;
   EntryLiteType entry_lite_;
 
   friend class ::google::protobuf::Arena;
   typedef void InternalArenaConstructable_;
   typedef void DestructorSkippable_;
   template <typename K, typename V, WireFormatLite::FieldType k_wire_type,
             WireFormatLite::FieldType, int default_enum>
   friend class internal::MapField;
   friend class internal::GeneratedMessageReflection;
 
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapEntry);
 };
 
 template <typename Key, typename Value, WireFormatLite::FieldType kKeyFieldType,
           WireFormatLite::FieldType kValueFieldType, int default_enum_value>
-uint32 MapEntry<Key, Value, kKeyFieldType, kValueFieldType,
+int MapEntry<Key, Value, kKeyFieldType, kValueFieldType,
              default_enum_value>::offsets_[2] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MapEntry, entry_lite_.key_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MapEntry, entry_lite_.value_),
 };
 
-template <typename Key, typename Value, WireFormatLite::FieldType kKeyFieldType,
-          WireFormatLite::FieldType kValueFieldType, int default_enum_value>
-uint32 MapEntry<Key, Value, kKeyFieldType, kValueFieldType,
-             default_enum_value>::has_bits_[2] = {0, 1};
-
 }  // namespace internal
 }  // namespace protobuf
 
 }  // namespace google
 #endif  // GOOGLE_PROTOBUF_MAP_ENTRY_H__