1 files changed, 39 insertions, 26 deletions

diff --git a/src/google/protobuf/metadata_lite.h b/src/google/protobuf/metadata_lite.h
index 454d088c..a0e101df 100644
--- a/src/google/protobuf/metadata_lite.h
+++ b/src/google/protobuf/metadata_lite.h
@@ -31,10 +31,18 @@
 #ifndef GOOGLE_PROTOBUF_METADATA_LITE_H__
 #define GOOGLE_PROTOBUF_METADATA_LITE_H__
 
+#include <string>
 #include <google/protobuf/stubs/common.h>
 #include <google/protobuf/arena.h>
+#include <google/protobuf/generated_message_util.h>
 #include <google/protobuf/message_lite.h>
-#include <google/protobuf/stubs/port.h>
+#include <google/protobuf/port.h>
+
+#include <google/protobuf/port_def.inc>
+
+#ifdef SWIG
+#error "You cannot SWIG proto headers"
+#endif
 
 namespace google {
 namespace protobuf {
@@ -63,35 +71,35 @@ class InternalMetadataWithArenaBase {
     ptr_ = NULL;
   }
 
-  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE const T& unknown_fields() const {
-    if (GOOGLE_PREDICT_FALSE(have_unknown_fields())) {
+  PROTOBUF_ALWAYS_INLINE const T& unknown_fields() const {
+    if (PROTOBUF_PREDICT_FALSE(have_unknown_fields())) {
       return PtrValue<Container>()->unknown_fields;
     } else {
       return Derived::default_instance();
     }
   }
 
-  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE T* mutable_unknown_fields() {
-    if (GOOGLE_PREDICT_TRUE(have_unknown_fields())) {
+  PROTOBUF_ALWAYS_INLINE T* mutable_unknown_fields() {
+    if (PROTOBUF_PREDICT_TRUE(have_unknown_fields())) {
       return &PtrValue<Container>()->unknown_fields;
     } else {
       return mutable_unknown_fields_slow();
     }
   }
 
-  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE Arena* arena() const {
-    if (GOOGLE_PREDICT_FALSE(have_unknown_fields())) {
+  PROTOBUF_ALWAYS_INLINE Arena* arena() const {
+    if (PROTOBUF_PREDICT_FALSE(have_unknown_fields())) {
       return PtrValue<Container>()->arena;
     } else {
       return PtrValue<Arena>();
     }
   }
 
-  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE bool have_unknown_fields() const {
+  PROTOBUF_ALWAYS_INLINE bool have_unknown_fields() const {
     return PtrTag() == kTagContainer;
   }
 
-  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE void Swap(Derived* other) {
+  PROTOBUF_ALWAYS_INLINE void Swap(Derived* other) {
     // Semantics here are that we swap only the unknown fields, not the arena
     // pointer. We cannot simply swap ptr_ with other->ptr_ because we need to
     // maintain our own arena ptr. Also, our ptr_ and other's ptr_ may be in
@@ -103,21 +111,19 @@ class InternalMetadataWithArenaBase {
     }
   }
 
-  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE void MergeFrom(const Derived& other) {
+  PROTOBUF_ALWAYS_INLINE void MergeFrom(const Derived& other) {
     if (other.have_unknown_fields()) {
       static_cast<Derived*>(this)->DoMergeFrom(other.unknown_fields());
     }
   }
 
-  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE void Clear() {
+  PROTOBUF_ALWAYS_INLINE void Clear() {
     if (have_unknown_fields()) {
       static_cast<Derived*>(this)->DoClear();
     }
   }
 
-  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE void* raw_arena_ptr() const {
-    return ptr_;
-  }
+  PROTOBUF_ALWAYS_INLINE void* raw_arena_ptr() const { return ptr_; }
 
  private:
   void* ptr_;
@@ -133,7 +139,7 @@ class InternalMetadataWithArenaBase {
   static const intptr_t kPtrValueMask = ~kPtrTagMask;
 
   // Accessors for pointer tag and pointer value.
-  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE int PtrTag() const {
+  PROTOBUF_ALWAYS_INLINE int PtrTag() const {
     return reinterpret_cast<intptr_t>(ptr_) & kPtrTagMask;
   }
 
@@ -148,7 +154,7 @@ class InternalMetadataWithArenaBase {
     Arena* arena;
   };
 
-  GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE T* mutable_unknown_fields_slow() {
+  PROTOBUF_NOINLINE T* mutable_unknown_fields_slow() {
     Arena* my_arena = arena();
     Container* container = Arena::Create<Container>(my_arena);
     // Two-step assignment works around a bug in clang's static analyzer:
@@ -165,20 +171,20 @@ class InternalMetadataWithArenaBase {
 // good interface for reading unknown fields into an ArenaString.  We may want
 // to revisit this to allow unknown fields to be parsed onto the Arena.
 class InternalMetadataWithArenaLite
-    : public InternalMetadataWithArenaBase<string,
+    : public InternalMetadataWithArenaBase<std::string,
                                            InternalMetadataWithArenaLite> {
  public:
   InternalMetadataWithArenaLite() {}
 
   explicit InternalMetadataWithArenaLite(Arena* arena)
-      : InternalMetadataWithArenaBase<string,
+      : InternalMetadataWithArenaBase<std::string,
                                       InternalMetadataWithArenaLite>(arena) {}
 
-  void DoSwap(string* other) {
+  void DoSwap(std::string* other) {
     mutable_unknown_fields()->swap(*other);
   }
 
-  void DoMergeFrom(const string& other) {
+  void DoMergeFrom(const std::string& other) {
     mutable_unknown_fields()->append(other);
   }
 
@@ -186,8 +192,13 @@ class InternalMetadataWithArenaLite
     mutable_unknown_fields()->clear();
   }
 
-  static const string& default_instance() {
-    return GetEmptyStringAlreadyInited();
+  static const std::string& default_instance() {
+    // Can't use GetEmptyStringAlreadyInited() here because empty string may
+    // not have been initalized yet. This happens when protocol compiler
+    // statically determines the user can't access defaults and omits init code
+    // from proto constructors. However unknown fields are always part of a
+    // proto so it needs to be lazily initailzed. See b/112613846.
+    return GetEmptyString();
   }
 };
 
@@ -199,7 +210,7 @@ class InternalMetadataWithArenaLite
 // LiteUnknownFieldSetter setter(&_internal_metadata_);
 // StringOutputStream stream(setter.buffer());
 // guarantees that the string is only swapped after stream is destroyed.
-class LIBPROTOBUF_EXPORT LiteUnknownFieldSetter {
+class PROTOBUF_EXPORT LiteUnknownFieldSetter {
  public:
   explicit LiteUnknownFieldSetter(InternalMetadataWithArenaLite* metadata)
       : metadata_(metadata) {
@@ -210,15 +221,17 @@ class LIBPROTOBUF_EXPORT LiteUnknownFieldSetter {
   ~LiteUnknownFieldSetter() {
     if (!buffer_.empty()) metadata_->mutable_unknown_fields()->swap(buffer_);
   }
-  string* buffer() { return &buffer_; }
+  std::string* buffer() { return &buffer_; }
 
  private:
   InternalMetadataWithArenaLite* metadata_;
-  string buffer_;
+  std::string buffer_;
 };
 
 }  // namespace internal
 }  // namespace protobuf
-
 }  // namespace google
+
+#include <google/protobuf/port_undef.inc>
+
 #endif  // GOOGLE_PROTOBUF_METADATA_LITE_H__