Move debug-related stuff from base to the base/debug directory and use the...

base/logging.cc

 // Copyright (c) 2010 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 24 matching lines @@
 typedef pthread_mutex_t* MutexHandle;
 #endif
 
 #include <ctime>
 #include <iomanip>
 #include <cstring>
 #include <algorithm>
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
-#include "base/debug_util.h"
+#include "base/debug/debugger.h"
+#include "base/debug/stack_trace.h"
 #include "base/eintr_wrapper.h"
 #include "base/lock_impl.h"
 #if defined(OS_POSIX)
 #include "base/safe_strerror_posix.h"
 #endif
 #include "base/process_util.h"
 #include "base/string_piece.h"
 #include "base/utf_string_conversions.h"
 #include "base/vlog.h"
 
@@ skipping 157 matching lines @@
         // \ 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(NULL, FALSE, t.c_str());
 
         if (log_mutex == NULL) {
 #if DEBUG
           // Keep the error code for debugging
           int error = GetLastError();  // NOLINT
-          DebugUtil::BreakDebugger();
+          base::debug::BreakDebugger();
 #endif
           // Return nicely without putting initialized to true.
           return;
         }
       }
 #endif
     } else {
       log_lock = new LockImpl();
     }
     initialized = true;
@@ skipping 339 matching lines @@
 LogMessage::~LogMessage() {
   // The macros in logging.h should already avoid creating LogMessages
   // when this holds, but it's possible that users create LogMessages
   // directly (e.g., using LOG_STREAM() directly).
   if (severity_ < min_log_level)
     return;
 
 #ifndef NDEBUG
   if (severity_ == LOG_FATAL) {
     // Include a stack trace on a fatal.
-    StackTrace trace;
+    base::debug::StackTrace trace;
     stream_ << std::endl;  // Newline to separate from log message.
     trace.OutputToStream(&stream_);
   }
 #endif
   stream_ << std::endl;
   std::string str_newline(stream_.str());
 
   // Give any log message handler first dibs on the message.
   if (log_message_handler && log_message_handler(severity_, str_newline))
     return;
@@ skipping 36 matching lines @@
                 NULL);
 #else
       fprintf(log_file, "%s", str_newline.c_str());
       fflush(log_file);
 #endif
     }
   }
 
   if (severity_ == LOG_FATAL) {
     // display a message or break into the debugger on a fatal error
-    if (DebugUtil::BeingDebugged()) {
-      DebugUtil::BreakDebugger();
+    if (base::debug::BeingDebugged()) {
+      base::debug::BreakDebugger();
     } else {
       if (log_assert_handler) {
         // make a copy of the string for the handler out of paranoia
         log_assert_handler(std::string(stream_.str()));
       } else {
         // Don't use the string with the newline, get a fresh version to send to
         // the debug message process. We also don't display assertions to the
         // user in release mode. The enduser can't do anything with this
         // information, and displaying message boxes when the application is
         // hosed can cause additional problems.
 #ifndef NDEBUG
         DisplayDebugMessageInDialog(stream_.str());
 #endif
         // Crash the process to generate a dump.
-        DebugUtil::BreakDebugger();
+        base::debug::BreakDebugger();
       }
     }
   } else if (severity_ == LOG_ERROR_REPORT) {
     // We are here only if the user runs with --enable-dcheck in release mode.
     if (log_report_handler) {
       log_report_handler(std::string(stream_.str()));
     } else {
       DisplayDebugMessageInDialog(stream_.str());
     }
   }
@@ skipping 118 matching lines @@
         rv = HANDLE_EINTR(write(STDERR_FILENO, "\n", 1));
         if (rv < 0) {
           // Give up, nothing we can do now.
           break;
         }
       } while (rv != 1);
     }
   }
 
   if (level == LOG_FATAL)
-    DebugUtil::BreakDebugger();
+    base::debug::BreakDebugger();
 }
 
 }  // namespace logging
 
 std::ostream& operator<<(std::ostream& out, const wchar_t* wstr) {
   return out << WideToUTF8(std::wstring(wstr));
 }