CC: Add a scheduled action for ManageTiles

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 "base/auto_reset.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "cc/debug/traced_value.h"
 
 namespace cc {
 
 Scheduler::Scheduler(SchedulerClient* client,
                      const SchedulerSettings& scheduler_settings)
     : settings_(scheduler_settings),
       client_(client),
       weak_factory_(this),
       last_set_needs_begin_frame_(false),
       has_pending_begin_frame_(false),
       state_machine_(scheduler_settings),
-      inside_process_scheduled_actions_(false) {
+      inside_process_scheduled_actions_(false),
+      inside_action_(SchedulerStateMachine::ACTION_NONE) {
   DCHECK(client_);
   DCHECK(!state_machine_.BeginFrameNeededToDrawByImplThread());
 }
 
 Scheduler::~Scheduler() {
   client_->SetNeedsBeginFrameOnImplThread(false);
 }
 
 void Scheduler::SetCanStart() {
   state_machine_.SetCanStart();
@@ skipping 24 matching lines @@
   state_machine_.SetNeedsCommit();
   state_machine_.SetNeedsForcedCommitForReadback();
   ProcessScheduledActions();
 }
 
 void Scheduler::SetNeedsRedraw() {
   state_machine_.SetNeedsRedraw();
   ProcessScheduledActions();
 }
 
+void Scheduler::SetNeedsManageTiles() {
+  DCHECK(!IsInsideAction(SchedulerStateMachine::ACTION_MANAGE_TILES));
+  state_machine_.SetNeedsManageTiles();
+  ProcessScheduledActions();
+}
+
 void Scheduler::SetSwapUsedIncompleteTile(bool used_incomplete_tile) {
   state_machine_.SetSwapUsedIncompleteTile(used_incomplete_tile);
   ProcessScheduledActions();
 }
 
 void Scheduler::SetMainThreadNeedsLayerTextures() {
   state_machine_.SetMainThreadNeedsLayerTextures();
   ProcessScheduledActions();
 }
 
@@ skipping 99 matching lines @@
   DCHECK(!has_pending_begin_frame_);
   has_pending_begin_frame_ = true;
   last_begin_frame_args_ = args;
   state_machine_.DidEnterBeginFrame(args);
   ProcessScheduledActions();
   state_machine_.DidLeaveBeginFrame();
 }
 
 void Scheduler::PollForAnticipatedDrawTriggers() {
   TRACE_EVENT0("cc", "Scheduler::PollForAnticipatedDrawTriggers");
-  state_machine_.PollForAnticipatedDrawTriggers();
+  state_machine_.DidEnterPollForAnticipatedDrawTriggers();
   ProcessScheduledActions();
+  state_machine_.DidLeavePollForAnticipatedDrawTriggers();
 }
 
 void Scheduler::DrawAndSwapIfPossible() {
   DrawSwapReadbackResult result =
       client_->ScheduledActionDrawAndSwapIfPossible();
   state_machine_.DidDrawIfPossibleCompleted(result.did_draw);
   if (result.did_swap)
     has_pending_begin_frame_ = false;
 }
 
@@ skipping 18 matching lines @@
 
   SchedulerStateMachine::Action action;
   do {
     state_machine_.CheckInvariants();
     action = state_machine_.NextAction();
     TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("cc.debug.scheduler"),
                  "SchedulerStateMachine",
                  "state",
                  TracedValue::FromValue(state_machine_.AsValue().release()));
     state_machine_.UpdateState(action);
+    base::AutoReset<SchedulerStateMachine::Action>
+        mark_inside_action(&inside_action_, action);
     switch (action) {
       case SchedulerStateMachine::ACTION_NONE:
         break;
       case SchedulerStateMachine::ACTION_SEND_BEGIN_FRAME_TO_MAIN_THREAD:
         client_->ScheduledActionSendBeginFrameToMainThread();
         break;
       case SchedulerStateMachine::ACTION_COMMIT:
         client_->ScheduledActionCommit();
         break;
       case SchedulerStateMachine::ACTION_UPDATE_VISIBLE_TILES:
@@ skipping 14 matching lines @@
         break;
       case SchedulerStateMachine::ACTION_DRAW_AND_READBACK:
         DrawAndReadback();
         break;
       case SchedulerStateMachine::ACTION_BEGIN_OUTPUT_SURFACE_CREATION:
         client_->ScheduledActionBeginOutputSurfaceCreation();
         break;
       case SchedulerStateMachine::ACTION_ACQUIRE_LAYER_TEXTURES_FOR_MAIN_THREAD:
         client_->ScheduledActionAcquireLayerTexturesForMainThread();
         break;
+      case SchedulerStateMachine::ACTION_MANAGE_TILES:
+        client_->ScheduledActionManageTiles();
+        break;
     }
   } while (action != SchedulerStateMachine::ACTION_NONE);
 
   SetupNextBeginFrameIfNeeded();
   client_->DidAnticipatedDrawTimeChange(AnticipatedDrawTime());
 }
 
 bool Scheduler::WillDrawIfNeeded() const {
   return !state_machine_.PendingDrawsShouldBeAborted();
 }
 
 }  // namespace cc