Reland "Throttle resource message requests during user interaction"

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 31 matching lines @@
   void RunUntilIdle() { mock_task_runner_->RunUntilIdle(); }
 
   void EnableIdleTasks() {
     scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
         BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),
         base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));
     scheduler_->DidCommitFrameToCompositor();
   }
 
  protected:
+  static base::TimeDelta compositor_priority_after_touch() {

[Sami, 2015/01/27 14:06:06]

nit: append "_duration" to the name?

[jdduke (slow), 2015/01/27 16:59:09]

Done.

+    return base::TimeDelta::FromMilliseconds(
+        RendererSchedulerImpl::kCompositorPriorityAfterTouchMillis);
+  }
+
   scoped_refptr<cc::TestNowSource> clock_;
   scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_;
 
   scoped_ptr<RendererSchedulerImpl> scheduler_;
   scoped_refptr<base::SingleThreadTaskRunner> default_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> loading_task_runner_;
   scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(RendererSchedulerImplTest);
@@ skipping 76 matching lines @@
     bool* should_yield_after) {
   *should_yield_before = scheduler->ShouldYieldForHighPriorityWork();
   task_runner->PostTask(FROM_HERE, base::Bind(NullTask));
   if (simulate_input) {
     scheduler->DidReceiveInputEventOnCompositorThread(
         blink::WebInputEvent::GestureFlingStart);
   }
   *should_yield_after = scheduler->ShouldYieldForHighPriorityWork();
 }
 
+void AnticipationTestTask(RendererSchedulerImpl* scheduler,
+                          bool simulate_input,
+                          bool* is_anticipated_before,
+                          bool* is_anticipated_after) {
+  *is_anticipated_before = scheduler->IsHighPriorityWorkAnticipated();
+  if (simulate_input) {
+    scheduler->DidReceiveInputEventOnCompositorThread(
+        blink::WebInputEvent::GestureFlingStart);
+  }
+  *is_anticipated_after = scheduler->IsHighPriorityWorkAnticipated();
+}
+
 TEST_F(RendererSchedulerImplTest, TestPostDefaultTask) {
   int result = 0;
   default_task_runner_->PostTask(FROM_HERE,
                                  base::Bind(OrderedTestTask, 1, &result));
   default_task_runner_->PostTask(FROM_HERE,
                                  base::Bind(OrderedTestTask, 2, &result));
   default_task_runner_->PostTask(FROM_HERE,
                                  base::Bind(OrderedTestTask, 3, &result));
   default_task_runner_->PostTask(FROM_HERE,
                                  base::Bind(OrderedTestTask, 4, &result));
@@ skipping 347 matching lines @@
       FROM_HERE,
       base::Bind(&AppendToVectorTestTask, &order, std::string("C2")));
 
   // Compositor policy mode should have ended now that the clock has advanced.
   RunUntilIdle();
   EXPECT_THAT(order,
               testing::ElementsAre(std::string("D1"), std::string("C1"),
                                    std::string("D2"), std::string("C2")));
 }
 
+TEST_F(RendererSchedulerImplTest, TestIsHighPriorityWorkAnticipated) {
+  bool is_anticipated_before = false;
+  bool is_anticipated_after = false;
+
+  bool simulate_input = false;
+  default_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&AnticipationTestTask, scheduler_.get(), simulate_input,
+                 &is_anticipated_before, &is_anticipated_after));
+  RunUntilIdle();
+  // In its default state, without input receipt, the scheduler should indicate
+  // that no high-priority is anticipated.
+  EXPECT_FALSE(is_anticipated_before);
+  EXPECT_FALSE(is_anticipated_after);
+
+  simulate_input = true;
+  default_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&AnticipationTestTask, scheduler_.get(), simulate_input,
+                 &is_anticipated_before, &is_anticipated_after));
+  RunUntilIdle();
+  // When input is received, the scheduler should indicate that high-priority
+  // work is anticipated.
+  EXPECT_FALSE(is_anticipated_before);
+  EXPECT_TRUE(is_anticipated_after);
+
+  clock_->AdvanceNow(compositor_priority_after_touch() * 2);
+  simulate_input = false;
+  default_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&AnticipationTestTask, scheduler_.get(), simulate_input,
+                 &is_anticipated_before, &is_anticipated_after));
+  RunUntilIdle();
+  // Without additional input, the scheduler should indicate that high-priority
+  // work is no longer anticipated.
+  EXPECT_FALSE(is_anticipated_before);
+  EXPECT_FALSE(is_anticipated_after);
+}
+
 TEST_F(RendererSchedulerImplTest, TestShouldYield) {
   bool should_yield_before = false;
   bool should_yield_after = false;
 
   default_task_runner_->PostTask(
       FROM_HERE, base::Bind(&PostingYieldingTestTask, scheduler_.get(),
                             default_task_runner_, false, &should_yield_before,
                             &should_yield_after));
   RunUntilIdle();
   // Posting to default runner shouldn't cause yielding.
@@ skipping 13 matching lines @@
       FROM_HERE, base::Bind(&PostingYieldingTestTask, scheduler_.get(),
                             compositor_task_runner_, true, &should_yield_before,
                             &should_yield_after));
   RunUntilIdle();
   // We should be able to switch to compositor priority mid-task.
   EXPECT_FALSE(should_yield_before);
   EXPECT_TRUE(should_yield_after);
 }
 
 }  // namespace content