cc: Split out BeginFrame needed verse proactive for commits.

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 697 matching lines @@
       current_frame_number_;
 }
 
 void SchedulerStateMachine::SetSkipNextBeginMainFrameToReduceLatency() {
   TRACE_EVENT_INSTANT0("cc",
                        "Scheduler: SkipNextBeginMainFrameToReduceLatency",
                        TRACE_EVENT_SCOPE_THREAD);
   skip_next_begin_main_frame_to_reduce_latency_ = true;
 }
 
-bool SchedulerStateMachine::BeginFrameNeededForChildren() const {
+bool SchedulerStateMachine::BeginFrameRequiredForChildren() const {
   return children_need_begin_frames_;
 }
 
 bool SchedulerStateMachine::BeginFrameNeeded() const {
   // We can't handle BeginFrames when output surface isn't initialized.
   // TODO(brianderson): Support output surface creation inside a BeginFrame.
   if (!HasInitializedOutputSurface())
     return false;
-  return (BeginFrameNeededToAnimateOrDraw() || BeginFrameNeededForChildren() ||
+  return (BeginFrameRequiredForAction() || BeginFrameRequiredForChildren() ||

[brianderson, 2015/04/08 01:46:56]

Should we put BeginFrameRequiredForChildren above the
HasInitializedOutputSurface check? None of our BeginFrameSources are  tied to
the existence of an OutputSurface anymore.

[mithro-old, 2015/04/09 04:08:07]

I'll do that in a different CL.

           ProactiveBeginFrameWanted());
 }
 
 void SchedulerStateMachine::SetChildrenNeedBeginFrames(
     bool children_need_begin_frames) {
   children_need_begin_frames_ = children_need_begin_frames;
 }
 
 void SchedulerStateMachine::SetDeferCommits(bool defer_commits) {
   defer_commits_ = defer_commits;
 }
 
-// These are the cases where we definitely (or almost definitely) have a
-// new frame to animate and/or draw and can draw.
-bool SchedulerStateMachine::BeginFrameNeededToAnimateOrDraw() const {
+// These are the cases where we require a BeginFrame message to make progress
+// on requested actions.
+bool SchedulerStateMachine::BeginFrameRequiredForAction() const {
   // If we are not visible, we don't need BeginFrame messages.
   if (!visible_)
     return false;
 
   // 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_animate_ || needs_redraw_;
+  return needs_animate_ || needs_redraw_ || (needs_commit_ && !defer_commits_);
 }
 
-// These are cases where we are very likely to draw soon, but might not
-// actually have a new frame to draw when we receive the next BeginImplFrame.
-// Proactively requesting the BeginImplFrame helps hide the round trip latency
-// of the SetNeedsBeginFrame request that has to go to the Browser.
+// These are cases where we are very likely want a BeginFrame message in the
+// near future. Proactively requesting the BeginImplFrame helps hide the round
+// trip latency of the SetNeedsBeginFrame request that has to go to the
+// Browser.
+// This includes things like drawing soon, but might not actually have a new
+// frame to draw when we receive the next BeginImplFrame.
 bool SchedulerStateMachine::ProactiveBeginFrameWanted() const {
   // Do not be proactive when invisible.
   if (!visible_)
     return false;
 
   // We should proactively request a BeginImplFrame if a commit is pending
   // because we will want to draw if the commit completes quickly. Do not
   // request frames when commits are disabled, because the frame requests will
   // not provide the needed commit (and will wake up the process when it could
   // stay idle).
-  if ((needs_commit_ || commit_state_ != COMMIT_STATE_IDLE) && !defer_commits_)
+  if ((commit_state_ != COMMIT_STATE_IDLE) && !defer_commits_)
     return true;
 
   // If the pending tree activates quickly, we'll want a BeginImplFrame soon
   // to draw the new active tree.
   if (has_pending_tree_)
     return true;
 
   // Changing priorities may allow us to activate (given the new priorities),
   // which may result in a new frame.
   if (needs_prepare_tiles_)
@@ skipping 322 matching lines @@
       static_cast<int>(begin_impl_frame_state_),
       static_cast<int>(commit_state_),
       has_pending_tree_ ? 'T' : 'F',
       pending_tree_is_ready_for_activation_ ? 'T' : 'F',
       active_tree_needs_first_draw_ ? 'T' : 'F',
       max_pending_swaps_,
       pending_swaps_);
 }
 
 }  // namespace cc