cc: Don't attempt main thread synchronization if it is slow.

cc/scheduler/scheduler_unittest.cc

 // Copyright 2011 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 "cc/scheduler/scheduler.h"
 
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 27 matching lines @@
 
 #define EXPECT_SCOPED(statements) \
   {                               \
     SCOPED_TRACE("");             \
     statements;                   \
   }
 
 namespace cc {
 namespace {
 
+base::TimeDelta kSlowDuration = base::TimeDelta::FromSeconds(1);
+base::TimeDelta kFastDuration = base::TimeDelta::FromMilliseconds(1);
+
 class FakeSchedulerClient : public SchedulerClient {
  public:
   FakeSchedulerClient()
       : automatic_swap_ack_(true),
         scheduler_(nullptr) {
     Reset();
   }
 
   void Reset() {
     actions_.clear();
@@ skipping 211 matching lines @@
     fake_compositor_timing_history_ = fake_compositor_timing_history.get();
 
     scheduler_ = TestScheduler::Create(
         now_src_.get(), client_.get(), scheduler_settings_, 0,
         task_runner_.get(), fake_external_begin_frame_source_.get(),
         fake_compositor_timing_history.Pass());
     DCHECK(scheduler_);
     client_->set_scheduler(scheduler_.get());
 
     // Use large estimates by default to avoid latency recovery in most tests.
-    base::TimeDelta slow_duration = base::TimeDelta::FromSeconds(1);
-    fake_compositor_timing_history_->SetAllEstimatesTo(slow_duration);
+    fake_compositor_timing_history_->SetAllEstimatesTo(kSlowDuration);
 
     return scheduler_.get();
   }
 
   void CreateSchedulerAndInitSurface() {
     CreateScheduler();
     EXPECT_SCOPED(InitializeOutputSurfaceAndFirstCommit());
   }
 
   void SetUpScheduler(bool initSurface) {
@@ skipping 126 matching lines @@
   }
 
   void CheckMainFrameSkippedAfterLateCommit(bool expect_send_begin_main_frame);
   void ImplFrameSkippedAfterLateSwapAck(bool swap_ack_before_deadline);
   void ImplFrameIsNotSkippedAfterLateSwapAck();
   void BeginFramesNotFromClient(bool use_external_begin_frame_source,
                                 bool throttle_frame_production);
   void BeginFramesNotFromClient_SwapThrottled(
       bool use_external_begin_frame_source,
       bool throttle_frame_production);
+  bool BeginMainFrameOnCriticalPath(TreePriority tree_priority,
+                                    ScrollHandlerState scroll_handler_state,
+                                    base::TimeDelta durations);
 
   scoped_ptr<base::SimpleTestTickClock> now_src_;
   scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
   scoped_ptr<FakeExternalBeginFrameSource> fake_external_begin_frame_source_;
   SchedulerSettings scheduler_settings_;
   scoped_ptr<FakeSchedulerClient> client_;
   scoped_ptr<TestScheduler> scheduler_;
   FakeCompositorTimingHistory* fake_compositor_timing_history_;
 };
 
@@ skipping 41 matching lines @@
   client_->Reset();
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_TRUE(client_->begin_frame_is_sent_to_children());
 }
 
 TEST_F(SchedulerTest, SendBeginFramesToChildrenDeadlineNotAdjusted) {
   // Set up client with specified estimates.
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
 
-  fake_compositor_timing_history_->SetBeginMainFrameToCommitDurationEstimate(
-      base::TimeDelta::FromMilliseconds(2));
+  fake_compositor_timing_history_
+      ->SetBeginMainFrameStartToCommitDurationEstimate(
+          base::TimeDelta::FromMilliseconds(2));
   fake_compositor_timing_history_->SetCommitToReadyToActivateDurationEstimate(
       base::TimeDelta::FromMilliseconds(4));
   fake_compositor_timing_history_->SetDrawDurationEstimate(
       base::TimeDelta::FromMilliseconds(1));
 
   EXPECT_FALSE(client_->needs_begin_frames());
   scheduler_->SetChildrenNeedBeginFrames(true);
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrames(true)", client_);
   EXPECT_TRUE(client_->needs_begin_frames());
 
@@ skipping 874 matching lines @@
   EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
 
   client_->Reset();
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
   task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
   EXPECT_EQ(expect_send_begin_main_frame,
             scheduler_->MainThreadMissedLastDeadline());
+  EXPECT_TRUE(client_->HasAction("WillBeginImplFrame"));
   EXPECT_EQ(expect_send_begin_main_frame,
             client_->HasAction("ScheduledActionSendBeginMainFrame"));
 }
 
 TEST_F(SchedulerTest, MainFrameSkippedAfterLateCommit) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
-
-  auto fast_duration = base::TimeDelta::FromMilliseconds(1);
-  fake_compositor_timing_history_->SetAllEstimatesTo(fast_duration);
+  fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
 
   bool expect_send_begin_main_frame = false;
   EXPECT_SCOPED(
       CheckMainFrameSkippedAfterLateCommit(expect_send_begin_main_frame));
 }
 
+// Response times of BeginMainFrame's without the critical path flag set
+// should not affect whether we recover latency or not.
+TEST_F(
+    SchedulerTest,
+    MainFrameSkippedAfterLateCommit_LongBeginMainFrameQueueDurationNotCritical) {
+  scheduler_settings_.use_external_begin_frame_source = true;
+  SetUpScheduler(true);
+  fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
+  fake_compositor_timing_history_
+      ->SetBeginMainFrameQueueDurationNotCriticalEstimate(kSlowDuration);
+
+  bool expect_send_begin_main_frame = false;
+  EXPECT_SCOPED(
+      CheckMainFrameSkippedAfterLateCommit(expect_send_begin_main_frame));
+}
+
+// Response times of BeginMainFrame's with the critical path flag set
+// should affect whether we recover latency or not.
+TEST_F(
+    SchedulerTest,
+    MainFrameNotSkippedAfterLateCommit_LongBeginMainFrameQueueDurationCritical) {
+  scheduler_settings_.use_external_begin_frame_source = true;
+  SetUpScheduler(true);
+  fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
+  fake_compositor_timing_history_
+      ->SetBeginMainFrameQueueDurationCriticalEstimate(kSlowDuration);
+  fake_compositor_timing_history_
+      ->SetBeginMainFrameQueueDurationNotCriticalEstimate(kSlowDuration);
+
+  bool expect_send_begin_main_frame = true;
+  EXPECT_SCOPED(
+      CheckMainFrameSkippedAfterLateCommit(expect_send_begin_main_frame));
+}
+
 TEST_F(SchedulerTest,
        MainFrameNotSkippedAfterLateCommitInPreferImplLatencyMode) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
-  scheduler_->SetImplLatencyTakesPriority(true);
-
-  auto fast_duration = base::TimeDelta::FromMilliseconds(1);
-  fake_compositor_timing_history_->SetAllEstimatesTo(fast_duration);
+  scheduler_->SetSmoothnessMode(SMOOTHNESS_TAKES_PRIORITY,
+                                SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER);
+  fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
 
   bool expect_send_begin_main_frame = true;
   EXPECT_SCOPED(
       CheckMainFrameSkippedAfterLateCommit(expect_send_begin_main_frame));
 }
 
 TEST_F(SchedulerTest,
        MainFrameNotSkippedAfterLateCommit_CommitEstimateTooLong) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
-  auto fast_duration = base::TimeDelta::FromMilliseconds(1);
-  fake_compositor_timing_history_->SetAllEstimatesTo(fast_duration);
-  auto slow_duration = base::TimeDelta::FromSeconds(1);
-  fake_compositor_timing_history_->SetBeginMainFrameToCommitDurationEstimate(
-      slow_duration);
+  fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
+  fake_compositor_timing_history_
+      ->SetBeginMainFrameStartToCommitDurationEstimate(kSlowDuration);
 
   bool expect_send_begin_main_frame = true;
   EXPECT_SCOPED(
       CheckMainFrameSkippedAfterLateCommit(expect_send_begin_main_frame));
 }
 
 TEST_F(SchedulerTest,
        MainFrameNotSkippedAfterLateCommit_ReadyToActivateEstimateTooLong) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
-  auto fast_duration = base::TimeDelta::FromMilliseconds(1);
-  fake_compositor_timing_history_->SetAllEstimatesTo(fast_duration);
-  auto slow_duration = base::TimeDelta::FromSeconds(1);
+  fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
   fake_compositor_timing_history_->SetCommitToReadyToActivateDurationEstimate(
-      slow_duration);
+      kSlowDuration);
 
   bool expect_send_begin_main_frame = true;
   EXPECT_SCOPED(
       CheckMainFrameSkippedAfterLateCommit(expect_send_begin_main_frame));
 }
 
 TEST_F(SchedulerTest,
        MainFrameNotSkippedAfterLateCommit_ActivateEstimateTooLong) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
-  auto fast_duration = base::TimeDelta::FromMilliseconds(1);
-  fake_compositor_timing_history_->SetAllEstimatesTo(fast_duration);
-  auto slow_duration = base::TimeDelta::FromSeconds(1);
-  fake_compositor_timing_history_->SetActivateDurationEstimate(slow_duration);
+  fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
+  fake_compositor_timing_history_->SetActivateDurationEstimate(kSlowDuration);
 
   bool expect_send_begin_main_frame = true;
   EXPECT_SCOPED(
       CheckMainFrameSkippedAfterLateCommit(expect_send_begin_main_frame));
 }
 
 TEST_F(SchedulerTest, MainFrameNotSkippedAfterLateCommit_DrawEstimateTooLong) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
-  auto fast_duration = base::TimeDelta::FromMilliseconds(1);
-  fake_compositor_timing_history_->SetAllEstimatesTo(fast_duration);
-  auto slow_duration = base::TimeDelta::FromSeconds(1);
-  fake_compositor_timing_history_->SetDrawDurationEstimate(slow_duration);
+  fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
+  fake_compositor_timing_history_->SetDrawDurationEstimate(kSlowDuration);
 
   bool expect_send_begin_main_frame = true;
   EXPECT_SCOPED(
       CheckMainFrameSkippedAfterLateCommit(expect_send_begin_main_frame));
 }
 
 void SchedulerTest::ImplFrameSkippedAfterLateSwapAck(
     bool swap_ack_before_deadline) {
   // To get into a high latency state, this test disables automatic swap acks.
   scheduler_->SetMaxSwapsPending(1);
@@ skipping 68 matching lines @@
     EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 1, 4);
     EXPECT_ACTION("ScheduledActionAnimate", client_, 2, 4);
     EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 3, 4);
   }
 }
 
 TEST_F(SchedulerTest,
        ImplFrameSkippedAfterLateSwapAck_FastEstimates_SwapAckThenDeadline) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
-
-  auto fast_duration = base::TimeDelta::FromMilliseconds(1);
-  fake_compositor_timing_history_->SetAllEstimatesTo(fast_duration);
+  fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
 
   bool swap_ack_before_deadline = true;
   EXPECT_SCOPED(ImplFrameSkippedAfterLateSwapAck(swap_ack_before_deadline));
 }
 
 TEST_F(SchedulerTest,
        ImplFrameSkippedAfterLateSwapAck_FastEstimates_DeadlineThenSwapAck) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
-
-  auto fast_duration = base::TimeDelta::FromMilliseconds(1);
-  fake_compositor_timing_history_->SetAllEstimatesTo(fast_duration);
+  fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
 
   bool swap_ack_before_deadline = false;
   EXPECT_SCOPED(ImplFrameSkippedAfterLateSwapAck(swap_ack_before_deadline));
+}
+
+TEST_F(
+    SchedulerTest,
+    ImplFrameSkippedAfterLateSwapAck_LongBeginMainFrameQueueDurationNotCritical) {
+  scheduler_settings_.use_external_begin_frame_source = true;
+  SetUpScheduler(true);
+  fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
+  fake_compositor_timing_history_
+      ->SetBeginMainFrameQueueDurationNotCriticalEstimate(kSlowDuration);
+
+  bool swap_ack_before_deadline = false;
+  EXPECT_SCOPED(ImplFrameSkippedAfterLateSwapAck(swap_ack_before_deadline));
 }
 
 TEST_F(SchedulerTest,
        ImplFrameSkippedAfterLateSwapAck_ImplLatencyTakesPriority) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
 
   // Even if every estimate related to the main thread is slow, we should
   // still expect to recover impl thread latency if the draw is fast and we
   // are in impl latency takes priority.
-  scheduler_->SetImplLatencyTakesPriority(true);
-  auto slow_duration = base::TimeDelta::FromSeconds(1);
-  fake_compositor_timing_history_->SetAllEstimatesTo(slow_duration);
-  auto fast_duration = base::TimeDelta::FromMilliseconds(1);
-  fake_compositor_timing_history_->SetDrawDurationEstimate(fast_duration);
+  scheduler_->SetSmoothnessMode(SMOOTHNESS_TAKES_PRIORITY,
+                                SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER);
+  fake_compositor_timing_history_->SetAllEstimatesTo(kSlowDuration);
+  fake_compositor_timing_history_->SetDrawDurationEstimate(kFastDuration);
 
   bool swap_ack_before_deadline = false;
   EXPECT_SCOPED(ImplFrameSkippedAfterLateSwapAck(swap_ack_before_deadline));
 }
 
 TEST_F(SchedulerTest,
        ImplFrameSkippedAfterLateSwapAck_OnlyImplSideUpdatesExpected) {
   // This tests that we recover impl thread latency when there are no commits.
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
 
   // To get into a high latency state, this test disables automatic swap acks.
   scheduler_->SetMaxSwapsPending(1);
   client_->SetAutomaticSwapAck(false);
 
   // Even if every estimate related to the main thread is slow, we should
   // still expect to recover impl thread latency if there are no commits from
   // the main thread.
-  auto slow_duration = base::TimeDelta::FromSeconds(1);
-  fake_compositor_timing_history_->SetAllEstimatesTo(slow_duration);
-  auto fast_duration = base::TimeDelta::FromMilliseconds(1);
-  fake_compositor_timing_history_->SetDrawDurationEstimate(fast_duration);
+  fake_compositor_timing_history_->SetAllEstimatesTo(kSlowDuration);
+  fake_compositor_timing_history_->SetDrawDurationEstimate(kFastDuration);
 
   // Draw and swap for first BeginFrame
   client_->Reset();
   scheduler_->SetNeedsRedraw();
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   SendNextBeginFrame();
   EXPECT_ACTION("SetNeedsBeginFrames(true)", client_, 0, 3);
   EXPECT_ACTION("WillBeginImplFrame", client_, 1, 3);
   EXPECT_ACTION("ScheduledActionAnimate", client_, 2, 3);
 
@@ skipping 86 matching lines @@
 
     // Verify that we don't skip the actions of the BeginImplFrame
     EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 0, 5);
     EXPECT_ACTION("ScheduledActionCommit", client_, 1, 5);
     EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 2, 5);
     EXPECT_ACTION("ScheduledActionAnimate", client_, 3, 5);
     EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 4, 5);
   }
 }
 
+TEST_F(
+    SchedulerTest,
+    ImplFrameIsNotSkippedAfterLateSwapAck_BeginMainFrameQueueDurationCriticalTooLong) {
+  scheduler_settings_.use_external_begin_frame_source = true;
+  SetUpScheduler(true);
+  fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
+  fake_compositor_timing_history_
+      ->SetBeginMainFrameQueueDurationCriticalEstimate(kSlowDuration);
+  fake_compositor_timing_history_
+      ->SetBeginMainFrameQueueDurationNotCriticalEstimate(kSlowDuration);
+  EXPECT_SCOPED(ImplFrameIsNotSkippedAfterLateSwapAck());
+}
+
 TEST_F(SchedulerTest,
        ImplFrameIsNotSkippedAfterLateSwapAck_CommitEstimateTooLong) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
-  auto fast_duration = base::TimeDelta::FromMilliseconds(1);
-  fake_compositor_timing_history_->SetAllEstimatesTo(fast_duration);
-  auto slow_duration = base::TimeDelta::FromSeconds(1);
-  fake_compositor_timing_history_->SetBeginMainFrameToCommitDurationEstimate(
-      slow_duration);
+  fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
+  fake_compositor_timing_history_
+      ->SetBeginMainFrameStartToCommitDurationEstimate(kSlowDuration);
   EXPECT_SCOPED(ImplFrameIsNotSkippedAfterLateSwapAck());
 }
 
 TEST_F(SchedulerTest,
        ImplFrameIsNotSkippedAfterLateSwapAck_ReadyToActivateEstimateTooLong) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
-  auto fast_duration = base::TimeDelta::FromMilliseconds(1);
-  fake_compositor_timing_history_->SetAllEstimatesTo(fast_duration);
-  auto slow_duration = base::TimeDelta::FromSeconds(1);
+  fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
   fake_compositor_timing_history_->SetCommitToReadyToActivateDurationEstimate(
-      slow_duration);
+      kSlowDuration);
   EXPECT_SCOPED(ImplFrameIsNotSkippedAfterLateSwapAck());
 }
 
 TEST_F(SchedulerTest,
        ImplFrameIsNotSkippedAfterLateSwapAck_ActivateEstimateTooLong) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
-  auto fast_duration = base::TimeDelta::FromMilliseconds(1);
-  fake_compositor_timing_history_->SetAllEstimatesTo(fast_duration);
-  auto slow_duration = base::TimeDelta::FromSeconds(1);
-  fake_compositor_timing_history_->SetActivateDurationEstimate(slow_duration);
+  fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
+  fake_compositor_timing_history_->SetActivateDurationEstimate(kSlowDuration);
   EXPECT_SCOPED(ImplFrameIsNotSkippedAfterLateSwapAck());
 }
 
 TEST_F(SchedulerTest,
        ImplFrameIsNotSkippedAfterLateSwapAck_DrawEstimateTooLong) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
-  auto fast_duration = base::TimeDelta::FromMilliseconds(1);
-  fake_compositor_timing_history_->SetAllEstimatesTo(fast_duration);
-  auto slow_duration = base::TimeDelta::FromSeconds(1);
-  fake_compositor_timing_history_->SetDrawDurationEstimate(slow_duration);
+  fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
+  fake_compositor_timing_history_->SetDrawDurationEstimate(kSlowDuration);
   EXPECT_SCOPED(ImplFrameIsNotSkippedAfterLateSwapAck());
 }
 
 TEST_F(SchedulerTest,
        MainFrameThenImplFrameSkippedAfterLateCommitAndLateSwapAck) {
   // Set up client with custom estimates.
   // This test starts off with expensive estimates to prevent latency recovery
   // initially, then lowers the estimates to enable it once both the main
   // and impl threads are in a high latency mode.
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
-
-  auto slow_duration = base::TimeDelta::FromSeconds(1);
-  fake_compositor_timing_history_->SetAllEstimatesTo(slow_duration);
+  fake_compositor_timing_history_->SetAllEstimatesTo(kSlowDuration);
 
   // To get into a high latency state, this test disables automatic swap acks.
   scheduler_->SetMaxSwapsPending(1);
   client_->SetAutomaticSwapAck(false);
 
   // Impl thread hits deadline before commit finishes to make
   // MainThreadMissedLastDeadline true
   client_->Reset();
   scheduler_->SetNeedsBeginMainFrame();
   EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
@@ skipping 41 matching lines @@
 
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionAnimate", client_, 1, 2);
   // Note: BeginMainFrame and swap are skipped here because of
   // swap ack backpressure, not because of latency recovery.
   EXPECT_FALSE(client_->HasAction("ScheduledActionSendBeginMainFrame"));
   EXPECT_FALSE(client_->HasAction("ScheduledActionDrawAndSwapIfPossible"));
   EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
 
   // Lower estimates so that the scheduler will attempt latency recovery.
-  auto fast_duration = base::TimeDelta::FromMilliseconds(1);
-  fake_compositor_timing_history_->SetAllEstimatesTo(fast_duration);
+  fake_compositor_timing_history_->SetAllEstimatesTo(kFastDuration);
 
   // Now that both threads are in a high latency mode, make sure we
   // skip the BeginMainFrame, then the BeginImplFrame, but not both
   // at the same time.
 
   // Verify we skip BeginMainFrame first.
   client_->Reset();
   // Previous commit request is still outstanding.
   EXPECT_TRUE(scheduler_->NeedsBeginMainFrame());
   EXPECT_TRUE(scheduler_->SwapThrottled());
@@ skipping 1635 matching lines @@
   EXPECT_SCOPED(AdvanceFrame());
 
   // At the next BeginFrame, authoritative interval is used instead of previous
   // interval.
   EXPECT_NE(initial_interval, scheduler_->BeginImplFrameInterval());
   EXPECT_EQ(authoritative_interval, scheduler_->BeginImplFrameInterval());
 }
 
 TEST_F(SchedulerTest, ImplLatencyTakesPriority) {
   SetUpScheduler(true);
-  scheduler_->SetImplLatencyTakesPriority(true);
+
+  scheduler_->SetSmoothnessMode(SMOOTHNESS_TAKES_PRIORITY,
+                                SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER);
+  scheduler_->SetCriticalBeginMainFrameToActivateIsFast(true);
+  EXPECT_TRUE(scheduler_->ImplLatencyTakesPriority());
+  scheduler_->SetCriticalBeginMainFrameToActivateIsFast(false);
   EXPECT_TRUE(scheduler_->ImplLatencyTakesPriority());
 
-  scheduler_->SetImplLatencyTakesPriority(false);
+  scheduler_->SetSmoothnessMode(SMOOTHNESS_TAKES_PRIORITY,
+                                SCROLL_AFFECTS_SCROLL_HANDLER);
+  scheduler_->SetCriticalBeginMainFrameToActivateIsFast(true);
+  EXPECT_FALSE(scheduler_->ImplLatencyTakesPriority());
+  scheduler_->SetCriticalBeginMainFrameToActivateIsFast(false);
+  EXPECT_TRUE(scheduler_->ImplLatencyTakesPriority());
+
+  scheduler_->SetSmoothnessMode(SAME_PRIORITY_FOR_BOTH_TREES,
+                                SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER);
+  scheduler_->SetCriticalBeginMainFrameToActivateIsFast(true);
+  EXPECT_FALSE(scheduler_->ImplLatencyTakesPriority());
+  scheduler_->SetCriticalBeginMainFrameToActivateIsFast(false);
+  EXPECT_FALSE(scheduler_->ImplLatencyTakesPriority());
+
+  scheduler_->SetSmoothnessMode(SAME_PRIORITY_FOR_BOTH_TREES,
+                                SCROLL_AFFECTS_SCROLL_HANDLER);
+  scheduler_->SetCriticalBeginMainFrameToActivateIsFast(true);
+  EXPECT_FALSE(scheduler_->ImplLatencyTakesPriority());
+  scheduler_->SetCriticalBeginMainFrameToActivateIsFast(false);
   EXPECT_FALSE(scheduler_->ImplLatencyTakesPriority());
 }
 
-TEST_F(SchedulerTest, BeginMainFrameArgs_OnCriticalPath) {
+// The three letters appeneded to each version of this test mean the following:s
+// tree_priority: B = both trees same priority; A = active tree priority;
+// scroll_handler_state: H = affects scroll handler; N = does not affect scroll
+// handler;
+// durations: F = fast durations; S = slow durations
+bool SchedulerTest::BeginMainFrameOnCriticalPath(
+    TreePriority tree_priority,
+    ScrollHandlerState scroll_handler_state,
+    base::TimeDelta durations) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
-
-  scheduler_->SetImplLatencyTakesPriority(false);
+  fake_compositor_timing_history_->SetAllEstimatesTo(durations);
+  client_->Reset();
+  scheduler_->SetSmoothnessMode(tree_priority, scroll_handler_state);
   scheduler_->SetNeedsBeginMainFrame();
-
-  client_->Reset();
   EXPECT_FALSE(client_->last_begin_main_frame_args().IsValid());
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_TRUE(client_->last_begin_main_frame_args().IsValid());
-  EXPECT_TRUE(client_->last_begin_main_frame_args().on_critical_path);
+  return client_->last_begin_main_frame_args().on_critical_path;
 }
 
-TEST_F(SchedulerTest, BeginMainFrameArgs_NotOnCriticalPath) {
-  scheduler_settings_.use_external_begin_frame_source = true;
-  SetUpScheduler(true);
+TEST_F(SchedulerTest, BeginMainFrameOnCriticalPath_BNF) {
+  EXPECT_TRUE(BeginMainFrameOnCriticalPath(
+      SAME_PRIORITY_FOR_BOTH_TREES, SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER,
+      kFastDuration));
+}
 
-  scheduler_->SetImplLatencyTakesPriority(true);
-  scheduler_->SetNeedsBeginMainFrame();
+TEST_F(SchedulerTest, BeginMainFrameOnCriticalPath_BNS) {
+  EXPECT_TRUE(BeginMainFrameOnCriticalPath(
+      SAME_PRIORITY_FOR_BOTH_TREES, SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER,
+      kSlowDuration));
+}
 
-  client_->Reset();
-  EXPECT_FALSE(client_->last_begin_main_frame_args().IsValid());
-  EXPECT_SCOPED(AdvanceFrame());
-  EXPECT_TRUE(client_->last_begin_main_frame_args().IsValid());
-  EXPECT_FALSE(client_->last_begin_main_frame_args().on_critical_path);
+TEST_F(SchedulerTest, BeginMainFrameOnCriticalPath_BHF) {
+  EXPECT_TRUE(BeginMainFrameOnCriticalPath(SAME_PRIORITY_FOR_BOTH_TREES,
+                                           SCROLL_AFFECTS_SCROLL_HANDLER,
+                                           kFastDuration));
+}
+
+TEST_F(SchedulerTest, BeginMainFrameOnCriticalPath_BHS) {
+  EXPECT_TRUE(BeginMainFrameOnCriticalPath(SAME_PRIORITY_FOR_BOTH_TREES,
+                                           SCROLL_AFFECTS_SCROLL_HANDLER,
+                                           kSlowDuration));
+}
+
+TEST_F(SchedulerTest, BeginMainFrameOnCriticalPath_ANF) {
+  EXPECT_FALSE(BeginMainFrameOnCriticalPath(
+      SMOOTHNESS_TAKES_PRIORITY, SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER,
+      kFastDuration));
+}
+
+TEST_F(SchedulerTest, BeginMainFrameOnCriticalPath_ANS) {
+  EXPECT_FALSE(BeginMainFrameOnCriticalPath(
+      SMOOTHNESS_TAKES_PRIORITY, SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER,
+      kSlowDuration));
+}
+
+TEST_F(SchedulerTest, BeginMainFrameOnCriticalPath_AHF) {
+  EXPECT_TRUE(BeginMainFrameOnCriticalPath(
+      SMOOTHNESS_TAKES_PRIORITY, SCROLL_AFFECTS_SCROLL_HANDLER, kFastDuration));
+}
+
+TEST_F(SchedulerTest, BeginMainFrameOnCriticalPath_AHS) {
+  EXPECT_FALSE(BeginMainFrameOnCriticalPath(
+      SMOOTHNESS_TAKES_PRIORITY, SCROLL_AFFECTS_SCROLL_HANDLER, kSlowDuration));
 }
 
 }  // namespace
 }  // namespace cc