Convert //tools to use std::unique_ptr

tools/cygprofile/cygprofile.h

 // Copyright 2014 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.
 //
 // Tool to log the execution of the process (Chrome). Writes logs containing
 // time and address of the callback being called for the first time.
 //
 // For performance reasons logs are buffered. Every thread has its own buffer
 // and log file so the contention between threads is minimal. As a side-effect,
 // functions called might be mentioned in many thread logs.
 //
 // A special thread is created in the process to periodically flush logs for all
 // threads in case the thread had stopped before flushing its logs.
 //
 // Also note that the instrumentation code is self-activated. It begins to
 // record the log data when it is called first, including the run-time startup.
 // Have it in mind when modifying it, in particular do not use global objects
 // with constructors as they are called during startup (too late for us).
 
 #ifndef TOOLS_CYGPROFILE_CYGPROFILE_H_
 #define TOOLS_CYGPROFILE_CYGPROFILE_H_
 
-#include <vector>
-
 #include <sys/time.h>
 #include <sys/types.h>
 
+#include <memory>
+#include <vector>
+
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "build/build_config.h"
 
 #if !defined(OS_ANDROID)
 // This is only supported on Android thanks to the fact that on Android
 // processes (other than the system's zygote) don't fork.
 //
 // To make cygprofile truly work (i.e. without any deadlock) on Chrome
 // platforms that use fork(), cygprofile.cc should be written in a way that
 // guarantees that:
@@ skipping 90 matching lines @@
 
   // Used for testing. The provided callbacks are used for testing to
   // synchronize the internal thread with the unit test running on the main
   // thread.
   ThreadLogsManager(const base::Closure& wait_callback,
                     const base::Closure& notify_callback);
 
   ~ThreadLogsManager();
 
   // Can be called from any thread.
-  void AddLog(scoped_ptr<ThreadLog> new_log);
+  void AddLog(std::unique_ptr<ThreadLog> new_log);
 
  private:
   void StartInternalFlushThread_Locked();
 
   // Flush thread's entry point.
   void FlushAllLogsOnFlushThread();
 
   // Used to make the internal thread sleep before each flush iteration.
   const base::Closure wait_callback_;
   // Used to trigger a notification when a flush happened on the internal
   // thread.
   const base::Closure notify_callback_;
 
   // Protects the state below.
   base::Lock lock_;
-  scoped_ptr<Thread> flush_thread_;
+  std::unique_ptr<Thread> flush_thread_;
   std::vector<ThreadLog*> logs_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadLogsManager);
 };
 
 }  // namespace cygprofile
 
 #endif  // TOOLS_CYGPROFILE_CYGPROFILE_H_