Get logging to chrome_debug.log working again on Windows Vista+.

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 158 matching lines @@
   if (last_backslash != PathString::npos)
     log_name.erase(last_backslash + 1);
   log_name += L"debug.log";
   return log_name;
 #elif defined(OS_POSIX)
   // On other platforms we just use the current directory.
   return PathString("debug.log");
 #endif
 }
 
+// We don't need locks on Windows for atomically appending to files. The OS
+// provides this functionality.
+#if !defined(OS_WIN)
 // This class acts as a wrapper for locking the logging files.
 // LoggingLock::Init() should be called from the main thread before any logging
 // is done. Then whenever logging, be sure to have a local LoggingLock
 // instance on the stack. This will ensure that the lock is unlocked upon
 // exiting the frame.
 // LoggingLocks can not be nested.
 class LoggingLock {
  public:
   LoggingLock() {
     LockLogging();
   }
 
   ~LoggingLock() {
     UnlockLogging();
   }
 
   static void Init(LogLockingState lock_log, const PathChar* new_log_file) {
     if (initialized)
       return;
     lock_log_file = lock_log;
-    if (lock_log_file == LOCK_LOG_FILE) {
-#if defined(OS_WIN)
-      if (!log_mutex) {
-        std::wstring safe_name;
-        if (new_log_file)
-          safe_name = new_log_file;
-        else
-          safe_name = GetDefaultLogFile();
-        // \ is not a legal character in mutex names so we replace \ with /
-        std::replace(safe_name.begin(), safe_name.end(), '\\', '/');
-        std::wstring t(L"Global\\");
-        t.append(safe_name);
-        log_mutex = ::CreateMutex(nullptr, FALSE, t.c_str());
 
-        if (log_mutex == nullptr) {
-#if DEBUG
-          // Keep the error code for debugging
-          int error = GetLastError();  // NOLINT
-          base::debug::BreakDebugger();
-#endif
-          // Return nicely without putting initialized to true.
-          return;
-        }
-      }
-#endif
-    } else {
+    if (lock_log_file != LOCK_LOG_FILE)
       log_lock = new base::internal::LockImpl();
-    }
+
     initialized = true;
   }
 
  private:
   static void LockLogging() {
     if (lock_log_file == LOCK_LOG_FILE) {
-#if defined(OS_WIN)
-      ::WaitForSingleObject(log_mutex, INFINITE);
-      // WaitForSingleObject could have returned WAIT_ABANDONED. We don't
-      // abort the process here. UI tests might be crashy sometimes,
-      // and aborting the test binary only makes the problem worse.
-      // We also don't use LOG macros because that might lead to an infinite
-      // loop. For more info see http://crbug.com/18028.
-#elif defined(OS_POSIX)
+#if defined(OS_POSIX)
       pthread_mutex_lock(&log_mutex);
 #endif
     } else {
       // use the lock
       log_lock->Lock();
     }
   }
 
   static void UnlockLogging() {
     if (lock_log_file == LOCK_LOG_FILE) {
-#if defined(OS_WIN)
-      ReleaseMutex(log_mutex);
-#elif defined(OS_POSIX)
+#if defined(OS_POSIX)
       pthread_mutex_unlock(&log_mutex);
 #endif
     } else {
       log_lock->Unlock();
     }
   }
 
   // The lock is used if log file locking is false. It helps us avoid problems
   // with multiple threads writing to the log file at the same time.  Use
   // LockImpl directly instead of using Lock, because Lock makes logging calls.
   static base::internal::LockImpl* log_lock;
 
   // When we don't use a lock, we are using a global mutex. We need to do this
   // because LockFileEx is not thread safe.
-#if defined(OS_WIN)
-  static MutexHandle log_mutex;
-#elif defined(OS_POSIX)
+#if defined(OS_POSIX)
   static pthread_mutex_t log_mutex;
 #endif
 
   static bool initialized;
   static LogLockingState lock_log_file;
 };
 
 // static
 bool LoggingLock::initialized = false;
 // static
 base::internal::LockImpl* LoggingLock::log_lock = nullptr;
 // static
 LogLockingState LoggingLock::lock_log_file = LOCK_LOG_FILE;
 
-#if defined(OS_WIN)
-// static
-MutexHandle LoggingLock::log_mutex = nullptr;
-#elif defined(OS_POSIX)
+#if defined(OS_POSIX)
 pthread_mutex_t LoggingLock::log_mutex = PTHREAD_MUTEX_INITIALIZER;
 #endif
 
+#endif  // OS_WIN
+
 // Called by logging functions to ensure that |g_log_file| is initialized
 // and can be used for writing. Returns false if the file could not be
 // initialized. |g_log_file| will be nullptr in this case.
 bool InitializeLogFileHandle() {
   if (g_log_file)
     return true;
 
   if (!g_log_file_name) {
     // Nobody has called InitLogging to specify a debug log file, so here we
     // initialize the log file name to a default.
     g_log_file_name = new PathString(GetDefaultLogFile());
   }
 
   if ((g_logging_destination & LOG_TO_FILE) != 0) {
 #if defined(OS_WIN)
-    g_log_file = CreateFile(g_log_file_name->c_str(), GENERIC_WRITE,
+    g_log_file = CreateFile(g_log_file_name->c_str(), FILE_APPEND_DATA,

[scottmg, 2015/09/16 23:30:47]

do we need FILE_APPEND_DATA | SYNCHRONIZE? (and below)

https://msdn.microsoft.com/en-us/library/ff548289.aspx is the first documented
place i found for atomic append-only writing.

[scottmg, 2015/09/16 23:34:58]

https://msdn.microsoft.com/en-us/library/gg258116(v=vs.85).aspx makes it seem
like FILE_APPEND_DATA is sufficient, so probably ignore this one.

[ananta, 2015/09/16 23:49:38]

msdn says that FILE_APPEND_DATA is enough.

                             FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr,
                             OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
     if (g_log_file == INVALID_HANDLE_VALUE || g_log_file == nullptr) {
       // try the current directory
-      g_log_file = CreateFile(L".\\debug.log", GENERIC_WRITE,
+      g_log_file = CreateFile(L".\\debug.log", FILE_APPEND_DATA,

[scottmg, 2015/09/16 23:30:47]

this case won't get a sandbox policy based on using GetLogFileFullPath().

[ananta, 2015/09/16 23:49:38]

Fixed

                               FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr,
                               OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
       if (g_log_file == INVALID_HANDLE_VALUE || g_log_file == nullptr) {
         g_log_file = nullptr;
         return false;
       }
     }
-    SetFilePointer(g_log_file, 0, 0, FILE_END);
 #elif defined(OS_POSIX)
     g_log_file = fopen(g_log_file_name->c_str(), "a");
     if (g_log_file == nullptr)
       return false;
 #endif
   }
 
   return true;
 }
 
@@ skipping 42 matching lines @@
                      command_line->GetSwitchValueASCII(switches::kVModule),
                      &g_min_log_level);
   }
 
   g_logging_destination = settings.logging_dest;
 
   // ignore file options unless logging to file is set.
   if ((g_logging_destination & LOG_TO_FILE) == 0)
     return true;
 
+  // We don't need a lock on Windows for atomic appends.
+#if !defined(OS_WIN)
   LoggingLock::Init(settings.lock_log, settings.log_file);
   LoggingLock logging_lock;
+#endif
 
   // Calling InitLogging twice or after some log call has already opened the
   // default log file will re-initialize to the new options.
   CloseLogFileUnlocked();
 
   if (!g_log_file_name)
     g_log_file_name = new PathString();
   *g_log_file_name = settings.log_file;
   if (settings.delete_old == DELETE_OLD_LOG_FILE)
     DeleteFilePath(*g_log_file_name);
@@ skipping 201 matching lines @@
 
   // write to log file
   if ((g_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.
+    // We don't need a lock on Windows for atomic appends.
+#if !defined(OS_WIN)
     LoggingLock::Init(LOCK_LOG_FILE, nullptr);
     LoggingLock logging_lock;
+#endif
     if (InitializeLogFileHandle()) {
 #if defined(OS_WIN)
-      SetFilePointer(g_log_file, 0, 0, SEEK_END);
       DWORD num_written;
       WriteFile(g_log_file,
                 static_cast<const void*>(str_newline.c_str()),
                 static_cast<DWORD>(str_newline.length()),
                 &num_written,
                 nullptr);
 #else
       ignore_result(fwrite(
           str_newline.data(), str_newline.size(), 1, g_log_file));
       fflush(g_log_file);
@@ skipping 139 matching lines @@
     : err_(err),
       log_message_(file, line, severity) {
 }
 
 ErrnoLogMessage::~ErrnoLogMessage() {
   stream() << ": " << SystemErrorCodeToString(err_);
 }
 #endif  // defined(OS_WIN)
 
 void CloseLogFile() {
+  // We don't need a lock on Windows for atomic appends.
+#if !defined(OS_WIN)
   LoggingLock logging_lock;
+#endif
   CloseLogFileUnlocked();
 }
 
 void RawLog(int level, const char* message) {
   if (level >= g_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(
@@ skipping 18 matching lines @@
   }
 
   if (level == LOG_FATAL)
     base::debug::BreakDebugger();
 }
 
 // This was defined at the beginning of this file.
 #undef write
 
 #if defined(OS_WIN)
+bool IsLoggingToFileEnabled() {
+  return g_logging_destination & LOG_TO_FILE;
+}
+
 std::wstring GetLogFileFullPath() {
   if (g_log_file_name)
     return *g_log_file_name;
   return std::wstring();
 }
 #endif
 
 BASE_EXPORT void LogErrorNotReached(const char* file, int line) {
   LogMessage(file, line, LOG_ERROR).stream()
       << "NOTREACHED() hit.";
 }
 
 }  // namespace logging
 
 std::ostream& std::operator<<(std::ostream& out, const wchar_t* wstr) {
   return out << base::WideToUTF8(wstr);
 }