Some scoped_ptr -> std::unique_ptr conversion, especially under //mojo.

mojo/message_pump/handle_watcher_unittest.cc

 // Copyright 2013 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 "mojo/message_pump/handle_watcher.h"
 
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/auto_reset.h"
@@ skipping 30 matching lines @@
 }
 
 void DeleteWatcherAndForwardResult(
     HandleWatcher* watcher,
     base::Callback<void(MojoResult)> next_callback,
     MojoResult result) {
   delete watcher;
   next_callback.Run(result);
 }
 
-scoped_ptr<base::MessageLoop> CreateMessageLoop(MessageLoopConfig config) {
-  scoped_ptr<base::MessageLoop> loop;
+std::unique_ptr<base::MessageLoop> CreateMessageLoop(MessageLoopConfig config) {
+  std::unique_ptr<base::MessageLoop> loop;
   if (config == MESSAGE_LOOP_CONFIG_DEFAULT)
     loop.reset(new base::MessageLoop());
   else
     loop.reset(new base::MessageLoop(MessagePumpMojo::Create()));
   return loop;
 }
 
 // Helper class to manage the callback and running the message loop waiting for
 // message to be received. Typical usage is something like:
 //   Schedule callback returned from GetCallback().
@@ skipping 68 matching lines @@
   }
 
   void InstallTickClock() {
     test::SetTickClockForTest(&tick_clock_);
   }
 
   base::SimpleTestTickClock tick_clock_;
 
  private:
   base::ShadowingAtExitManager at_exit_;
-  scoped_ptr<base::MessageLoop> message_loop_;
+  std::unique_ptr<base::MessageLoop> message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(HandleWatcherTest);
 };
 
 INSTANTIATE_TEST_CASE_P(
     MultipleMessageLoopConfigs, HandleWatcherTest,
     testing::Values(MESSAGE_LOOP_CONFIG_DEFAULT, MESSAGE_LOOP_CONFIG_MOJO));
 
 // Trivial test case with a single handle to watch.
 TEST_P(HandleWatcherTest, SingleHandler) {
@@ skipping 261 matching lines @@
       callback_helper.Start(&watcher, test_pipe.handle0.get());
       RunUntilIdle();
       EXPECT_FALSE(callback_helper.got_callback());
       EXPECT_TRUE(mojo::test::WriteTextMessage(test_pipe.handle1.get(),
                                                std::string()));
       base::MessageLoop::ScopedNestableTaskAllower scoper(
           base::MessageLoop::current());
       callback_helper.RunUntilGotCallback();
       EXPECT_TRUE(callback_helper.got_callback());
     } else {
-      scoped_ptr<TestData> test_data(new TestData);
+      std::unique_ptr<TestData> test_data(new TestData);
       ASSERT_TRUE(test_data->pipe.handle0.is_valid());
       test_data->watcher.Start(test_data->pipe.handle0.get(),
                     MOJO_HANDLE_SIGNAL_READABLE,
                     MOJO_DEADLINE_INDEFINITE,
                     base::Bind(&NeverReached));
       data_vector.push_back(test_data.release());
     }
     if (i % 15 == 0)
       data_vector.clear();
   }
@@ skipping 16 matching lines @@
 #endif
 
   base::ShadowingAtExitManager at_exit;
   base::MessageLoop message_loop;
   base::RunLoop run_loop;
   ScopedVector<base::Thread> threads;
   int threads_active_counter = kThreadCount;
   // Starts the threads first and then post the task in hopes of having more
   // threads running at once.
   for (int i = 0; i < kThreadCount; ++i) {
-    scoped_ptr<base::Thread> thread(new base::Thread("test thread"));
+    std::unique_ptr<base::Thread> thread(new base::Thread("test thread"));
     if (i % 2) {
       base::Thread::Options thread_options;
       thread_options.message_pump_factory =
           base::Bind(&MessagePumpMojo::Create);
       thread->StartWithOptions(thread_options);
     } else {
       thread->Start();
     }
     threads.push_back(thread.release());
   }
   for (int i = 0; i < kThreadCount; ++i) {
     threads[i]->task_runner()->PostTask(
         FROM_HERE, base::Bind(&RunStressTest, kWatchCount,
                               message_loop.task_runner(),
                               &run_loop, &threads_active_counter));
   }
   run_loop.Run();
   ASSERT_EQ(0, threads_active_counter);
 }
 
 }  // namespace test
 }  // namespace common
 }  // namespace mojo