third_party/protobuf: Update to HEAD (83d681ee2c)

third_party/protobuf/src/google/protobuf/wire_format_lite.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 137 matching lines @@
   // _inl.h)
   //
   // This is different from MakeTag(field->number(), field->type()) in the case
   // of packed repeated fields.
   static uint32 MakeTag(int field_number, WireType type);
   static WireType GetTagWireType(uint32 tag);
   static int GetTagFieldNumber(uint32 tag);
 
   // Compute the byte size of a tag.  For groups, this includes both the start
   // and end tags.
-  static inline int TagSize(int field_number, WireFormatLite::FieldType type);
+  static inline size_t TagSize(int field_number,
+                               WireFormatLite::FieldType type);
 
   // Skips a field value with the given tag.  The input should start
   // positioned immediately after the tag.  Skipped values are simply discarded,
   // not recorded anywhere.  See WireFormat::SkipField() for a version that
   // records to an UnknownFieldSet.
   static bool SkipField(io::CodedInputStream* input, uint32 tag);
 
   // Skips a field value with the given tag.  The input should start
   // positioned immediately after the tag. Skipped values are recorded to a
   // CodedOutputStream.
@@ skipping 36 matching lines @@
     GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(kMessageSetItemNumber,
                                 WireFormatLite::WIRETYPE_END_GROUP);
   static const int kMessageSetTypeIdTag =
     GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(kMessageSetTypeIdNumber,
                                 WireFormatLite::WIRETYPE_VARINT);
   static const int kMessageSetMessageTag =
     GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(kMessageSetMessageNumber,
                                 WireFormatLite::WIRETYPE_LENGTH_DELIMITED);
 
   // Byte size of all tags of a MessageSet::Item combined.
-  static const int kMessageSetItemTagsSize;
+  static const size_t kMessageSetItemTagsSize;
 
   // Helper functions for converting between floats/doubles and IEEE-754
   // uint32s/uint64s so that they can be written.  (Assumes your platform
   // uses IEEE-754 floats.)
   static uint32 EncodeFloat(float value);
   static float DecodeFloat(uint32 value);
   static uint64 EncodeDouble(double value);
   static double DecodeDouble(uint64 value);
 
   // Helper functions for mapping signed integers to unsigned integers in
   // such a way that numbers with small magnitudes will encode to smaller
   // varints.  If you simply static_cast a negative number to an unsigned
   // number and varint-encode it, it will always take 10 bytes, defeating
   // the purpose of varint.  So, for the "sint32" and "sint64" field types,
   // we ZigZag-encode the values.
   static uint32 ZigZagEncode32(int32 n);
   static int32  ZigZagDecode32(uint32 n);
   static uint64 ZigZagEncode64(int64 n);
   static int64  ZigZagDecode64(uint64 n);
 
   // =================================================================
   // Methods for reading/writing individual field.  The implementations
   // of these methods are defined in wire_format_lite_inl.h; you must #include
   // that file to use these.
 
 // Avoid ugly line wrapping
 #define input  io::CodedInputStream*  input_arg
 #define output io::CodedOutputStream* output_arg
 #define field_number int field_number_arg
+#ifdef NDEBUG
 #define INL GOOGLE_ATTRIBUTE_ALWAYS_INLINE
+#else
+// Avoid excessive inlining in non-optimized builds. Without other optimizations
+// the inlining is not going to provide benefits anyway and the huge resulting
+// functions, especially in the proto-generated serialization functions, produce
+// stack frames so large that many tests run into stack overflows (b/32192897).
+#define INL
+#endif
 
   // Read fields, not including tags.  The assumption is that you already
   // read the tag to determine what field to read.
 
   // For primitive fields, we just use a templatized routine parameterized by
   // the represented type and the FieldType. These are specialized with the
   // appropriate definition for each declared type.
   template <typename CType, enum FieldType DeclaredType> INL
   static bool ReadPrimitive(input, CType* value);
 
@@ skipping 194 matching lines @@
   INL static uint8* WriteFloatToArray(field_number, float value, output);
   INL static uint8* WriteDoubleToArray(field_number, double value, output);
   INL static uint8* WriteBoolToArray(field_number, bool value, output);
   INL static uint8* WriteEnumToArray(field_number, int value, output);
 
   INL static uint8* WriteStringToArray(
     field_number, const string& value, output);
   INL static uint8* WriteBytesToArray(
     field_number, const string& value, output);
 
-  INL static uint8* WriteGroupToArray(
-      field_number, const MessageLite& value, output);
-  INL static uint8* WriteMessageToArray(
-      field_number, const MessageLite& value, output);
+  // Whether to serialize deterministically (e.g., map keys are
+  // sorted) is a property of a CodedOutputStream, and in the process
+  // of serialization, the "ToArray" variants may be invoked.  But they don't
+  // have a CodedOutputStream available, so they get an additional parameter
+  // telling them whether to serialize deterministically.
+  INL static uint8* InternalWriteGroupToArray(
+      field_number, const MessageLite& value, bool deterministic, output);
+  INL static uint8* InternalWriteMessageToArray(
+      field_number, const MessageLite& value, bool deterministic, output);
 
   // Like above, but de-virtualize the call to SerializeWithCachedSizes().  The
   // pointer must point at an instance of MessageType, *not* a subclass (or
   // the subclass must not override SerializeWithCachedSizes()).
   template<typename MessageType>
+  INL static uint8* InternalWriteGroupNoVirtualToArray(
+    field_number, const MessageType& value, bool deterministic, output);
+  template<typename MessageType>
+  INL static uint8* InternalWriteMessageNoVirtualToArray(
+    field_number, const MessageType& value, bool deterministic, output);
+
+  // For backward-compatibility, the last four methods also have versions
+  // that are non-deterministic always.
+  INL static uint8* WriteGroupToArray(
+      field_number, const MessageLite& value, output) {
+    return InternalWriteGroupToArray(field_number_arg, value, false, target);
+  }
+  INL static uint8* WriteMessageToArray(
+      field_number, const MessageLite& value, output) {
+    return InternalWriteMessageToArray(field_number_arg, value, false, target);
+  }
+  template<typename MessageType>
   INL static uint8* WriteGroupNoVirtualToArray(
-    field_number, const MessageType& value, output);
+      field_number, const MessageType& value, output) {
+    return InternalWriteGroupNoVirtualToArray(field_number_arg, value, false,
+                                              target);
+  }
   template<typename MessageType>
   INL static uint8* WriteMessageNoVirtualToArray(
-    field_number, const MessageType& value, output);
+      field_number, const MessageType& value, output) {
+    return InternalWriteMessageNoVirtualToArray(field_number_arg, value, false,
+                                                target);
+  }
 
 #undef output
 #undef input
 #undef INL
 
 #undef field_number
 
   // Compute the byte size of a field.  The XxSize() functions do NOT include
   // the tag, so you must also call TagSize().  (This is because, for repeated
   // fields, you should only call TagSize() once and multiply it by the element
   // count, but you may have to call XxSize() for each individual element.)
-  static inline int Int32Size   ( int32 value);
-  static inline int Int64Size   ( int64 value);
-  static inline int UInt32Size  (uint32 value);
-  static inline int UInt64Size  (uint64 value);
-  static inline int SInt32Size  ( int32 value);
-  static inline int SInt64Size  ( int64 value);
-  static inline int EnumSize    (   int value);
+  static inline size_t Int32Size   ( int32 value);
+  static inline size_t Int64Size   ( int64 value);
+  static inline size_t UInt32Size  (uint32 value);
+  static inline size_t UInt64Size  (uint64 value);
+  static inline size_t SInt32Size  ( int32 value);
+  static inline size_t SInt64Size  ( int64 value);
+  static inline size_t EnumSize    (   int value);
 
   // These types always have the same size.
-  static const int kFixed32Size  = 4;
-  static const int kFixed64Size  = 8;
-  static const int kSFixed32Size = 4;
-  static const int kSFixed64Size = 8;
-  static const int kFloatSize    = 4;
-  static const int kDoubleSize   = 8;
-  static const int kBoolSize     = 1;
+  static const size_t kFixed32Size  = 4;
+  static const size_t kFixed64Size  = 8;
+  static const size_t kSFixed32Size = 4;
+  static const size_t kSFixed64Size = 8;
+  static const size_t kFloatSize    = 4;
+  static const size_t kDoubleSize   = 8;
+  static const size_t kBoolSize     = 1;
 
-  static inline int StringSize(const string& value);
-  static inline int BytesSize (const string& value);
+  static inline size_t StringSize(const string& value);
+  static inline size_t BytesSize (const string& value);
 
-  static inline int GroupSize  (const MessageLite& value);
-  static inline int MessageSize(const MessageLite& value);
+  static inline size_t GroupSize  (const MessageLite& value);
+  static inline size_t MessageSize(const MessageLite& value);
 
   // Like above, but de-virtualize the call to ByteSize().  The
   // pointer must point at an instance of MessageType, *not* a subclass (or
   // the subclass must not override ByteSize()).
   template<typename MessageType>
-  static inline int GroupSizeNoVirtual  (const MessageType& value);
+  static inline size_t GroupSizeNoVirtual  (const MessageType& value);
   template<typename MessageType>
-  static inline int MessageSizeNoVirtual(const MessageType& value);
+  static inline size_t MessageSizeNoVirtual(const MessageType& value);
 
   // Given the length of data, calculate the byte size of the data on the
   // wire if we encode the data as a length delimited field.
-  static inline int LengthDelimitedSize(int length);
+  static inline size_t LengthDelimitedSize(size_t length);
 
  private:
   // A helper method for the repeated primitive reader. This method has
   // optimizations for primitive types that have fixed size on the wire, and
   // can be read using potentially faster paths.
   template <typename CType, enum FieldType DeclaredType> GOOGLE_ATTRIBUTE_ALWAYS_INLINE
   static bool ReadRepeatedFixedSizePrimitive(
       int tag_size,
       uint32 tag,
       google::protobuf::io::CodedInputStream* input,
@@ skipping 62 matching lines @@
 }
 
 inline WireFormatLite::WireType WireFormatLite::GetTagWireType(uint32 tag) {
   return static_cast<WireType>(tag & kTagTypeMask);
 }
 
 inline int WireFormatLite::GetTagFieldNumber(uint32 tag) {
   return static_cast<int>(tag >> kTagTypeBits);
 }
 
-inline int WireFormatLite::TagSize(int field_number,
-                                   WireFormatLite::FieldType type) {
-  int result = io::CodedOutputStream::VarintSize32(
+inline size_t WireFormatLite::TagSize(int field_number,
+                                      WireFormatLite::FieldType type) {
+  size_t result = io::CodedOutputStream::VarintSize32(
     field_number << kTagTypeBits);
   if (type == TYPE_GROUP) {
     // Groups have both a start and an end tag.
     return result * 2;
   } else {
     return result;
   }
 }
 
 inline uint32 WireFormatLite::EncodeFloat(float value) {
@@ skipping 73 matching lines @@
 inline bool WireFormatLite::ReadString(io::CodedInputStream* input,
                                        string** p) {
   return ReadBytes(input, p);
 }
 
 }  // namespace internal
 }  // namespace protobuf
 
 }  // namespace google
 #endif  // GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_H__