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

cc/scheduler/scheduler.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 <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
@@ skipping 192 matching lines @@
     DCHECK_EQ(state_machine_.NextAction(), SchedulerStateMachine::ACTION_NONE);
   }
 }
 
 void Scheduler::DidSwapBuffersComplete() {
   DCHECK_GT(state_machine_.pending_swaps(), 0) << AsValue()->ToString();
   state_machine_.DidSwapBuffersComplete();
   ProcessScheduledActions();
 }
 
-void Scheduler::SetImplLatencyTakesPriority(bool impl_latency_takes_priority) {
-  state_machine_.SetImplLatencyTakesPriority(impl_latency_takes_priority);
+void Scheduler::SetSmoothnessMode(bool smoothness_takes_priority,
+                                  bool scroll_affects_scroll_handler) {
+  state_machine_.SetSmoothnessMode(smoothness_takes_priority,
+                                   scroll_affects_scroll_handler);
   ProcessScheduledActions();
 }
 
 void Scheduler::NotifyReadyToCommit() {
   TRACE_EVENT0("cc", "Scheduler::NotifyReadyToCommit");
   state_machine_.NotifyReadyToCommit();
   ProcessScheduledActions();
 }
 
 void Scheduler::DidCommit() {
@@ skipping 231 matching lines @@
   TRACE_EVENT2("cc,benchmark", "Scheduler::BeginImplFrame", "args",
                args.AsValue(), "main_thread_missed_last_deadline",
                main_thread_is_in_high_latency_mode);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
                  "MainThreadLatency", main_thread_is_in_high_latency_mode);
 
   BeginFrameArgs adjusted_args = args;
   adjusted_args.deadline -= compositor_timing_history_->DrawDurationEstimate();
   adjusted_args.deadline -= kDeadlineFudgeFactor;
 
-  if (ShouldRecoverMainLatency(adjusted_args)) {
+  base::TimeDelta bmf_to_activate_estimate =
+      compositor_timing_history_->BeginMainFrameToCommitDurationEstimate() +
+      compositor_timing_history_->CommitToReadyToActivateDurationEstimate() +
+      compositor_timing_history_->ActivateDurationEstimate();
+
+  state_machine_.SetMainThreadIsFast(bmf_to_activate_estimate < args.interval);

[Sami, 2015/10/29 10:53:56]

This part I'm a little unsure about. The delay of BeginMainFrames depends on
whether the scheduler is prioritizing them or not, so we should really only
measure the delay any time we're actually trying to prioritize it.

I wonder if we just did this when BeginFrame.on_critical_path is true? That'd
still be a somewhat circular dependency because we likely wouldn't set the flag
unless we think the main thread is fast.

Another option would be to only measure the time from when BeginMainFrame starts
to execute up to the activation, i.e., ignore the queueing delay. The scheduler
can often make the queueing delay disappear if critical_path is set.

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

What if we:
1) Make adjusted_args.on_critical_path = (scroll_affects_scroll_handler_ &&
smoothness_takes_priority), which should break the circular dependency.
2) Split CompositorTimingHistory::BeginMainFrameToCommit into 3: a) queueing
duration w/ on_critical_path set, b) queueing duration w/o on_critical_path set
c) BeginMainFrame starts to commit.

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

I like both ideas!

+
+  bool can_activate_before_deadline = CanCommitAndActivateBeforeDeadline(
+      adjusted_args, bmf_to_activate_estimate);
+  if (ShouldRecoverMainLatency(adjusted_args, can_activate_before_deadline)) {
     TRACE_EVENT_INSTANT0("cc", "SkipBeginMainFrameToReduceLatency",
                          TRACE_EVENT_SCOPE_THREAD);
     state_machine_.SetSkipNextBeginMainFrameToReduceLatency();
-  } else if (ShouldRecoverImplLatency(adjusted_args)) {
+  } else if (ShouldRecoverImplLatency(adjusted_args,
+                                      can_activate_before_deadline)) {
     TRACE_EVENT_INSTANT0("cc", "SkipBeginImplFrameToReduceLatency",
                          TRACE_EVENT_SCOPE_THREAD);
     frame_source_->DidFinishFrame(begin_retro_frame_args_.size());
     return;
   }
 
   BeginImplFrame(adjusted_args);
 
   // The deadline will be scheduled in ProcessScheduledActions.
   state_machine_.OnBeginImplFrameDeadlinePending();
@@ skipping 288 matching lines @@
   state->BeginDictionary("compositor_timing_history");
   compositor_timing_history_->AsValueInto(state);
   state->EndDictionary();
 }
 
 void Scheduler::UpdateCompositorTimingHistoryRecordingEnabled() {
   compositor_timing_history_->SetRecordingEnabled(
       state_machine_.HasInitializedOutputSurface() && state_machine_.visible());
 }
 
-bool Scheduler::ShouldRecoverMainLatency(const BeginFrameArgs& args) const {
+bool Scheduler::ShouldRecoverMainLatency(
+    const BeginFrameArgs& args,
+    bool can_activate_before_deadline) const {
   DCHECK(!settings_.using_synchronous_renderer_compositor);
 
   if (!state_machine_.main_thread_missed_last_deadline())
     return false;
 
   // When prioritizing impl thread latency, we currently put the
   // main thread in a high latency mode. Don't try to fight it.
-  if (state_machine_.impl_latency_takes_priority())
+  if (state_machine_.ImplLatencyTakesPriority())
     return false;
 
-  return CanCommitAndActivateBeforeDeadline(args);
+  return can_activate_before_deadline;
 }
 
-bool Scheduler::ShouldRecoverImplLatency(const BeginFrameArgs& args) const {
+bool Scheduler::ShouldRecoverImplLatency(
+    const BeginFrameArgs& args,
+    bool can_activate_before_deadline) const {
   DCHECK(!settings_.using_synchronous_renderer_compositor);
 
   // Disable impl thread latency recovery when using the unthrottled
   // begin frame source since we will always get a BeginFrame before
   // the swap ack and our heuristics below will not work.
   if (!throttle_frame_production_)
     return false;
 
   // If we are swap throttled at the BeginFrame, that means the impl thread is
   // very likely in a high latency mode.
   bool impl_thread_is_likely_high_latency = state_machine_.SwapThrottled();
   if (!impl_thread_is_likely_high_latency)
     return false;
 
   // The deadline may be in the past if our draw time is too long.
   bool can_draw_before_deadline = args.frame_time < args.deadline;
 
   // When prioritizing impl thread latency, the deadline doesn't wait
   // for the main thread.
-  if (state_machine_.impl_latency_takes_priority())
+  if (state_machine_.ImplLatencyTakesPriority())
     return can_draw_before_deadline;
 
   // If we only have impl-side updates, the deadline doesn't wait for
   // the main thread.
   if (state_machine_.OnlyImplSideUpdatesExpected())
     return can_draw_before_deadline;
 
   // If we get here, we know the main thread is in a low-latency mode relative
   // to the impl thread. In this case, only try to also recover impl thread
   // latency if both the main and impl threads can run serially before the
   // deadline.
-  return CanCommitAndActivateBeforeDeadline(args);
+  return can_activate_before_deadline;
 }
 
 bool Scheduler::CanCommitAndActivateBeforeDeadline(
-    const BeginFrameArgs& args) const {
+    const BeginFrameArgs& args,
+    base::TimeDelta bmf_to_activate_estimate) const {
   // Check if the main thread computation and commit can be finished before the
   // impl thread's deadline.
   base::TimeTicks estimated_draw_time =
-      args.frame_time +
-      compositor_timing_history_->BeginMainFrameToCommitDurationEstimate() +
-      compositor_timing_history_->CommitToReadyToActivateDurationEstimate() +
-      compositor_timing_history_->ActivateDurationEstimate();
+      args.frame_time + bmf_to_activate_estimate;
 
   return estimated_draw_time < args.deadline;
 }
 
 bool Scheduler::IsBeginMainFrameSentOrStarted() const {
   return (state_machine_.begin_main_frame_state() ==
               SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_SENT ||
           state_machine_.begin_main_frame_state() ==
               SchedulerStateMachine::BEGIN_MAIN_FRAME_STATE_STARTED);
 }
 
 }  // namespace cc