scheduler: Disable expensive task blocking policy in M48

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 886 matching lines @@
   SimulateMainThreadGestureStart(TouchEventPolicy::DONT_SEND_TOUCH_START,
                                  blink::WebInputEvent::GestureScrollBegin);
   scheduler_->DidCommitFrameToCompositor();  // Starts Idle Period
   RunUntilIdle();
 
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("C1"), std::string("T1")));
 }
 
 TEST_F(RendererSchedulerImplTest,
-       ExpensiveTimersDontRunWhenMainThreadScrolling) {
+       ExpensiveTimersDontRunWhenMainThreadScrolling_DISABLED) {
   std::vector<std::string> run_order;
 
   scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
   SimulateExpensiveTasks(timer_task_runner_);
   DoMainFrame();
   SimulateMainThreadGestureStart(TouchEventPolicy::SEND_TOUCH_START,
                                  blink::WebInputEvent::GestureScrollBegin);
 
   // Timers should now be disabled during main thread user user interactions.
   PostTestTasks(&run_order, "C1 T1");
@@ skipping 12 matching lines @@
 
   clock_->Advance(subsequent_input_expected_after_input_duration() * 2);
 
   run_order.clear();
   RunUntilIdle();
   EXPECT_FALSE(TouchStartExpectedSoon());
   EXPECT_EQ(RendererScheduler::UseCase::NONE, CurrentUseCase());
   EXPECT_THAT(run_order, testing::ElementsAre(std::string("T1")));
 }
 
-TEST_F(RendererSchedulerImplTest,
-       ExpensiveTimersDontRunWhenMainThreadScrolling_AndOnCriticalPath) {
+TEST_F(
+    RendererSchedulerImplTest,
+    ExpensiveTimersDontRunWhenMainThreadScrolling_AndOnCriticalPath_DISABLED) {
   std::vector<std::string> run_order;
 
   scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
   SimulateExpensiveTasks(timer_task_runner_);
   DoMainFrameOnCriticalPath();
   SimulateMainThreadGestureStart(TouchEventPolicy::SEND_TOUCH_START,
                                  blink::WebInputEvent::GestureScrollBegin);
 
   // Timers should now be disabled during main thread user user interactions.
   PostTestTasks(&run_order, "C1 T1");
@@ skipping 1157 matching lines @@
               testing::ElementsAre(std::string("T4"), std::string("T5")));
 
   // Subsequent timer tasks should fire as usual.
   run_order.clear();
   PostTestTasks(&run_order, "T6");
   RunUntilIdle();
   EXPECT_THAT(run_order, testing::ElementsAre(std::string("T6")));
 }
 
 TEST_F(RendererSchedulerImplTest,
-       ExpensiveLoadingTasksNotBlockedTillFirstBeginMainFrame) {
+       ExpensiveLoadingTasksNotBlockedTillFirstBeginMainFrame_DISABLED) {
   std::vector<std::string> run_order;
 
   EnableTaskBlocking();
   scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
   SimulateExpensiveTasks(loading_task_runner_);
   ForceTouchStartToBeExpectedSoon();
   PostTestTasks(&run_order, "L1 D1");
   RunUntilIdle();
 
   EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
@@ skipping 33 matching lines @@
 
   EXPECT_EQ(UseCase::NONE, ForceUpdatePolicyAndGetCurrentUseCase());
   EXPECT_TRUE(HaveSeenABeginMainframe());
   EXPECT_TRUE(LoadingTasksSeemExpensive());
   EXPECT_FALSE(TimerTasksSeemExpensive());
   EXPECT_FALSE(TouchStartExpectedSoon());
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("L1"), std::string("D1")));
 }
 
-TEST_F(RendererSchedulerImplTest, ExpensiveTimerTaskBlocked) {
+TEST_F(RendererSchedulerImplTest, ExpensiveTimerTaskBlocked_DISABLED) {
   std::vector<std::string> run_order;
 
   EnableTaskBlocking();
   scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
   DoMainFrame();
   SimulateExpensiveTasks(timer_task_runner_);
   ForceTouchStartToBeExpectedSoon();
 
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::GestureFlingStart),
@@ skipping 29 matching lines @@
             ForceUpdatePolicyAndGetCurrentUseCase());
   EXPECT_TRUE(HaveSeenABeginMainframe());
   EXPECT_FALSE(LoadingTasksSeemExpensive());
   EXPECT_TRUE(TimerTasksSeemExpensive());
   EXPECT_TRUE(TouchStartExpectedSoon());
   EXPECT_THAT(run_order, testing::ElementsAre(std::string("T1"),
                                               std::string("D1")));
 }
 
 TEST_F(RendererSchedulerImplTest,
-       ExpensiveTimerTaskNotBlocked_IfBeginMainFrameNotExpectedSoon) {
+       ExpensiveTimerTaskNotBlocked_IfBeginMainFrameNotExpectedSoon_DISABLED) {
   std::vector<std::string> run_order;
 
   EnableTaskBlocking();
   scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
   DoMainFrame();
   SimulateExpensiveTasks(timer_task_runner_);
   ForceTouchStartToBeExpectedSoon();
   scheduler_->BeginFrameNotExpectedSoon();
 
   scheduler_->DidHandleInputEventOnCompositorThread(
       FakeInputEvent(blink::WebInputEvent::GestureFlingStart),
       RendererScheduler::InputEventState::EVENT_FORWARDED_TO_MAIN_THREAD);
   PostTestTasks(&run_order, "T1 D1");
   RunUntilIdle();
 
   EXPECT_EQ(UseCase::MAIN_THREAD_GESTURE,
             ForceUpdatePolicyAndGetCurrentUseCase());
   EXPECT_TRUE(HaveSeenABeginMainframe());
   EXPECT_FALSE(LoadingTasksSeemExpensive());
   EXPECT_FALSE(TimerTasksSeemExpensive());
   EXPECT_TRUE(TouchStartExpectedSoon());
   EXPECT_THAT(run_order,
               testing::ElementsAre(std::string("T1"), std::string("D1")));
 }
 
 TEST_F(RendererSchedulerImplTest,
-       ExpensiveLoadingTasksNotBlockedIfNavigationExpected) {
+       ExpensiveLoadingTasksNotBlockedIfNavigationExpected_DISABLED) {
   std::vector<std::string> run_order;
 
   EnableTaskBlocking();
   DoMainFrame();
   scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
   SimulateExpensiveTasks(loading_task_runner_);
   ForceTouchStartToBeExpectedSoon();
   scheduler_->AddPendingNavigation();
 
   PostTestTasks(&run_order, "L1 D1");
@@ skipping 18 matching lines @@
   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) {
+    ExpensiveLoadingTasksNotBlockedIfNavigationExpected_MultipleNavigations_DISABLED) {
   std::vector<std::string> run_order;
 
   EnableTaskBlocking();
   DoMainFrame();
   scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
   SimulateExpensiveTasks(loading_task_runner_);
   ForceTouchStartToBeExpectedSoon();
   scheduler_->AddPendingNavigation();
   scheduler_->AddPendingNavigation();
 
@@ skipping 95 matching lines @@
     EXPECT_FALSE(LoadingTasksSeemExpensive()) << " i = " << i;
     EXPECT_FALSE(TimerTasksSeemExpensive()) << " i = " << i;
 
     base::TimeDelta time_till_next_frame =
         EstimatedNextFrameBegin() - clock_->NowTicks();
     if (time_till_next_frame > base::TimeDelta())
       clock_->Advance(time_till_next_frame);
   }
 }
 
-TEST_F(RendererSchedulerImplTest, ExpensiveTimer_Blocked) {
+TEST_F(RendererSchedulerImplTest, ExpensiveTimer_Blocked_DISABLED) {
   EnableTaskBlocking();
   scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
   SimulateMainThreadGestureStart(TouchEventPolicy::SEND_TOUCH_START,
                                  blink::WebInputEvent::TouchMove);
   RunUntilIdle();
   for (int i = 0; i < 20; i++) {
     simulate_timer_task_ran_ = false;
 
     cc::BeginFrameArgs begin_frame_args = cc::BeginFrameArgs::Create(
         BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),
@@ skipping 24 matching lines @@
     }
 
     base::TimeDelta time_till_next_frame =
         EstimatedNextFrameBegin() - clock_->NowTicks();
     if (time_till_next_frame > base::TimeDelta())
       clock_->Advance(time_till_next_frame);
   }
 }
 
 }  // namespace scheduler