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 200 matching lines @@
   }
 }
 
 void Scheduler::DidSwapBuffersComplete() {
   DCHECK_GT(state_machine_.pending_swaps(), 0) << AsValue()->ToString();
   compositor_timing_history_->DidSwapBuffersComplete();
   state_machine_.DidSwapBuffersComplete();
   ProcessScheduledActions();
 }
 
-void Scheduler::SetImplLatencyTakesPriority(bool impl_latency_takes_priority) {
-  state_machine_.SetImplLatencyTakesPriority(impl_latency_takes_priority);
+void Scheduler::SetSmoothnessMode(TreePriority tree_priority,

[brianderson, 2015/11/17 23:01:45]

Note: I ended up keeping this a single function so we don't have to worry about
calling ProcessedScheduledActions twice. To make it easier to read, I replaced
the bools with enums.

[Sami, 2015/11/18 19:46:04]

Ok, the enums do make the call sites easier to read.

+                                  ScrollHandlerState scroll_handler_state) {
+  state_machine_.SetSmoothnessMode(tree_priority, scroll_handler_state);
   ProcessScheduledActions();
 }
 
 void Scheduler::NotifyReadyToCommit() {
   TRACE_EVENT0("cc", "Scheduler::NotifyReadyToCommit");
   state_machine_.NotifyReadyToCommit();
   ProcessScheduledActions();
 }
 
 void Scheduler::DidCommit() {
@@ skipping 77 matching lines @@
   TRACE_EVENT1("cc,benchmark", "Scheduler::BeginFrame", "args", args.AsValue());
 
   // Trace this begin frame time through the Chrome stack
   TRACE_EVENT_FLOW_BEGIN0(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler.frames"), "BeginFrameArgs",
       args.frame_time.ToInternalValue());
 
   // TODO(brianderson): Adjust deadline in the DisplayScheduler.
   BeginFrameArgs adjusted_args(args);
   adjusted_args.deadline -= EstimatedParentDrawTime();
-  adjusted_args.on_critical_path = !ImplLatencyTakesPriority();
 
   // Deliver BeginFrames to children.
   // TODO(brianderson): Move this responsibility to the DisplayScheduler.
   if (state_machine_.children_need_begin_frames())
     client_->SendBeginFramesToChildren(adjusted_args);
 
   if (settings_.using_synchronous_renderer_compositor) {
     BeginImplFrameSynchronous(adjusted_args);
     return true;
   }
@@ skipping 136 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_start_to_activate =
+      compositor_timing_history_
+          ->BeginMainFrameStartToCommitDurationEstimate() +
+      compositor_timing_history_->CommitToReadyToActivateDurationEstimate() +
+      compositor_timing_history_->ActivateDurationEstimate();
+
+  base::TimeDelta bmf_to_activate_estimate_if_critical =
+      bmf_start_to_activate +
+      compositor_timing_history_->BeginMainFrameQueueDurationCriticalEstimate();
+
+  bool can_activate_before_deadline_if_critical =
+      CanBeginMainFrameAndActivateBeforeDeadline(
+          adjusted_args, bmf_to_activate_estimate_if_critical);
+  state_machine_.SetCriticalBeginMainFrameToActivateIsFast(
+      can_activate_before_deadline_if_critical);
+
+  // Update the BeginMainFrame args now that we know whether the main
+  // thread will be on the critical path or not.
+  begin_main_frame_args_ = adjusted_args;
+  begin_main_frame_args_.on_critical_path = !ImplLatencyTakesPriority();
+
+  bool can_activate_before_deadline = can_activate_before_deadline_if_critical;
+  if (!begin_main_frame_args_.on_critical_path) {
+    base::TimeDelta bmf_to_activate_estimate =
+        bmf_start_to_activate +
+        compositor_timing_history_
+            ->BeginMainFrameQueueDurationNotCriticalEstimate();
+
+    can_activate_before_deadline = CanBeginMainFrameAndActivateBeforeDeadline(
+        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();
   ProcessScheduledActions();
 }
 
 void Scheduler::BeginImplFrameSynchronous(const BeginFrameArgs& args) {
   TRACE_EVENT1("cc,benchmark", "Scheduler::BeginImplFrame", "args",
                args.AsValue());
+
+  // The main thread currently can't commit before we draw with the
+  // synchronous compositor, so never consider the BeginMainFrame fast.
+  state_machine_.SetCriticalBeginMainFrameToActivateIsFast(false);
+  begin_main_frame_args_ = args;
+  begin_main_frame_args_.on_critical_path = !ImplLatencyTakesPriority();
+
   BeginImplFrame(args);
   FinishImplFrame();
 }
 
 void Scheduler::FinishImplFrame() {
   state_machine_.OnBeginImplFrameIdle();
   ProcessScheduledActions();
 
   client_->DidFinishImplFrame();
   frame_source_->DidFinishFrame(begin_retro_frame_args_.size());
   begin_impl_frame_tracker_.Finish();
 }
 
 // BeginImplFrame starts a compositor frame that will wait up until a deadline
 // for a BeginMainFrame+activation to complete before it times out and draws
 // any asynchronous animation and scroll/pinch updates.
 void Scheduler::BeginImplFrame(const BeginFrameArgs& args) {
   DCHECK_EQ(state_machine_.begin_impl_frame_state(),
             SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE);
   DCHECK(!BeginImplFrameDeadlinePending());
   DCHECK(state_machine_.HasInitializedOutputSurface());
 
   begin_impl_frame_tracker_.Start(args);
-  begin_main_frame_args_ = args;
   state_machine_.OnBeginImplFrame();
   devtools_instrumentation::DidBeginFrame(layer_tree_host_id_);
   client_->WillBeginImplFrame(begin_impl_frame_tracker_.Current());
 
   ProcessScheduledActions();
 }
 
 void Scheduler::ScheduleBeginImplFrameDeadline() {
   // The synchronous compositor does not post a deadline task.
   DCHECK(!settings_.using_synchronous_renderer_compositor);
@@ skipping 251 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 {
+bool Scheduler::CanBeginMainFrameAndActivateBeforeDeadline(
+    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