NOT FOR COMMIT: Move background pausing to the WebView level

third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl_unittest.cc

Index: third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl_unittest.cc
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl_unittest.cc b/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl_unittest.cc
index f2f6239d3c1d6061ea0127e300209ff10c71f3ad..cb26acce9846681456b4a4a99875f64d3ebbb8c9 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl_unittest.cc
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl_unittest.cc
@@ -2348,94 +2348,146 @@ TEST_F(RendererSchedulerImplTest, MultipleSuspendsNeedMultipleResumes) {
               testing::ElementsAre(std::string("T1"), std::string("T2")));
 }
 
-TEST_F(RendererSchedulerImplTest, SuspendRenderer) {
-  // Assume that the renderer is backgrounded.
-  scheduler_->OnRendererBackgrounded();
-
-  // Tasks in some queues don't fire when the renderer is suspended.
-  std::vector<std::string> run_order;
-  PostTestTasks(&run_order, "D1 C1 L1 I1 T1");
-  scheduler_->SuspendRenderer();
-  EnableIdleTasks();
-  RunUntilIdle();
-  EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("D1"), std::string("C1"),
-                                   std::string("I1")));
-
-  // The rest queued tasks fire when the tab goes foregrounded.
-  run_order.clear();
-  scheduler_->OnRendererForegrounded();
-  RunUntilIdle();
-  EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("L1"), std::string("T1")));
-
-  run_order.clear();
-  PostTestTasks(&run_order, "D2 T2");
-  // The renderer is foregrounded. Suspending doesn't take effect.
-  scheduler_->SuspendRenderer();
-  RunUntilIdle();
-  EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("D2"), std::string("T2")));
-}
-
-TEST_F(RendererSchedulerImplTest, ResumeRenderer) {
-  ScopedAutoAdvanceNowEnabler enable_auto_advance_now(mock_task_runner_);
-
-  // Assume that the renderer is backgrounded.
-  scheduler_->OnRendererBackgrounded();
-
-  // Tasks in some queues don't fire when the renderer is suspended.
-  std::vector<std::string> run_order;
-  PostTestTasks(&run_order, "D1 C1 L1 I1 T1");
-  scheduler_->SuspendRenderer();
-  EnableIdleTasks();
-  RunUntilIdle();
-  EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("D1"), std::string("C1"),
-                                   std::string("I1")));
-
-  // The rest queued tasks fire when the renderer is resumed.
-  run_order.clear();
-  scheduler_->ResumeRenderer();
-  RunUntilIdle();
-  EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("L1"), std::string("T1")));
-
-  run_order.clear();
-  // No crash occurs when the renderer is suspended again, and
-  // tasks in some queues don't fire because of suspended.
-  PostTestTasks(&run_order, "D2 C2 L2 I2 T2");
-  scheduler_->SuspendRenderer();
-  EnableIdleTasks();
-  RunUntilIdle();
-  EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("D2"), std::string("C2"),
-                                   std::string("I2")));
-
-  // The rest queued tasks fire when the renderer is resumed.
-  run_order.clear();
-  scheduler_->ResumeRenderer();
-  RunUntilIdle();
-  EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("L2"), std::string("T2")));
-
-  run_order.clear();
-  PostTestTasks(&run_order, "D3 T3");
-  // No crash occurs when the resumed renderer goes foregrounded.
-  // Posted tasks while the renderer is resumed fire.
-  scheduler_->OnRendererForegrounded();
-  RunUntilIdle();
-  EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("D3"), std::string("T3")));
-
-  run_order.clear();
-  PostTestTasks(&run_order, "D4 T4");
-  // The renderer is foregrounded. Resuming doesn't take effect.
-  scheduler_->ResumeRenderer();
-  RunUntilIdle();
-  EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("D4"), std::string("T4")));
-}
+// TODO(ojan): Port these.
+
+// TEST_F(RendererSchedulerImplTest, SuspendRenderer) {
+//   // Assume that the renderer is backgrounded.
+//   scheduler_->OnRendererBackgrounded();
+
+//   // Tasks in some queues don't fire when the renderer is suspended.
+//   std::vector<std::string> run_order;
+//   PostTestTasks(&run_order, "D1 C1 L1 I1 T1");
+//   scheduler_->SuspendRenderer();
+//   EnableIdleTasks();
+//   RunUntilIdle();
+//   EXPECT_THAT(run_order,
+//               testing::ElementsAre(std::string("D1"), std::string("C1"),
+//                                    std::string("I1")));
+
+//   // The rest queued tasks fire when the tab goes foregrounded.
+//   run_order.clear();
+//   scheduler_->OnRendererForegrounded();
+//   RunUntilIdle();
+//   EXPECT_THAT(run_order,
+//               testing::ElementsAre(std::string("L1"), std::string("T1")));
+
+//   run_order.clear();
+//   PostTestTasks(&run_order, "D2 T2");
+//   // The renderer is foregrounded. Suspending doesn't take effect.
+//   scheduler_->SuspendRenderer();
+//   RunUntilIdle();
+//   EXPECT_THAT(run_order,
+//               testing::ElementsAre(std::string("D2"), std::string("T2")));
+// }
+
+// TEST_F(RendererSchedulerImplTest, ResumeRenderer) {
+//   ScopedAutoAdvanceNowEnabler enable_auto_advance_now(mock_task_runner_);
+
+//   // Assume that the renderer is backgrounded.
+//   scheduler_->OnRendererBackgrounded();
+
+//   // Tasks in some queues don't fire when the renderer is suspended.
+//   std::vector<std::string> run_order;
+//   PostTestTasks(&run_order, "D1 C1 L1 I1 T1");
+//   scheduler_->SuspendRenderer();
+//   EnableIdleTasks();
+//   RunUntilIdle();
+//   EXPECT_THAT(run_order,
+//               testing::ElementsAre(std::string("D1"), std::string("C1"),
+//                                    std::string("I1")));
+
+//   // The rest queued tasks fire when the renderer is resumed.
+//   run_order.clear();
+//   scheduler_->ResumeRenderer();
+//   RunUntilIdle();
+//   EXPECT_THAT(run_order,
+//               testing::ElementsAre(std::string("L1"), std::string("T1")));
+
+//   run_order.clear();
+//   // No crash occurs when the renderer is suspended again, and
+//   // tasks in some queues don't fire because of suspended.
+//   PostTestTasks(&run_order, "D2 C2 L2 I2 T2");
+//   scheduler_->SuspendRenderer();
+//   EnableIdleTasks();
+//   RunUntilIdle();
+//   EXPECT_THAT(run_order,
+//               testing::ElementsAre(std::string("D2"), std::string("C2"),
+//                                    std::string("I2")));
+
+//   // The rest queued tasks fire when the renderer is resumed.
+//   run_order.clear();
+//   scheduler_->ResumeRenderer();
+//   RunUntilIdle();
+//   EXPECT_THAT(run_order,
+//               testing::ElementsAre(std::string("L2"), std::string("T2")));
+
+//   run_order.clear();
+//   PostTestTasks(&run_order, "D3 T3");
+//   // No crash occurs when the resumed renderer goes foregrounded.
+//   // Posted tasks while the renderer is resumed fire.
+//   scheduler_->OnRendererForegrounded();
+//   RunUntilIdle();
+//   EXPECT_THAT(run_order,
+//               testing::ElementsAre(std::string("D3"), std::string("T3")));
+
+//   run_order.clear();
+//   PostTestTasks(&run_order, "D4 T4");
+//   // The renderer is foregrounded. Resuming doesn't take effect.
+//   scheduler_->ResumeRenderer();
+//   RunUntilIdle();
+//   EXPECT_THAT(run_order,
+//               testing::ElementsAre(std::string("D4"), std::string("T4")));
+// }
+
+// TEST_F(RendererSchedulerImplTest, TestRendererBackgroundedTimerSuspension) {
+//   scheduler_->SetTimerQueueSuspensionWhenBackgroundedEnabled(true);
+
+//   std::vector<std::string> run_order;
+//   PostTestTasks(&run_order, "T1 T2");
+
+//   base::TimeTicks now;
+
+//   // The background signal will not immediately suspend the timer queue.
+//   scheduler_->OnRendererBackgrounded();
+//   now += base::TimeDelta::FromMilliseconds(1100);
+//   clock_->SetNowTicks(now);
+//   RunUntilIdle();
+//   EXPECT_THAT(run_order,
+//               testing::ElementsAre(std::string("T1"), std::string("T2")));
+
+//   run_order.clear();
+//   PostTestTasks(&run_order, "T3");
+
+//   now += base::TimeDelta::FromSeconds(1);
+//   clock_->SetNowTicks(now);
+//   RunUntilIdle();
+//   EXPECT_THAT(run_order, testing::ElementsAre(std::string("T3")));
+
+//   // Advance the time until after the scheduled timer queue suspension.
+//   now = base::TimeTicks() + suspend_timers_when_backgrounded_delay() +
+//         base::TimeDelta::FromMilliseconds(10);
+//   run_order.clear();
+//   clock_->SetNowTicks(now);
+//   RunUntilIdle();
+//   ASSERT_TRUE(run_order.empty());
+
+//   // Timer tasks should be suspended until the foregrounded signal.
+//   PostTestTasks(&run_order, "T4 T5");
+//   now += base::TimeDelta::FromSeconds(10);
+//   RunUntilIdle();
+//   EXPECT_TRUE(run_order.empty());
+
+//   scheduler_->OnRendererForegrounded();
+//   RunUntilIdle();
+//   EXPECT_THAT(run_order,
+//               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, UseCaseToString) {
   CheckAllUseCaseToString();
@@ -2474,56 +2526,6 @@ TEST_F(RendererSchedulerImplTest, ShutdownPreventsPostingOfNewTasks) {
   EXPECT_TRUE(run_order.empty());
 }
 
-TEST_F(RendererSchedulerImplTest, TestRendererBackgroundedTimerSuspension) {
-  scheduler_->SetTimerQueueSuspensionWhenBackgroundedEnabled(true);
-
-  std::vector<std::string> run_order;
-  PostTestTasks(&run_order, "T1 T2");
-
-  base::TimeTicks now;
-
-  // The background signal will not immediately suspend the timer queue.
-  scheduler_->OnRendererBackgrounded();
-  now += base::TimeDelta::FromMilliseconds(1100);
-  clock_->SetNowTicks(now);
-  RunUntilIdle();
-  EXPECT_THAT(run_order,
-              testing::ElementsAre(std::string("T1"), std::string("T2")));
-
-  run_order.clear();
-  PostTestTasks(&run_order, "T3");
-
-  now += base::TimeDelta::FromSeconds(1);
-  clock_->SetNowTicks(now);
-  RunUntilIdle();
-  EXPECT_THAT(run_order, testing::ElementsAre(std::string("T3")));
-
-  // Advance the time until after the scheduled timer queue suspension.
-  now = base::TimeTicks() + suspend_timers_when_backgrounded_delay() +
-        base::TimeDelta::FromMilliseconds(10);
-  run_order.clear();
-  clock_->SetNowTicks(now);
-  RunUntilIdle();
-  ASSERT_TRUE(run_order.empty());
-
-  // Timer tasks should be suspended until the foregrounded signal.
-  PostTestTasks(&run_order, "T4 T5");
-  now += base::TimeDelta::FromSeconds(10);
-  RunUntilIdle();
-  EXPECT_TRUE(run_order.empty());
-
-  scheduler_->OnRendererForegrounded();
-  RunUntilIdle();
-  EXPECT_THAT(run_order,
-              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) {
   std::vector<std::string> run_order;