Header cleanup in base....

base/debug_util_posix.cc

-// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
+// 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/debug_util.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/stat.h>
 #include <sys/sysctl.h>
 #include <sys/types.h>
 #include <unistd.h>
 
+#include <string>
+#include <vector>
+
 #if defined(__GLIBCXX__)
 #include <cxxabi.h>
 #endif
 
 #if defined(OS_MACOSX)
 #include <AvailabilityMacros.h>
 #endif
 
 #include <iostream>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/compat_execinfo.h"
 #include "base/eintr_wrapper.h"
 #include "base/logging.h"
 #include "base/safe_strerror_posix.h"
 #include "base/scoped_ptr.h"
 #include "base/string_piece.h"
-#include "base/string_util.h"
+#include "base/stringprintf.h"
 
 #if defined(USE_SYMBOLIZE)
 #include "base/third_party/symbolize/symbolize.h"
 #endif
 
 namespace {
 // The prefix used for mangled symbols, per the Itanium C++ ABI:
 // http://www.codesourcery.com/cxx-abi/abi.html#mangling
 const char kMangledSymbolPrefix[] = "_Z";
 
@@ skipping 57 matching lines @@
 
 #if defined(USE_SYMBOLIZE)
   for (int i = 0; i < size; ++i) {
     char symbol[1024];
     // Subtract by one as return address of function may be in the next
     // function when a function is annotated as noreturn.
     if (google::Symbolize(static_cast<char *>(trace[i]) - 1,
                           symbol, sizeof(symbol))) {
       // Don't call DemangleSymbols() here as the symbol is demangled by
       // google::Symbolize().
-      trace_strings->push_back(StringPrintf("%s [%p]", symbol, trace[i]));
+      trace_strings->push_back(
+          base::StringPrintf("%s [%p]", symbol, trace[i]));
       symbolized = true;
     } else {
-      trace_strings->push_back(StringPrintf("%p", trace[i]));
+      trace_strings->push_back(base::StringPrintf("%p", trace[i]));
     }
   }
 #else
   scoped_ptr_malloc<char*> trace_symbols(backtrace_symbols(trace, size));
   if (trace_symbols.get()) {
     for (int i = 0; i < size; ++i) {
       std::string trace_symbol = trace_symbols.get()[i];
       DemangleSymbols(&trace_symbol);
       trace_strings->push_back(trace_symbol);
     }
     symbolized = true;
   } else {
     for (int i = 0; i < size; ++i) {
-      trace_strings->push_back(StringPrintf("%p", trace[i]));
+      trace_strings->push_back(base::StringPrintf("%p", trace[i]));
     }
   }
 #endif  // defined(USE_SYMBOLIZE)
 
   return symbolized;
 }
 
 }  // namespace
 
 // static
@@ skipping 153 matching lines @@
     (*os) << "Backtrace:\n";
   } else {
     (*os) << "Unable get symbols for backtrace (" << safe_strerror(errno)
           << "). Dumping raw addresses in trace:\n";
   }
 
   for (size_t i = 0; i < trace_strings.size(); ++i) {
     (*os) << "\t" << trace_strings[i] << "\n";
   }
 }