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

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 33 matching lines @@
       needs_prepare_tiles_(false),
       needs_begin_main_frame_(false),
       needs_one_begin_impl_frame_(false),
       visible_(false),
       resourceless_draw_(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),
+      tree_priority_(NEW_CONTENT_TAKES_PRIORITY),
+      scroll_handler_state_(
+          ScrollHandlerState::SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER),
+      critical_begin_main_frame_to_activate_is_fast_(true),
       main_thread_missed_last_deadline_(false),
       skip_next_begin_main_frame_to_reduce_latency_(false),
       children_need_begin_frames_(false),
       defer_commits_(false),
       video_needs_begin_frames_(false),
       last_commit_had_no_updates_(false),
       wait_for_ready_to_draw_(false),
       did_request_swap_in_last_frame_(false),
       did_perform_swap_in_last_draw_(false) {}
 
@@ skipping 78 matching lines @@
       return "FORCED_REDRAW_STATE_WAITING_FOR_COMMIT";
     case FORCED_REDRAW_STATE_WAITING_FOR_ACTIVATION:
       return "FORCED_REDRAW_STATE_WAITING_FOR_ACTIVATION";
     case FORCED_REDRAW_STATE_WAITING_FOR_DRAW:
       return "FORCED_REDRAW_STATE_WAITING_FOR_DRAW";
   }
   NOTREACHED();
   return "???";
 }
 
+const char* ScrollHandlerStateToString(ScrollHandlerState state) {
+  switch (state) {
+    case ScrollHandlerState::SCROLL_AFFECTS_SCROLL_HANDLER:
+      return "SCROLL_AFFECTS_SCROLL_HANDLER";
+    case ScrollHandlerState::SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER:
+      return "SCROLL_DOES_NOT_AFFECT_SCROLL_HANDLER";
+  }
+  NOTREACHED();
+  return "???";
+}
+
 const char* SchedulerStateMachine::ActionToString(Action action) {
   switch (action) {
     case ACTION_NONE:
       return "ACTION_NONE";
     case ACTION_ANIMATE:
       return "ACTION_ANIMATE";
     case ACTION_SEND_BEGIN_MAIN_FRAME:
       return "ACTION_SEND_BEGIN_MAIN_FRAME";
     case ACTION_COMMIT:
       return "ACTION_COMMIT";
@@ skipping 70 matching lines @@
   state->SetBoolean("can_draw", can_draw_);
   state->SetBoolean("resourceless_draw", resourceless_draw_);
   state->SetBoolean("has_pending_tree", has_pending_tree_);
   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_ready_to_draw", wait_for_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->SetString("tree_priority", TreePriorityToString(tree_priority_));
+  state->SetString("scroll_handler_state",
+                   ScrollHandlerStateToString(scroll_handler_state_));
+  state->SetBoolean("critical_begin_main_frame_to_activate_is_fast_",
+                    critical_begin_main_frame_to_activate_is_fast_);
   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("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_);
@@ skipping 173 matching lines @@
     return false;
 
   // Only send BeginMainFrame when there isn't another commit pending already.
   // Other parts of the state machine indirectly defer the BeginMainFrame
   // by transitioning to WAITING commit states rather than going
   // immediately to IDLE.
   if (begin_main_frame_state_ != BEGIN_MAIN_FRAME_STATE_IDLE)
     return false;
 
   // Don't send BeginMainFrame early if we are prioritizing the active tree
-  // because of impl_latency_takes_priority_.
-  if (impl_latency_takes_priority_ &&
+  // because of ImplLatencyTakesPriority.
+  if (ImplLatencyTakesPriority() &&
       (has_pending_tree_ || active_tree_needs_first_draw_)) {
     return false;
   }
 
   // We should not send BeginMainFrame while we are in the idle state since we
   // might have new user input arriving soon. It's okay to send BeginMainFrame
   // for the synchronous compositor because the main thread is always high
   // latency in that case.
   // TODO(brianderson): Allow sending BeginMainFrame while idle when the main
   // thread isn't consuming user input for non-synchronous compositor.
@@ skipping 15 matching lines @@
     return false;
 
   // Make sure the BeginMainFrame can finish eventually if we start it.
   if (SendingBeginMainFrameMightCauseDeadlock())
     return false;
 
   if (!settings_.main_frame_while_swap_throttled_enabled) {
     // SwapAck throttle the BeginMainFrames unless we just swapped to
     // potentially improve impl-thread latency over main-thread throughput.
     // TODO(brianderson): Remove this restriction to improve throughput or
-    // make it conditional on impl_latency_takes_priority_.
+    // make it conditional on ImplLatencyTakesPriority.
     bool just_swapped_in_deadline =
         begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE &&
         did_perform_swap_in_last_draw_;
     if (SwapThrottled() && !just_swapped_in_deadline)
       return false;
   }
 
   if (skip_next_begin_main_frame_to_reduce_latency_)
     return false;
 
@@ skipping 410 matching lines @@
 
   // This is used to prioritize impl-thread draws when the main thread isn't
   // producing anything, e.g., after an aborted commit. We also check that we
   // don't have a pending tree -- otherwise we should give it a chance to
   // activate.
   // TODO(skyostil): Revisit this when we have more accurate deadline estimates.
   if (begin_main_frame_state_ == BEGIN_MAIN_FRAME_STATE_IDLE &&
       !has_pending_tree_)
     return true;
 
-  // Prioritize impl-thread draws in impl_latency_takes_priority_ mode.
-  if (impl_latency_takes_priority_)
+  // Prioritize impl-thread draws in ImplLatencyTakesPriority mode.
+  if (ImplLatencyTakesPriority())
     return true;
 
   return false;
 }
 
 bool SchedulerStateMachine::main_thread_missed_last_deadline() const {
   return main_thread_missed_last_deadline_;
 }
 
 bool SchedulerStateMachine::SwapThrottled() const {
@@ skipping 51 matching lines @@
 
   did_perform_swap_in_last_draw_ = true;
   last_frame_number_swap_performed_ = current_frame_number_;
 }
 
 void SchedulerStateMachine::DidSwapBuffersComplete() {
   TRACE_EVENT_ASYNC_END0("cc", "Scheduler:pending_swaps", this);
   pending_swaps_--;
 }
 
-void SchedulerStateMachine::SetImplLatencyTakesPriority(
-    bool impl_latency_takes_priority) {
-  impl_latency_takes_priority_ = impl_latency_takes_priority;
+void SchedulerStateMachine::SetTreePrioritiesAndScrollState(
+    TreePriority tree_priority,
+    ScrollHandlerState scroll_handler_state) {
+  tree_priority_ = tree_priority;
+  scroll_handler_state_ = scroll_handler_state;
+}
+
+void SchedulerStateMachine::SetCriticalBeginMainFrameToActivateIsFast(
+    bool is_fast) {
+  critical_begin_main_frame_to_activate_is_fast_ = is_fast;
+}
+
+bool SchedulerStateMachine::ImplLatencyTakesPriority() const {
+  // Attempt to synchronize with the main thread if it has a scroll listener
+  // and is fast.
+  if (ScrollHandlerState::SCROLL_AFFECTS_SCROLL_HANDLER ==
+          scroll_handler_state_ &&
+      critical_begin_main_frame_to_activate_is_fast_)
+    return false;
+
+  // Don't wait for the main thread if we are prioritizing smoothness.
+  if (SMOOTHNESS_TAKES_PRIORITY == tree_priority_)
+    return true;
+
+  return false;
 }
 
 void SchedulerStateMachine::DidDrawIfPossibleCompleted(DrawResult result) {
   switch (result) {
     case INVALID_RESULT:
       NOTREACHED() << "Uninitialized DrawResult.";
       break;
     case DRAW_ABORTED_CANT_DRAW:
     case DRAW_ABORTED_CONTEXT_LOST:
       NOTREACHED() << "Invalid return value from DrawAndSwapIfPossible:"
@@ skipping 120 matching lines @@
     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