Protobuf: Remove protobuf globals patch

third_party/protobuf/src/google/protobuf/arena.cc

Index: third_party/protobuf/src/google/protobuf/arena.cc
diff --git a/third_party/protobuf/src/google/protobuf/arena.cc b/third_party/protobuf/src/google/protobuf/arena.cc
index 3ce17e343e93714711af34cc2f722eba116488b8..613e5897144151967594abc84da94bc610cb0ce2 100755
--- a/third_party/protobuf/src/google/protobuf/arena.cc
+++ b/third_party/protobuf/src/google/protobuf/arena.cc
@@ -39,18 +39,24 @@ namespace google {
 namespace protobuf {
 
 
+google::protobuf::internal::SequenceNumber Arena::lifecycle_id_generator_;
 #if defined(GOOGLE_PROTOBUF_NO_THREADLOCAL)
-Arena::ThreadCache& Arena::cr_thread_cache() {
+Arena::ThreadCache& Arena::thread_cache() {
   static internal::ThreadLocalStorage<ThreadCache>* thread_cache_ =
       new internal::ThreadLocalStorage<ThreadCache>();
   return *thread_cache_->Get();
 }
-#elif !defined(PROTOBUF_USE_DLLS)
+#elif defined(PROTOBUF_USE_DLLS)
+Arena::ThreadCache& Arena::thread_cache() {
+  static GOOGLE_THREAD_LOCAL ThreadCache thread_cache_ = { -1, NULL };
+  return thread_cache_;
+}
+#else
 GOOGLE_THREAD_LOCAL Arena::ThreadCache Arena::thread_cache_ = { -1, NULL };
 #endif
 
 void Arena::Init() {
-  lifecycle_id_ = internal::cr_lifecycle_id_generator_.GetNext();
+  lifecycle_id_ = lifecycle_id_generator_.GetNext();
   blocks_ = 0;
   hint_ = 0;
   owns_first_block_ = true;
@@ -68,7 +74,7 @@ void Arena::Init() {
     // Thread which calls Init() owns the first block. This allows the
     // single-threaded case to allocate on the first block without taking any
     // locks.
-    first_block->owner = &cr_thread_cache();
+    first_block->owner = &thread_cache();
     SetThreadCacheBlock(first_block);
     AddBlockInternal(first_block);
     owns_first_block_ = false;
@@ -93,7 +99,7 @@ Arena::~Arena() {
 
 uint64 Arena::Reset() {
   // Invalidate any ThreadCaches pointing to any blocks we just destroyed.
-  lifecycle_id_ = internal::cr_lifecycle_id_generator_.GetNext();
+  lifecycle_id_ = lifecycle_id_generator_.GetNext();
   return ResetInternal();
 }
 
@@ -178,18 +184,18 @@ void* Arena::AllocateAligned(const std::type_info* allocated, size_t n) {
   // If this thread already owns a block in this arena then try to use that.
   // This fast path optimizes the case where multiple threads allocate from the
   // same arena.
-  if (cr_thread_cache().last_lifecycle_id_seen == lifecycle_id_ &&
-      cr_thread_cache().last_block_used_ != NULL) {
-    if (cr_thread_cache().last_block_used_->avail() < n) {
+  if (thread_cache().last_lifecycle_id_seen == lifecycle_id_ &&
+      thread_cache().last_block_used_ != NULL) {
+    if (thread_cache().last_block_used_->avail() < n) {
       return SlowAlloc(n);
     }
-    return AllocFromBlock(cr_thread_cache().last_block_used_, n);
+    return AllocFromBlock(thread_cache().last_block_used_, n);
   }
 
   // Check whether we own the last accessed block on this arena.
   // This fast path optimizes the case where a single thread uses multiple
   // arenas.
-  void* me = &cr_thread_cache();
+  void* me = &thread_cache();
   Block* b = reinterpret_cast<Block*>(google::protobuf::internal::Acquire_Load(&hint_));
   if (!b || b->owner != me || b->avail() < n) {
     return SlowAlloc(n);
@@ -207,7 +213,7 @@ void* Arena::AllocFromBlock(Block* b, size_t n) {
 }
 
 void* Arena::SlowAlloc(size_t n) {
-  void* me = &cr_thread_cache();
+  void* me = &thread_cache();
   Block* b = FindBlock(me);  // Find block owned by me.
   // See if allocation fits in my latest block.
   if (b != NULL && b->avail() >= n) {
@@ -284,7 +290,7 @@ uint64 Arena::FreeBlocks() {
     // Thread which calls Reset() owns the first block. This allows the
     // single-threaded case to allocate on the first block without taking any
     // locks.
-    first_block->owner = &cr_thread_cache();
+    first_block->owner = &thread_cache();
     SetThreadCacheBlock(first_block);
     AddBlockInternal(first_block);
   }