Add RetainedRef uses where needed.

components/scheduler/renderer/renderer_scheduler_impl_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/renderer/renderer_scheduler_impl.h"
 
 #include <utility>
 
 #include "base/callback.h"
 #include "base/macros.h"
@@ skipping 580 matching lines @@
   PostTestTasks(&run_order, "D1 C1");
   RunUntilIdle();
   EXPECT_THAT(run_order, testing::Contains("D1"));
   EXPECT_THAT(run_order, testing::Contains("C1"));
 }
 
 TEST_F(RendererSchedulerImplTest, TestRentrantTask) {
   int count = 0;
   std::vector<int> run_order;
   default_task_runner_->PostTask(
-      FROM_HERE, base::Bind(AppendToVectorReentrantTask, default_task_runner_,
-                            &run_order, &count, 5));
+      FROM_HERE, base::Bind(AppendToVectorReentrantTask,
+                            base::RetainedRef(default_task_runner_), &run_order,
+                            &count, 5));
   RunUntilIdle();
 
   EXPECT_THAT(run_order, testing::ElementsAre(0, 1, 2, 3, 4));
 }
 
 TEST_F(RendererSchedulerImplTest, TestPostIdleTask) {
   int run_count = 0;
   base::TimeTicks expected_deadline =
       clock_->NowTicks() + base::TimeDelta::FromMilliseconds(2300);
   base::TimeTicks deadline_in_task;
@@ skipping 24 matching lines @@
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
   EXPECT_EQ(expected_deadline, deadline_in_task);
 }
 
 TEST_F(RendererSchedulerImplTest, TestRepostingIdleTask) {
   int run_count = 0;
 
   max_idle_task_reposts = 2;
   idle_task_runner_->PostIdleTask(
-      FROM_HERE,
-      base::Bind(&RepostingIdleTestTask, idle_task_runner_, &run_count));
+      FROM_HERE, base::Bind(&RepostingIdleTestTask,
+                            base::RetainedRef(idle_task_runner_), &run_count));
   EnableIdleTasks();
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
 
   // Reposted tasks shouldn't run until next idle period.
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
 
   EnableIdleTasks();
   RunUntilIdle();
@@ skipping 761 matching lines @@
   EXPECT_FALSE(is_anticipated_before);
   EXPECT_FALSE(is_anticipated_after);
 }
 
 TEST_F(RendererSchedulerImplTest, TestShouldYield) {
   bool should_yield_before = false;
   bool should_yield_after = false;
 
   default_task_runner_->PostTask(
       FROM_HERE, base::Bind(&PostingYieldingTestTask, scheduler_.get(),
-                            default_task_runner_, false, &should_yield_before,
-                            &should_yield_after));
+                            base::RetainedRef(default_task_runner_), false,
+                            &should_yield_before, &should_yield_after));
   RunUntilIdle();
   // Posting to default runner shouldn't cause yielding.
   EXPECT_FALSE(should_yield_before);
   EXPECT_FALSE(should_yield_after);
 
   default_task_runner_->PostTask(
       FROM_HERE, base::Bind(&PostingYieldingTestTask, scheduler_.get(),
-                            compositor_task_runner_, false,
+                            base::RetainedRef(compositor_task_runner_), false,
                             &should_yield_before, &should_yield_after));
   RunUntilIdle();
   // Posting while not mainthread scrolling shouldn't cause yielding.
   EXPECT_FALSE(should_yield_before);
   EXPECT_FALSE(should_yield_after);
 
   default_task_runner_->PostTask(
       FROM_HERE, base::Bind(&PostingYieldingTestTask, scheduler_.get(),
-                            compositor_task_runner_, true, &should_yield_before,
-                            &should_yield_after));
+                            base::RetainedRef(compositor_task_runner_), true,
+                            &should_yield_before, &should_yield_after));
   RunUntilIdle();
   // We should be able to switch to compositor priority mid-task.
   EXPECT_FALSE(should_yield_before);
   EXPECT_TRUE(should_yield_after);
 }
 
 TEST_F(RendererSchedulerImplTest, TestShouldYield_TouchStart) {
   // Receiving a touchstart should immediately trigger yielding, even if
   // there's no immediately pending work in the compositor queue.
   EXPECT_FALSE(scheduler_->ShouldYieldForHighPriorityWork());
@@ skipping 364 matching lines @@
 
 TEST_F(RendererSchedulerImplTest, TestLongIdlePeriodRepeating) {
   mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
   std::vector<base::TimeTicks> actual_deadlines;
   int run_count = 0;
 
   max_idle_task_reposts = 3;
   base::TimeTicks clock_before(clock_->NowTicks());
   base::TimeDelta idle_task_runtime(base::TimeDelta::FromMilliseconds(10));
   idle_task_runner_->PostIdleTask(
-      FROM_HERE, base::Bind(&RepostingUpdateClockIdleTestTask,
-                            idle_task_runner_, &run_count, clock_.get(),
-                            idle_task_runtime, &actual_deadlines));
+      FROM_HERE,
+      base::Bind(&RepostingUpdateClockIdleTestTask,
+                 base::RetainedRef(idle_task_runner_), &run_count, clock_.get(),
+                 idle_task_runtime, &actual_deadlines));
   scheduler_->BeginFrameNotExpectedSoon();
   RunUntilIdle();
   EXPECT_EQ(3, run_count);
   EXPECT_THAT(
       actual_deadlines,
       testing::ElementsAre(
           clock_before + maximum_idle_period_duration(),
           clock_before + idle_task_runtime + maximum_idle_period_duration(),
           clock_before + (2 * idle_task_runtime) +
               maximum_idle_period_duration()));
 
   // Check that idle tasks don't run after the idle period ends with a
   // new BeginMainFrame.
   max_idle_task_reposts = 5;
   idle_task_runner_->PostIdleTask(
-      FROM_HERE, base::Bind(&RepostingUpdateClockIdleTestTask,
-                            idle_task_runner_, &run_count, clock_.get(),
-                            idle_task_runtime, &actual_deadlines));
+      FROM_HERE,
+      base::Bind(&RepostingUpdateClockIdleTestTask,
+                 base::RetainedRef(idle_task_runner_), &run_count, clock_.get(),
+                 idle_task_runtime, &actual_deadlines));
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&WillBeginFrameIdleTask,
                             base::Unretained(scheduler_.get()), clock_.get()));
   RunUntilIdle();
   EXPECT_EQ(4, run_count);
 }
 
 TEST_F(RendererSchedulerImplTest, TestLongIdlePeriodDoesNotWakeScheduler) {
   base::TimeTicks deadline_in_task;
   int run_count = 0;
@@ skipping 108 matching lines @@
       BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
       base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));
   EXPECT_FALSE(scheduler_->CanExceedIdleDeadlineIfRequired());
 }
 
 TEST_F(RendererSchedulerImplTest, TestRendererHiddenIdlePeriod) {
   int run_count = 0;
 
   max_idle_task_reposts = 2;
   idle_task_runner_->PostIdleTask(
-      FROM_HERE,
-      base::Bind(&RepostingIdleTestTask, idle_task_runner_, &run_count));
+      FROM_HERE, base::Bind(&RepostingIdleTestTask,
+                            base::RetainedRef(idle_task_runner_), &run_count));
 
   // Renderer should start in visible state.
   RunUntilIdle();
   EXPECT_EQ(0, run_count);
 
   // When we hide the renderer it should start a max deadline idle period, which
   // will run an idle task and then immediately start a new idle period, which
   // runs the second idle task.
   scheduler_->SetAllRenderWidgetsHidden(true);
   RunUntilIdle();
   EXPECT_EQ(2, run_count);
 
   // Advance time by amount of time by the maximum amount of time we execute
   // idle tasks when hidden (plus some slack) - idle period should have ended.
   max_idle_task_reposts = 3;
   idle_task_runner_->PostIdleTask(
-      FROM_HERE,
-      base::Bind(&RepostingIdleTestTask, idle_task_runner_, &run_count));
+      FROM_HERE, base::Bind(&RepostingIdleTestTask,
+                            base::RetainedRef(idle_task_runner_), &run_count));
   clock_->Advance(end_idle_when_hidden_delay() +
                   base::TimeDelta::FromMilliseconds(10));
   RunUntilIdle();
   EXPECT_EQ(2, run_count);
 }
 
 TEST_F(RendererSchedulerImplTest, TimerQueueEnabledByDefault) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "T1 T2");
   RunUntilIdle();
@@ skipping 784 matching lines @@
 
   // Make sure TouchStart causes a policy change.
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::TouchStart),
       RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
   EXPECT_EQ(RendererScheduler::UseCase::TOUCHSTART,
             ForceUpdatePolicyAndGetCurrentUseCase());
 }
 
 }  // namespace scheduler