base: Remove some unnecessary const scoped_refptr<>&.

base/test/sequenced_task_runner_test_template.h

 // 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.
 
 // SequencedTaskRunnerTest defines tests that implementations of
 // SequencedTaskRunner should pass in order to be conformant.
 // See task_runner_test_template.h for a description of how to use the
 // constructs in this file; these work the same.
 
 #ifndef BASE_TEST_SEQUENCED_TASK_RUNNER_TEST_TEMPLATE_H_
@@ skipping 23 matching lines @@
   int i;
   Type type;
 };
 
 // Utility class used in the tests below.
 class SequencedTaskTracker : public RefCountedThreadSafe<SequencedTaskTracker> {
  public:
   SequencedTaskTracker();
 
   // Posts the non-nestable task |task|, and records its post event.
-  void PostWrappedNonNestableTask(
-      const scoped_refptr<SequencedTaskRunner>& task_runner,
-      const Closure& task);
+  void PostWrappedNonNestableTask(SequencedTaskRunner* task_runner,
+                                  const Closure& task);
 
   // Posts the nestable task |task|, and records its post event.
-  void PostWrappedNestableTask(
-      const scoped_refptr<SequencedTaskRunner>& task_runner,
-      const Closure& task);
+  void PostWrappedNestableTask(SequencedTaskRunner* task_runner,
+                               const Closure& task);
 
   // Posts the delayed non-nestable task |task|, and records its post event.
-  void PostWrappedDelayedNonNestableTask(
-      const scoped_refptr<SequencedTaskRunner>& task_runner,
-      const Closure& task,
-      TimeDelta delay);
+  void PostWrappedDelayedNonNestableTask(SequencedTaskRunner* task_runner,
+                                         const Closure& task,
+                                         TimeDelta delay);
 
   // Posts |task_count| non-nestable tasks.
-  void PostNonNestableTasks(
-      const scoped_refptr<SequencedTaskRunner>& task_runner,
-      int task_count);
+  void PostNonNestableTasks(SequencedTaskRunner* task_runner, int task_count);
 
   const std::vector<TaskEvent>& GetTaskEvents() const;
 
   // Returns after the tracker observes a total of |count| task completions.
   void WaitForCompletedTasks(int count);
 
  private:
   friend class RefCountedThreadSafe<SequencedTaskTracker>;
 
   ~SequencedTaskTracker();
@@ skipping 61 matching lines @@
 // overlapping. I.e. that each task starts only after the previously-posted
 // one has finished.
 TYPED_TEST_P(SequencedTaskRunnerTest, SequentialNonNestable) {
   const int kTaskCount = 1000;
 
   this->delegate_.StartTaskRunner();
   const scoped_refptr<SequencedTaskRunner> task_runner =
       this->delegate_.GetTaskRunner();
 
   this->task_tracker_->PostWrappedNonNestableTask(
-      task_runner, Bind(&PlatformThread::Sleep, TimeDelta::FromSeconds(1)));
+      task_runner.get(),
+      Bind(&PlatformThread::Sleep, TimeDelta::FromSeconds(1)));
   for (int i = 1; i < kTaskCount; ++i) {
-    this->task_tracker_->PostWrappedNonNestableTask(task_runner, Closure());
+    this->task_tracker_->PostWrappedNonNestableTask(task_runner.get(),
+                                                    Closure());
   }
 
   this->delegate_.StopTaskRunner();
 
   EXPECT_TRUE(CheckNonNestableInvariants(this->task_tracker_->GetTaskEvents(),
                                          kTaskCount));
 }
 
 // This test posts N nestable tasks in sequence. It has the same expectations
 // as SequentialNonNestable because even though the tasks are nestable, they
 // will not be run nestedly in this case.
 TYPED_TEST_P(SequencedTaskRunnerTest, SequentialNestable) {
   const int kTaskCount = 1000;
 
   this->delegate_.StartTaskRunner();
   const scoped_refptr<SequencedTaskRunner> task_runner =
       this->delegate_.GetTaskRunner();
 
   this->task_tracker_->PostWrappedNestableTask(
-      task_runner,
+      task_runner.get(),
       Bind(&PlatformThread::Sleep, TimeDelta::FromSeconds(1)));
   for (int i = 1; i < kTaskCount; ++i) {
-    this->task_tracker_->PostWrappedNestableTask(task_runner, Closure());
+    this->task_tracker_->PostWrappedNestableTask(task_runner.get(), Closure());
   }
 
   this->delegate_.StopTaskRunner();
 
   EXPECT_TRUE(CheckNonNestableInvariants(this->task_tracker_->GetTaskEvents(),
                                          kTaskCount));
 }
 
 // This test posts non-nestable tasks in order of increasing delay, and checks
 // that that the tasks are run in FIFO order and that there is no execution
 // overlap whatsoever between any two tasks.
 TYPED_TEST_P(SequencedTaskRunnerTest, SequentialDelayedNonNestable) {
   const int kTaskCount = 20;
   const int kDelayIncrementMs = 50;
 
   this->delegate_.StartTaskRunner();
   const scoped_refptr<SequencedTaskRunner> task_runner =
       this->delegate_.GetTaskRunner();
 
   for (int i = 0; i < kTaskCount; ++i) {
     this->task_tracker_->PostWrappedDelayedNonNestableTask(
-        task_runner,
-        Closure(),
+        task_runner.get(), Closure(),
         TimeDelta::FromMilliseconds(kDelayIncrementMs * i));
   }
 
   this->task_tracker_->WaitForCompletedTasks(kTaskCount);
   this->delegate_.StopTaskRunner();
 
   EXPECT_TRUE(CheckNonNestableInvariants(this->task_tracker_->GetTaskEvents(),
                                          kTaskCount));
 }
 
 // This test posts a fast, non-nestable task from within each of a number of
 // slow, non-nestable tasks and checks that they all run in the sequence they
 // were posted in and that there is no execution overlap whatsoever.
 TYPED_TEST_P(SequencedTaskRunnerTest, NonNestablePostFromNonNestableTask) {
   const int kParentCount = 10;
   const int kChildrenPerParent = 10;
 
   this->delegate_.StartTaskRunner();
   const scoped_refptr<SequencedTaskRunner> task_runner =
       this->delegate_.GetTaskRunner();
 
   for (int i = 0; i < kParentCount; ++i) {
     Closure task = Bind(
         &internal::SequencedTaskTracker::PostNonNestableTasks,
         this->task_tracker_,
         task_runner,
         kChildrenPerParent);
-    this->task_tracker_->PostWrappedNonNestableTask(task_runner, task);
+    this->task_tracker_->PostWrappedNonNestableTask(task_runner.get(), task);
   }
 
   this->delegate_.StopTaskRunner();
 
   EXPECT_TRUE(CheckNonNestableInvariants(
       this->task_tracker_->GetTaskEvents(),
       kParentCount * (kChildrenPerParent + 1)));
 }
 
 // This test posts two tasks with the same delay, and checks that the tasks are
 // run in the order in which they were posted.
 //
 // NOTE: This is actually an approximate test since the API only takes a
 // "delay" parameter, so we are not exactly simulating two tasks that get
 // posted at the exact same time. It would be nice if the API allowed us to
 // specify the desired run time.
 TYPED_TEST_P(SequencedTaskRunnerTest, DelayedTasksSameDelay) {
   const int kTaskCount = 2;
   const TimeDelta kDelay = TimeDelta::FromMilliseconds(100);
 
   this->delegate_.StartTaskRunner();
   const scoped_refptr<SequencedTaskRunner> task_runner =
       this->delegate_.GetTaskRunner();
 
-  this->task_tracker_->PostWrappedDelayedNonNestableTask(
-      task_runner, Closure(), kDelay);
-  this->task_tracker_->PostWrappedDelayedNonNestableTask(
-      task_runner, Closure(), kDelay);
+  this->task_tracker_->PostWrappedDelayedNonNestableTask(task_runner.get(),
+                                                         Closure(), kDelay);
+  this->task_tracker_->PostWrappedDelayedNonNestableTask(task_runner.get(),
+                                                         Closure(), kDelay);
   this->task_tracker_->WaitForCompletedTasks(kTaskCount);
   this->delegate_.StopTaskRunner();
 
   EXPECT_TRUE(CheckNonNestableInvariants(this->task_tracker_->GetTaskEvents(),
                                          kTaskCount));
 }
 
 // This test posts a normal task and a delayed task, and checks that the
 // delayed task runs after the normal task even if the normal task takes
 // a long time to run.
 TYPED_TEST_P(SequencedTaskRunnerTest, DelayedTaskAfterLongTask) {
   const int kTaskCount = 2;
 
   this->delegate_.StartTaskRunner();
   const scoped_refptr<SequencedTaskRunner> task_runner =
       this->delegate_.GetTaskRunner();
 
   this->task_tracker_->PostWrappedNonNestableTask(
-      task_runner, base::Bind(&PlatformThread::Sleep,
-                              TimeDelta::FromMilliseconds(50)));
+      task_runner.get(),
+      base::Bind(&PlatformThread::Sleep, TimeDelta::FromMilliseconds(50)));
   this->task_tracker_->PostWrappedDelayedNonNestableTask(
-      task_runner, Closure(), TimeDelta::FromMilliseconds(10));
+      task_runner.get(), Closure(), TimeDelta::FromMilliseconds(10));
   this->task_tracker_->WaitForCompletedTasks(kTaskCount);
   this->delegate_.StopTaskRunner();
 
   EXPECT_TRUE(CheckNonNestableInvariants(this->task_tracker_->GetTaskEvents(),
                                          kTaskCount));
 }
 
 // Test that a pile of normal tasks and a delayed task run in the
 // time-to-run order.
 TYPED_TEST_P(SequencedTaskRunnerTest, DelayedTaskAfterManyLongTasks) {
   const int kTaskCount = 11;
 
   this->delegate_.StartTaskRunner();
   const scoped_refptr<SequencedTaskRunner> task_runner =
       this->delegate_.GetTaskRunner();
 
   for (int i = 0; i < kTaskCount - 1; i++) {
     this->task_tracker_->PostWrappedNonNestableTask(
-        task_runner, base::Bind(&PlatformThread::Sleep,
-                                TimeDelta::FromMilliseconds(50)));
+        task_runner.get(),
+        base::Bind(&PlatformThread::Sleep, TimeDelta::FromMilliseconds(50)));
   }
   this->task_tracker_->PostWrappedDelayedNonNestableTask(
-      task_runner, Closure(), TimeDelta::FromMilliseconds(10));
+      task_runner.get(), Closure(), TimeDelta::FromMilliseconds(10));
   this->task_tracker_->WaitForCompletedTasks(kTaskCount);
   this->delegate_.StopTaskRunner();
 
   EXPECT_TRUE(CheckNonNestableInvariants(this->task_tracker_->GetTaskEvents(),
                                          kTaskCount));
 }
 
 
 // TODO(francoisk777@gmail.com) Add a test, similiar to the above, which runs
 // some tasked nestedly (which should be implemented in the test
@@ skipping 22 matching lines @@
 // the specified time.
 TYPED_TEST_P(SequencedTaskRunnerDelayedTest, DelayedTaskBasic) {
   const int kTaskCount = 1;
   const TimeDelta kDelay = TimeDelta::FromMilliseconds(100);
 
   this->delegate_.StartTaskRunner();
   const scoped_refptr<SequencedTaskRunner> task_runner =
       this->delegate_.GetTaskRunner();
 
   Time time_before_run = Time::Now();
-  this->task_tracker_->PostWrappedDelayedNonNestableTask(task_runner, Closure(),
-                                                         kDelay);
+  this->task_tracker_->PostWrappedDelayedNonNestableTask(task_runner.get(),
+                                                         Closure(), kDelay);
   this->task_tracker_->WaitForCompletedTasks(kTaskCount);
   this->delegate_.StopTaskRunner();
   Time time_after_run = Time::Now();
 
   EXPECT_TRUE(CheckNonNestableInvariants(this->task_tracker_->GetTaskEvents(),
                                          kTaskCount));
   EXPECT_LE(kDelay, time_after_run - time_before_run);
 }
 
 // SequencedTaskRunnerDelayedTest tests that the |delay| parameter of
 // is used to actually wait for |delay| ms before executing the task.
 // This is not mandatory for a SequencedTaskRunner to be compliant.
 REGISTER_TYPED_TEST_CASE_P(SequencedTaskRunnerDelayedTest, DelayedTaskBasic);
 
 }  // namespace base
 
 #endif  // BASE_TEST_SEQUENCED_TASK_RUNNER_TEST_TEMPLATE_H_