Convert Pass()→std::move() in //components/[n-z]*

components/scheduler/base/task_queue_manager_unittest.cc

 // 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.
 
 #include "components/scheduler/base/task_queue_manager.h"
 
 #include <stddef.h>
+#include <utility>
 
 #include "base/location.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/threading/thread.h"
 #include "cc/test/ordered_simple_task_runner.h"
 #include "components/scheduler/base/real_time_domain.h"
 #include "components/scheduler/base/task_queue_impl.h"
 #include "components/scheduler/base/task_queue_manager_delegate_for_test.h"
 #include "components/scheduler/base/task_queue_selector.h"
 #include "components/scheduler/base/test_always_fail_time_source.h"
 #include "components/scheduler/base/test_time_source.h"
 #include "components/scheduler/base/virtual_time_domain.h"
 #include "components/scheduler/base/work_queue.h"
 #include "components/scheduler/base/work_queue_sets.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using testing::ElementsAre;
 using testing::ElementsAreArray;
 using testing::_;
 using scheduler::internal::EnqueueOrder;
 
 namespace scheduler {
 
 class MessageLoopTaskRunner : public TaskQueueManagerDelegateForTest {
  public:
   static scoped_refptr<MessageLoopTaskRunner> Create(
       scoped_ptr<base::TickClock> tick_clock) {
-    return make_scoped_refptr(new MessageLoopTaskRunner(tick_clock.Pass()));
+    return make_scoped_refptr(new MessageLoopTaskRunner(std::move(tick_clock)));
   }
 
   // NestableTaskRunner implementation.
   bool IsNested() const override {
     return base::MessageLoop::current()->IsNested();
   }
 
  private:
   explicit MessageLoopTaskRunner(scoped_ptr<base::TickClock> tick_clock)
       : TaskQueueManagerDelegateForTest(base::MessageLoop::current()
                                             ->task_runner(),
-                                        tick_clock.Pass()) {}
+                                        std::move(tick_clock)) {}
   ~MessageLoopTaskRunner() override {}
 };
 
 class TaskQueueManagerTest : public testing::Test {
  public:
   void DeleteTaskQueueManager() { manager_.reset(); }
 
  protected:
   void InitializeWithClock(size_t num_queues,
                            scoped_ptr<base::TickClock> test_time_source) {
@@ skipping 1638 matching lines @@
   double ratio = static_cast<double>(linear_delayed_task.count()) /
                  static_cast<double>(quadratic_immediate_task.count());
 
   // This is by design, we want to enforce a strict ordering in task execution
   // where by delayed tasks can not skip ahead of non-delayed work.
   EXPECT_GT(ratio, 0.0);
   EXPECT_LT(ratio, 0.1);
 }
 
 }  // namespace scheduler