Push out changes from internal codebase.

All Languages
* Repeated fields of primitive types (types other that string, group, and
  nested messages) may now use the option [packed = true] to get a more
  efficient encoding.  In the new encoding, the entire list is written
  as a single byte blob using the "length-delimited" wire type.  Within
  this blob, the individual values are encoded the same way they would
  be normally except without a tag before each value (thus, they are
  tightly "packed").

C++
* UnknownFieldSet now supports STL-like iteration.
* Message interface has method ParseFromBoundedZeroCopyStream() which parses
  a limited number of bytes from an input stream rather than parsing until
  EOF.

Java
* Fixed bug where Message.mergeFrom(Message) failed to merge extensions.
* Message interface has new method toBuilder() which is equivalent to
  newBuilderForType().mergeFrom(this).
* All enums now implement the ProtocolMessageEnum interface.
* Setting a field to null now throws NullPointerException.
* Fixed tendency for TextFormat's parsing to overflow the stack when
  parsing large string values.  The underlying problem is with Java's
  regex implementation (which unfortunately uses recursive backtracking
  rather than building an NFA).  Worked around by making use of possesive
  quantifiers.

Python
* Updated RPC interfaces to allow for blocking operation.  A client may
  now pass None for a callback when making an RPC, in which case the
  call will block until the response is received, and the response
  object will be returned directly to the caller.  This interface change
  cannot be used in practice until RPC implementations are updated to
  implement it.

1 files changed, 35 insertions, 7 deletions

diff --git a/src/google/protobuf/wire_format.h b/src/google/protobuf/wire_format.h
index 06f20d2a..9004caaa 100644
--- a/src/google/protobuf/wire_format.h
+++ b/src/google/protobuf/wire_format.h
@@ -163,13 +163,20 @@ class LIBPROTOBUF_EXPORT WireFormat {
   static inline WireType WireTypeForFieldType(FieldDescriptor::Type type) {
     return kWireTypeForFieldType[type];
   }
+  // This is different from WireTypeForFieldType(field->type()) in the case of
+  // packed repeated fields.
+  static inline WireType WireTypeForField(const FieldDescriptor* field);
 
   // Number of bits in a tag which identify the wire type.
   static const int kTagTypeBits = 3;
   // Mask for those bits.
   static const uint32 kTagTypeMask = (1 << kTagTypeBits) - 1;
 
-  // Helper functions for encoding and decoding tags.  (Inlined below.)
+  // Helper functions for encoding and decoding tags.  (Inlined below and in
+  // _inl.h)
+  //
+  // This is different from MakeTag(field->number(), field->type()) in the case
+  // of packed repeated fields.
   static uint32 MakeTag(const FieldDescriptor* field);
   static uint32 MakeTag(int field_number, WireType type);
   static WireType GetTagWireType(uint32 tag);
@@ -258,10 +265,27 @@ class LIBPROTOBUF_EXPORT WireFormat {
   template<typename MessageType>
   static inline bool ReadMessageNoVirtual(input, MessageType* value);
 
-  // Write a tag.  The Write*() functions automatically include the tag, so
-  // normally there's no need to call this.
+  // Write a tag.  The Write*() functions typically include the tag, so
+  // normally there's no need to call this unless using the Write*NoTag()
+  // variants.
   static inline bool WriteTag(field_number, WireType type, output) INL;
 
+  // Write fields, without tags.
+  static inline bool WriteInt32NoTag   (int32 value, output) INL;
+  static inline bool WriteInt64NoTag   (int64 value, output) INL;
+  static inline bool WriteUInt32NoTag  (uint32 value, output) INL;
+  static inline bool WriteUInt64NoTag  (uint64 value, output) INL;
+  static inline bool WriteSInt32NoTag  (int32 value, output) INL;
+  static inline bool WriteSInt64NoTag  (int64 value, output) INL;
+  static inline bool WriteFixed32NoTag (uint32 value, output) INL;
+  static inline bool WriteFixed64NoTag (uint64 value, output) INL;
+  static inline bool WriteSFixed32NoTag(int32 value, output) INL;
+  static inline bool WriteSFixed64NoTag(int64 value, output) INL;
+  static inline bool WriteFloatNoTag   (float value, output) INL;
+  static inline bool WriteDoubleNoTag  (double value, output) INL;
+  static inline bool WriteBoolNoTag    (bool value, output) INL;
+  static inline bool WriteEnumNoTag    (int value, output) INL;
+
   // Write fields, including tags.
   static inline bool WriteInt32   (field_number,  int32 value, output) INL;
   static inline bool WriteInt64   (field_number,  int64 value, output) INL;
@@ -355,6 +379,14 @@ class LIBPROTOBUF_EXPORT WireFormat {
       const FieldDescriptor* field,
       const Message& message);
 
+  // Computes the byte size of a field, excluding tags. For packed fields, it
+  // only includes the size of the raw data, and not the size of the total
+  // length, but for other length-delimited types, the size of the length is
+  // included.
+  static int FieldDataOnlyByteSize(
+      const FieldDescriptor* field,        // Cannot be NULL
+      const Message& message);
+
   GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(WireFormat);
 };
 
@@ -368,10 +400,6 @@ class LIBPROTOBUF_EXPORT WireFormat {
   static_cast<uint32>(                                              \
     ((FIELD_NUMBER) << ::google::protobuf::internal::WireFormat::kTagTypeBits) | (TYPE))
 
-inline uint32 WireFormat::MakeTag(const FieldDescriptor* field) {
-  return MakeTag(field->number(), WireTypeForFieldType(field->type()));
-}
-
 inline uint32 WireFormat::MakeTag(int field_number, WireType type) {
   return GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(field_number, type);
 }