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

net/disk_cache/stress_cache.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.
 
 // This is a simple application that stress-tests the crash recovery of the disk
 // cache. The main application starts a copy of itself on a loop, checking the
 // exit code of the child process. When the child dies in an unexpected way,
 // the main application quits.
 
 // The child application has two threads: one to exercise the cache in an
 // infinite loop, and another one to asynchronously kill the process.
 
 // A regular build should never crash.
 // To test that the disk cache doesn't generate critical errors with regular
 // application level crashes, add the following code and re-compile:
 //
 //     void BackendImpl::CriticalError(int error) {
 //       NOTREACHED();
 //
 //     void BackendImpl::ReportError(int error) {
 //       if (error && error != ERR_PREVIOUS_CRASH) {
 //         NOTREACHED();
 //       }
 
 #include <string>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
-#include "base/debug_util.h"
+#include "base/debug/debugger.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/platform_thread.h"
 #include "base/process_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/thread.h"
 #include "base/utf_string_conversions.h"
@@ skipping 165 matching lines @@
   base::Thread* thread = new base::Thread("party_crasher");
   if (!thread->Start())
     return false;
 
   CrashTask::RunSoon(thread->message_loop());
   return true;
 }
 
 void CrashHandler(const std::string& str) {
   g_crashing = true;
-  DebugUtil::BreakDebugger();
+  base::debug::BreakDebugger();
 }
 
 // -----------------------------------------------------------------------
 
 int main(int argc, const char* argv[]) {
   // Setup an AtExitManager so Singleton objects will be destructed.
   base::AtExitManager at_exit_manager;
 
   if (argc < 2)
     return MasterCode();
 
   logging::SetLogAssertHandler(CrashHandler);
 
   // Some time for the memory manager to flush stuff.
   PlatformThread::Sleep(3000);
   MessageLoop message_loop(MessageLoop::TYPE_IO);
 
   char* end;
   long int iteration = strtol(argv[1], &end, 0);
 
   if (!StartCrashThread()) {
     printf("failed to start thread\n");
     return kError;
   }
 
   StressTheCache(iteration);
   return 0;
 }