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 467 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 894 matching lines @@
 
   bool expect_send_begin_main_frame = false;
   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);
+  scheduler_->SetSmoothnessMode(true, false);
 
   auto fast_duration = base::TimeDelta::FromMilliseconds(1);
   fake_compositor_timing_history_->SetAllEstimatesTo(fast_duration);
 
   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_
+      ->SetBeginMainFrameStartToCommitDurationEstimate(slow_duration);
 
   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);
@@ skipping 138 matching lines @@
 }
 
 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);
+  scheduler_->SetSmoothnessMode(true, false);
   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);
 
   bool swap_ack_before_deadline = false;
   EXPECT_SCOPED(ImplFrameSkippedAfterLateSwapAck(swap_ack_before_deadline));
 }
 
 TEST_F(SchedulerTest,
@@ skipping 119 matching lines @@
   }
 }
 
 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_
+      ->SetBeginMainFrameStartToCommitDurationEstimate(slow_duration);
   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);
@@ skipping 1746 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(true, false);
   EXPECT_TRUE(scheduler_->ImplLatencyTakesPriority());
 
-  scheduler_->SetImplLatencyTakesPriority(false);
+  scheduler_->SetSmoothnessMode(false, false);
   EXPECT_FALSE(scheduler_->ImplLatencyTakesPriority());
 }
 
 TEST_F(SchedulerTest, BeginMainFrameArgs_OnCriticalPath) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
 
-  scheduler_->SetImplLatencyTakesPriority(false);
+  scheduler_->SetSmoothnessMode(false, false);
   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);
 }
 
 TEST_F(SchedulerTest, BeginMainFrameArgs_NotOnCriticalPath) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
 
-  scheduler_->SetImplLatencyTakesPriority(true);
+  scheduler_->SetSmoothnessMode(true, false);
   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_FALSE(client_->last_begin_main_frame_args().on_critical_path);
 }
 
 }  // namespace
 }  // namespace cc