tools: Use stl utilities from the base namespace

tools/cygprofile/cygprofile.cc

 // Copyright (c) 2011 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 "tools/cygprofile/cygprofile.h"
 
 #include <fcntl.h>
 #include <pthread.h>
 #include <stddef.h>
 #include <stdint.h>
@@ skipping 231 matching lines @@
     // though) due to OOM.
     CHECK_LE(entries_.size(), kMaxBufferSize);
   }
 
   in_use_ = false;
 }
 
 void ThreadLog::TakeEntries(std::vector<LogEntry>* destination) {
   base::AutoLock auto_lock(lock_);
   destination->swap(entries_);
-  STLClearObject(&entries_);
+  base::STLClearObject(&entries_);
 }
 
 void ThreadLog::Flush(std::vector<LogEntry>* entries) const {
   flush_callback_.Run(entries);
 }
 
 void ThreadLog::FlushInternal(std::vector<LogEntry>* entries) const {
   const std::string log_filename(
       base::StringPrintf(
           kLogFilenameFormat, kLogFileNamePrefix, getpid(), tid_, getppid()));
   const base::ScopedFILE file(fopen(log_filename.c_str(), "a"));
   CHECK(file.get());
 
   const long offset = ftell(file.get());
   if (offset == 0)
     fprintf(file.get(), "%s", g_file_header_line.Get().value.c_str());
 
   for (std::vector<LogEntry>::const_iterator it = entries->begin();
        it != entries->end(); ++it) {
     fprintf(file.get(), "%ld %ld\t%d:%d\t%p\n", it->time.tv_sec,
             it->time.tv_nsec / 1000, it->pid, it->tid, it->address);
   }
 
-  STLClearObject(entries);
+  base::STLClearObject(entries);
 }
 
 ThreadLogsManager::ThreadLogsManager()
     : wait_callback_(base::Bind(&SleepSec, kFlushThreadIdleTimeSec)) {
 }
 
 ThreadLogsManager::ThreadLogsManager(const base::Closure& wait_callback,
                                      const base::Closure& notify_callback)
 
     : wait_callback_(wait_callback),
       notify_callback_(notify_callback) {
 }
 
 ThreadLogsManager::~ThreadLogsManager() {
   // Note that the internal thread does some work until it sees |flush_thread_|
   // = NULL.
   std::unique_ptr<Thread> flush_thread;
   {
     base::AutoLock auto_lock(lock_);
     flush_thread_.swap(flush_thread);
   }
   flush_thread.reset();  // Joins the flush thread.
 
-  STLDeleteContainerPointers(logs_.begin(), logs_.end());
+  base::STLDeleteContainerPointers(logs_.begin(), logs_.end());
 }
 
 void ThreadLogsManager::AddLog(std::unique_ptr<ThreadLog> new_log) {
   base::AutoLock auto_lock(lock_);
 
   if (logs_.empty())
     StartInternalFlushThread_Locked();
 
   logs_.push_back(new_log.release());
 }
@@ skipping 87 matching lines @@
   }
 
   if (thread_log != kMagicBeingConstructed)
     thread_log->AddEntry(this_fn);
 }
 
 void __cyg_profile_func_exit(void* this_fn, void* call_site) {}
 
 }  // extern "C"
 }  // namespace cygprofile