Revert https://codereview.chromium.org/1291903002 (protobuf roll).

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/
+// http://code.google.com/p/protobuf/
 //
 // 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 15 matching lines @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // Author: kenton@google.com (Kenton Varda)
 //         wink@google.com (Wink Saville) (refactored from wire_format.h)
 //  Based on original Protocol Buffers design by
 //  Sanjay Ghemawat, Jeff Dean, and others.
 
 #ifndef GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_INL_H__
 #define GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_INL_H__
 
-#ifdef _MSC_VER
-// This is required for min/max on VS2013 only.
-#include <algorithm>
-#endif
-
 #include <string>
 #include <google/protobuf/stubs/common.h>
 #include <google/protobuf/message_lite.h>
 #include <google/protobuf/repeated_field.h>
 #include <google/protobuf/wire_format_lite.h>
 #include <google/protobuf/io/coded_stream.h>
-#include <google/protobuf/arenastring.h>
 
 
 namespace google {
 namespace protobuf {
 namespace internal {
 
 // Implementation details of ReadPrimitive.
 
 template <>
 inline bool WireFormatLite::ReadPrimitive<int32, WireFormatLite::TYPE_INT32>(
@@ skipping 88 matching lines @@
     double* value) {
   uint64 temp;
   if (!input->ReadLittleEndian64(&temp)) return false;
   *value = DecodeDouble(temp);
   return true;
 }
 template <>
 inline bool WireFormatLite::ReadPrimitive<bool, WireFormatLite::TYPE_BOOL>(
     io::CodedInputStream* input,
     bool* value) {
-  uint64 temp;
-  if (!input->ReadVarint64(&temp)) return false;
+  uint32 temp;
+  if (!input->ReadVarint32(&temp)) return false;
   *value = temp != 0;
   return true;
 }
 template <>
 inline bool WireFormatLite::ReadPrimitive<int, WireFormatLite::TYPE_ENUM>(
     io::CodedInputStream* input,
     int* value) {
   uint32 temp;
   if (!input->ReadVarint32(&temp)) return false;
   *value = static_cast<int>(temp);
@@ skipping 49 matching lines @@
   double, WireFormatLite::TYPE_DOUBLE>(
     const uint8* buffer,
     double* value) {
   uint64 temp;
   buffer = io::CodedInputStream::ReadLittleEndian64FromArray(buffer, &temp);
   *value = DecodeDouble(temp);
   return buffer;
 }
 
 template <typename CType, enum WireFormatLite::FieldType DeclaredType>
-inline bool WireFormatLite::ReadRepeatedPrimitive(
-    int,  // tag_size, unused.
-    uint32 tag,
-    io::CodedInputStream* input,
-    RepeatedField<CType>* values) {
+inline bool WireFormatLite::ReadRepeatedPrimitive(int, // tag_size, unused.
+                                               uint32 tag,
+                                               io::CodedInputStream* input,
+                                               RepeatedField<CType>* values) {
   CType value;
   if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
   values->Add(value);
   int elements_already_reserved = values->Capacity() - values->size();
   while (elements_already_reserved > 0 && input->ExpectTag(tag)) {
     if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
     values->AddAlreadyReserved(value);
     elements_already_reserved--;
   }
   return true;
@@ skipping 39 matching lines @@
       ++num_read;
     }
     const int read_bytes = num_read * per_value_size;
     if (read_bytes > 0) {
       input->Skip(read_bytes);
     }
   }
   return true;
 }
 
-// Specializations of ReadRepeatedPrimitive for the fixed size types, which use
+// Specializations of ReadRepeatedPrimitive for the fixed size types, which use 
 // the optimized code path.
 #define READ_REPEATED_FIXED_SIZE_PRIMITIVE(CPPTYPE, DECLARED_TYPE)             \
 template <>                                                                    \
 inline bool WireFormatLite::ReadRepeatedPrimitive<                             \
   CPPTYPE, WireFormatLite::DECLARED_TYPE>(                                     \
     int tag_size,                                                              \
     uint32 tag,                                                                \
     io::CodedInputStream* input,                                               \
     RepeatedField<CPPTYPE>* values) {                                          \
   return ReadRepeatedFixedSizePrimitive<                                       \
@@ skipping 29 matching lines @@
   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);
-  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 {
-    bytes_limit =
-        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) {
-      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) {
-      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)      \
-template <>                                                                    \
-inline bool WireFormatLite::ReadPackedPrimitive<                               \
-  CPPTYPE, WireFormatLite::DECLARED_TYPE>(                                     \
-    io::CodedInputStream* input,                                               \
-    RepeatedField<CPPTYPE>* values) {                                          \
-  return ReadPackedFixedSizePrimitive<                                         \
-      CPPTYPE, WireFormatLite::DECLARED_TYPE>(input, values);                  \
-}
-
-READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(uint32, TYPE_FIXED32);
-READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(uint64, TYPE_FIXED64);
-READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(int32, TYPE_SFIXED32);
-READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(int64, TYPE_SFIXED64);
-READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(float, TYPE_FLOAT);
-READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(double, TYPE_DOUBLE);
-
-#undef READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE
-
-template <typename CType, enum WireFormatLite::FieldType DeclaredType>
 bool WireFormatLite::ReadPackedPrimitiveNoInline(io::CodedInputStream* input,
                                                  RepeatedField<CType>* values) {
   return ReadPackedPrimitive<CType, DeclaredType>(input, values);
 }
 
 
-
 inline bool WireFormatLite::ReadGroup(int field_number,
                                       io::CodedInputStream* input,
                                       MessageLite* value) {
   if (!input->IncrementRecursionDepth()) return false;
   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;
-  std::pair<io::CodedInputStream::Limit, int> p =
-      input->IncrementRecursionDepthAndPushLimit(length);
-  if (p.second < 0 || !value->MergePartialFromCodedStream(input)) return false;
+  if (!input->IncrementRecursionDepth()) return false;
+  io::CodedInputStream::Limit limit = input->PushLimit(length);
+  if (!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);
+  if (!input->ConsumedEntireMessage()) return false;
+  input->PopLimit(limit);
+  input->DecrementRecursionDepth();
+  return true;
 }
 
 // We name the template parameter something long and extremely unlikely to occur
 // elsewhere because a *qualified* member access expression designed to avoid
 // virtual dispatch, C++03 [basic.lookup.classref] 3.4.5/4 requires that the
 // name of the qualifying class to be looked up both in the context of the full
 // expression (finding the template parameter) and in the context of the object
 // whose member we are accessing. This could potentially find a nested type
 // within that object. The standard goes on to require these names to refer to
 // the same entity, which this collision would violate. The lack of a safe way
 // to avoid this collision appears to be a defect in the standard, but until it
 // is corrected, we choose the name to avoid accidental collisions.
 template<typename MessageType_WorkAroundCppLookupDefect>
 inline bool WireFormatLite::ReadGroupNoVirtual(
     int field_number, io::CodedInputStream* input,
     MessageType_WorkAroundCppLookupDefect* value) {
   if (!input->IncrementRecursionDepth()) return false;
   if (!value->
       MessageType_WorkAroundCppLookupDefect::MergePartialFromCodedStream(input))
     return false;
-  input->UnsafeDecrementRecursionDepth();
+  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;
 }
 template<typename MessageType_WorkAroundCppLookupDefect>
-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;
-  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>
-inline bool WireFormatLite::ReadMessageNoVirtualNoRecursionDepth(
-    io::CodedInputStream* input, MessageType_WorkAroundCppLookupDefect* value) {
-  io::CodedInputStream::Limit old_limit = input->ReadLengthAndPushLimit();
+  if (!input->IncrementRecursionDepth()) return false;
+  io::CodedInputStream::Limit limit = input->PushLimit(length);
   if (!value->
       MessageType_WorkAroundCppLookupDefect::MergePartialFromCodedStream(input))
     return false;
   // Make sure that parsing stopped when the limit was hit, not at an endgroup
   // tag.
-  return input->CheckEntireMessageConsumedAndPopLimit(old_limit);
+  if (!input->ConsumedEntireMessage()) return false;
+  input->PopLimit(limit);
+  input->DecrementRecursionDepth();
+  return true;
 }
 
 // ===================================================================
 
 inline void WireFormatLite::WriteTag(int field_number, WireType type,
                                      io::CodedOutputStream* output) {
   output->WriteTag(MakeTag(field_number, type));
 }
 
 inline void WireFormatLite::WriteInt32NoTag(int32 value,
@@ skipping 232 matching lines @@
 }
 
 inline uint8* WireFormatLite::WriteStringToArray(int field_number,
                                                  const string& value,
                                                  uint8* target) {
   // String is for UTF-8 text only
   // WARNING:  In wire_format.cc, both strings and bytes are handled by
   //   WriteString() to avoid code duplication.  If the implementations become
   //   different, you will need to update that usage.
   target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
-  return io::CodedOutputStream::WriteStringWithSizeToArray(value, target);
+  target = io::CodedOutputStream::WriteVarint32ToArray(value.size(), target);
+  return io::CodedOutputStream::WriteStringToArray(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);
+  target = io::CodedOutputStream::WriteVarint32ToArray(value.size(), target);
+  return io::CodedOutputStream::WriteStringToArray(value, target);
 }
 
 
 inline uint8* WireFormatLite::WriteGroupToArray(int field_number,
                                                 const MessageLite& value,
                                                 uint8* target) {
   target = WriteTagToArray(field_number, WIRETYPE_START_GROUP, target);
   target = value.SerializeWithCachedSizesToArray(target);
   return WriteTagToArray(field_number, WIRETYPE_END_GROUP, target);
 }
@@ skipping 85 matching lines @@
 
 inline int WireFormatLite::LengthDelimitedSize(int length) {
   return io::CodedOutputStream::VarintSize32(length) + length;
 }
 
 }  // namespace internal
 }  // namespace protobuf
 
 }  // namespace google
 #endif  // GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_INL_H__