Purge memory before suspending timer queues when backgrounded.

third_party/WebKit/Source/platform/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 "platform/scheduler/renderer/renderer_scheduler_impl.h"
 
 #include <utility>
 
 #include "base/callback.h"
 #include "base/macros.h"
@@ skipping 613 matching lines @@
   static base::TimeDelta maximum_idle_period_duration() {
     return base::TimeDelta::FromMilliseconds(
         IdleHelper::kMaximumIdlePeriodMillis);
   }
 
   static base::TimeDelta end_idle_when_hidden_delay() {
     return base::TimeDelta::FromMilliseconds(
         RendererSchedulerImpl::kEndIdleWhenHiddenDelayMillis);
   }
 
-  static base::TimeDelta suspend_timers_when_backgrounded_delay() {
-    return base::TimeDelta::FromMilliseconds(
-        RendererSchedulerImpl::kSuspendTimersWhenBackgroundedDelayMillis);
-  }
-
   static base::TimeDelta rails_response_time() {
     return base::TimeDelta::FromMilliseconds(
         RendererSchedulerImpl::kRailsResponseTimeMillis);
   }
 
   template <typename E>
   static void CallForEachEnumValue(E first,
                                    E last,
                                    const char* (*function)(E)) {
     for (E val = first; val < last;
@@ skipping 1815 matching lines @@
 }
 
 TEST_F(RendererSchedulerImplTest, ShutdownPreventsPostingOfNewTasks) {
   scheduler_->Shutdown();
   std::vector<std::string> run_order;
   PostTestTasks(&run_order, "D1 C1");
   RunUntilIdle();
   EXPECT_TRUE(run_order.empty());
 }
 
-TEST_F(RendererSchedulerImplTest, TestRendererBackgroundedTimerSuspension) {

[haraken, 2017/02/02 08:53:13]

It's unfortunate that we're losing the test. Can we add the test somewhere else?

[tasak, 2017/02/03 03:13:14]

I think, render_thread_impl_browsertest. render_thread_impl_unittest is not
RenderThreadImpl's test. It tests only RenderThreadImpl::HistogramCustomizer.

I think, SuspendRenderer() and ResumeRenderer() are tested in
renderer_scheduler's unittest. So we need to see whether Purge method is invoked
or not and whether SuspendRenderer() is invoked or not.
To do so, we need to make RendererSchedulerImpl to use
base::SimpleTestTickClock, because we don't want to wait 5 minutes until the
test is finished.

-  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;
 
   scheduler_->SetHasVisibleRenderWidgetWithTouchHandler(true);
   SimulateExpensiveTasks(loading_task_runner_);
   ForceTouchStartToBeExpectedSoon();
   PostTestTasks(&run_order, "L1 D1");
   RunUntilIdle();
 
@@ skipping 1256 matching lines @@
   // While the queueing time estimator is locked, we believe the thread to still
   // be unresponsive.
   EXPECT_TRUE(scheduler_->MainThreadSeemsUnresponsive());
   // Once we've dropped the lock, we realize the main thread is responsive.
   DropQueueingTimeEstimatorLock();
   EXPECT_FALSE(scheduler_->MainThreadSeemsUnresponsive());
 }
 
 }  // namespace scheduler
 }  // namespace blink