Convert //base to use std::unique_ptr

base/message_loop/message_loop_task_runner_unittest.cc

 // Copyright (c) 2012 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/message_loop/message_loop_task_runner.h"
 
+#include <memory>
+
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/debug/leak_annotations.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 namespace base {
 
@@ skipping 60 matching lines @@
     recorder->RecordRun();
     MessageLoop::current()->QuitWhenIdle();
   }
 
   void UnblockTaskThread() { thread_sync_.Signal(); }
 
   void BlockTaskThreadHelper() { thread_sync_.Wait(); }
 
   static StaticAtomicSequenceNumber g_order;
 
-  scoped_ptr<MessageLoop> current_loop_;
+  std::unique_ptr<MessageLoop> current_loop_;
   Thread task_thread_;
 
  private:
   base::WaitableEvent thread_sync_;
 };
 
 StaticAtomicSequenceNumber MessageLoopTaskRunnerTest::g_order;
 
 TEST_F(MessageLoopTaskRunnerTest, PostTaskAndReply_Basic) {
   MessageLoop* task_run_on = NULL;
@@ skipping 194 matching lines @@
 
     ~DeletedOnFile() {
       test_->AssertOnFileThread();
       test_->Quit();
     }
 
    private:
     MessageLoopTaskRunnerThreadingTest* test_;
   };
 
-  scoped_ptr<Thread> io_thread_;
-  scoped_ptr<Thread> file_thread_;
+  std::unique_ptr<Thread> io_thread_;
+  std::unique_ptr<Thread> file_thread_;
 
  private:
   mutable MessageLoop loop_;
 };
 
 TEST_F(MessageLoopTaskRunnerThreadingTest, Release) {
   EXPECT_TRUE(io_thread_->task_runner()->ReleaseSoon(FROM_HERE, this));
   MessageLoop::current()->Run();
 }
 
 TEST_F(MessageLoopTaskRunnerThreadingTest, Delete) {
   DeletedOnFile* deleted_on_file = new DeletedOnFile(this);
   EXPECT_TRUE(
       file_thread_->task_runner()->DeleteSoon(FROM_HERE, deleted_on_file));
   MessageLoop::current()->Run();
 }
 
 TEST_F(MessageLoopTaskRunnerThreadingTest, PostTask) {
   EXPECT_TRUE(file_thread_->task_runner()->PostTask(
       FROM_HERE, Bind(&MessageLoopTaskRunnerThreadingTest::BasicFunction,
                       Unretained(this))));
   MessageLoop::current()->Run();
 }
 
 TEST_F(MessageLoopTaskRunnerThreadingTest, PostTaskAfterThreadExits) {
-  scoped_ptr<Thread> test_thread(
+  std::unique_ptr<Thread> test_thread(
       new Thread("MessageLoopTaskRunnerThreadingTest_Dummy"));
   test_thread->Start();
   scoped_refptr<SingleThreadTaskRunner> task_runner =
       test_thread->task_runner();
   test_thread->Stop();
 
   bool ret = task_runner->PostTask(
       FROM_HERE, Bind(&MessageLoopTaskRunnerThreadingTest::AssertNotRun));
   EXPECT_FALSE(ret);
 }
 
 TEST_F(MessageLoopTaskRunnerThreadingTest, PostTaskAfterThreadIsDeleted) {
   scoped_refptr<SingleThreadTaskRunner> task_runner;
   {
-    scoped_ptr<Thread> test_thread(
+    std::unique_ptr<Thread> test_thread(
         new Thread("MessageLoopTaskRunnerThreadingTest_Dummy"));
     test_thread->Start();
     task_runner = test_thread->task_runner();
   }
   bool ret = task_runner->PostTask(
       FROM_HERE, Bind(&MessageLoopTaskRunnerThreadingTest::AssertNotRun));
   EXPECT_FALSE(ret);
 }
 
 }  // namespace base