cc: Simplify and rename MainThreadIsInHighLatency logic

cc/scheduler/scheduler_state_machine.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_state_machine.h"
 
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 29 matching lines @@
       needs_prepare_tiles_(false),
       needs_commit_(false),
       visible_(false),
       can_start_(false),
       can_draw_(false),
       has_pending_tree_(false),
       pending_tree_is_ready_for_activation_(false),
       active_tree_needs_first_draw_(false),
       did_create_and_initialize_first_output_surface_(false),
       impl_latency_takes_priority_(false),
+      main_thread_missed_last_deadline_(false),
       skip_next_begin_main_frame_to_reduce_latency_(false),
       continuous_painting_(false),
       children_need_begin_frames_(false),
       defer_commits_(false),
       video_needs_begin_frames_(false),
       last_commit_had_no_updates_(false),
       wait_for_active_tree_ready_to_draw_(false),
       did_request_swap_in_last_frame_(false),
       did_perform_swap_in_last_draw_(false) {
 }
@@ skipping 170 matching lines @@
   state->SetBoolean("pending_tree_is_ready_for_activation",
                     pending_tree_is_ready_for_activation_);
   state->SetBoolean("active_tree_needs_first_draw",
                     active_tree_needs_first_draw_);
   state->SetBoolean("wait_for_active_tree_ready_to_draw",
                     wait_for_active_tree_ready_to_draw_);
   state->SetBoolean("did_create_and_initialize_first_output_surface",
                     did_create_and_initialize_first_output_surface_);
   state->SetBoolean("impl_latency_takes_priority",
                     impl_latency_takes_priority_);
-  state->SetBoolean("main_thread_is_in_high_latency_mode",
-                    MainThreadIsInHighLatencyMode());
+  state->SetBoolean("main_thread_missed_last_deadline",
+                    main_thread_missed_last_deadline_);
   state->SetBoolean("skip_next_begin_main_frame_to_reduce_latency",
                     skip_next_begin_main_frame_to_reduce_latency_);
   state->SetBoolean("continuous_painting", continuous_painting_);
   state->SetBoolean("children_need_begin_frames", children_need_begin_frames_);
   state->SetBoolean("video_needs_begin_frames", video_needs_begin_frames_);
   state->SetBoolean("defer_commits", defer_commits_);
   state->SetBoolean("last_commit_had_no_updates", last_commit_had_no_updates_);
   state->SetBoolean("did_request_swap_in_last_frame",
                     did_request_swap_in_last_frame_);
   state->SetBoolean("did_perform_swap_in_last_draw",
@@ skipping 620 matching lines @@
   if (settings_.using_synchronous_renderer_compositor) {
     if (prepare_tiles_funnel_ > 0)
       prepare_tiles_funnel_--;
   }
 }
 
 void SchedulerStateMachine::OnBeginImplFrameIdle() {
   begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_IDLE;
 
   skip_next_begin_main_frame_to_reduce_latency_ = false;
+
+  // If a new or undrawn active tree is pending after the deadline,
+  // then the main thread is in a high latency mode.
+  main_thread_missed_last_deadline_ =
+      CommitPending() || has_pending_tree_ || active_tree_needs_first_draw_;
 }
 
 SchedulerStateMachine::BeginImplFrameDeadlineMode
 SchedulerStateMachine::CurrentBeginImplFrameDeadlineMode() const {
   if (settings_.using_synchronous_renderer_compositor) {
     // No deadline for synchronous compositor.
     return BEGIN_IMPL_FRAME_DEADLINE_MODE_NONE;
   } else if (wait_for_active_tree_ready_to_draw_) {
     // When we are waiting for ready to draw signal, we do not wait to post a
     // deadline yet.
@@ skipping 40 matching lines @@
   if (commit_state_ == COMMIT_STATE_IDLE && !has_pending_tree_)
     return true;
 
   // Prioritize impl-thread draws in impl_latency_takes_priority_ mode.
   if (impl_latency_takes_priority_)
     return true;
 
   return false;
 }
 
-bool SchedulerStateMachine::MainThreadIsInHighLatencyMode() const {
-  // If a commit is pending before the previous commit has been drawn, we
-  // are definitely in a high latency mode.
-  if (CommitPending() && (active_tree_needs_first_draw_ || has_pending_tree_))
-    return true;
-
-  // If we just sent a BeginMainFrame and haven't hit the deadline yet, the main
-  // thread is in a low latency mode.
-  if (send_begin_main_frame_funnel_ &&
-      (begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING ||
-       begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME))
-    return false;
-
-  // If there's a commit in progress it must either be from the previous frame
-  // or it started after the impl thread's deadline. In either case the main
-  // thread is in high latency mode.
-  if (CommitPending())
-    return true;
-
-  // Similarly, if there's a pending tree the main thread is in high latency
-  // mode, because either
-  //   it's from the previous frame
-  // or
-  //   we're currently drawing the active tree and the pending tree will thus
-  //   only be drawn in the next frame.
-  if (has_pending_tree_)
-    return true;
-
-  if (begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE) {
-    // Even if there's a new active tree to draw at the deadline or we've just
-    // swapped it, it may have been triggered by a previous BeginImplFrame, in
-    // which case the main thread is in a high latency mode.
-    return (active_tree_needs_first_draw_ || did_perform_swap_in_last_draw_) &&
-           !send_begin_main_frame_funnel_;
-  }
-
-  // If the active tree needs its first draw in any other state, we know the
-  // main thread is in a high latency mode.
-  return active_tree_needs_first_draw_;
+bool SchedulerStateMachine::main_thread_missed_last_deadline() const {
+  return main_thread_missed_last_deadline_;
 }
 
 bool SchedulerStateMachine::SwapThrottled() const {
   return pending_swaps_ >= max_pending_swaps_;
 }
 
-void SchedulerStateMachine::SetVisible(bool visible) { visible_ = visible; }
+void SchedulerStateMachine::SetVisible(bool visible) {
+  if (visible_ == visible)
+    return;
+
+  if (visible)
+    main_thread_missed_last_deadline_ = false;
+
+  visible_ = visible;
+}
 
 void SchedulerStateMachine::SetCanDraw(bool can_draw) { can_draw_ = can_draw; }
 
 void SchedulerStateMachine::SetNeedsRedraw() { needs_redraw_ = true; }
 
 void SchedulerStateMachine::SetNeedsAnimate() {
   needs_animate_ = true;
 }
 
 void SchedulerStateMachine::SetWaitForReadyToDraw() {
@@ skipping 140 matching lines @@
   output_surface_state_ = OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT;
 
   if (did_create_and_initialize_first_output_surface_) {
     // TODO(boliu): See if we can remove this when impl-side painting is always
     // on. Does anything on the main thread need to update after recreate?
     needs_commit_ = true;
   }
   did_create_and_initialize_first_output_surface_ = true;
   pending_swaps_ = 0;
   swaps_with_current_output_surface_ = 0;
+  main_thread_missed_last_deadline_ = false;

[sunnyps, 2015/07/13 20:03:09]

It looks like we need to set main_thread_missed_last_deadline_ to false whenever
NeedsBeginFrames goes from false to true. I need to do something similar in an
upcoming CL for a webview bug.

 }
 
 void SchedulerStateMachine::NotifyBeginMainFrameStarted() {
   DCHECK_EQ(commit_state_, COMMIT_STATE_BEGIN_MAIN_FRAME_SENT);
   commit_state_ = COMMIT_STATE_BEGIN_MAIN_FRAME_STARTED;
 }
 
 bool SchedulerStateMachine::HasInitializedOutputSurface() const {
   switch (output_surface_state_) {
     case OUTPUT_SURFACE_LOST:
     case OUTPUT_SURFACE_CREATING:
       return false;
 
     case OUTPUT_SURFACE_ACTIVE:
     case OUTPUT_SURFACE_WAITING_FOR_FIRST_COMMIT:
     case OUTPUT_SURFACE_WAITING_FOR_FIRST_ACTIVATION:
       return true;
   }
   NOTREACHED();
   return false;
 }
 
 }  // namespace cc