Convert Pass()→std::move() in mojo/

mojo/message_pump/handle_watcher_perftest.cc

 // Copyright 2015 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 <utility>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
+#include "mojo/message_pump/handle_watcher.h"
 #include "mojo/message_pump/message_pump_mojo.h"
 #include "mojo/public/cpp/test_support/test_support.h"
 #include "mojo/public/cpp/test_support/test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace common {
 namespace test {
 
 enum MessageLoopConfig {
   MESSAGE_LOOP_CONFIG_DEFAULT = 0,
   MESSAGE_LOOP_CONFIG_MOJO = 1
 };
 
 scoped_ptr<base::MessageLoop> CreateMessageLoop(MessageLoopConfig config) {
   scoped_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.Pass();
+  return loop;
 }
 
 void OnWatcherSignaled(const base::Closure& callback, MojoResult /* result */) {
   callback.Run();
 }
 
 class ScopedPerfTimer {
  public:
   ScopedPerfTimer(const std::string& test_name,
                   const std::string& sub_test_name,
@@ skipping 64 matching lines @@
   struct TestData {
     MessagePipe pipe;
     HandleWatcher watcher;
   };
   ScopedVector<TestData> data_vector;
   // Create separately from the start/stop loops to avoid affecting the
   // benchmark.
   for (uint64_t i = 0; i < kHandles; i++) {
     scoped_ptr<TestData> test_data(new TestData);
     ASSERT_TRUE(test_data->pipe.handle0.is_valid());
-    data_vector.push_back(test_data.Pass());
+    data_vector.push_back(std::move(test_data));
   }
 
   ScopedPerfTimer timer("StartAllThenStop_1000Handles", GetMessageLoopName(),
                         kIterations * kHandles);
   for (uint64_t iter = 0; iter < kIterations; iter++) {
     for (uint64_t i = 0; i < kHandles; i++) {
       TestData* test_data = data_vector[i];
       test_data->watcher.Start(
           test_data->pipe.handle0.get(), MOJO_HANDLE_SIGNAL_READABLE,
           MOJO_DEADLINE_INDEFINITE, base::Bind(&NeverReached));
@@ skipping 41 matching lines @@
     MessagePipe pipe;
     HandleWatcher watcher;
   };
   ScopedVector<TestData> data_vector;
   for (uint64_t i = 0; i < kWaitingHandles; i++) {
     scoped_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.Pass());
+    data_vector.push_back(std::move(test_data));
   }
 
   ScopedPerfTimer timer("StartAndSignal_1000Waiting", GetMessageLoopName(),
                         kIterations);
   for (uint64_t i = 0; i < kIterations; i++) {
     base::RunLoop run_loop;
     watcher.Start(pipe.handle0.get(), MOJO_HANDLE_SIGNAL_READABLE,
                   MOJO_DEADLINE_INDEFINITE,
                   base::Bind(&OnWatcherSignaled, run_loop.QuitClosure()));
     ASSERT_TRUE(mojo::test::WriteTextMessage(pipe.handle1.get(), kMessage));
     run_loop.Run();
     watcher.Stop();
 
     ASSERT_TRUE(
         mojo::test::ReadTextMessage(pipe.handle0.get(), &received_message));
     EXPECT_EQ(kMessage, received_message);
     received_message.clear();
   }
 }
 
 }  // namespace test
 }  // namespace common
 }  // namespace mojo