cc/scheduler.cc

   1 // Copyright 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/scheduler.h"
   6
   7 #include "base/auto_reset.h"
   8 #include "base/debug/trace_event.h"
   9 #include "base/logging.h"
  10
  11 namespace cc {
  12
  13 Scheduler::Scheduler(SchedulerClient* client, scoped_ptr<FrameRateController> frameRateController)
  14     : m_client(client)
  15     , m_frameRateController(frameRateController.Pass())
  16     , m_insideProcessScheduledActions(false)
  17 {
  18     DCHECK(m_client);
  19     m_frameRateController->setClient(this);
  20     DCHECK(!m_stateMachine.vsyncCallbackNeeded());
  21 }
  22
  23 Scheduler::~Scheduler()
  24 {
  25     m_frameRateController->setActive(false);
  26 }
  27
  28 void Scheduler::setCanBeginFrame(bool can)
  29 {
  30     m_stateMachine.setCanBeginFrame(can);
  31     processScheduledActions();
  32 }
  33
  34 void Scheduler::setVisible(bool visible)
  35 {
  36     m_stateMachine.setVisible(visible);
  37     processScheduledActions();
  38 }
  39
  40 void Scheduler::setCanDraw(bool canDraw)
  41 {
  42     m_stateMachine.setCanDraw(canDraw);
  43     processScheduledActions();
  44 }
  45
  46 void Scheduler::setNeedsCommit()
  47 {
  48     m_stateMachine.setNeedsCommit();
  49     processScheduledActions();
  50 }
  51
  52 void Scheduler::setNeedsForcedCommit()
  53 {
  54     m_stateMachine.setNeedsCommit();
  55     m_stateMachine.setNeedsForcedCommit();
  56     processScheduledActions();
  57 }
  58
  59 void Scheduler::setNeedsRedraw()
  60 {
  61     m_stateMachine.setNeedsRedraw();
  62     processScheduledActions();
  63 }
  64
  65 void Scheduler::setNeedsForcedRedraw()
  66 {
  67     m_stateMachine.setNeedsForcedRedraw();
  68     processScheduledActions();
  69 }
  70
  71 void Scheduler::setMainThreadNeedsLayerTextures()
  72 {
  73     m_stateMachine.setMainThreadNeedsLayerTextures();
  74     processScheduledActions();
  75 }
  76
  77 void Scheduler::beginFrameComplete()
  78 {
  79     TRACE_EVENT0("cc", "Scheduler::beginFrameComplete");
  80     m_stateMachine.beginFrameComplete();
  81     processScheduledActions();
  82 }
  83
  84 void Scheduler::beginFrameAborted()
  85 {
  86     TRACE_EVENT0("cc", "Scheduler::beginFrameAborted");
  87     m_stateMachine.beginFrameAborted();
  88     processScheduledActions();
  89 }
  90
  91 void Scheduler::setMaxFramesPending(int maxFramesPending)
  92 {
  93     m_frameRateController->setMaxFramesPending(maxFramesPending);
  94 }
  95
  96 void Scheduler::setSwapBuffersCompleteSupported(bool supported)
  97 {
  98     m_frameRateController->setSwapBuffersCompleteSupported(supported);
  99 }
 100
 101 void Scheduler::didSwapBuffersComplete()
 102 {
 103     TRACE_EVENT0("cc", "Scheduler::didSwapBuffersComplete");
 104     m_frameRateController->didFinishFrame();
 105 }
 106
 107 void Scheduler::didLoseContext()
 108 {
 109     TRACE_EVENT0("cc", "Scheduler::didLoseContext");
 110     m_frameRateController->didAbortAllPendingFrames();
 111     m_stateMachine.didLoseContext();
 112     processScheduledActions();
 113 }
 114
 115 void Scheduler::didRecreateContext()
 116 {
 117     TRACE_EVENT0("cc", "Scheduler::didRecreateContext");
 118     m_stateMachine.didRecreateContext();
 119     processScheduledActions();
 120 }
 121
 122 void Scheduler::setTimebaseAndInterval(base::TimeTicks timebase, base::TimeDelta interval)
 123 {
 124     m_frameRateController->setTimebaseAndInterval(timebase, interval);
 125 }
 126
 127 base::TimeTicks Scheduler::anticipatedDrawTime()
 128 {
 129     return m_frameRateController->nextTickTime();
 130 }
 131
 132 void Scheduler::vsyncTick(bool throttled)
 133 {
 134     TRACE_EVENT1("cc", "Scheduler::vsyncTick", "throttled", throttled);
 135     if (!throttled)
 136         m_stateMachine.didEnterVSync();
 137     processScheduledActions();
 138     if (!throttled)
 139         m_stateMachine.didLeaveVSync();
 140 }
 141
 142 void Scheduler::processScheduledActions()
 143 {
 144     // We do not allow processScheduledActions to be recursive.
 145     // The top-level call will iteratively execute the next action for us anyway.
 146     if (m_insideProcessScheduledActions)
 147         return;
 148
 149     base::AutoReset<bool> markInside(&m_insideProcessScheduledActions, true);
 150
 151     SchedulerStateMachine::Action action = m_stateMachine.nextAction();
 152     while (action != SchedulerStateMachine::ACTION_NONE) {
 153         m_stateMachine.updateState(action);
 154         TRACE_EVENT1("cc", "Scheduler::processScheduledActions()", "action", action);
 155
 156         switch (action) {
 157         case SchedulerStateMachine::ACTION_NONE:
 158             break;
 159         case SchedulerStateMachine::ACTION_BEGIN_FRAME:
 160             m_client->scheduledActionBeginFrame();
 161             break;
 162         case SchedulerStateMachine::ACTION_COMMIT:
 163             m_client->scheduledActionCommit();
 164             break;
 165         case SchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE: {
 166             ScheduledActionDrawAndSwapResult result = m_client->scheduledActionDrawAndSwapIfPossible();
 167             m_stateMachine.didDrawIfPossibleCompleted(result.didDraw);
 168             if (result.didSwap)
 169                 m_frameRateController->didBeginFrame();
 170             break;
 171         }
 172         case SchedulerStateMachine::ACTION_DRAW_FORCED: {
 173             ScheduledActionDrawAndSwapResult result = m_client->scheduledActionDrawAndSwapForced();
 174             if (result.didSwap)
 175                 m_frameRateController->didBeginFrame();
 176             break;
 177         } case SchedulerStateMachine::ACTION_BEGIN_CONTEXT_RECREATION:
 178             m_client->scheduledActionBeginContextRecreation();
 179             break;
 180         case SchedulerStateMachine::ACTION_ACQUIRE_LAYER_TEXTURES_FOR_MAIN_THREAD:
 181             m_client->scheduledActionAcquireLayerTexturesForMainThread();
 182             break;
 183         }
 184         action = m_stateMachine.nextAction();
 185     }
 186
 187     // Activate or deactivate the frame rate controller.
 188     m_frameRateController->setActive(m_stateMachine.vsyncCallbackNeeded());
 189     m_client->didAnticipatedDrawTimeChange(m_frameRateController->nextTickTime());
 190 }
 191
 192 }  // namespace cc