Convert //tools to use std::unique_ptr

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>
 #include <sys/stat.h>
 #include <sys/syscall.h>
 #include <sys/time.h>
 #include <sys/types.h>
 
 #include <cstdio>
 #include <fstream>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/files/scoped_file.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 
 namespace cygprofile {
 namespace {
 
 // Allow 8 MBytes of data for each thread log.
@@ skipping 222 matching lines @@
 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.
-  scoped_ptr<Thread> flush_thread;
+  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());
 }
 
-void ThreadLogsManager::AddLog(scoped_ptr<ThreadLog> new_log) {
+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());
 }
 
 void ThreadLogsManager::StartInternalFlushThread_Locked() {
   lock_.AssertAcquired();
@@ skipping 64 matching lines @@
 void __cyg_profile_func_enter(void* this_fn, void* call_site)
     __attribute__((no_instrument_function));
 void __cyg_profile_func_exit(void* this_fn, void* call_site)
     __attribute__((no_instrument_function));
 
 void __cyg_profile_func_enter(void* this_fn, void* callee_unused) {
   if (g_tls_log == NULL) {
     g_tls_log = kMagicBeingConstructed;
     ThreadLog* new_log = new ThreadLog();
     CHECK(new_log);
-    g_logs_manager.Pointer()->AddLog(make_scoped_ptr(new_log));
+    g_logs_manager.Pointer()->AddLog(base::WrapUnique(new_log));
     g_tls_log = new_log;
   }
 
   if (g_tls_log != kMagicBeingConstructed)
     g_tls_log->AddEntry(this_fn);
 }
 
 void __cyg_profile_func_exit(void* this_fn, void* call_site) {}
 
 }  // extern "C"
 }  // namespace cygprofile