cc/CCScheduler.cpp

   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 "config.h"
   6
   7 #include "CCScheduler.h"
   8
   9 #include "TraceEvent.h"
  10 #include <base/auto_reset.h>
  11
  12 namespace cc {
  13
  14 CCScheduler::CCScheduler(CCSchedulerClient* client, PassOwnPtr<CCFrameRateController> frameRateController)
  15     : m_client(client)
  16     , m_frameRateController(frameRateController)
  17     , m_insideProcessScheduledActions(false)
  18 {
  19     ASSERT(m_client);
  20     m_frameRateController->setClient(this);
  21     ASSERT(!m_stateMachine.vsyncCallbackNeeded());
  22 }
  23
  24 CCScheduler::~CCScheduler()
  25 {
  26     m_frameRateController->setActive(false);
  27 }
  28
  29 void CCScheduler::setCanBeginFrame(bool can)
  30 {
  31     m_stateMachine.setCanBeginFrame(can);
  32     processScheduledActions();
  33 }
  34
  35 void CCScheduler::setVisible(bool visible)
  36 {
  37     m_stateMachine.setVisible(visible);
  38     processScheduledActions();
  39 }
  40
  41 void CCScheduler::setCanDraw(bool canDraw)
  42 {
  43     m_stateMachine.setCanDraw(canDraw);
  44     processScheduledActions();
  45 }
  46
  47 void CCScheduler::setNeedsCommit()
  48 {
  49     m_stateMachine.setNeedsCommit();
  50     processScheduledActions();
  51 }
  52
  53 void CCScheduler::setNeedsForcedCommit()
  54 {
  55     m_stateMachine.setNeedsForcedCommit();
  56     processScheduledActions();
  57 }
  58
  59 void CCScheduler::setNeedsRedraw()
  60 {
  61     m_stateMachine.setNeedsRedraw();
  62     processScheduledActions();
  63 }
  64
  65 void CCScheduler::setNeedsForcedRedraw()
  66 {
  67     m_stateMachine.setNeedsForcedRedraw();
  68     processScheduledActions();
  69 }
  70
  71 void CCScheduler::setMainThreadNeedsLayerTextures()
  72 {
  73     m_stateMachine.setMainThreadNeedsLayerTextures();
  74     processScheduledActions();
  75 }
  76
  77 void CCScheduler::beginFrameComplete()
  78 {
  79     TRACE_EVENT0("cc", "CCScheduler::beginFrameComplete");
  80     m_stateMachine.beginFrameComplete();
  81     processScheduledActions();
  82 }
  83
  84 void CCScheduler::beginFrameAborted()
  85 {
  86     TRACE_EVENT0("cc", "CCScheduler::beginFrameAborted");
  87     m_stateMachine.beginFrameAborted();
  88     processScheduledActions();
  89 }
  90
  91 void CCScheduler::setMaxFramesPending(int maxFramesPending)
  92 {
  93     m_frameRateController->setMaxFramesPending(maxFramesPending);
  94 }
  95
  96 void CCScheduler::setSwapBuffersCompleteSupported(bool supported)
  97 {
  98     m_frameRateController->setSwapBuffersCompleteSupported(supported);
  99 }
 100
 101 void CCScheduler::didSwapBuffersComplete()
 102 {
 103     TRACE_EVENT0("cc", "CCScheduler::didSwapBuffersComplete");
 104     m_frameRateController->didFinishFrame();
 105 }
 106
 107 void CCScheduler::didLoseContext()
 108 {
 109     TRACE_EVENT0("cc", "CCScheduler::didLoseContext");
 110     m_frameRateController->didAbortAllPendingFrames();
 111     m_stateMachine.didLoseContext();
 112     processScheduledActions();
 113 }
 114
 115 void CCScheduler::didRecreateContext()
 116 {
 117     TRACE_EVENT0("cc", "CCScheduler::didRecreateContext");
 118     m_stateMachine.didRecreateContext();
 119     processScheduledActions();
 120 }
 121
 122 void CCScheduler::setTimebaseAndInterval(base::TimeTicks timebase, base::TimeDelta interval)
 123 {
 124     m_frameRateController->setTimebaseAndInterval(timebase, interval);
 125 }
 126
 127 base::TimeTicks CCScheduler::anticipatedDrawTime()
 128 {
 129     return m_frameRateController->nextTickTime();
 130 }
 131
 132 void CCScheduler::vsyncTick(bool throttled)
 133 {
 134     TRACE_EVENT1("cc", "CCScheduler::vsyncTick", "throttled", throttled);
 135     if (!throttled)
 136         m_stateMachine.didEnterVSync();
 137     processScheduledActions();
 138     if (!throttled)
 139         m_stateMachine.didLeaveVSync();
 140 }
 141
 142 void CCScheduler::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     AutoReset<bool> markInside(&m_insideProcessScheduledActions, true);
 150
 151     CCSchedulerStateMachine::Action action = m_stateMachine.nextAction();
 152     while (action != CCSchedulerStateMachine::ACTION_NONE) {
 153         m_stateMachine.updateState(action);
 154         TRACE_EVENT1("cc", "CCScheduler::processScheduledActions()", "action", action);
 155
 156         switch (action) {
 157         case CCSchedulerStateMachine::ACTION_NONE:
 158             break;
 159         case CCSchedulerStateMachine::ACTION_BEGIN_FRAME:
 160             m_client->scheduledActionBeginFrame();
 161             break;
 162         case CCSchedulerStateMachine::ACTION_COMMIT:
 163             m_client->scheduledActionCommit();
 164             break;
 165         case CCSchedulerStateMachine::ACTION_DRAW_IF_POSSIBLE: {
 166             CCScheduledActionDrawAndSwapResult result = m_client->scheduledActionDrawAndSwapIfPossible();
 167             m_stateMachine.didDrawIfPossibleCompleted(result.didDraw);
 168             if (result.didSwap)
 169                 m_frameRateController->didBeginFrame();
 170             break;
 171         }
 172         case CCSchedulerStateMachine::ACTION_DRAW_FORCED: {
 173             CCScheduledActionDrawAndSwapResult result = m_client->scheduledActionDrawAndSwapForced();
 174             if (result.didSwap)
 175                 m_frameRateController->didBeginFrame();
 176             break;
 177         } case CCSchedulerStateMachine::ACTION_BEGIN_CONTEXT_RECREATION:
 178             m_client->scheduledActionBeginContextRecreation();
 179             break;
 180         case CCSchedulerStateMachine::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 }