Prevent multiple pending UpdatePolicy tasks.

content/renderer/scheduler/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 "content/renderer/scheduler/renderer_scheduler_impl.h"
 
 #include "base/callback.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/test/ordered_simple_task_runner.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 38 matching lines @@
         mock_task_runner_(new cc::OrderedSimpleTaskRunner(clock_, false)),
         scheduler_(new RendererSchedulerImpl(mock_task_runner_)),
         default_task_runner_(scheduler_->DefaultTaskRunner()),
         compositor_task_runner_(scheduler_->CompositorTaskRunner()),
         loading_task_runner_(scheduler_->LoadingTaskRunner()),
         idle_task_runner_(scheduler_->IdleTaskRunner()) {
     scheduler_->SetTimeSourceForTesting(clock_);
   }
   ~RendererSchedulerImplTest() override {}
 
-  void RunUntilIdle() { mock_task_runner_->RunUntilIdle(); }
+  void TearDown() override {
+    // Check that all tests stop posting tasks.
+    mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
+    while (RunUntilIdle())
+      ;
+  }
+
+  bool RunUntilIdle() { return mock_task_runner_->RunUntilIdle(); }
 
   void DoMainFrame() {
     scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
         BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),
         base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));
     scheduler_->DidCommitFrameToCompositor();
   }
 
   void EnableIdleTasks() { DoMainFrame(); }
 
   Policy CurrentPolicy() { return scheduler_->current_policy_; }
 
+  void EnsureUgentPolicyUpdatePostedOnMainThread() {
+    base::AutoLock lock(scheduler_->incoming_signals_lock_);
+    scheduler_->EnsureUgentPolicyUpdatePostedOnMainThread(FROM_HERE);
+  }
+
+  void ScheduleDelayedPolicyUpdate(base::TimeDelta delay) {
+    scheduler_->delayed_update_policy_runner_.SetDeadline(FROM_HERE, delay,
+                                                          clock_->Now());
+  }
+
   // Helper for posting several tasks of specific types. |task_descriptor| is a
   // string with space delimited task identifiers. The first letter of each
   // task identifier specifies the task type:
   // - 'D': Default task
   // - 'C': Compositor task
   // - 'L': Loading task
   // - 'I': Idle task
   void PostTestTasks(std::vector<std::string>* run_order,
                      const std::string& task_descriptor) {
     std::istringstream stream(task_descriptor);
@@ skipping 758 matching lines @@
   RunUntilIdle();
   EXPECT_EQ(Policy::COMPOSITOR_PRIORITY, CurrentPolicy());
 
   // Process the input event with a new BeginMainFrame.
   DoMainFrame();
   clock_->AdvanceNow(2 * priority_escalation_after_input_duration());
   RunUntilIdle();
   EXPECT_EQ(Policy::NORMAL, CurrentPolicy());
 }
 
+class MockRendererSchedulerImpl : public RendererSchedulerImpl {
+ public:
+  MockRendererSchedulerImpl(
+      scoped_refptr<base::SingleThreadTaskRunner> main_task_runner)
+      : RendererSchedulerImpl(main_task_runner), update_policy_count_(0) {}
+
+  void UpdatePolicyLocked() override {
+    update_policy_count_++;
+    RendererSchedulerImpl::UpdatePolicyLocked();
+  }
+
+  int update_policy_count_;
+};
+
+TEST_F(RendererSchedulerImplTest, OnlyOnePendingUrgentPolicyUpdatey) {
+  MockRendererSchedulerImpl* mock_scheduler =
+      new MockRendererSchedulerImpl(mock_task_runner_);
+  scheduler_.reset(mock_scheduler);
+
+  EnsureUgentPolicyUpdatePostedOnMainThread();
+  EnsureUgentPolicyUpdatePostedOnMainThread();
+  EnsureUgentPolicyUpdatePostedOnMainThread();
+  EnsureUgentPolicyUpdatePostedOnMainThread();
+
+  RunUntilIdle();
+
+  EXPECT_EQ(1, mock_scheduler->update_policy_count_);
+}
+
+TEST_F(RendererSchedulerImplTest, OnePendingDelayedAndOneUrgentUpdatePolicy) {
+  MockRendererSchedulerImpl* mock_scheduler =
+      new MockRendererSchedulerImpl(mock_task_runner_);
+  scheduler_.reset(mock_scheduler);
+  scheduler_->SetTimeSourceForTesting(clock_);
+  mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
+
+  ScheduleDelayedPolicyUpdate(base::TimeDelta::FromMilliseconds(1));
+  EnsureUgentPolicyUpdatePostedOnMainThread();
+
+  RunUntilIdle();
+
+  // We expect both the urgent and the delayed updates to run.
+  EXPECT_EQ(2, mock_scheduler->update_policy_count_);
+}
+
+TEST_F(RendererSchedulerImplTest, OneUrgentAndOnePendingDelayedUpdatePolicy) {
+  MockRendererSchedulerImpl* mock_scheduler =
+      new MockRendererSchedulerImpl(mock_task_runner_);
+  scheduler_.reset(mock_scheduler);
+  scheduler_->SetTimeSourceForTesting(clock_);
+  mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
+
+  EnsureUgentPolicyUpdatePostedOnMainThread();
+  ScheduleDelayedPolicyUpdate(base::TimeDelta::FromMilliseconds(1));
+
+  RunUntilIdle();
+
+  // We expect both the urgent and the delayed updates to run.
+  EXPECT_EQ(2, mock_scheduler->update_policy_count_);
+}
+
+TEST_F(RendererSchedulerImplTest, UpdatePolicyCountTriggeredByOneInputEvent) {
+  MockRendererSchedulerImpl* mock_scheduler =
+      new MockRendererSchedulerImpl(mock_task_runner_);
+  scheduler_.reset(mock_scheduler);
+  scheduler_->SetTimeSourceForTesting(clock_);
+  mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
+
+  scheduler_->DidReceiveInputEventOnCompositorThread(
+      FakeInputEvent(blink::WebInputEvent::TouchStart));
+
+  RunUntilIdle();
+
+  EXPECT_EQ(2, mock_scheduler->update_policy_count_);
+}
+
+TEST_F(RendererSchedulerImplTest, UpdatePolicyCountTriggeredByTwoInputEvents) {
+  MockRendererSchedulerImpl* mock_scheduler =
+      new MockRendererSchedulerImpl(mock_task_runner_);
+  scheduler_.reset(mock_scheduler);
+  scheduler_->SetTimeSourceForTesting(clock_);
+  mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
+
+  scheduler_->DidReceiveInputEventOnCompositorThread(
+      FakeInputEvent(blink::WebInputEvent::TouchStart));
+  scheduler_->DidReceiveInputEventOnCompositorThread(
+      FakeInputEvent(blink::WebInputEvent::TouchMove));
+
+  RunUntilIdle();
+
+  EXPECT_EQ(2, mock_scheduler->update_policy_count_);
+}
+
+TEST_F(RendererSchedulerImplTest, EnsureUpdatePolicyNotTriggeredTooOften) {
+  MockRendererSchedulerImpl* mock_scheduler =
+      new MockRendererSchedulerImpl(mock_task_runner_);
+  scheduler_.reset(mock_scheduler);
+  scheduler_->SetTimeSourceForTesting(clock_);
+  mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
+
+  scheduler_->DidReceiveInputEventOnCompositorThread(
+      FakeInputEvent(blink::WebInputEvent::TouchStart));
+  scheduler_->DidReceiveInputEventOnCompositorThread(
+      FakeInputEvent(blink::WebInputEvent::TouchMove));
+
+  // We expect the first call to IsHighPriorityWorkAnticipated to be called
+  // after recieving an input event (but before the UpdateTask was processed) to
+  // call UpdatePolicy.
+  EXPECT_EQ(0, mock_scheduler->update_policy_count_);
+  scheduler_->IsHighPriorityWorkAnticipated();
+  EXPECT_EQ(1, mock_scheduler->update_policy_count_);
+  // Subsequent calls should not call UpdateTask.

[Sami, 2015/03/12 18:15:22]

nit: UpdatePolicy

[alex clarke (OOO till 29th), 2015/03/12 18:24:08]

Done.

+  scheduler_->IsHighPriorityWorkAnticipated();
+  scheduler_->IsHighPriorityWorkAnticipated();
+  scheduler_->IsHighPriorityWorkAnticipated();
+  scheduler_->ShouldYieldForHighPriorityWork();
+  scheduler_->ShouldYieldForHighPriorityWork();
+  scheduler_->ShouldYieldForHighPriorityWork();
+  scheduler_->ShouldYieldForHighPriorityWork();
+
+  EXPECT_EQ(1, mock_scheduler->update_policy_count_);
+
+  RunUntilIdle();
+  // We expect both the urgent and the delayed updates to run in addition to the
+  // earlier updated cause by IsHighPriorityWorkAnticipated.
+  EXPECT_EQ(3, mock_scheduler->update_policy_count_);
+}
+
 }  // namespace content