Adds BeginFrameControl via DevTools.

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 42 matching lines @@
       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),
       defer_commits_(false),
       video_needs_begin_frames_(false),
       last_commit_had_no_updates_(false),
       wait_for_ready_to_draw_(false),
       did_draw_in_last_frame_(false),
-      did_submit_in_last_frame_(false) {}
+      did_submit_in_last_frame_(false),
+      begin_frame_allows_latency_optimizations_(true) {}
 
 const char* SchedulerStateMachine::CompositorFrameSinkStateToString(
     CompositorFrameSinkState state) {
   switch (state) {
     case COMPOSITOR_FRAME_SINK_NONE:
       return "COMPOSITOR_FRAME_SINK_NONE";
     case COMPOSITOR_FRAME_SINK_ACTIVE:
       return "COMPOSITOR_FRAME_SINK_ACTIVE";
     case COMPOSITOR_FRAME_SINK_CREATING:
       return "COMPOSITOR_FRAME_SINK_CREATING";
@@ skipping 293 matching lines @@
   if (wait_for_ready_to_draw_) {
     DCHECK(settings_.commit_to_active_tree);
     return false;
   }
 
   // Browser compositor commit steals any resources submitted in draw. Therefore
   // drawing while a commit is pending is wasteful.
   if (settings_.commit_to_active_tree && CommitPending())
     return false;
 
-  // Only handle forced redraws due to timeouts on the regular deadline.
-  if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_DRAW)
+  // Only handle forced redraws due to timeouts on the regular deadline and
+  // (temporarily) for |!begin_frame_allows_latency_optimizations_|.
+  if (ShouldForceDraw())
     return true;
 
   return needs_redraw_;
 }
 
+bool SchedulerStateMachine::ShouldForceDraw() const {
+  // Browser compositor doesn't support forced draws.
+  if (settings_.commit_to_active_tree)
+    return false;
+
+  if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_DRAW)
+    return true;
+
+  // |!begin_frame_allows_latency_optimizations_| is typically used with long
+  // deadlines, for which we depend on a timely acknowledgment of the BeginFrame
+  // in the browser. Since we currently don't have a unified acknowledgment for
+  // unsuccessful draws, we force a draw and wait for surface damage in the
+  // browser's DisplayScheduler.
+  // TODO(eseckler): Remove once we have unified BeginFrame acknowledgments.
+  if (!begin_frame_allows_latency_optimizations_)
+    return true;
+
+  return false;
+}
+
 bool SchedulerStateMachine::ShouldActivatePendingTree() const {
   // There is nothing to activate.
   if (!has_pending_tree_)
     return false;
 
   // We should not activate a second tree before drawing the first one.
   // Even if we need to force activation of the pending tree, we should abort
   // drawing the active tree first.
   if (active_tree_needs_first_draw_)
     return false;
@@ skipping 153 matching lines @@
 }
 
 SchedulerStateMachine::Action SchedulerStateMachine::NextAction() const {
   if (ShouldActivatePendingTree())
     return ACTION_ACTIVATE_SYNC_TREE;
   if (ShouldCommit())
     return ACTION_COMMIT;
   if (ShouldDraw()) {
     if (PendingDrawsShouldBeAborted())
       return ACTION_DRAW_ABORT;
-    else if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_DRAW)
+    else if (ShouldForceDraw())
       return ACTION_DRAW_FORCED;
     else
       return ACTION_DRAW_IF_POSSIBLE;
   }
   if (ShouldPrepareTiles())
     return ACTION_PREPARE_TILES;
   if (ShouldSendBeginMainFrame())
     return ACTION_SEND_BEGIN_MAIN_FRAME;
   if (ShouldInvalidateCompositorFrameSink())
     return ACTION_INVALIDATE_COMPOSITOR_FRAME_SINK;
@@ skipping 192 matching lines @@
 
 void SchedulerStateMachine::SetVideoNeedsBeginFrames(
     bool video_needs_begin_frames) {
   video_needs_begin_frames_ = video_needs_begin_frames;
 }
 
 void SchedulerStateMachine::SetDeferCommits(bool defer_commits) {
   defer_commits_ = defer_commits;
 }
 
+void SchedulerStateMachine::SetBeginFrameAllowsLatencyOptimizations(
+    bool allow_latency_optimizations) {
+  // In this mode, we ensure that we don't skip the BeginFrame/BeginMainFrame
+  // and that we don't prioritize impl thread latency. Thus, we first give the
+  // main thread a chance to produce updates, and only if it doesn't (or doesn't
+  // respond in time for the deadline), we produce an impl frame.
+
+  // |!allow_latency_optimizations| is often used in combination with long or
+  // infinite BeginFrame deadlines. To respond timely, we rely on triggering the
+  // BeginFrame deadline immediately if the main frame has no updates or as soon
+  // as it was activated (see ShouldTriggerBeginImplFrameDeadlineImmediately()).
+
+  begin_frame_allows_latency_optimizations_ = allow_latency_optimizations;
+}
+
 // These are the cases where we require a BeginFrame message to make progress
 // on requested actions.
 bool SchedulerStateMachine::BeginFrameRequiredForAction() const {
   // The forced draw respects our normal draw scheduling, so we need to
   // request a BeginImplFrame for it.
   if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_DRAW)
     return true;
 
   return needs_redraw_ || needs_one_begin_impl_frame_ ||
          (needs_begin_main_frame_ && !defer_commits_);
@@ skipping 95 matching lines @@
 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_ready_to_draw_) {
     // In browser compositor, wait for active tree to be rasterized.
     DCHECK(settings_.commit_to_active_tree);
     return BEGIN_IMPL_FRAME_DEADLINE_MODE_BLOCKED_ON_READY_TO_DRAW;
   } else if (ShouldTriggerBeginImplFrameDeadlineImmediately()) {
     return BEGIN_IMPL_FRAME_DEADLINE_MODE_IMMEDIATE;
-  } else if (needs_redraw_) {
+  } else if (needs_redraw_ && begin_frame_allows_latency_optimizations_) {
     // We have an animation or fast input path on the impl thread that wants
     // to draw, so don't wait too long for a new active tree.
     return BEGIN_IMPL_FRAME_DEADLINE_MODE_REGULAR;
   } else {
     // The impl thread doesn't have anything it wants to draw and we are just
     // waiting for a new active tree. In short we are blocked.
     return BEGIN_IMPL_FRAME_DEADLINE_MODE_LATE;
   }
 }
 
 bool SchedulerStateMachine::ShouldTriggerBeginImplFrameDeadlineImmediately()
     const {
   // If we just forced activation, we should end the deadline right now.
   if (PendingActivationsShouldBeForced() && !has_pending_tree_)
     return true;
 
   // Throttle the deadline on CompositorFrameAck since we wont draw and submit
   // anyway.
   if (IsDrawThrottled())
     return false;
 
   if (active_tree_needs_first_draw_)
     return true;
 
+  // Immediately respond to the BeginFrame if the main frame 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. We
+  // trigger an immediate deadline even if the impl thread doesn't want to draw
+  // anything either, because we don't want to stall the BeginFrame
+  // acknowledgment unnecessarily.
+  // TODO(skyostil): Revisit this when we have more accurate deadline estimates.
+  if (!CommitPending() && !has_pending_tree_)
+    return true;
+
   if (!needs_redraw_)
     return false;
 
-  // 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 (!CommitPending() && !has_pending_tree_)
-    return true;
-
   // Prioritize impl-thread draws in ImplLatencyTakesPriority mode.
   if (ImplLatencyTakesPriority())
     return true;
 
   return false;
 }
 
 bool SchedulerStateMachine::IsDrawThrottled() const {
   return pending_submit_frames_ >= kMaxPendingSubmitFrames;
 }
@@ skipping 68 matching lines @@
   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 {
+  // Wait for main frame if requested by BeginFrameArgs.
+  if (!begin_frame_allows_latency_optimizations_)
+    return false;
+
   // 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;
@@ skipping 93 matching lines @@
     case COMPOSITOR_FRAME_SINK_ACTIVE:
     case COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_COMMIT:
     case COMPOSITOR_FRAME_SINK_WAITING_FOR_FIRST_ACTIVATION:
       return true;
   }
   NOTREACHED();
   return false;
 }
 
 }  // namespace cc