Only use the LoggingLock when actually logging to a file

base/logging.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/logging.h"
 
 #if defined(OS_WIN)
 #include <io.h>
 #include <windows.h>
 typedef HANDLE FileHandle;
@@ skipping 134 matching lines @@
   clock_gettime(CLOCK_MONOTONIC, &ts);
 
   uint64 absolute_micro =
     static_cast<int64>(ts.tv_sec) * 1000000 +
     static_cast<int64>(ts.tv_nsec) / 1000;
 
   return absolute_micro;
 #endif
 }
 
-void CloseFile(FileHandle log) {
-#if defined(OS_WIN)
-  CloseHandle(log);
-#else
-  fclose(log);
-#endif
-}
-
 void DeleteFilePath(const PathString& log_name) {
 #if defined(OS_WIN)
   DeleteFile(log_name.c_str());
 #elif defined (OS_NACL)
   // Do nothing; unlink() isn't supported on NaCl.
 #else
   unlink(log_name.c_str());
 #endif
 }
 
@@ skipping 161 matching lines @@
 #elif defined(OS_POSIX)
     log_file = fopen(log_file_name->c_str(), "a");
     if (log_file == NULL)
       return false;
 #endif
   }
 
   return true;
 }
 
+void CloseFile(FileHandle log) {
+#if defined(OS_WIN)
+  CloseHandle(log);
+#else
+  fclose(log);
+#endif
+}
+
+void CloseLogFileUnlocked() {
+  if (!log_file)
+    return;
+
+  CloseFile(log_file);
+  log_file = NULL;
+}
+
 }  // namespace
 
 LoggingSettings::LoggingSettings()
     : logging_dest(LOG_DEFAULT),
       log_file(NULL),
       lock_log(LOCK_LOG_FILE),
       delete_old(APPEND_TO_OLD_LOG_FILE),
       dcheck_state(DISABLE_DCHECK_FOR_NON_OFFICIAL_RELEASE_BUILDS) {}
 
 bool BaseInitLoggingImpl(const LoggingSettings& settings) {
@@ skipping 12 matching lines @@
     // one. We keep track of both to avoid memory leak warnings.
     CHECK(!g_vlog_info_prev);
     g_vlog_info_prev = g_vlog_info;
 
     g_vlog_info =
         new VlogInfo(command_line->GetSwitchValueASCII(switches::kV),
                      command_line->GetSwitchValueASCII(switches::kVModule),
                      &min_log_level);
   }
 
-  LoggingLock::Init(settings.lock_log, settings.log_file);
-
-  LoggingLock logging_lock;
-
-  if (log_file) {
-    // calling InitLogging twice or after some log call has already opened the
-    // default log file will re-initialize to the new options
-    CloseFile(log_file);
-    log_file = NULL;
-  }
-
   logging_destination = settings.logging_dest;
 
   // ignore file options unless logging to file is set.
   if ((logging_destination & LOG_TO_FILE) == 0)
     return true;
 
+  LoggingLock::Init(settings.lock_log, settings.log_file);
+  LoggingLock logging_lock;
+
+  // Calling InitLogging twice or after some log call has already opened the
+  // default log file will re-initialize to the new options.
+  CloseLogFileUnlocked();
+
   if (!log_file_name)
     log_file_name = new PathString();
   *log_file_name = settings.log_file;
   if (settings.delete_old == DELETE_OLD_LOG_FILE)
     DeleteFilePath(*log_file_name);
 
   return InitializeLogFileHandle();
 }
 
 void SetMinLogLevel(int level) {
@@ skipping 198 matching lines @@
     fprintf(stderr, "%s", str_newline.c_str());
     fflush(stderr);
   } else if (severity_ >= kAlwaysPrintErrorLevel) {
     // When we're only outputting to a log file, above a certain log level, we
     // should still output to stderr so that we can better detect and diagnose
     // problems with unit tests, especially on the buildbots.
     fprintf(stderr, "%s", str_newline.c_str());
     fflush(stderr);
   }
 
-  // We can have multiple threads and/or processes, so try to prevent them
-  // from clobbering each other's writes.
-  // If the client app did not call InitLogging, and the lock has not
-  // been created do it now. We do this on demand, but if two threads try
-  // to do this at the same time, there will be a race condition to create
-  // the lock. This is why InitLogging should be called from the main
-  // thread at the beginning of execution.
-  LoggingLock::Init(LOCK_LOG_FILE, NULL);
   // write to log file
   if ((logging_destination & LOG_TO_FILE) != 0) {
+    // We can have multiple threads and/or processes, so try to prevent them
+    // from clobbering each other's writes.
+    // If the client app did not call InitLogging, and the lock has not
+    // been created do it now. We do this on demand, but if two threads try
+    // to do this at the same time, there will be a race condition to create
+    // the lock. This is why InitLogging should be called from the main
+    // thread at the beginning of execution.
+    LoggingLock::Init(LOCK_LOG_FILE, NULL);
     LoggingLock logging_lock;
     if (InitializeLogFileHandle()) {
 #if defined(OS_WIN)
       SetFilePointer(log_file, 0, 0, SEEK_END);
       DWORD num_written;
       WriteFile(log_file,
                 static_cast<const void*>(str_newline.c_str()),
                 static_cast<DWORD>(str_newline.length()),
                 &num_written,
                 NULL);
@@ skipping 172 matching lines @@
       log_message_(file, line, severity) {
 }
 
 ErrnoLogMessage::~ErrnoLogMessage() {
   stream() << ": " << safe_strerror(err_);
 }
 #endif  // OS_WIN
 
 void CloseLogFile() {
   LoggingLock logging_lock;
-
-  if (!log_file)
-    return;
-
-  CloseFile(log_file);
-  log_file = NULL;
+  CloseLogFileUnlocked();
 }
 
 void RawLog(int level, const char* message) {
   if (level >= min_log_level) {
     size_t bytes_written = 0;
     const size_t message_len = strlen(message);
     int rv;
     while (bytes_written < message_len) {
       rv = HANDLE_EINTR(
           write(STDERR_FILENO, message + bytes_written,
@@ skipping 29 matching lines @@
     return *log_file_name;
   return std::wstring();
 }
 #endif
 
 }  // namespace logging
 
 std::ostream& operator<<(std::ostream& out, const wchar_t* wstr) {
   return out << WideToUTF8(std::wstring(wstr));
 }