cc: Simplify and rename MainThreadIsInHighLatency logic

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 1313 matching lines @@
   task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_ACTION("ScheduledActionBeginOutputSurfaceCreation", client_, 0, 3);
   EXPECT_ACTION("SetNeedsBeginFrames(false)", client_, 1, 3);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 2, 3);
 }
 
 void SchedulerTest::CheckMainFrameSkippedAfterLateCommit(
     bool expect_send_begin_main_frame) {
   // Impl thread hits deadline before commit finishes.
   scheduler_->SetNeedsCommit();
-  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   EXPECT_SCOPED(AdvanceFrame());
-  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
-  EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
   scheduler_->NotifyBeginMainFrameStarted();
   scheduler_->NotifyReadyToCommit();
   scheduler_->NotifyReadyToActivate();
   EXPECT_ACTION("SetNeedsBeginFrames(true)", client_, 0, 5);
   EXPECT_ACTION("WillBeginImplFrame", client_, 1, 5);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 2, 5);
   EXPECT_ACTION("ScheduledActionCommit", client_, 3, 5);
   EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 4, 5);
-  EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
 
   client_->Reset();
   scheduler_->SetNeedsCommit();
-  EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
   EXPECT_SCOPED(AdvanceFrame());
-  EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
   task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
   EXPECT_EQ(expect_send_begin_main_frame,
-            scheduler_->MainThreadIsInHighLatencyMode());
+            scheduler_->MainThreadMissedLastDeadline());
   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);
@@ skipping 77 matching lines @@
 void SchedulerTest::ImplFrameSkippedAfterLateSwapAck(
     bool swap_ack_before_deadline) {
   // To get into a high latency state, this test disables automatic swap acks.
   scheduler_->SetMaxSwapsPending(1);
   client_->SetAutomaticSwapAck(false);
 
   // Draw and swap for first BeginFrame
   client_->Reset();
   scheduler_->SetNeedsCommit();
   scheduler_->SetNeedsRedraw();
-  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   SendNextBeginFrame();
   EXPECT_ACTION("SetNeedsBeginFrames(true)", client_, 0, 4);
   EXPECT_ACTION("WillBeginImplFrame", client_, 1, 4);
   EXPECT_ACTION("ScheduledActionAnimate", client_, 2, 4);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 3, 4);
 
   client_->Reset();
   scheduler_->NotifyBeginMainFrameStarted();
   scheduler_->NotifyReadyToCommit();
   scheduler_->NotifyReadyToActivate();
-  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
   EXPECT_ACTION("ScheduledActionCommit", client_, 0, 4);
   EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 1, 4);
   EXPECT_ACTION("ScheduledActionAnimate", client_, 2, 4);
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 3, 4);
 
   // Verify we skip every other frame if the swap ack consistently
   // comes back late.
   for (int i = 0; i < 10; i++) {
     // Not calling scheduler_->DidSwapBuffersComplete() until after next
     // BeginImplFrame puts the impl thread in high latency mode.
     client_->Reset();
     scheduler_->SetNeedsCommit();
     scheduler_->SetNeedsRedraw();
-    EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+    EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
     SendNextBeginFrame();
     // Verify that we skip the BeginImplFrame
     EXPECT_NO_ACTION(client_);
     EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
-    EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+    EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
 
     // Verify that we do not perform any actions after we are no longer
     // swap throttled.
     client_->Reset();
     if (swap_ack_before_deadline) {
       // It shouldn't matter if the swap ack comes back before the deadline...
       scheduler_->DidSwapBuffersComplete();
       task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
     } else {
       // ... or after the deadline.
       task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
       scheduler_->DidSwapBuffersComplete();
     }
     EXPECT_NO_ACTION(client_);
 
     // Verify that we start the next BeginImplFrame and continue normally
     // after having just skipped a BeginImplFrame.
     client_->Reset();
-    EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+    EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
     SendNextBeginFrame();
     EXPECT_ACTION("WillBeginImplFrame", client_, 0, 3);
     EXPECT_ACTION("ScheduledActionAnimate", client_, 1, 3);
     EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 2, 3);
 
     client_->Reset();
     scheduler_->NotifyBeginMainFrameStarted();
     scheduler_->NotifyReadyToCommit();
     scheduler_->NotifyReadyToActivate();
     task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
@@ skipping 60 matching lines @@
   // 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);
 
   // Draw and swap for first BeginFrame
   client_->Reset();
   scheduler_->SetNeedsRedraw();
-  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   SendNextBeginFrame();
   EXPECT_ACTION("SetNeedsBeginFrames(true)", client_, 0, 3);
   EXPECT_ACTION("WillBeginImplFrame", client_, 1, 3);
   EXPECT_ACTION("ScheduledActionAnimate", client_, 2, 3);
 
   client_->Reset();
-  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
   EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client_);
 
   // Verify we skip every other frame if the swap ack consistently
   // comes back late.
   for (int i = 0; i < 10; i++) {
     // Not calling scheduler_->DidSwapBuffersComplete() until after next
     // BeginImplFrame puts the impl thread in high latency mode.
     client_->Reset();
     scheduler_->SetNeedsRedraw();
-    EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+    EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
     SendNextBeginFrame();
     // Verify that we skip the BeginImplFrame
     EXPECT_NO_ACTION(client_);
     EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
-    EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+    EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
 
     // Verify that we do not perform any actions after we are no longer
     // swap throttled.
     client_->Reset();
     scheduler_->DidSwapBuffersComplete();
     EXPECT_NO_ACTION(client_);
 
     // Verify that we start the next BeginImplFrame and continue normally
     // after having just skipped a BeginImplFrame.
     client_->Reset();
-    EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+    EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
     SendNextBeginFrame();
     EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
     EXPECT_ACTION("ScheduledActionAnimate", client_, 1, 2);
 
     client_->Reset();
     // Deadline should be immediate.
     EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
     task_runner().RunUntilTime(now_src_->NowTicks());
     EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
     EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client_);
   }
 }
 
 void SchedulerTest::ImplFrameIsNotSkippedAfterLateSwapAck() {
   // To get into a high latency state, this test disables automatic swap acks.
   scheduler_->SetMaxSwapsPending(1);
   client_->SetAutomaticSwapAck(false);
 
   // Draw and swap for first BeginFrame
   client_->Reset();
   scheduler_->SetNeedsCommit();
-  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   SendNextBeginFrame();
   EXPECT_ACTION("SetNeedsBeginFrames(true)", client_, 0, 3);
   EXPECT_ACTION("WillBeginImplFrame", client_, 1, 3);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 2, 3);
 
   client_->Reset();
   scheduler_->NotifyBeginMainFrameStarted();
   scheduler_->NotifyReadyToCommit();
   scheduler_->NotifyReadyToActivate();
-  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
   EXPECT_ACTION("ScheduledActionCommit", client_, 0, 4);
   EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 1, 4);
   EXPECT_ACTION("ScheduledActionAnimate", client_, 2, 4);
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 3, 4);
 
   // Verify impl thread consistently operates in high latency mode
   // without skipping any frames.
   for (int i = 0; i < 10; i++) {
     // Not calling scheduler_->DidSwapBuffersComplete() until after next frame
     // puts the impl thread in high latency mode.
     client_->Reset();
     scheduler_->SetNeedsCommit();
-    EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+    EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
     SendNextBeginFrame();
     EXPECT_SINGLE_ACTION("WillBeginImplFrame", client_);
     EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
-    EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+    EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
 
     client_->Reset();
     scheduler_->DidSwapBuffersComplete();
     scheduler_->NotifyBeginMainFrameStarted();
     scheduler_->NotifyReadyToCommit();
     scheduler_->NotifyReadyToActivate();
     task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
 
     // Verify that we don't skip the actions of the BeginImplFrame
     EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 0, 5);
@@ skipping 60 matching lines @@
   SetUpScheduler(true);
 
   auto slow_duration = base::TimeDelta::FromSeconds(1);
   fake_compositor_timing_history_->SetAllEstimatesTo(slow_duration);
 
   // 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
-  // MainThreadIsInHighLatencyMode true
+  // MainThreadMissedLastDeadline true
   client_->Reset();
   scheduler_->SetNeedsCommit();
-  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   EXPECT_SCOPED(AdvanceFrame());
-  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
-  EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
   scheduler_->NotifyBeginMainFrameStarted();
   scheduler_->NotifyReadyToCommit();
   scheduler_->NotifyReadyToActivate();
-  EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
 
   EXPECT_ACTION("SetNeedsBeginFrames(true)", client_, 0, 5);
   EXPECT_ACTION("WillBeginImplFrame", client_, 1, 5);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 2, 5);
   EXPECT_ACTION("ScheduledActionCommit", client_, 3, 5);
   EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 4, 5);
 
   // Draw and swap for first commit, start second commit.
   client_->Reset();
   scheduler_->SetNeedsCommit();
-  EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
   EXPECT_SCOPED(AdvanceFrame());
-  EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
   task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
   scheduler_->NotifyBeginMainFrameStarted();
   scheduler_->NotifyReadyToCommit();
   scheduler_->NotifyReadyToActivate();
 
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 6);
   EXPECT_ACTION("ScheduledActionAnimate", client_, 1, 6);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 2, 6);
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 3, 6);
   EXPECT_ACTION("ScheduledActionCommit", client_, 4, 6);
   EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 5, 6);
 
   // Don't call scheduler_->DidSwapBuffersComplete() until after next frame
   // to put the impl thread in a high latency mode.
   client_->Reset();
   scheduler_->SetNeedsCommit();
-  EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode());
-  EXPECT_TRUE(scheduler_->SwapThrottled());
+  EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
   EXPECT_SCOPED(AdvanceFrame());
-  EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
   task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
 
   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_->MainThreadIsInHighLatencyMode());
+  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);
 
   // 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_->NeedsCommit());
   EXPECT_TRUE(scheduler_->SwapThrottled());
   SendNextBeginFrame();
-  EXPECT_TRUE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_TRUE(scheduler_->MainThreadMissedLastDeadline());
   scheduler_->DidSwapBuffersComplete();
   task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
 
-  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 3);
   EXPECT_ACTION("ScheduledActionAnimate", client_, 1, 3);
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 2, 3);
 
   // Verify we skip the BeginImplFrame second.
   client_->Reset();
   // Previous commit request is still outstanding.
   EXPECT_TRUE(scheduler_->NeedsCommit());
-  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   SendNextBeginFrame();
   task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
-  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   scheduler_->DidSwapBuffersComplete();
-  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
 
   EXPECT_NO_ACTION(client_);
 
   // Then verify we operate in a low latency mode.
   client_->Reset();
   // Previous commit request is still outstanding.
   EXPECT_TRUE(scheduler_->NeedsCommit());
-  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   SendNextBeginFrame();
-  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   scheduler_->NotifyBeginMainFrameStarted();
   scheduler_->NotifyReadyToCommit();
   scheduler_->NotifyReadyToActivate();
   task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
-  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
   scheduler_->DidSwapBuffersComplete();
-  EXPECT_FALSE(scheduler_->MainThreadIsInHighLatencyMode());
+  EXPECT_FALSE(scheduler_->MainThreadMissedLastDeadline());
 
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 6);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 6);
   EXPECT_ACTION("ScheduledActionCommit", client_, 2, 6);
   EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 3, 6);
   EXPECT_ACTION("ScheduledActionAnimate", client_, 4, 6);
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 5, 6);
 }
 
 TEST_F(
@@ skipping 1628 matching lines @@
   scheduler_->SetImplLatencyTakesPriority(true);
   scheduler_->SetChildrenNeedBeginFrames(true);
 
   EXPECT_SCOPED(AdvanceFrame());
   EXPECT_TRUE(client_->begin_frame_is_sent_to_children());
   EXPECT_FALSE(client_->begin_frame_args_sent_to_children().on_critical_path);
 }
 
 }  // namespace
 }  // namespace cc