Add a signal to the scheduler that a navigation is expected

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 "base/callback.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/test/ordered_simple_task_runner.h"
@@ skipping 290 matching lines @@
   }
 
   void ForceMainThreadScrollingUseCase() {
     cc::BeginFrameArgs begin_frame_args = cc::BeginFrameArgs::Create(
         BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
         base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL);
     begin_frame_args.on_critical_path = true;
     scheduler_->WillBeginFrame(begin_frame_args);
   }
 
+  void ForceTouchStartToBeExpectedSoon() {
+    scheduler_->DidHandleInputEventOnCompositorThread(
+        FakeInputEvent(blink::WebInputEvent::GestureScrollEnd),
+        RendererScheduler::InputEventState::EVENT_CONSUMED_BY_COMPOSITOR);
+    clock_->Advance(priority_escalation_after_input_duration() * 2);
+    scheduler_->ForceUpdatePolicy();
+  }
+
+  void SimulateExpensiveTasks(
+      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) {
+    // RunUntilIdle won't actually run all of the SimpleTestTickClock::Advance
+    // tasks unless we set AutoAdvanceNow to true :/
+    mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
+
+    // Simulate a bunch of expensive tasks
+    for (int i = 0; i < 10; i++) {
+      task_runner->PostTask(FROM_HERE,
+                            base::Bind(&base::SimpleTestTickClock::Advance,
+                                       base::Unretained(clock_.get()),
+                                       base::TimeDelta::FromMilliseconds(500)));
+    }
+
+    RunUntilIdle();
+
+    // Switch back to not auto-advancing because we want to be in control of
+    // when time advances.
+    mock_task_runner_->SetAutoAdvanceNowToPendingTasks(false);
+  }
+
   void EnableIdleTasks() { DoMainFrame(); }
 
   UseCase CurrentUseCase() {
     return scheduler_->MainThreadOnly().current_use_case;
   }
 
   UseCase ForceUpdatePolicyAndGetCurrentUseCase() {
     scheduler_->ForceUpdatePolicy();
     return scheduler_->MainThreadOnly().current_use_case;
   }
@@ skipping 384 matching lines @@
                                    std::string("D2"), std::string("C2"),
                                    std::string("I1")));
   EXPECT_EQ(RendererScheduler::UseCase::COMPOSITOR_GESTURE, CurrentUseCase());
 }
 
 TEST_F(
     RendererSchedulerImplTest,
     TestCompositorPolicy_ExpensiveTimersDontRunWhenMainThreadOnCriticalPath) {
   std::vector<std::string> run_order;
 
-  // RunUntilIdle won't actually run all of the SimpleTestTickClock::Advance
-  // tasks unless we set AutoAdvanceNow to true :/
-  mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
-
-  // Simulate a bunch of expensive timer tasks
-  for (int i = 0; i < 10; i++) {
-    timer_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&base::SimpleTestTickClock::Advance,
-                              base::Unretained(clock_.get()),
-                              base::TimeDelta::FromMilliseconds(500)));
-  }
-
-  RunUntilIdle();
-
-  // Switch back to not auto-advancing because we want to be in control of when
-  // time advances.
-  mock_task_runner_->SetAutoAdvanceNowToPendingTasks(false);
+  SimulateExpensiveTasks(timer_task_runner_);
 
   // Timers should now be disabled during main thread user user interactions.
   PostTestTasks(&run_order, "C1 T1");
 
   // Trigger main_thread_gesture UseCase
   scheduler_->DidAnimateForInputOnCompositorThread();
   cc::BeginFrameArgs begin_frame_args1 = cc::BeginFrameArgs::Create(
       BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
       base::TimeDelta::FromMilliseconds(16), cc::BeginFrameArgs::NORMAL);
   begin_frame_args1.on_critical_path = true;
   scheduler_->WillBeginFrame(begin_frame_args1);
   RunUntilIdle();
   EXPECT_EQ(RendererScheduler::UseCase::MAIN_THREAD_GESTURE, CurrentUseCase());
 
   EXPECT_THAT(run_order, testing::ElementsAre(std::string("C1")));
   clock_->Advance(subsequent_input_expected_after_input_duration() * 2);
 
   run_order.clear();
   RunUntilIdle();
   EXPECT_EQ(RendererScheduler::UseCase::NONE, CurrentUseCase());
   EXPECT_THAT(run_order, testing::ElementsAre(std::string("T1")));
 }
 
 TEST_F(RendererSchedulerImplTest, Navigation_ResetsTaskCostEstimations) {
   std::vector<std::string> run_order;
 
-  // RunUntilIdle won't actually run all of the SimpleTestTickClock::Advance
-  // tasks unless we set AutoAdvanceNow to true :/
-  mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
-
-  // Simulate a bunch of expensive timer tasks
-  for (int i = 0; i < 10; i++) {
-    timer_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&base::SimpleTestTickClock::Advance,
-                              base::Unretained(clock_.get()),
-                              base::TimeDelta::FromMilliseconds(500)));
-  }
-
-  RunUntilIdle();
-
-  // Switch back to not auto-advancing because we want to be in control of when
-  // time advances.
-  mock_task_runner_->SetAutoAdvanceNowToPendingTasks(false);
-
-  scheduler_->OnPageLoadStarted();
+  SimulateExpensiveTasks(timer_task_runner_);
+  scheduler_->OnNavigationStarted();
   PostTestTasks(&run_order, "C1 T1");
 
   scheduler_->DidAnimateForInputOnCompositorThread();
   cc::BeginFrameArgs begin_frame_args1 = cc::BeginFrameArgs::Create(
       BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
       base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL);
   begin_frame_args1.on_critical_path = true;
   scheduler_->WillBeginFrame(begin_frame_args1);
   scheduler_->DidCommitFrameToCompositor();  // Starts Idle Period
   RunUntilIdle();
@@ skipping 122 matching lines @@
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("L1"), std::string("T1"),
                                    std::string("T2")));
 }
 
 // TODO(alexclarke): Reenable once we've reinstaed the Loading UseCase.
 TEST_F(RendererSchedulerImplTest, DISABLED_LoadingUseCase) {
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "I1 D1 C1 T1 L1 D2 C2 T2 L2");
 
-  scheduler_->OnPageLoadStarted();
+  scheduler_->OnNavigationStarted();
   EnableIdleTasks();
   RunUntilIdle();
 
   // In loading policy, loading tasks are prioritized other others.
   std::string loading_policy_expected[] = {
       std::string("D1"), std::string("L1"), std::string("D2"),
       std::string("L2"), std::string("C1"), std::string("T1"),
       std::string("C2"), std::string("T2"), std::string("I1")};
   EXPECT_THAT(run_order, testing::ElementsAreArray(loading_policy_expected));
   EXPECT_EQ(RendererScheduler::UseCase::LOADING, CurrentUseCase());
@@ skipping 1049 matching lines @@
   run_order.clear();
   PostTestTasks(&run_order, "T6");
   RunUntilIdle();
   EXPECT_THAT(run_order, testing::ElementsAre(std::string("T6")));
 }
 
 TEST_F(RendererSchedulerImplTest,
        ExpensiveLoadingTasksNotBlockedTillFirstBeginMainFrame) {
   std::vector<std::string> run_order;
 
-  // RunUntilIdle won't actually run all of the SimpleTestTickClock::Advance
-  // tasks unless we set AutoAdvanceNow to true :/
-  mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
-
-  // Simulate a bunch of expensive loading tasks
-  for (int i = 0; i < 10; i++) {
-    loading_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&base::SimpleTestTickClock::Advance,
-                              base::Unretained(clock_.get()),
-                              base::TimeDelta::FromMilliseconds(500)));
-  }
-
-  RunUntilIdle();
-
+  SimulateExpensiveTasks(loading_task_runner_);
+  ForceTouchStartToBeExpectedSoon();
   PostTestTasks(&run_order, "L1 D1");
   RunUntilIdle();
 
   EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
   EXPECT_FALSE(HaveSeenABeginMainframe());
   EXPECT_TRUE(LoadingTasksSeemExpensive());
   EXPECT_FALSE(TimerTasksSeemExpensive());
+  EXPECT_TRUE(TouchStartExpectedSoon());
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("L1"), std::string("D1")));
 
   // Emit a BeginMainFrame, and the loading task should get blocked.
   DoMainFrame();
   run_order.clear();
 
   PostTestTasks(&run_order, "L1 D1");
+  RunUntilIdle();
+
+  EXPECT_EQ(RendererScheduler::UseCase::NONE, CurrentUseCase());
+  EXPECT_TRUE(HaveSeenABeginMainframe());
+  EXPECT_TRUE(LoadingTasksSeemExpensive());
+  EXPECT_FALSE(TimerTasksSeemExpensive());
+  EXPECT_TRUE(TouchStartExpectedSoon());
+  EXPECT_THAT(run_order, testing::ElementsAre(std::string("D1")));
+}
+
+TEST_F(RendererSchedulerImplTest,
+       ExpensiveLoadingTasksNotBlockedIfNavigationExpected) {
+  std::vector<std::string> run_order;
+
+  DoMainFrame();
+  SimulateExpensiveTasks(loading_task_runner_);
+  ForceTouchStartToBeExpectedSoon();
+  scheduler_->AddPendingNavigation();
+
+  PostTestTasks(&run_order, "L1 D1");
+  RunUntilIdle();
+
+  EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
+  EXPECT_TRUE(HaveSeenABeginMainframe());
+  EXPECT_TRUE(LoadingTasksSeemExpensive());
+  EXPECT_FALSE(TimerTasksSeemExpensive());
+  EXPECT_TRUE(TouchStartExpectedSoon());
+  EXPECT_THAT(run_order,
+              testing::ElementsAre(std::string("L1"), std::string("D1")));
+
+  // After the nagigation has been cancelled, the expensive loading tasks should
+  // get blocked.
+  scheduler_->RemovePendingNavigation();
+  run_order.clear();
+
+  PostTestTasks(&run_order, "L1 D1");
   RunUntilIdle();
 
   EXPECT_EQ(RendererScheduler::UseCase::NONE, CurrentUseCase());
   EXPECT_TRUE(HaveSeenABeginMainframe());
   EXPECT_TRUE(LoadingTasksSeemExpensive());
   EXPECT_FALSE(TimerTasksSeemExpensive());
+  EXPECT_TRUE(TouchStartExpectedSoon());
+  EXPECT_THAT(run_order, testing::ElementsAre(std::string("D1")));
+}
+
+TEST_F(
+    RendererSchedulerImplTest,
+    ExpensiveLoadingTasksNotBlockedIfNavigationExpected_MultipleNavigations) {
+  std::vector<std::string> run_order;
+
+  DoMainFrame();
+  SimulateExpensiveTasks(loading_task_runner_);
+  ForceTouchStartToBeExpectedSoon();
+  scheduler_->AddPendingNavigation();
+  scheduler_->AddPendingNavigation();
+
+  PostTestTasks(&run_order, "L1 D1");
+  RunUntilIdle();
+
+  EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
+  EXPECT_TRUE(HaveSeenABeginMainframe());
+  EXPECT_TRUE(LoadingTasksSeemExpensive());
+  EXPECT_FALSE(TimerTasksSeemExpensive());
+  EXPECT_TRUE(TouchStartExpectedSoon());
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("L1"), std::string("D1")));
+
+
+  run_order.clear();
+  scheduler_->RemovePendingNavigation();
+  // Navigation task expected ref count non-zero so expensive tasks still not
+  // blocked.
+  PostTestTasks(&run_order, "L1 D1");
+  RunUntilIdle();
+
+  EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
+  EXPECT_TRUE(HaveSeenABeginMainframe());
+  EXPECT_TRUE(LoadingTasksSeemExpensive());
+  EXPECT_FALSE(TimerTasksSeemExpensive());
+  EXPECT_TRUE(TouchStartExpectedSoon());
+  EXPECT_THAT(run_order,
+              testing::ElementsAre(std::string("L1"), std::string("D1")));
+
+
+  run_order.clear();
+  scheduler_->RemovePendingNavigation();
+  // Navigation task expected ref count is now zero, the expensive loading tasks
+  // should get blocked.
+  PostTestTasks(&run_order, "L1 D1");
+  RunUntilIdle();
+
+  EXPECT_EQ(RendererScheduler::UseCase::NONE, CurrentUseCase());
+  EXPECT_TRUE(HaveSeenABeginMainframe());
+  EXPECT_TRUE(LoadingTasksSeemExpensive());
+  EXPECT_FALSE(TimerTasksSeemExpensive());
+  EXPECT_TRUE(TouchStartExpectedSoon());
+  EXPECT_THAT(run_order, testing::ElementsAre(std::string("D1")));
 }
 
+
 }  // namespace scheduler