Protobuf: Remove protobuf globals patch

third_party/protobuf/src/google/protobuf/stubs/common.cc

 // 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 98 matching lines @@
 // emulates google3/base/logging.cc
 
 namespace internal {
 #if defined(__ANDROID__)
 inline void DefaultLogHandler(LogLevel level, const char* filename, int line,
                               const string& message) {
 #ifdef GOOGLE_PROTOBUF_MIN_LOG_LEVEL
   if (level < GOOGLE_PROTOBUF_MIN_LOG_LEVEL) {
     return;
   }
-  static const char* const level_names[] = {"INFO", "WARNING", "ERROR",
-                                            "FATAL"};
+  static const char* level_names[] = {"INFO", "WARNING", "ERROR", "FATAL"};
 
   static const int android_log_levels[] = {
       ANDROID_LOG_INFO,   // LOG(INFO),
       ANDROID_LOG_WARN,   // LOG(WARNING)
       ANDROID_LOG_ERROR,  // LOG(ERROR)
       ANDROID_LOG_FATAL,  // LOG(FATAL)
   };
 
   // Bound the logging level.
   const int android_log_level = android_log_levels[level];
@@ skipping 11 matching lines @@
   // Indicate termination if needed.
   if (android_log_level == ANDROID_LOG_FATAL) {
     __android_log_write(ANDROID_LOG_FATAL, "libprotobuf-native",
                         "terminating.\n");
   }
 #endif
 }
 #else
 void DefaultLogHandler(LogLevel level, const char* filename, int line,
                        const string& message) {
-  static const char* const level_names[] = {"INFO", "WARNING", "ERROR",
-                                            "FATAL"};
+  static const char* level_names[] = { "INFO", "WARNING", "ERROR", "FATAL" };
 
   // We use fprintf() instead of cerr because we want this to work at static
   // initialization time.
   fprintf(stderr, "[libprotobuf %s %s:%d] %s\n",
           level_names[level], filename, line, message.c_str());
   fflush(stderr);  // Needed on MSVC.
 }
 #endif
 
 void NullLogHandler(LogLevel /* level */, const char* /* filename */,
                     int /* line */, const string& /* message */) {
   // Nothing.
 }
 
-extern LogHandler* cr_log_handler_;
-extern int cr_log_silencer_count_;
+static LogHandler* log_handler_ = &DefaultLogHandler;
+static int log_silencer_count_ = 0;
 
-extern Mutex* cr_log_silencer_count_mutex_;
-extern ProtobufOnceType cr_log_silencer_count_init_;
+static Mutex* log_silencer_count_mutex_ = NULL;
+GOOGLE_PROTOBUF_DECLARE_ONCE(log_silencer_count_init_);
 
 void DeleteLogSilencerCount() {
-  delete cr_log_silencer_count_mutex_;
-  cr_log_silencer_count_mutex_ = NULL;
+  delete log_silencer_count_mutex_;
+  log_silencer_count_mutex_ = NULL;
 }
 void InitLogSilencerCount() {
-  cr_log_silencer_count_mutex_ = new Mutex;
+  log_silencer_count_mutex_ = new Mutex;
   OnShutdown(&DeleteLogSilencerCount);
 }
 void InitLogSilencerCountOnce() {
-  GoogleOnceInit(&cr_log_silencer_count_init_, &InitLogSilencerCount);
+  GoogleOnceInit(&log_silencer_count_init_, &InitLogSilencerCount);
 }
 
 LogMessage& LogMessage::operator<<(const string& value) {
   message_ += value;
   return *this;
 }
 
 LogMessage& LogMessage::operator<<(const char* value) {
   message_ += value;
   return *this;
@@ skipping 47 matching lines @@
 
 LogMessage::LogMessage(LogLevel level, const char* filename, int line)
   : level_(level), filename_(filename), line_(line) {}
 LogMessage::~LogMessage() {}
 
 void LogMessage::Finish() {
   bool suppress = false;
 
   if (level_ != LOGLEVEL_FATAL) {
     InitLogSilencerCountOnce();
-    MutexLock lock(cr_log_silencer_count_mutex_);
-    suppress = cr_log_silencer_count_ > 0;
+    MutexLock lock(log_silencer_count_mutex_);
+    suppress = log_silencer_count_ > 0;
   }
 
   if (!suppress) {
-    (cr_log_handler_ ? cr_log_handler_ : DefaultLogHandler)(level_, filename_,
-                                                            line_, message_);
+    log_handler_(level_, filename_, line_, message_);
   }
 
   if (level_ == LOGLEVEL_FATAL) {
 #if PROTOBUF_USE_EXCEPTIONS
     throw FatalException(filename_, line_, message_);
 #else
     abort();
 #endif
   }
 }
 
 void LogFinisher::operator=(LogMessage& other) {
   other.Finish();
 }
 
 }  // namespace internal
 
 LogHandler* SetLogHandler(LogHandler* new_func) {
-  LogHandler* old = internal::cr_log_handler_ ? internal::cr_log_handler_
-                                              : internal::DefaultLogHandler;
+  LogHandler* old = internal::log_handler_;
   if (old == &internal::NullLogHandler) {
     old = NULL;
   }
   if (new_func == NULL) {
-    internal::cr_log_handler_ = &internal::NullLogHandler;
+    internal::log_handler_ = &internal::NullLogHandler;
   } else {
-    internal::cr_log_handler_ = new_func;
+    internal::log_handler_ = new_func;
   }
   return old;
 }
 
 LogSilencer::LogSilencer() {
   internal::InitLogSilencerCountOnce();
-  MutexLock lock(internal::cr_log_silencer_count_mutex_);
-  ++internal::cr_log_silencer_count_;
+  MutexLock lock(internal::log_silencer_count_mutex_);
+  ++internal::log_silencer_count_;
 };
 
 LogSilencer::~LogSilencer() {
   internal::InitLogSilencerCountOnce();
-  MutexLock lock(internal::cr_log_silencer_count_mutex_);
-  --internal::cr_log_silencer_count_;
+  MutexLock lock(internal::log_silencer_count_mutex_);
+  --internal::log_silencer_count_;
 };
 
 // ===================================================================
 // emulates google3/base/callback.cc
 
 Closure::~Closure() {}
 
 namespace internal { FunctionClosure0::~FunctionClosure0() {} }
 
 void DoNothing() {}
@@ skipping 95 matching lines @@
   result_array[3] = static_cast<uint8>(x & 0xFF);
   return result;
 }
 
 // ===================================================================
 // Shutdown support.
 
 namespace internal {
 
 typedef void OnShutdownFunc();
-extern vector<void (*)()>* cr_shutdown_functions;
-extern Mutex* cr_shutdown_functions_mutex;
-extern ProtobufOnceType cr_shutdown_functions_init;
+vector<void (*)()>* shutdown_functions = NULL;
+Mutex* shutdown_functions_mutex = NULL;
+GOOGLE_PROTOBUF_DECLARE_ONCE(shutdown_functions_init);
 
 void InitShutdownFunctions() {
-  cr_shutdown_functions = new vector<void (*)()>;
-  cr_shutdown_functions_mutex = new Mutex;
+  shutdown_functions = new vector<void (*)()>;
+  shutdown_functions_mutex = new Mutex;
 }
 
 inline void InitShutdownFunctionsOnce() {
-  GoogleOnceInit(&cr_shutdown_functions_init, &InitShutdownFunctions);
+  GoogleOnceInit(&shutdown_functions_init, &InitShutdownFunctions);
 }
 
 void OnShutdown(void (*func)()) {
   InitShutdownFunctionsOnce();
-  MutexLock lock(cr_shutdown_functions_mutex);
-  cr_shutdown_functions->push_back(func);
+  MutexLock lock(shutdown_functions_mutex);
+  shutdown_functions->push_back(func);
 }
 
 }  // namespace internal
 
 void ShutdownProtobufLibrary() {
   internal::InitShutdownFunctionsOnce();
 
-  // We don't need to lock cr_shutdown_functions_mutex because it's up to the
+  // We don't need to lock shutdown_functions_mutex because it's up to the
   // caller to make sure that no one is using the library before this is
   // called.
 
   // Make it safe to call this multiple times.
-  if (internal::cr_shutdown_functions == NULL) return;
+  if (internal::shutdown_functions == NULL) return;
 
-  for (int i = 0; i < internal::cr_shutdown_functions->size(); i++) {
-    internal::cr_shutdown_functions->at(i)();
+  for (int i = 0; i < internal::shutdown_functions->size(); i++) {
+    internal::shutdown_functions->at(i)();
   }
-  delete internal::cr_shutdown_functions;
-  internal::cr_shutdown_functions = NULL;
-  delete internal::cr_shutdown_functions_mutex;
-  internal::cr_shutdown_functions_mutex = NULL;
+  delete internal::shutdown_functions;
+  internal::shutdown_functions = NULL;
+  delete internal::shutdown_functions_mutex;
+  internal::shutdown_functions_mutex = NULL;
 }
 
 #if PROTOBUF_USE_EXCEPTIONS
 FatalException::~FatalException() throw() {}
 
 const char* FatalException::what() const throw() {
   return message_.c_str();
 }
 #endif
 
 }  // namespace protobuf
 }  // namespace google