Move throttling of background timers into the renderer scheduler

components/scheduler/renderer/throttling_helper_unittest.cc

Index: components/scheduler/renderer/throttling_helper_unittest.cc
diff --git a/components/scheduler/renderer/throttling_helper_unittest.cc b/components/scheduler/renderer/throttling_helper_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..61b9537672b7af439dfe3d6dba1e1d6e4a1d088b
--- /dev/null
+++ b/components/scheduler/renderer/throttling_helper_unittest.cc
@@ -0,0 +1,210 @@
+// Copyright 2015 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/throttling_helper.h"
+
+#include "base/callback.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/test/simple_test_tick_clock.h"
+#include "cc/test/ordered_simple_task_runner.h"
+#include "components/scheduler/base/test_time_source.h"
+#include "components/scheduler/child/scheduler_tqm_delegate_for_test.h"
+#include "components/scheduler/renderer/renderer_scheduler_impl.h"
+#include "components/scheduler/renderer/web_frame_scheduler_impl.h"
+#include "components/scheduler/renderer/web_view_scheduler_impl.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/WebKit/public/platform/WebTaskRunner.h"
+#include "third_party/WebKit/public/platform/WebTraceLocation.h"
+
+using testing::ElementsAre;
+
+namespace scheduler {
+
+class ThrottlingHelperTest : public testing::Test {
+ public:
+  ThrottlingHelperTest() {}
+  ~ThrottlingHelperTest() override {}
+
+  void SetUp() override {
+    clock_.reset(new base::SimpleTestTickClock());
+    clock_->Advance(base::TimeDelta::FromMicroseconds(5000));
+    mock_task_runner_ =
+        make_scoped_refptr(new cc::OrderedSimpleTaskRunner(clock_.get(), true));
+    delegate_ = SchedulerTqmDelegateForTest::Create(
+        mock_task_runner_, make_scoped_ptr(new TestTimeSource(clock_.get())));
+    scheduler_.reset(new RendererSchedulerImpl(delegate_));
+    throttling_helper_ = scheduler_->throttling_helper();
+    web_view_scheduler_.reset(
+        new WebViewSchedulerImpl(nullptr, scheduler_.get()));
+    web_frame_scheduler_ = web_view_scheduler_->createWebFrameSchedulerImpl();
+  }
+
+  void TearDown() override {
+    web_frame_scheduler_.reset();
+    web_view_scheduler_.reset();
+    scheduler_->Shutdown();
+    scheduler_.reset();
+  }
+
+ protected:
+  scoped_ptr<base::SimpleTestTickClock> clock_;
+  scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_;
+  scoped_refptr<SchedulerTqmDelegate> delegate_;
+  scoped_ptr<RendererSchedulerImpl> scheduler_;
+  scoped_ptr<WebViewSchedulerImpl> web_view_scheduler_;
+  scoped_ptr<WebFrameSchedulerImpl> web_frame_scheduler_;
+  ThrottlingHelper* throttling_helper_;  // NOT OWNED
+
+  DISALLOW_COPY_AND_ASSIGN(ThrottlingHelperTest);
+};
+
+TEST_F(ThrottlingHelperTest, DelayToNextRunTimeInSeconds) {
+  EXPECT_EQ(base::TimeDelta::FromSecondsD(1.0),
+            ThrottlingHelper::DelayToNextRunTimeInSeconds(
+                base::TimeTicks() + base::TimeDelta::FromSecondsD(0.0)));
+
+  EXPECT_EQ(base::TimeDelta::FromSecondsD(0.9),
+            ThrottlingHelper::DelayToNextRunTimeInSeconds(
+                base::TimeTicks() + base::TimeDelta::FromSecondsD(0.1)));
+
+  EXPECT_EQ(base::TimeDelta::FromSecondsD(0.8),
+            ThrottlingHelper::DelayToNextRunTimeInSeconds(
+                base::TimeTicks() + base::TimeDelta::FromSecondsD(0.2)));
+
+  EXPECT_EQ(base::TimeDelta::FromSecondsD(0.5),
+            ThrottlingHelper::DelayToNextRunTimeInSeconds(
+                base::TimeTicks() + base::TimeDelta::FromSecondsD(0.5)));
+
+  EXPECT_EQ(base::TimeDelta::FromSecondsD(0.2),
+            ThrottlingHelper::DelayToNextRunTimeInSeconds(
+                base::TimeTicks() + base::TimeDelta::FromSecondsD(0.8)));
+
+  EXPECT_EQ(base::TimeDelta::FromSecondsD(0.1),
+            ThrottlingHelper::DelayToNextRunTimeInSeconds(
+                base::TimeTicks() + base::TimeDelta::FromSecondsD(0.9)));
+
+  EXPECT_EQ(base::TimeDelta::FromSecondsD(1.0),
+            ThrottlingHelper::DelayToNextRunTimeInSeconds(
+                base::TimeTicks() + base::TimeDelta::FromSecondsD(1.0)));
+
+  EXPECT_EQ(base::TimeDelta::FromSecondsD(0.9),
+            ThrottlingHelper::DelayToNextRunTimeInSeconds(
+                base::TimeTicks() + base::TimeDelta::FromSecondsD(1.1)));
+
+  EXPECT_EQ(base::TimeDelta::FromSecondsD(1.0),
+            ThrottlingHelper::DelayToNextRunTimeInSeconds(
+                base::TimeTicks() + base::TimeDelta::FromSecondsD(8.0)));
+
+  EXPECT_EQ(base::TimeDelta::FromSecondsD(0.9),
+            ThrottlingHelper::DelayToNextRunTimeInSeconds(
+                base::TimeTicks() + base::TimeDelta::FromSecondsD(8.1)));
+}
+
+namespace {
+class TestTask : public blink::WebTaskRunner::Task {
+ public:
+  TestTask(std::vector<double>* run_times_millis,
+           base::SimpleTestTickClock* clock)
+      : run_times_millis_(run_times_millis), clock_(clock) {}
+
+  ~TestTask() override {}
+
+  void run() override {
+    run_times_millis_->push_back(
+        (clock_->NowTicks() - base::TimeTicks()).InMillisecondsF());
+  }
+
+ private:
+  std::vector<double>* run_times_millis_;  // NOT OWNED
+  base::SimpleTestTickClock* clock_;       // NOT OWNED
+};
+}  // namespace
+
+TEST_F(ThrottlingHelperTest, TimerAlignment) {
+  std::vector<double> run_times_millis;
+  web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
+      BLINK_FROM_HERE, new TestTask(&run_times_millis, clock_.get()), 200.0);
+
+  web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
+      BLINK_FROM_HERE, new TestTask(&run_times_millis, clock_.get()), 800.0);
+
+  web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
+      BLINK_FROM_HERE, new TestTask(&run_times_millis, clock_.get()), 1200.0);
+
+  web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
+      BLINK_FROM_HERE, new TestTask(&run_times_millis, clock_.get()), 8300.0);
+
+  throttling_helper_->ThrottleBackgroundFrame(
+      static_cast<WebFrameSchedulerImpl*>(web_frame_scheduler_.get()));
+
+  mock_task_runner_->RunUntilIdle();
+
+  // Times are aligned to a multipple of 1000 milliseconds.
+  EXPECT_THAT(run_times_millis, ElementsAre(1000.0, 1000.0, 2000.0, 9000.0));
+}
+
+TEST_F(ThrottlingHelperTest, TimerAlignment_Unthrottled) {
+  std::vector<double> run_times_millis;
+  double start_time_millis =
+      (clock_->NowTicks() - base::TimeTicks()).InMillisecondsF();
+  web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
+      BLINK_FROM_HERE, new TestTask(&run_times_millis, clock_.get()), 200.0);
+
+  web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
+      BLINK_FROM_HERE, new TestTask(&run_times_millis, clock_.get()), 800.0);
+
+  web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
+      BLINK_FROM_HERE, new TestTask(&run_times_millis, clock_.get()), 1200.0);
+
+  web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
+      BLINK_FROM_HERE, new TestTask(&run_times_millis, clock_.get()), 8300.0);
+
+  throttling_helper_->ThrottleBackgroundFrame(
+      static_cast<WebFrameSchedulerImpl*>(web_frame_scheduler_.get()));
+  throttling_helper_->UnthrottleForegroundFrame(
+      static_cast<WebFrameSchedulerImpl*>(web_frame_scheduler_.get()));
+
+  mock_task_runner_->RunUntilIdle();
+
+  // Times are not aligned.
+  EXPECT_THAT(
+      run_times_millis,
+      ElementsAre(start_time_millis + 200.0, start_time_millis + 800.0,
+                  start_time_millis + 1200.0, start_time_millis + 8300.0));
+}
+
+TEST_F(ThrottlingHelperTest, WakeUpForNonDelayedTask) {
+  std::vector<double> run_times_millis;
+
+  // Nothing is posted on web_frame_scheduler_ so PumpThrottledTasks will not
+  // tick.
+  throttling_helper_->ThrottleBackgroundFrame(
+      static_cast<WebFrameSchedulerImpl*>(web_frame_scheduler_.get()));
+
+  // Posting a task should trigger the pump.
+  web_frame_scheduler_->timerTaskRunner()->postTask(
+      BLINK_FROM_HERE, new TestTask(&run_times_millis, clock_.get()));
+
+  mock_task_runner_->RunUntilIdle();
+  EXPECT_THAT(run_times_millis, ElementsAre(1000.0));
+}
+
+TEST_F(ThrottlingHelperTest, WakeUpForDelayedTask) {
+  std::vector<double> run_times_millis;
+
+  // Nothing is posted on web_frame_scheduler_ so PumpThrottledTasks will not
+  // tick.
+  throttling_helper_->ThrottleBackgroundFrame(
+      static_cast<WebFrameSchedulerImpl*>(web_frame_scheduler_.get()));
+
+  // Posting a task should trigger the pump.
+  web_frame_scheduler_->timerTaskRunner()->postDelayedTask(
+      BLINK_FROM_HERE, new TestTask(&run_times_millis, clock_.get()), 1200.0);
+
+  mock_task_runner_->RunUntilIdle();
+  EXPECT_THAT(run_times_millis, ElementsAre(2000.0));
+}
+
+}  // namespace scheduler