third_party/protobuf: Update to HEAD (f52e188fe4)

third_party/protobuf/src/google/protobuf/wire_format_lite_inl.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 233 matching lines @@
   }
   return true;
 }
 
 template <typename CType, enum WireFormatLite::FieldType DeclaredType>
 inline bool WireFormatLite::ReadRepeatedFixedSizePrimitive(
     int tag_size,
     uint32 tag,
     io::CodedInputStream* input,
     RepeatedField<CType>* values) {
-  GOOGLE_DCHECK_EQ(UInt32Size(tag), tag_size);
+  GOOGLE_DCHECK_EQ(UInt32Size(tag), static_cast<size_t>(tag_size));
   CType value;
   if (!ReadPrimitive<CType, DeclaredType>(input, &value))
     return false;
   values->Add(value);
 
   // For fixed size values, repeated values can be read more quickly by
   // reading directly from a raw array.
   //
   // We can get a tight loop by only reading as many elements as can be
   // added to the RepeatedField without having to do any resizing. Additionally,
   // we only try to read as many elements as are available from the current
   // buffer space. Doing so avoids having to perform boundary checks when
   // reading the value: the maximum number of elements that can be read is
   // known outside of the loop.
   const void* void_pointer;
   int size;
   input->GetDirectBufferPointerInline(&void_pointer, &size);
   if (size > 0) {
     const uint8* buffer = reinterpret_cast<const uint8*>(void_pointer);
     // The number of bytes each type occupies on the wire.
     const int per_value_size = tag_size + sizeof(value);
 
+    // parentheses around (std::min) prevents macro expansion of min(...)
     int elements_available =
-        std::min(values->Capacity() - values->size(), size / per_value_size);
+        (std::min)(values->Capacity() - values->size(), size / per_value_size);
     int num_read = 0;
     while (num_read < elements_available &&
            (buffer = io::CodedInputStream::ExpectTagFromArray(
                buffer, tag)) != NULL) {
       buffer = ReadPrimitiveFromArray<CType, DeclaredType>(buffer, &value);
       values->AddAlreadyReserved(value);
       ++num_read;
     }
     const int read_bytes = num_read * per_value_size;
     if (read_bytes > 0) {
@@ skipping 33 matching lines @@
     uint32 tag,
     io::CodedInputStream* input,
     RepeatedField<CType>* value) {
   return ReadRepeatedPrimitive<CType, DeclaredType>(
       tag_size, tag, input, value);
 }
 
 template <typename CType, enum WireFormatLite::FieldType DeclaredType>
 inline bool WireFormatLite::ReadPackedPrimitive(io::CodedInputStream* input,
                                                 RepeatedField<CType>* values) {
-  uint32 length;
-  if (!input->ReadVarint32(&length)) return false;
+  int length;
+  if (!input->ReadVarintSizeAsInt(&length)) return false;
   io::CodedInputStream::Limit limit = input->PushLimit(length);
   while (input->BytesUntilLimit() > 0) {
     CType value;
     if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
     values->Add(value);
   }
   input->PopLimit(limit);
   return true;
 }
 
 template <typename CType, enum WireFormatLite::FieldType DeclaredType>
 inline bool WireFormatLite::ReadPackedFixedSizePrimitive(
     io::CodedInputStream* input, RepeatedField<CType>* values) {
-  uint32 length;
-  if (!input->ReadVarint32(&length)) return false;
-  const uint32 old_entries = values->size();
-  const uint32 new_entries = length / sizeof(CType);
-  const uint32 new_bytes = new_entries * sizeof(CType);
+  int length;
+  if (!input->ReadVarintSizeAsInt(&length)) return false;
+  const int old_entries = values->size();
+  const int new_entries = length / sizeof(CType);
+  const int new_bytes = new_entries * sizeof(CType);
   if (new_bytes != length) return false;
   // We would *like* to pre-allocate the buffer to write into (for
   // speed), but *must* avoid performing a very large allocation due
   // to a malicious user-supplied "length" above.  So we have a fast
   // path that pre-allocates when the "length" is less than a bound.
   // We determine the bound by calling BytesUntilTotalBytesLimit() and
   // BytesUntilLimit().  These return -1 to mean "no limit set".
   // There are four cases:
   // TotalBytesLimit  Limit
   // -1               -1     Use slow path.
   // -1               >= 0   Use fast path if length <= Limit.
   // >= 0             -1     Use slow path.
   // >= 0             >= 0   Use fast path if length <= min(both limits).
   int64 bytes_limit = input->BytesUntilTotalBytesLimit();
   if (bytes_limit == -1) {
     bytes_limit = input->BytesUntilLimit();
   } else {
+    // parentheses around (std::min) prevents macro expansion of min(...)
     bytes_limit =
-        std::min(bytes_limit, static_cast<int64>(input->BytesUntilLimit()));
+        (std::min)(bytes_limit, static_cast<int64>(input->BytesUntilLimit()));
   }
   if (bytes_limit >= new_bytes) {
     // Fast-path that pre-allocates *values to the final size.
 #if defined(PROTOBUF_LITTLE_ENDIAN)
     values->Resize(old_entries + new_entries, 0);
     // values->mutable_data() may change after Resize(), so do this after:
     void* dest = reinterpret_cast<void*>(values->mutable_data() + old_entries);
     if (!input->ReadRaw(dest, new_bytes)) {
       values->Truncate(old_entries);
       return false;
     }
 #else
     values->Reserve(old_entries + new_entries);
     CType value;
-    for (uint32 i = 0; i < new_entries; ++i) {
+    for (int i = 0; i < new_entries; ++i) {
       if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
       values->AddAlreadyReserved(value);
     }
 #endif
   } else {
     // This is the slow-path case where "length" may be too large to
     // safely allocate.  We read as much as we can into *values
     // without pre-allocating "length" bytes.
     CType value;
-    for (uint32 i = 0; i < new_entries; ++i) {
+    for (int i = 0; i < new_entries; ++i) {
       if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
       values->Add(value);
     }
   }
   return true;
 }
 
 // Specializations of ReadPackedPrimitive for the fixed size types, which use
 // an optimized code path.
 #define READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(CPPTYPE, DECLARED_TYPE)      \
@@ skipping 30 matching lines @@
   if (!value->MergePartialFromCodedStream(input)) return false;
   input->DecrementRecursionDepth();
   // Make sure the last thing read was an end tag for this group.
   if (!input->LastTagWas(MakeTag(field_number, WIRETYPE_END_GROUP))) {
     return false;
   }
   return true;
 }
 inline bool WireFormatLite::ReadMessage(io::CodedInputStream* input,
                                         MessageLite* value) {
-  uint32 length;
-  if (!input->ReadVarint32(&length)) return false;
+  int length;
+  if (!input->ReadVarintSizeAsInt(&length)) return false;
   std::pair<io::CodedInputStream::Limit, int> p =
       input->IncrementRecursionDepthAndPushLimit(length);
   if (p.second < 0 || !value->MergePartialFromCodedStream(input)) return false;
   // Make sure that parsing stopped when the limit was hit, not at an endgroup
   // tag.
   return input->DecrementRecursionDepthAndPopLimit(p.first);
 }
 
 // We name the template parameter something long and extremely unlikely to occur
 // elsewhere because a *qualified* member access expression designed to avoid
@@ skipping 24 matching lines @@
 inline bool WireFormatLite::ReadGroupNoVirtualNoRecursionDepth(
     int field_number, io::CodedInputStream* input,
     MessageType_WorkAroundCppLookupDefect* value) {
   return value->MessageType_WorkAroundCppLookupDefect::
              MergePartialFromCodedStream(input) &&
          input->LastTagWas(MakeTag(field_number, WIRETYPE_END_GROUP));
 }
 template<typename MessageType_WorkAroundCppLookupDefect>
 inline bool WireFormatLite::ReadMessageNoVirtual(
     io::CodedInputStream* input, MessageType_WorkAroundCppLookupDefect* value) {
-  uint32 length;
-  if (!input->ReadVarint32(&length)) return false;
+  int length;
+  if (!input->ReadVarintSizeAsInt(&length)) return false;
   std::pair<io::CodedInputStream::Limit, int> p =
       input->IncrementRecursionDepthAndPushLimit(length);
   if (p.second < 0 || !value->
       MessageType_WorkAroundCppLookupDefect::MergePartialFromCodedStream(input))
     return false;
   // Make sure that parsing stopped when the limit was hit, not at an endgroup
   // tag.
   return input->DecrementRecursionDepthAndPopLimit(p.first);
 }
 template<typename MessageType_WorkAroundCppLookupDefect>
@@ skipping 261 matching lines @@
   return io::CodedOutputStream::WriteStringWithSizeToArray(value, target);
 }
 inline uint8* WireFormatLite::WriteBytesToArray(int field_number,
                                                 const string& value,
                                                 uint8* target) {
   target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
   return io::CodedOutputStream::WriteStringWithSizeToArray(value, target);
 }
 
 
-inline uint8* WireFormatLite::WriteGroupToArray(int field_number,
-                                                const MessageLite& value,
-                                                uint8* target) {
+inline uint8* WireFormatLite::InternalWriteGroupToArray(
+    int field_number, const MessageLite& value, bool deterministic,
+    uint8* target) {
   target = WriteTagToArray(field_number, WIRETYPE_START_GROUP, target);
-  target = value.SerializeWithCachedSizesToArray(target);
+  target = value.InternalSerializeWithCachedSizesToArray(deterministic, target);
   return WriteTagToArray(field_number, WIRETYPE_END_GROUP, target);
 }
-inline uint8* WireFormatLite::WriteMessageToArray(int field_number,
-                                                  const MessageLite& value,
-                                                  uint8* target) {
+inline uint8* WireFormatLite::InternalWriteMessageToArray(
+    int field_number, const MessageLite& value, bool deterministic,
+    uint8* target) {
   target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
   target = io::CodedOutputStream::WriteVarint32ToArray(
     value.GetCachedSize(), target);
-  return value.SerializeWithCachedSizesToArray(target);
+  return value.InternalSerializeWithCachedSizesToArray(deterministic, target);
 }
 
 // See comment on ReadGroupNoVirtual to understand the need for this template
 // parameter name.
 template<typename MessageType_WorkAroundCppLookupDefect>
-inline uint8* WireFormatLite::WriteGroupNoVirtualToArray(
+inline uint8* WireFormatLite::InternalWriteGroupNoVirtualToArray(
     int field_number, const MessageType_WorkAroundCppLookupDefect& value,
-    uint8* target) {
+    bool deterministic, uint8* target) {
   target = WriteTagToArray(field_number, WIRETYPE_START_GROUP, target);
-  target = value.MessageType_WorkAroundCppLookupDefect
-      ::SerializeWithCachedSizesToArray(target);
+  target = value.InternalSerializeWithCachedSizesToArray(deterministic, target);
   return WriteTagToArray(field_number, WIRETYPE_END_GROUP, target);
 }
 template<typename MessageType_WorkAroundCppLookupDefect>
-inline uint8* WireFormatLite::WriteMessageNoVirtualToArray(
+inline uint8* WireFormatLite::InternalWriteMessageNoVirtualToArray(
     int field_number, const MessageType_WorkAroundCppLookupDefect& value,
-    uint8* target) {
+    bool deterministic, uint8* target) {
   target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
   target = io::CodedOutputStream::WriteVarint32ToArray(
     value.MessageType_WorkAroundCppLookupDefect::GetCachedSize(), target);
-  return value.MessageType_WorkAroundCppLookupDefect
-      ::SerializeWithCachedSizesToArray(target);
+  return value.InternalSerializeWithCachedSizesToArray(deterministic, target);
 }
 
 // ===================================================================
 
-inline int WireFormatLite::Int32Size(int32 value) {
+inline size_t WireFormatLite::Int32Size(int32 value) {
   return io::CodedOutputStream::VarintSize32SignExtended(value);
 }
-inline int WireFormatLite::Int64Size(int64 value) {
+inline size_t WireFormatLite::Int64Size(int64 value) {
   return io::CodedOutputStream::VarintSize64(static_cast<uint64>(value));
 }
-inline int WireFormatLite::UInt32Size(uint32 value) {
+inline size_t WireFormatLite::UInt32Size(uint32 value) {
   return io::CodedOutputStream::VarintSize32(value);
 }
-inline int WireFormatLite::UInt64Size(uint64 value) {
+inline size_t WireFormatLite::UInt64Size(uint64 value) {
   return io::CodedOutputStream::VarintSize64(value);
 }
-inline int WireFormatLite::SInt32Size(int32 value) {
+inline size_t WireFormatLite::SInt32Size(int32 value) {
   return io::CodedOutputStream::VarintSize32(ZigZagEncode32(value));
 }
-inline int WireFormatLite::SInt64Size(int64 value) {
+inline size_t WireFormatLite::SInt64Size(int64 value) {
   return io::CodedOutputStream::VarintSize64(ZigZagEncode64(value));
 }
-inline int WireFormatLite::EnumSize(int value) {
+inline size_t WireFormatLite::EnumSize(int value) {
   return io::CodedOutputStream::VarintSize32SignExtended(value);
 }
 
-inline int WireFormatLite::StringSize(const string& value) {
-  return static_cast<int>(
-      io::CodedOutputStream::VarintSize32(static_cast<uint32>(value.size())) +
-      value.size());
+inline size_t WireFormatLite::StringSize(const string& value) {
+  return LengthDelimitedSize(value.size());
 }
-inline int WireFormatLite::BytesSize(const string& value) {
-  return static_cast<int>(
-      io::CodedOutputStream::VarintSize32(static_cast<uint32>(value.size())) +
-      value.size());
+inline size_t WireFormatLite::BytesSize(const string& value) {
+  return LengthDelimitedSize(value.size());
 }
 
 
-inline int WireFormatLite::GroupSize(const MessageLite& value) {
-  return value.ByteSize();
+inline size_t WireFormatLite::GroupSize(const MessageLite& value) {
+  return value.ByteSizeLong();
 }
-inline int WireFormatLite::MessageSize(const MessageLite& value) {
-  return LengthDelimitedSize(value.ByteSize());
+inline size_t WireFormatLite::MessageSize(const MessageLite& value) {
+  return LengthDelimitedSize(value.ByteSizeLong());
 }
 
 // See comment on ReadGroupNoVirtual to understand the need for this template
 // parameter name.
 template<typename MessageType_WorkAroundCppLookupDefect>
-inline int WireFormatLite::GroupSizeNoVirtual(
+inline size_t WireFormatLite::GroupSizeNoVirtual(
     const MessageType_WorkAroundCppLookupDefect& value) {
-  return value.MessageType_WorkAroundCppLookupDefect::ByteSize();
+  return value.MessageType_WorkAroundCppLookupDefect::ByteSizeLong();
 }
 template<typename MessageType_WorkAroundCppLookupDefect>
-inline int WireFormatLite::MessageSizeNoVirtual(
+inline size_t WireFormatLite::MessageSizeNoVirtual(
     const MessageType_WorkAroundCppLookupDefect& value) {
   return LengthDelimitedSize(
-      value.MessageType_WorkAroundCppLookupDefect::ByteSize());
+      value.MessageType_WorkAroundCppLookupDefect::ByteSizeLong());
 }
 
-inline int WireFormatLite::LengthDelimitedSize(int length) {
-  return io::CodedOutputStream::VarintSize32(length) + length;
+inline size_t WireFormatLite::LengthDelimitedSize(size_t length) {
+  // The static_cast here prevents an error in certain compiler configurations
+  // but is not technically correct--if length is too large to fit in a uint32
+  // then it will be silently truncated. We will need to fix this if we ever
+  // decide to start supporting serialized messages greater than 2 GiB in size.
+  return length + io::CodedOutputStream::VarintSize32(
+      static_cast<uint32>(length));
 }
 
 }  // namespace internal
 }  // namespace protobuf
 
 }  // namespace google
 #endif  // GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_INL_H__