Remove stl_util's deletion function use from tools/.

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 278 matching lines @@
 
 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.
-
-  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());
+  logs_.push_back(std::move(new_log));
 }
 
 void ThreadLogsManager::StartInternalFlushThread_Locked() {
   lock_.AssertAcquired();
   CHECK(!flush_thread_);
   // Note that the |flush_thread_| joins at destruction which guarantees that it
   // will never outlive |this|, i.e. it's safe not to use ref-counting.
   flush_thread_.reset(
       new Thread(base::Bind(&ThreadLogsManager::FlushAllLogsOnFlushThread,
                             base::Unretained(this))));
@@ skipping 18 matching lines @@
     // Sleep for a few secs and then flush all thread's buffers. There is a
     // danger that, when quitting Chrome, this thread may see unallocated data
     // and segfault. We do not care because we need logs when Chrome is working.
     wait_callback_.Run();
 
     // Copy the ThreadLog pointers to avoid acquiring both the logs manager's
     // lock and the one for individual thread logs.
     std::vector<ThreadLog*> thread_logs_copy;
     {
       base::AutoLock auto_lock(lock_);
-      thread_logs_copy = logs_;
+      for (const auto& log : logs_)
+        thread_logs_copy.push_back(log.get());
     }
 
     // Move the logs' data before flushing them so that the mutexes are not
     // acquired for too long.
     std::vector<LogData> logs;
     for (std::vector<ThreadLog*>::const_iterator it =
              thread_logs_copy.begin();
          it != thread_logs_copy.end(); ++it) {
       ThreadLog* const thread_log = *it;
       LogData log_data(thread_log);
@@ skipping 39 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