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));

[brianderson, 2013/09/13 00:29:00]

How does ManagingTiles result in SetNeedsManageTiles from being called and why
is it okay to ignore it here?

[epennerAtGoogle, 2013/09/13 00:37:56]

We don't do it. This is just meant to insure we never do that by mistake.

[brianderson, 2013/09/13 00:42:34]

Ah, I completely miss read the code.

I really like the concept of the IsInsideAction method. We can probably use it
to DCHECK in a few other places.

+  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 139 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);

[enne (OOO), 2013/09/13 00:47:01]

Nifty!

     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