cc: Make scheduling be driven by vsync for android webview.

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"
 #include "base/trace_event/trace_event_argument.h"
 #include "base/values.h"
 #include "ui/gfx/frame_time.h"
 
 namespace cc {
 
 SchedulerStateMachine::SchedulerStateMachine(const SchedulerSettings& settings)
     : settings_(settings),
       output_surface_state_(OUTPUT_SURFACE_LOST),
       begin_impl_frame_state_(BEGIN_IMPL_FRAME_STATE_IDLE),
       commit_state_(COMMIT_STATE_IDLE),
       forced_redraw_state_(FORCED_REDRAW_STATE_IDLE),
       commit_count_(0),
       current_frame_number_(0),
       last_frame_number_animate_performed_(-1),
       last_frame_number_swap_performed_(-1),
       last_frame_number_swap_requested_(-1),
       last_frame_number_begin_main_frame_sent_(-1),
+      last_frame_number_invalidate_output_surface_performed_(-1),
       prepare_tiles_funnel_(0),
       consecutive_checkerboard_animations_(0),
       max_pending_swaps_(1),
       pending_swaps_(0),
       needs_redraw_(false),
       needs_animate_(false),
       needs_prepare_tiles_(false),
       needs_commit_(false),
-      inside_poll_for_anticipated_draw_triggers_(false),
       visible_(false),
       can_start_(false),
       can_draw_(false),
       has_pending_tree_(false),
       pending_tree_is_ready_for_activation_(false),
       active_tree_needs_first_draw_(false),
       did_commit_after_animating_(false),
       did_create_and_initialize_first_output_surface_(false),
       impl_latency_takes_priority_(false),
       skip_next_begin_main_frame_to_reduce_latency_(false),
@@ skipping 31 matching lines @@
       return "BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING";
     case BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME:
       return "BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME";
     case BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE:
       return "BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE";
   }
   NOTREACHED();
   return "???";
 }
 
+const char* SchedulerStateMachine::BeginImplFrameDeadlineModeToString(
+    BeginImplFrameDeadlineMode mode) {
+  switch (mode) {
+    case BEGIN_IMPL_FRAME_DEADLINE_MODE_IMMEDIATE_SYNCHRONOUS:
+      return "BEGIN_IMPL_FRAME_DEADLINE_MODE_IMMEDIATE_SYNCHRONOUS";
+    case BEGIN_IMPL_FRAME_DEADLINE_MODE_IMMEDIATE_ASYNCHRONOUS:
+      return "BEGIN_IMPL_FRAME_DEADLINE_MODE_IMMEDIATE_ASYNCHRONOUS";
+    case BEGIN_IMPL_FRAME_DEADLINE_MODE_REGULAR:
+      return "BEGIN_IMPL_FRAME_DEADLINE_MODE_REGULAR";
+    case BEGIN_IMPL_FRAME_DEADLINE_MODE_LATE:
+      return "BEGIN_IMPL_FRAME_DEADLINE_MODE_LATE";
+  }
+  NOTREACHED();
+  return "???";
+}
+
 const char* SchedulerStateMachine::CommitStateToString(CommitState state) {
   switch (state) {
     case COMMIT_STATE_IDLE:
       return "COMMIT_STATE_IDLE";
     case COMMIT_STATE_BEGIN_MAIN_FRAME_SENT:
       return "COMMIT_STATE_BEGIN_MAIN_FRAME_SENT";
     case COMMIT_STATE_BEGIN_MAIN_FRAME_STARTED:
       return "COMMIT_STATE_BEGIN_MAIN_FRAME_STARTED";
     case COMMIT_STATE_READY_TO_COMMIT:
       return "COMMIT_STATE_READY_TO_COMMIT";
@@ skipping 37 matching lines @@
     case ACTION_DRAW_AND_SWAP_IF_POSSIBLE:
       return "ACTION_DRAW_AND_SWAP_IF_POSSIBLE";
     case ACTION_DRAW_AND_SWAP_FORCED:
       return "ACTION_DRAW_AND_SWAP_FORCED";
     case ACTION_DRAW_AND_SWAP_ABORT:
       return "ACTION_DRAW_AND_SWAP_ABORT";
     case ACTION_BEGIN_OUTPUT_SURFACE_CREATION:
       return "ACTION_BEGIN_OUTPUT_SURFACE_CREATION";
     case ACTION_PREPARE_TILES:
       return "ACTION_PREPARE_TILES";
+    case ACTION_INVALIDATE_OUTPUT_SURFACE:
+      return "ACTION_INVALIDATE_OUTPUT_SURFACE";
   }
   NOTREACHED();
   return "???";
 }
 
 scoped_refptr<base::trace_event::ConvertableToTraceFormat>
 SchedulerStateMachine::AsValue() const {
   scoped_refptr<base::trace_event::TracedValue> state =
       new base::trace_event::TracedValue();
   AsValueInto(state.get(), gfx::FrameTime::Now());
@@ skipping 80 matching lines @@
   state->SetBoolean("skip_next_begin_main_frame_to_reduce_latency",
                     skip_next_begin_main_frame_to_reduce_latency_);
   state->SetBoolean("continuous_painting", continuous_painting_);
   state->SetBoolean("impl_latency_takes_priority_on_battery",
                     impl_latency_takes_priority_on_battery_);
   state->SetBoolean("children_need_begin_frames", children_need_begin_frames_);
   state->SetBoolean("defer_commits", defer_commits_);
   state->EndDictionary();
 }
 
-void SchedulerStateMachine::AdvanceCurrentFrameNumber() {
+void SchedulerStateMachine::AdvanceFrame() {
   current_frame_number_++;
 
   // "Drain" the PrepareTiles funnel.
   if (prepare_tiles_funnel_ > 0)
     prepare_tiles_funnel_--;
 
   skip_begin_main_frame_to_reduce_latency_ =
       skip_next_begin_main_frame_to_reduce_latency_;
   skip_next_begin_main_frame_to_reduce_latency_ = false;
 }
 
 bool SchedulerStateMachine::HasAnimatedThisFrame() const {
   return last_frame_number_animate_performed_ == current_frame_number_;
 }
 
 bool SchedulerStateMachine::HasSentBeginMainFrameThisFrame() const {
   return current_frame_number_ ==
          last_frame_number_begin_main_frame_sent_;
 }
 
 bool SchedulerStateMachine::HasSwappedThisFrame() const {
   return current_frame_number_ == last_frame_number_swap_performed_;
 }
 
 bool SchedulerStateMachine::HasRequestedSwapThisFrame() const {
   return current_frame_number_ == last_frame_number_swap_requested_;
 }
 
+bool SchedulerStateMachine::HasInvalidatedOutputSurfaceThisFrame() const {
+  return current_frame_number_ ==
+         last_frame_number_invalidate_output_surface_performed_;
+}
+
 bool SchedulerStateMachine::PendingDrawsShouldBeAborted() const {
   // These are all the cases where we normally cannot or do not want to draw
   // but, if needs_redraw_ is true and we do not draw to make forward progress,
   // we might deadlock with the main thread.
   // This should be a superset of PendingActivationsShouldBeForced() since
   // activation of the pending tree is blocked by drawing of the active tree and
   // the main thread might be blocked on activation of the most recent commit.
   if (PendingActivationsShouldBeForced())
     return true;
 
@@ skipping 44 matching lines @@
   // are initializing the output surface.
   if (active_tree_needs_first_draw_ || has_pending_tree_)
     return false;
 
   // We need to create the output surface if we don't have one and we haven't
   // started creating one yet.
   return output_surface_state_ == OUTPUT_SURFACE_LOST;
 }
 
 bool SchedulerStateMachine::ShouldDraw() const {
+  // In the synchronous compositor mode, draw only when asked to.
+  if (settings_.using_synchronous_renderer_compositor &&
+      begin_impl_frame_args_.type != BeginFrameArgs::SYNCHRONOUS_DRAW)
+    return false;
+
   // If we need to abort draws, we should do so ASAP since the draw could
   // be blocking other important actions (like output surface initialization),
   // from occuring. If we are waiting for the first draw, then perfom the
   // aborted draw to keep things moving. If we are not waiting for the first
   // draw however, we don't want to abort for no reason.
   if (PendingDrawsShouldBeAborted())
     return active_tree_needs_first_draw_;
 
   // Don't draw if we are waiting on the first commit after a surface.
   if (output_surface_state_ != OUTPUT_SURFACE_ACTIVE)
@@ skipping 143 matching lines @@
 }
 
 bool SchedulerStateMachine::ShouldPrepareTiles() const {
   // PrepareTiles only really needs to be called immediately after commit
   // and then periodically after that. Use a funnel to make sure we average
   // one PrepareTiles per BeginImplFrame in the long run.
   if (prepare_tiles_funnel_ > 0)
     return false;
 
   // Limiting to once per-frame is not enough, since we only want to
-  // prepare tiles _after_ draws. Polling for draw triggers and
-  // begin-frame are mutually exclusive, so we limit to these two cases.
-  if (begin_impl_frame_state_ != BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE &&
-      !inside_poll_for_anticipated_draw_triggers_)
+  // prepare tiles _after_ draws.
+  if (begin_impl_frame_state_ != BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE)
     return false;
+
   return needs_prepare_tiles_;
 }
 
+bool SchedulerStateMachine::ShouldInvalidateOutputSurface() const {
+  // Only the synchronous compositor requires invalidations.
+  if (!settings_.using_synchronous_renderer_compositor)
+    return false;
+
+  // Invalidations are only performed inside a BeginFrame deadline.
+  if (begin_impl_frame_state_ != BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE)
+    return false;
+
+  // Invalidate the output surface only once per frame.
+  if (HasInvalidatedOutputSurfaceThisFrame())
+    return false;
+
+  return needs_redraw_;
+}
+
 SchedulerStateMachine::Action SchedulerStateMachine::NextAction() const {
   if (ShouldActivatePendingTree())
     return ACTION_ACTIVATE_SYNC_TREE;
   if (ShouldCommit())
     return ACTION_COMMIT;
   if (ShouldAnimate())
     return ACTION_ANIMATE;
   if (ShouldDraw()) {
     if (PendingDrawsShouldBeAborted())
       return ACTION_DRAW_AND_SWAP_ABORT;
     else if (forced_redraw_state_ == FORCED_REDRAW_STATE_WAITING_FOR_DRAW)
       return ACTION_DRAW_AND_SWAP_FORCED;
     else
       return ACTION_DRAW_AND_SWAP_IF_POSSIBLE;
   }
   if (ShouldPrepareTiles())
     return ACTION_PREPARE_TILES;
   if (ShouldSendBeginMainFrame())
     return ACTION_SEND_BEGIN_MAIN_FRAME;
+  if (ShouldInvalidateOutputSurface())
+    return ACTION_INVALIDATE_OUTPUT_SURFACE;
   if (ShouldBeginOutputSurfaceCreation())
     return ACTION_BEGIN_OUTPUT_SURFACE_CREATION;
   return ACTION_NONE;
 }
 
 void SchedulerStateMachine::UpdateState(Action action) {
   switch (action) {
     case ACTION_NONE:
       return;
 
@@ skipping 47 matching lines @@
       // The pipeline should be flushed entirely before we start output
       // surface creation to avoid complicated corner cases.
       DCHECK_EQ(commit_state_, COMMIT_STATE_IDLE);
       DCHECK(!has_pending_tree_);
       DCHECK(!active_tree_needs_first_draw_);
       return;
 
     case ACTION_PREPARE_TILES:
       UpdateStateOnPrepareTiles();
       return;
+
+    case ACTION_INVALIDATE_OUTPUT_SURFACE:
+      last_frame_number_invalidate_output_surface_performed_ =
+          current_frame_number_;
+      return;
   }
 }
 
 void SchedulerStateMachine::UpdateStateOnCommit(bool commit_has_no_updates) {
   commit_count_++;
 
   if (!commit_has_no_updates && HasAnimatedThisFrame())
     did_commit_after_animating_ = true;
 
   if (commit_has_no_updates || settings_.main_frame_before_activation_enabled) {
@@ skipping 93 matching lines @@
     return children_need_begin_frames_;
 
   return false;
 }
 
 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;
-
-  if (SupportsProactiveBeginFrame()) {
-    return (BeginFrameNeededToAnimateOrDraw() ||
-            BeginFrameNeededForChildren() ||
-            ProactiveBeginFrameWanted());
-  }
-
-  // Proactive BeginFrames are bad for the synchronous compositor because we
-  // have to draw when we get the BeginFrame and could end up drawing many
-  // duplicate frames if our new frame isn't ready in time.
-  // To poll for state with the synchronous compositor without having to draw,
-  // we rely on ShouldPollForAnticipatedDrawTriggers instead.
-  // Synchronous compositor doesn't have a browser.
-  DCHECK(!children_need_begin_frames_);
-  return BeginFrameNeededToAnimateOrDraw();
+  return (BeginFrameNeededToAnimateOrDraw() || BeginFrameNeededForChildren() ||
+          ProactiveBeginFrameWanted());
 }
 
 bool SchedulerStateMachine::ShouldSetNeedsBeginFrames(
     bool frame_source_needs_begin_frames) const {
   bool needs_begin_frame = BeginFrameNeeded();
 
   // Never call SetNeedsBeginFrames if the frame source has the right value.
   if (needs_begin_frame == frame_source_needs_begin_frames)
     return false;
 
   // Always request the BeginFrame immediately if it's needed.
   if (needs_begin_frame)
     return true;
 
   // Stop requesting BeginFrames after a deadline.
   if (begin_impl_frame_state_ == BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE)
     return true;
 
   // Stop requesting BeginFrames immediately when output surface is lost.
   if (!HasInitializedOutputSurface())
     return true;
 
   return false;
 }
 
-bool SchedulerStateMachine::ShouldPollForAnticipatedDrawTriggers() const {
-  // ShouldPollForAnticipatedDrawTriggers is what we use in place of
-  // ProactiveBeginFrameWanted when we are using the synchronous
-  // compositor.
-  if (!SupportsProactiveBeginFrame()) {
-    return !BeginFrameNeededToAnimateOrDraw() && ProactiveBeginFrameWanted();
-  }
-
-  // Non synchronous compositors should rely on
-  // ProactiveBeginFrameWanted to poll for state instead.
-  return false;
-}
-
-// Note: If SupportsProactiveBeginFrame is false, the scheduler should poll
-// for changes in it's draw state so it can request a BeginFrame when it's
-// actually ready.
-bool SchedulerStateMachine::SupportsProactiveBeginFrame() const {
-  // It is undesirable to proactively request BeginFrames if we are
-  // using a synchronous compositor because we *must* draw for every
-  // BeginFrame, which could cause duplicate draws.
-  return !settings_.using_synchronous_renderer_compositor;
-}
-
 void SchedulerStateMachine::SetChildrenNeedBeginFrames(
     bool children_need_begin_frames) {
   DCHECK(settings_.forward_begin_frames_to_children);
   children_need_begin_frames_ = children_need_begin_frames;
 }
 
 void SchedulerStateMachine::SetDeferCommits(bool defer_commits) {
   defer_commits_ = defer_commits;
 }
 
@@ skipping 37 matching lines @@
   // SetNeedsBeginFrame requests, which may propagate to the BeginImplFrame
   // provider and get sampled at an inopportune time, delaying the next
   // BeginImplFrame.
   if (HasRequestedSwapThisFrame())
     return true;
 
   return false;
 }
 
 void SchedulerStateMachine::OnBeginImplFrame(const BeginFrameArgs& args) {
-  AdvanceCurrentFrameNumber();
   begin_impl_frame_args_ = args;
+
+  // Advance frame for synchronous compositor on SYNCHRONOUS_ANIMATE only.
+  if (!settings_.using_synchronous_renderer_compositor ||
+      begin_impl_frame_args_.type == BeginFrameArgs::SYNCHRONOUS_ANIMATE)
+    AdvanceFrame();
+
   DCHECK_EQ(begin_impl_frame_state_, BEGIN_IMPL_FRAME_STATE_IDLE)
       << AsValue()->ToString();
   begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING;
 }
 
 void SchedulerStateMachine::OnBeginImplFrameDeadlinePending() {
   DCHECK_EQ(begin_impl_frame_state_,
             BEGIN_IMPL_FRAME_STATE_BEGIN_FRAME_STARTING)
       << AsValue()->ToString();
   begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME;
 }
 
 void SchedulerStateMachine::OnBeginImplFrameDeadline() {
   DCHECK_EQ(begin_impl_frame_state_, BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME)
       << AsValue()->ToString();
   begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE;
 }
 
 void SchedulerStateMachine::OnBeginImplFrameIdle() {
   DCHECK_EQ(begin_impl_frame_state_, BEGIN_IMPL_FRAME_STATE_INSIDE_DEADLINE)
       << AsValue()->ToString();
   begin_impl_frame_state_ = BEGIN_IMPL_FRAME_STATE_IDLE;
 }
 
 SchedulerStateMachine::BeginImplFrameDeadlineMode
 SchedulerStateMachine::CurrentBeginImplFrameDeadlineMode() const {
-  if (ShouldTriggerBeginImplFrameDeadlineImmediately()) {
-    return BEGIN_IMPL_FRAME_DEADLINE_MODE_IMMEDIATE;
+  if (settings_.using_synchronous_renderer_compositor) {
+    // If the synchronous compositor wants to draw now.
+    return BEGIN_IMPL_FRAME_DEADLINE_MODE_IMMEDIATE_SYNCHRONOUS;
+  } else if (ShouldTriggerBeginImplFrameDeadlineImmediately()) {
+    return BEGIN_IMPL_FRAME_DEADLINE_MODE_IMMEDIATE_ASYNCHRONOUS;
   } else if (needs_redraw_ && pending_swaps_ < max_pending_swaps_) {
     // 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.
     // If we are swap throttled we should wait until we are unblocked.
     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 or we are swap throttled. In short we are
     // blocked.
     return BEGIN_IMPL_FRAME_DEADLINE_MODE_LATE;
   }
 }
 
 bool SchedulerStateMachine::ShouldTriggerBeginImplFrameDeadlineImmediately()
     const {
   // TODO(brianderson): This should take into account multiple commit sources.
-
   if (begin_impl_frame_state_ != BEGIN_IMPL_FRAME_STATE_INSIDE_BEGIN_FRAME)
     return false;
 
   // If we've lost the output surface, end the current BeginImplFrame ASAP
   // so we can start creating the next output surface.
   if (output_surface_state_ == OUTPUT_SURFACE_LOST)
     return true;
 
   // SwapAck throttle the deadline since we wont draw and swap anyway.
   if (pending_swaps_ >= max_pending_swaps_)
@@ skipping 59 matching lines @@
     // which case the main thread is in a high latency mode.
     return (active_tree_needs_first_draw_ || HasSwappedThisFrame()) &&
            !HasSentBeginMainFrameThisFrame();
   }
 
   // If the active tree needs its first draw in any other state, we know the
   // main thread is in a high latency mode.
   return active_tree_needs_first_draw_;
 }
 
-void SchedulerStateMachine::DidEnterPollForAnticipatedDrawTriggers() {
-  AdvanceCurrentFrameNumber();
-  inside_poll_for_anticipated_draw_triggers_ = true;
-}
-
-void SchedulerStateMachine::DidLeavePollForAnticipatedDrawTriggers() {
-  inside_poll_for_anticipated_draw_triggers_ = false;
-}
-
 void SchedulerStateMachine::SetVisible(bool visible) { visible_ = visible; }
 
 void SchedulerStateMachine::SetCanDraw(bool can_draw) { can_draw_ = can_draw; }
 
 void SchedulerStateMachine::SetNeedsRedraw() { needs_redraw_ = true; }
 
 void SchedulerStateMachine::SetNeedsAnimate() {
   needs_animate_ = true;
 }
 
@@ skipping 158 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