Integrated internal changes from Google

1 files changed, 21 insertions, 18 deletions

diff --git a/src/google/protobuf/message_lite.cc b/src/google/protobuf/message_lite.cc
index 83a92d5a..6184472d 100644
--- a/src/google/protobuf/message_lite.cc
+++ b/src/google/protobuf/message_lite.cc
@@ -103,15 +103,15 @@ string InitializationErrorMessage(const char* action,
 // call MergePartialFromCodedStream().  However, when parsing very small
 // messages, every function call introduces significant overhead.  To avoid
 // this without reproducing code, we use these forced-inline helpers.
-GOOGLE_ATTRIBUTE_ALWAYS_INLINE bool InlineMergeFromCodedStream(
+GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE bool InlineMergeFromCodedStream(
     io::CodedInputStream* input, MessageLite* message);
-GOOGLE_ATTRIBUTE_ALWAYS_INLINE bool InlineParseFromCodedStream(
+GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE bool InlineParseFromCodedStream(
     io::CodedInputStream* input, MessageLite* message);
-GOOGLE_ATTRIBUTE_ALWAYS_INLINE bool InlineParsePartialFromCodedStream(
+GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE bool InlineParsePartialFromCodedStream(
     io::CodedInputStream* input, MessageLite* message);
-GOOGLE_ATTRIBUTE_ALWAYS_INLINE bool InlineParseFromArray(
+GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE bool InlineParseFromArray(
     const void* data, int size, MessageLite* message);
-GOOGLE_ATTRIBUTE_ALWAYS_INLINE bool InlineParsePartialFromArray(
+GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE bool InlineParsePartialFromArray(
     const void* data, int size, MessageLite* message);
 
 inline bool InlineMergeFromCodedStream(io::CodedInputStream* input,
@@ -344,10 +344,13 @@ string MessageLite::SerializePartialAsString() const {
   return output;
 }
 
-void MessageLite::SerializeWithCachedSizes(io::CodedOutputStream* output) const
-    {
+void MessageLite::SerializeWithCachedSizes(
+    io::CodedOutputStream* output) const {
   GOOGLE_DCHECK(InternalGetTable());
-  internal::TableSerialize(*this, static_cast<const internal::SerializationTable*>(InternalGetTable()), output);
+  internal::TableSerialize(
+      *this,
+      static_cast<const internal::SerializationTable*>(InternalGetTable()),
+      output);
 }
 
 // The table driven code optimizes the case that the CodedOutputStream buffer
@@ -355,20 +358,20 @@ void MessageLite::SerializeWithCachedSizes(io::CodedOutputStream* output) const
 // If the proto is optimized for speed, this method will be overridden by
 // generated code for maximum speed. If the proto is optimized for size or
 // is lite, then we need to specialize this to avoid infinite recursion.
-uint8* MessageLite::InternalSerializeWithCachedSizesToArray(bool deterministic,
-                                               uint8* target) const {
+uint8* MessageLite::InternalSerializeWithCachedSizesToArray(
+    bool deterministic, uint8* target) const {
   const internal::SerializationTable* table =
       static_cast<const internal::SerializationTable*>(InternalGetTable());
   if (table == NULL) {
     // We only optimize this when using optimize_for = SPEED.  In other cases
-  // we just use the CodedOutputStream path.
-  int size = GetCachedSize();
-  io::ArrayOutputStream out(target, size);
-  io::CodedOutputStream coded_out(&out);
-  coded_out.SetSerializationDeterministic(deterministic);
-  SerializeWithCachedSizes(&coded_out);
-  GOOGLE_CHECK(!coded_out.HadError());
-  return target + size;
+    // we just use the CodedOutputStream path.
+    int size = GetCachedSize();
+    io::ArrayOutputStream out(target, size);
+    io::CodedOutputStream coded_out(&out);
+    coded_out.SetSerializationDeterministic(deterministic);
+    SerializeWithCachedSizes(&coded_out);
+    GOOGLE_CHECK(!coded_out.HadError());
+    return target + size;
   } else {
     return internal::TableSerializeToArray(*this, table, deterministic, target);
   }