cc: Use multiple PrepareTiles approaches

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 150 matching lines @@
 void Scheduler::SetCanDraw(bool can_draw) {
   state_machine_.SetCanDraw(can_draw);
   ProcessScheduledActions();
 }
 
 void Scheduler::NotifyReadyToActivate() {
   state_machine_.NotifyReadyToActivate();
   ProcessScheduledActions();
 }
 
+void Scheduler::SetRequiresHighResToDraw(bool required) {
+  state_machine_.SetRequiresHighResToDraw(required);
+  ProcessScheduledActions();
+}
+
 void Scheduler::NotifyReadyToDraw() {
   // Future work might still needed for crbug.com/352894.
   state_machine_.NotifyReadyToDraw();
   ProcessScheduledActions();
 }
 
 void Scheduler::SetThrottleFrameProduction(bool throttle) {
   throttle_frame_production_ = throttle;
   if (throttle) {
     frame_source_->SetActiveSource(primary_frame_source_);
@@ skipping 11 matching lines @@
 void Scheduler::SetNeedsRedraw() {
   state_machine_.SetNeedsRedraw();
   ProcessScheduledActions();
 }
 
 void Scheduler::SetNeedsAnimate() {
   state_machine_.SetNeedsAnimate();
   ProcessScheduledActions();
 }
 
-void Scheduler::SetNeedsPrepareTiles() {
-  DCHECK(!IsInsideAction(SchedulerStateMachine::ACTION_PREPARE_TILES));
-  state_machine_.SetNeedsPrepareTiles();
+void Scheduler::SetNeedsPrepareTiles(bool for_commit) {
+  state_machine_.SetNeedsPrepareTiles(for_commit);
   ProcessScheduledActions();
 }
 
 void Scheduler::SetWaitForReadyToDraw() {
   state_machine_.SetWaitForReadyToDraw();
   ProcessScheduledActions();
 }
 
 void Scheduler::SetMaxSwapsPending(int max) {
   state_machine_.SetMaxSwapsPending(max);
@@ skipping 25 matching lines @@
   ProcessScheduledActions();
 }
 
 void Scheduler::BeginMainFrameAborted(CommitEarlyOutReason reason) {
   TRACE_EVENT1("cc", "Scheduler::BeginMainFrameAborted", "reason",
                CommitEarlyOutReasonToString(reason));
   state_machine_.BeginMainFrameAborted(reason);
   ProcessScheduledActions();
 }
 
-void Scheduler::DidPrepareTiles() {
-  state_machine_.DidPrepareTiles();
-}
-
 void Scheduler::DidLoseOutputSurface() {
   TRACE_EVENT0("cc", "Scheduler::DidLoseOutputSurface");
   begin_retro_frame_args_.clear();
   begin_retro_frame_task_.Cancel();
   state_machine_.DidLoseOutputSurface();
   ProcessScheduledActions();
 }
 
 void Scheduler::DidCreateAndInitializeOutputSurface() {
   TRACE_EVENT0("cc", "Scheduler::DidCreateAndInitializeOutputSurface");
@@ skipping 20 matching lines @@
   return timebase + (begin_impl_frame_args_.interval * intervals);
 }
 
 base::TimeTicks Scheduler::LastBeginImplFrameTime() {
   return begin_impl_frame_args_.frame_time;
 }
 
 void Scheduler::SetupNextBeginFrameIfNeeded() {
   // Never call SetNeedsBeginFrames if the frame source already has the right
   // value.
-  if (frame_source_->NeedsBeginFrames() != state_machine_.BeginFrameNeeded()) {
-    if (state_machine_.BeginFrameNeeded()) {
+  bool begin_frames_needed = state_machine_.BeginFrameNeeded();
+  if (frame_source_->NeedsBeginFrames() != begin_frames_needed) {
+    if (begin_frames_needed) {
       // Call SetNeedsBeginFrames(true) as soon as possible.
       frame_source_->SetNeedsBeginFrames(true);
     } else if (state_machine_.begin_impl_frame_state() ==
                SchedulerStateMachine::BEGIN_IMPL_FRAME_STATE_IDLE) {
       // Call SetNeedsBeginFrames(false) in between frames only.
       frame_source_->SetNeedsBeginFrames(false);
       client_->SendBeginMainFrameNotExpectedSoon();
     }
+    state_machine_.NotifyBeginFrameSourceActive(begin_frames_needed);
   }
 
   PostBeginRetroFrameIfNeeded();
 }
 
 // We may need to poll when we can't rely on BeginFrame to advance certain
 // state or to avoid deadlock.
 void Scheduler::SetupPollingMechanisms() {
   // At this point we'd prefer to advance through the commit flow by
   // drawing a frame, however it's possible that the frame rate controller
@@ skipping 197 matching lines @@
 }
 
 void Scheduler::BeginImplFrameSynchronous(const BeginFrameArgs& args) {
   TRACE_EVENT1("cc,benchmark", "Scheduler::BeginImplFrame", "args",
                args.AsValue());
   begin_impl_frame_args_ = args;
   BeginImplFrame();
   FinishImplFrame();
 }
 
+// Retry the BeginImplFrame if the draw aborted due to checkerboards and
+// we need a new commit to get a new RasterSource.
+void Scheduler::RetryBeginImplFrameWithDeadline() {
+  TRACE_EVENT0("cc", "Scheduler::RetryBeginImplFrameWithDeadline");
+  state_machine_.ResetRetryBeginImplFrame();
+
+  BeginImplFrame();
+
+  // The deadline will be scheduled in ProcessScheduledActions.
+  state_machine_.OnBeginImplFrameDeadlinePending();
+  ProcessScheduledActions();
+}
+
+// Retry the deadline if the draw aborted due to checkerboards, but we
+// do not need a new commit to get a new RasterSource.
+void Scheduler::RetryBeginImplFrameDeadline() {
+  TRACE_EVENT0("cc", "Scheduler::RetryImplFrameDeadline");
+  state_machine_.ResetRetryBeginImplFrame();
+
+  // The deadline will be scheduled in ProcessScheduledActions.
+  state_machine_.OnBeginImplFrameDeadlinePending();
+  ProcessScheduledActions();
+}
+
 void Scheduler::FinishImplFrame() {
   state_machine_.OnBeginImplFrameIdle();
   ProcessScheduledActions();
 
   client_->DidFinishImplFrame();
   frame_source_->DidFinishFrame(begin_retro_frame_args_.size());
 }
 
 // BeginImplFrame starts a compositor frame that will wait up until a deadline
 // for a BeginMainFrame+activation to complete before it times out and draws
@@ skipping 37 matching lines @@
       deadline = begin_impl_frame_args_.deadline;
       break;
     case SchedulerStateMachine::BEGIN_IMPL_FRAME_DEADLINE_MODE_LATE:
       // We are blocked for one reason or another and we should wait.
       // TODO(brianderson): Handle long deadlines (that are past the next
       // frame's frame time) properly instead of using this hack.
       deadline =
           begin_impl_frame_args_.frame_time + begin_impl_frame_args_.interval;
       break;
     case SchedulerStateMachine::
+        BEGIN_IMPL_FRAME_DEADLINE_MODE_TRY_TO_AVOID_CHECKERBOARD:
+      // We will wait up until this deadline for the ReadyToDraw signal.
+      // TODO(brianderson): Use a different timeout for touch vs. mouse wheel.
+      deadline = begin_impl_frame_args_.frame_time +
+                 (5 * begin_impl_frame_args_.interval);
+      break;
+    case SchedulerStateMachine::
         BEGIN_IMPL_FRAME_DEADLINE_MODE_BLOCKED_ON_READY_TO_DRAW:
       // We are blocked because we are waiting for ReadyToDraw signal. We would
       // post deadline after we received ReadyToDraw singal.
       TRACE_EVENT1("cc", "Scheduler::ScheduleBeginImplFrameDeadline",
                    "deadline_mode", "blocked_on_ready_to_draw");
       return;
   }
 
   TRACE_EVENT2("cc", "Scheduler::ScheduleBeginImplFrameDeadline", "mode",
                SchedulerStateMachine::BeginImplFrameDeadlineModeToString(
@@ skipping 31 matching lines @@
   //     order to wait for more user-input before starting the next commit.
   // * Creating a new OuputSurface will not occur during the deadline in
   //     order to allow the state machine to "settle" first.
 
   // TODO(robliao): Remove ScopedTracker below once crbug.com/461509 is fixed.
   tracked_objects::ScopedTracker tracking_profile1(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "461509 Scheduler::OnBeginImplFrameDeadline1"));
   state_machine_.OnBeginImplFrameDeadline();
   ProcessScheduledActions();
-  FinishImplFrame();
+
+  if (state_machine_.retry_begin_impl_frame()) {
+    RetryBeginImplFrameWithDeadline();
+  } else if (state_machine_.retry_begin_impl_frame_deadline()) {
+    RetryBeginImplFrameDeadline();
+  } else {
+    FinishImplFrame();
+  }
 }
 
 
 void Scheduler::PollToAdvanceCommitState() {
   TRACE_EVENT0("cc", "Scheduler::PollToAdvanceCommitState");
   advance_commit_state_task_.Cancel();
   ProcessScheduledActions();
 }
 
 void Scheduler::DrawAndSwapIfPossible() {
   DrawResult result = client_->ScheduledActionDrawAndSwapIfPossible();
-  state_machine_.DidDrawIfPossibleCompleted(result);
+  state_machine_.SetDrawResult(result);
+}
+
+void Scheduler::DrawAndSwapForced() {
+  DrawResult result = client_->ScheduledActionDrawAndSwapForced();
+  state_machine_.SetDrawResult(result);
 }
 
 void Scheduler::SetDeferCommits(bool defer_commits) {
   TRACE_EVENT1("cc", "Scheduler::SetDeferCommits",
                 "defer_commits",
                 defer_commits);
   state_machine_.SetDeferCommits(defer_commits);
   ProcessScheduledActions();
 }
 
 void Scheduler::ProcessScheduledActions() {
   // We do not allow ProcessScheduledActions to be recursive.
   // The top-level call will iteratively execute the next action for us anyway.
   if (inside_process_scheduled_actions_)
     return;
 
   base::AutoReset<bool> mark_inside(&inside_process_scheduled_actions_, true);
 
   SchedulerStateMachine::Action action;
   do {
     action = state_machine_.NextAction();
     TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
                  "SchedulerStateMachine",
                  "state",
                  AsValue());
     DVLOG(2) << "Scheduler::ProcessScheduledActions: "
              << SchedulerStateMachine::ActionToString(action) << " "
              << state_machine_.GetStatesForDebugging();
-    state_machine_.UpdateState(action);
     base::AutoReset<SchedulerStateMachine::Action>
         mark_inside_action(&inside_action_, action);
+    state_machine_.WillAction(action);
     switch (action) {
       case SchedulerStateMachine::ACTION_NONE:
         break;
       case SchedulerStateMachine::ACTION_ANIMATE:
         client_->ScheduledActionAnimate();
         break;
       case SchedulerStateMachine::ACTION_SEND_BEGIN_MAIN_FRAME:
         client_->ScheduledActionSendBeginMainFrame();
         break;
       case SchedulerStateMachine::ACTION_COMMIT: {
@@ skipping 28 matching lines @@
         client_->ScheduledActionBeginOutputSurfaceCreation();
         break;
       case SchedulerStateMachine::ACTION_PREPARE_TILES:
         client_->ScheduledActionPrepareTiles();
         break;
       case SchedulerStateMachine::ACTION_INVALIDATE_OUTPUT_SURFACE: {
         client_->ScheduledActionInvalidateOutputSurface();
         break;
       }
     }
+    state_machine_.DidAction(action);
   } while (action != SchedulerStateMachine::ACTION_NONE);
 
   SetupPollingMechanisms();
 
   client_->DidAnticipatedDrawTimeChange(AnticipatedDrawTime());
 
   ScheduleBeginImplFrameDeadlineIfNeeded();
 
   SetupNextBeginFrameIfNeeded();
 }
@@ skipping 91 matching lines @@
 }
 
 bool Scheduler::IsBeginMainFrameSentOrStarted() const {
   return (state_machine_.commit_state() ==
               SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_SENT ||
           state_machine_.commit_state() ==
               SchedulerStateMachine::COMMIT_STATE_BEGIN_MAIN_FRAME_STARTED);
 }
 
 }  // namespace cc