Pipe impl_latency_takes_priority_ to the RenderScheduler.

components/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 "components/scheduler/renderer/renderer_scheduler_impl.h"
 
 #include "base/callback.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/test/ordered_simple_task_runner.h"
 #include "cc/test/test_now_source.h"
@@ skipping 83 matching lines @@
   deadlines->push_back(deadline);
   (*run_count)++;
   clock->AdvanceNow(advance_time);
 }
 
 void WillBeginFrameIdleTask(RendererScheduler* scheduler,
                             scoped_refptr<cc::TestNowSource> clock,
                             base::TimeTicks deadline) {
   scheduler->WillBeginFrame(cc::BeginFrameArgs::Create(
       BEGINFRAME_FROM_HERE, clock->Now(), base::TimeTicks(),
-      base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));
+      base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL,
+      true));
 }
 
 void UpdateClockToDeadlineIdleTestTask(
     cc::TestNowSource* clock,
     int* run_count,
     base::TimeTicks deadline) {
   clock->SetNow(deadline);
   (*run_count)++;
 }
 
@@ skipping 84 matching lines @@
     DCHECK(!mock_task_runner_.get() || !message_loop_.get());
     if (mock_task_runner_.get())
       mock_task_runner_->RunUntilIdle();
     else
       message_loop_->RunUntilIdle();
   }
 
   void DoMainFrame() {
     scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
         BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),
-        base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));
+        base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL,
+        true));
     scheduler_->DidCommitFrameToCompositor();
   }
 
   void EnableIdleTasks() { DoMainFrame(); }
 
   Policy CurrentPolicy() { return scheduler_->current_policy_; }
 
+  bool BeginMainFrameOnCriticalPath() {
+    return scheduler_->begin_main_frame_on_critical_path_;
+  }
+
   // 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
   // - 'T': Timer task
   void PostTestTasks(std::vector<std::string>* run_order,
                      const std::string& task_descriptor) {
@@ skipping 154 matching lines @@
 
   clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(100));
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 
   RunUntilIdle();
   EXPECT_EQ(0, run_count);  // Shouldn't run yet as no WillBeginFrame.
 
   scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
       BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),
-      base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));
+      base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL,
+      true));
   RunUntilIdle();
   EXPECT_EQ(0, run_count);  // Shouldn't run as no DidCommitFrameToCompositor.
 
   clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(1200));
   scheduler_->DidCommitFrameToCompositor();
   RunUntilIdle();
   EXPECT_EQ(0, run_count);  // We missed the deadline.
 
   scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
       BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),
-      base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));
+      base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL,
+      true));
   clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(800));
   scheduler_->DidCommitFrameToCompositor();
   RunUntilIdle();
   EXPECT_EQ(1, run_count);
   EXPECT_EQ(expected_deadline, deadline_in_task);
 }
 
 TEST_F(RendererSchedulerImplTest, TestRepostingIdleTask) {
   int run_count = 0;
 
@@ skipping 102 matching lines @@
 TEST_F(RendererSchedulerImplTest, TestDelayedEndIdlePeriodCanceled) {
   int run_count = 0;
 
   base::TimeTicks deadline_in_task;
   idle_task_runner_->PostIdleTask(
       FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));
 
   // Trigger the beginning of an idle period for 1000ms.
   scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
       BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),
-      base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));
+      base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL,
+      true));
   DoMainFrame();
 
   // End the idle period early (after 500ms), and send a WillBeginFrame which
   // specifies that the next idle period should end 1000ms from now.
   clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(500));
   scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
       BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),
-      base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));
+      base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL,
+      true));
 
   RunUntilIdle();
   EXPECT_EQ(0, run_count);  // Not currently in an idle period.
 
   // Trigger the start of the idle period before the task to end the previous
   // idle period has been triggered.
   clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(400));
   scheduler_->DidCommitFrameToCompositor();
 
   // Post a task which simulates running until after the previous end idle
@@ skipping 993 matching lines @@
       base::Bind(&TestCanExceedIdleDeadlineIfRequiredTask, scheduler_.get(),
                  &can_exceed_idle_deadline, &run_count));
   RunUntilIdle();
   EXPECT_EQ(3, run_count);
   EXPECT_TRUE(can_exceed_idle_deadline);
 
   // Next long idle period will be for the maximum time, so
   // CanExceedIdleDeadlineIfRequired should return true.
   scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
       BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),
-      base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));
+      base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL,
+      true));
   EXPECT_FALSE(scheduler_->CanExceedIdleDeadlineIfRequired());
 }
 
 TEST_F(RendererSchedulerImplTest, TestRendererHiddenIdlePeriod) {
   int run_count = 0;
 
   max_idle_task_reposts = 2;
   idle_task_runner_->PostIdleTask(
       FROM_HERE,
       base::Bind(&RepostingIdleTestTask, idle_task_runner_, &run_count));
@@ skipping 77 matching lines @@
 
 TEST_F(RendererSchedulerImplTest, MismatchedDidHandleInputEventOnMainThread) {
   // This should not DCHECK because there was no corresponding compositor side
   // call to DidHandleInputEventOnCompositorThread with
   // INPUT_EVENT_ACK_STATE_NOT_CONSUMED. There are legitimate reasons for the
   // compositor to not be there and we don't want to make debugging impossible.
   scheduler_->DidHandleInputEventOnMainThread(
       FakeInputEvent(blink::WebInputEvent::GestureFlingStart));
 }
 
+TEST_F(RendererSchedulerImplTest, BeginMainFrameOnCriticalPath) {
+  ASSERT_FALSE(BeginMainFrameOnCriticalPath());
+
+  scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
+      BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),
+      base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL,
+      true));
+  ASSERT_TRUE(BeginMainFrameOnCriticalPath());
+
+  scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
+      BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),
+      base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL,
+      false));
+  ASSERT_FALSE(BeginMainFrameOnCriticalPath());
+}
+
 }  // namespace scheduler