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

third_party/protobuf/src/google/protobuf/map_type_handler.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 140 matching lines @@
   static const WireFormatLite::WireType kWireType =
       MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE, Type>::kWireType;
   // Whether wire type is for message.
   static const bool kIsMessage =
       MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE, Type>::kIsMessage;
   // Whether wire type is for enum.
   static const bool kIsEnum =
       MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE, Type>::kIsEnum;
 
   // Functions used in parsing and serialization. ===================
-  static inline size_t ByteSize(const MapEntryAccessorType& value);
+  static inline int ByteSize(const MapEntryAccessorType& value);
   static inline int GetCachedSize(const MapEntryAccessorType& value);
   static inline bool Read(io::CodedInputStream* input,
                           MapEntryAccessorType* value);
   static inline void Write(int field, const MapEntryAccessorType& value,
                            io::CodedOutputStream* output);
-  static inline uint8* InternalWriteToArray(int field,
-                                            const MapEntryAccessorType& value,
-                                            bool deterministic, uint8* target);
   static inline uint8* WriteToArray(int field,
                                     const MapEntryAccessorType& value,
-                                    uint8* target);
+                                    uint8* output);
 
   // Functions to manipulate data on memory. ========================
   static inline const Type& GetExternalReference(const Type* value);
   static inline void DeleteNoArena(const Type* x);
   static inline void Merge(const Type& from, Type** to, Arena* arena);
   static inline void Clear(Type** value, Arena* arena);
   static inline void ClearMaybeByDefaultEnum(Type** value, Arena* arena,
                                              int default_enum_value);
   static inline void Initialize(Type** x, Arena* arena);
 
@@ skipping 33 matching lines @@
                                Type>::kIsMessage;                             \
     static const bool kIsEnum =                                               \
         MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType,              \
                                Type>::kIsEnum;                                \
     static inline int ByteSize(const MapEntryAccessorType& value);            \
     static inline int GetCachedSize(const MapEntryAccessorType& value);       \
     static inline bool Read(io::CodedInputStream* input,                      \
                             MapEntryAccessorType* value);                     \
     static inline void Write(int field, const MapEntryAccessorType& value,    \
                              io::CodedOutputStream* output);                  \
-    static inline uint8* InternalWriteToArray(                                \
-        int field,                                                            \
-        const MapEntryAccessorType& value,                                    \
-        bool deterministic,                                                   \
-        uint8* target);                                                       \
     static inline uint8* WriteToArray(int field,                              \
                                       const MapEntryAccessorType& value,      \
-                                      uint8* target) {                        \
-      return InternalWriteToArray(field, value, false, target);               \
-    }                                                                         \
+                                      uint8* output);                         \
     static inline const MapEntryAccessorType& GetExternalReference(           \
         const TypeOnMemory& value);                                           \
     static inline void DeleteNoArena(const TypeOnMemory& x);                  \
     static inline void Merge(const MapEntryAccessorType& from,                \
                              TypeOnMemory* to, Arena* arena);                 \
     static inline void Clear(TypeOnMemory* value, Arena* arena);              \
     static inline void ClearMaybeByDefaultEnum(TypeOnMemory* value,           \
                                                Arena* arena,                  \
                                                int default_enum);             \
     static inline int SpaceUsedInMapEntry(const TypeOnMemory& value);         \
@@ skipping 23 matching lines @@
 MAP_HANDLER(DOUBLE)
 MAP_HANDLER(FLOAT)
 MAP_HANDLER(FIXED64)
 MAP_HANDLER(FIXED32)
 MAP_HANDLER(SFIXED64)
 MAP_HANDLER(SFIXED32)
 MAP_HANDLER(BOOL)
 #undef MAP_HANDLER
 
 template <typename Type>
-inline size_t
+inline int
 MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::ByteSize(
     const MapEntryAccessorType& value) {
   return WireFormatLite::MessageSizeNoVirtual(value);
 }
 
 #define GOOGLE_PROTOBUF_BYTE_SIZE(FieldType, DeclaredType)                     \
   template <typename Type>                                                     \
   inline int MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::ByteSize( \
       const MapEntryAccessorType& value) {                                     \
     return WireFormatLite::DeclaredType##Size(value);                          \
@@ skipping 75 matching lines @@
 
 template <typename Type>
 inline void MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Write(
     int field, const MapEntryAccessorType& value,
     io::CodedOutputStream* output) {
   WireFormatLite::WriteMessageMaybeToArray(field, value, output);
 }
 
 template <typename Type>
 inline uint8*
-MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::InternalWriteToArray(
-    int field, const MapEntryAccessorType& value, bool deterministic,
-    uint8* target) {
-  return WireFormatLite::InternalWriteMessageToArray(field, value,
-                                                     deterministic, target);
+MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::WriteToArray(
+    int field, const MapEntryAccessorType& value, uint8* output) {
+  return WireFormatLite::WriteMessageToArray(field, value, output);
 }
 
 #define WRITE_METHOD(FieldType, DeclaredType)                                  \
   template <typename Type>                                                     \
   inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Write(   \
       int field, const MapEntryAccessorType& value,                            \
       io::CodedOutputStream* output) {                                         \
     return WireFormatLite::Write##DeclaredType(field, value, output);          \
   }                                                                            \
   template <typename Type>                                                     \
   inline uint8*                                                                \
-  MapTypeHandler<WireFormatLite::TYPE_##FieldType,                             \
-                 Type>::InternalWriteToArray(                                  \
-      int field, const MapEntryAccessorType& value, bool, uint8* target) {     \
-    return WireFormatLite::Write##DeclaredType##ToArray(field, value, target); \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::WriteToArray(        \
+      int field, const MapEntryAccessorType& value, uint8* output) {           \
+    return WireFormatLite::Write##DeclaredType##ToArray(field, value, output); \
   }
 
 WRITE_METHOD(STRING  , String)
 WRITE_METHOD(BYTES   , Bytes)
 WRITE_METHOD(INT64   , Int64)
 WRITE_METHOD(UINT64  , UInt64)
 WRITE_METHOD(INT32   , Int32)
 WRITE_METHOD(UINT32  , UInt32)
 WRITE_METHOD(SINT64  , SInt64)
 WRITE_METHOD(SINT32  , SInt32)
@@ skipping 144 matching lines @@
 }
 
 // Definition for string/bytes handler
 
 #define STRING_OR_BYTES_HANDLER_FUNCTIONS(FieldType)                           \
   template <typename Type>                                                     \
   inline const typename MapTypeHandler<WireFormatLite::TYPE_##FieldType,       \
                                        Type>::MapEntryAccessorType&            \
   MapTypeHandler<WireFormatLite::TYPE_##FieldType,                             \
                  Type>::GetExternalReference(const TypeOnMemory& value) {      \
-    return value.Get();                                                        \
+    return value.Get(&::google::protobuf::internal::GetEmptyString());                   \
   }                                                                            \
   template <typename Type>                                                     \
   inline int                                                                   \
   MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::SpaceUsedInMapEntry( \
       const TypeOnMemory& value) {                                             \
     return sizeof(value);                                                      \
   }                                                                            \
   template <typename Type>                                                     \
   inline int MapTypeHandler<WireFormatLite::TYPE_##FieldType,                  \
                             Type>::SpaceUsedInMap(const TypeOnMemory& value) { \
     return sizeof(value);                                                      \
   }                                                                            \
   template <typename Type>                                                     \
   inline int MapTypeHandler<WireFormatLite::TYPE_##FieldType,                  \
                             Type>::SpaceUsedInMap(const string& value) {       \
     return sizeof(value);                                                      \
   }                                                                            \
   template <typename Type>                                                     \
   inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Clear(   \
       TypeOnMemory* value, Arena* arena) {                                     \
-    value->ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),    \
-                        arena);                                                \
+    value->ClearToEmpty(&::google::protobuf::internal::GetEmptyString(), arena);         \
   }                                                                            \
   template <typename Type>                                                     \
-  inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::         \
-      ClearMaybeByDefaultEnum(TypeOnMemory* value, Arena* arena,               \
-                              int default_enum) {                              \
+  inline void                                                                  \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType,                             \
+                 Type>::ClearMaybeByDefaultEnum(TypeOnMemory* value,           \
+                                                Arena* arena,                  \
+                                                int default_enum) {            \
     Clear(value, arena);                                                       \
   }                                                                            \
   template <typename Type>                                                     \
   inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Merge(   \
       const MapEntryAccessorType& from, TypeOnMemory* to, Arena* arena) {      \
-    to->Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from, arena);  \
+    to->Set(&::google::protobuf::internal::GetEmptyString(), from, arena);               \
   }                                                                            \
   template <typename Type>                                                     \
   void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::DeleteNoArena(  \
       TypeOnMemory& value) {                                                   \
-    value.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());  \
+    value.DestroyNoArena(&::google::protobuf::internal::GetEmptyString());               \
   }                                                                            \
   template <typename Type>                                                     \
   inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType,                 \
                              Type>::AssignDefaultValue(TypeOnMemory* value) {} \
   template <typename Type>                                                     \
   inline void                                                                  \
   MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Initialize(          \
       TypeOnMemory* value, Arena* arena) {                                     \
-    value->UnsafeSetDefault(                                                   \
-        &::google::protobuf::internal::GetEmptyStringAlreadyInited());                   \
+    value->UnsafeSetDefault(&::google::protobuf::internal::GetEmptyString());            \
   }                                                                            \
   template <typename Type>                                                     \
-  inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::         \
-      InitializeMaybeByDefaultEnum(TypeOnMemory* value,                        \
-                                   int default_enum_value, Arena* arena) {     \
+  inline void                                                                  \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType,                             \
+                 Type>::InitializeMaybeByDefaultEnum(TypeOnMemory* value,      \
+                                                     int default_enum_value,   \
+                                                     Arena* arena) {           \
     Initialize(value, arena);                                                  \
   }                                                                            \
   template <typename Type>                                                     \
   inline typename MapTypeHandler<WireFormatLite::TYPE_##FieldType,             \
                                  Type>::MapEntryAccessorType*                  \
   MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::EnsureMutable(       \
       TypeOnMemory* value, Arena* arena) {                                     \
-    return value->Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),  \
-                          arena);                                              \
+    return value->Mutable(&::google::protobuf::internal::GetEmptyString(), arena);       \
   }                                                                            \
   template <typename Type>                                                     \
   inline const typename MapTypeHandler<WireFormatLite::TYPE_##FieldType,       \
                                        Type>::MapEntryAccessorType&            \
   MapTypeHandler<WireFormatLite::TYPE_##FieldType,                             \
                  Type>::DefaultIfNotInitialized(const TypeOnMemory& value,     \
                                                 const TypeOnMemory&            \
                                                     default_value) {           \
-    return value.Get();                                                        \
+    return value.Get(&::google::protobuf::internal::GetEmptyString());                   \
   }                                                                            \
   template <typename Type>                                                     \
   inline bool MapTypeHandler<WireFormatLite::TYPE_##FieldType,                 \
                              Type>::IsInitialized(const TypeOnMemory& value) { \
     return true;                                                               \
   }
 STRING_OR_BYTES_HANDLER_FUNCTIONS(STRING)
 STRING_OR_BYTES_HANDLER_FUNCTIONS(BYTES)
 #undef STRING_OR_BYTES_HANDLER_FUNCTIONS
 
@@ skipping 89 matching lines @@
 PRIMITIVE_HANDLER_FUNCTIONS(SFIXED64)
 PRIMITIVE_HANDLER_FUNCTIONS(SFIXED32)
 PRIMITIVE_HANDLER_FUNCTIONS(BOOL)
 #undef PRIMITIVE_HANDLER_FUNCTIONS
 
 }  // namespace internal
 }  // namespace protobuf
 
 }  // namespace google
 #endif  // GOOGLE_PROTOBUF_TYPE_HANDLER_H__