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 28 matching lines @@
       needs_animate_(false),
       needs_prepare_tiles_(false),
       needs_begin_main_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),
+      smoothness_takes_priority_(false),
+      scroll_affects_scroll_handler_(false),
+      main_thread_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 168 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->SetBoolean("smoothness_takes_priority", smoothness_takes_priority_);
+  state->SetBoolean("scroll_affects_scroll_handler",
+                    scroll_affects_scroll_handler_);
+  state->SetBoolean("main_thread_is_fast", main_thread_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 412 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 53 matching lines @@
   DCHECK_LE(pending_swaps_, max_pending_swaps_);
 
   did_perform_swap_in_last_draw_ = true;
   last_frame_number_swap_performed_ = current_frame_number_;
 }
 
 void SchedulerStateMachine::DidSwapBuffersComplete() {
   pending_swaps_--;
 }
 
-void SchedulerStateMachine::SetImplLatencyTakesPriority(
-    bool impl_latency_takes_priority) {
-  impl_latency_takes_priority_ = impl_latency_takes_priority;
+void SchedulerStateMachine::SetSmoothnessMode(
+    bool smoothness_takes_priority,
+    bool scroll_affects_scroll_handler) {
+  smoothness_takes_priority_ = smoothness_takes_priority;
+  scroll_affects_scroll_handler_ = scroll_affects_scroll_handler;
+}
+
+void SchedulerStateMachine::SetMainThreadIsFast(bool is_fast) {
+  main_thread_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 (scroll_affects_scroll_handler_ && main_thread_is_fast_)

[brianderson, 2015/10/29 17:56:51]

Somewhat related to this patch, I wonder if we should have a
SynchronizationTakesPriority mode that sets the deadline to be the next
interval, where SynchronizationTakesPriority is equal to this condition and
would tell the TileManager to make the tree priorities more equal.

[Sami, 2015/10/29 18:37:04]

I think that describes the underlying thing pretty well. We'd probably want that
to kick in for all the existing things plus rAF and main thread animations.

+    return false;
+
+  // Don't wait for the main thread if we are prioritizing smoothness.
+  if (smoothness_takes_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 116 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