LoggingLock::Init() should append a non-empty string to

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 279 matching lines @@
 bool LoggingLock::initialized = false;
 // static
 base::internal::LockImpl* LoggingLock::log_lock = NULL;
 // static
 LogLockingState LoggingLock::lock_log_file = LOCK_LOG_FILE;
 
 #if defined(OS_WIN)
 // static
 MutexHandle LoggingLock::log_mutex = NULL;
 #elif defined(OS_POSIX)
+// TODO(wtc): this pthread_mutex_t is not process-shared!
 pthread_mutex_t LoggingLock::log_mutex = PTHREAD_MUTEX_INITIALIZER;
 #endif
 
 // Called by logging functions to ensure that debug_file is initialized
 // and can be used for writing. Returns false if the file could not be
 // initialized. debug_file will be NULL in this case.
 bool InitializeLogFileHandle() {
   if (log_file)
     return true;
 
@@ skipping 302 matching lines @@
   // 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_NONE &&
       logging_destination != LOG_ONLY_TO_SYSTEM_DEBUG_LOG) {
     LoggingLock logging_lock;

[wtc, 2012/09/12 20:27:09]

This is the only place where we write to a log file.

Note that we won't get here in a Release build of Chrome
because logging_destination is LOG_NONE. So LoggingLock
does NOT need to lock the log file if logging_destination
is LOG_NONE or LOG_ONLY_TO_SYSTEM_DEBUG_LOG.

     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);
 #else
@@ skipping 218 matching lines @@
 }
 
 // This was defined at the beginning of this file.
 #undef write
 
 }  // namespace logging
 
 std::ostream& operator<<(std::ostream& out, const wchar_t* wstr) {
   return out << WideToUTF8(std::wstring(wstr));
 }