cc/CCSingleThreadProxy.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 "CCSingleThreadProxy.h"
   8
   9 #include "CCDrawQuad.h"
  10 #include "CCGraphicsContext.h"
  11 #include "CCLayerTreeHost.h"
  12 #include "CCTextureUpdateController.h"
  13 #include "CCTimer.h"
  14 #include "TraceEvent.h"
  15 #include <wtf/CurrentTime.h>
  16
  17 using namespace WTF;
  18
  19 namespace WebCore {
  20
  21 PassOwnPtr<CCProxy> CCSingleThreadProxy::create(CCLayerTreeHost* layerTreeHost)
  22 {
  23     return adoptPtr(new CCSingleThreadProxy(layerTreeHost));
  24 }
  25
  26 CCSingleThreadProxy::CCSingleThreadProxy(CCLayerTreeHost* layerTreeHost)
  27     : m_layerTreeHost(layerTreeHost)
  28     , m_contextLost(false)
  29     , m_rendererInitialized(false)
  30     , m_nextFrameIsNewlyCommittedFrame(false)
  31 {
  32     TRACE_EVENT0("cc", "CCSingleThreadProxy::CCSingleThreadProxy");
  33     ASSERT(CCProxy::isMainThread());
  34 }
  35
  36 void CCSingleThreadProxy::start()
  37 {
  38     DebugScopedSetImplThread impl;
  39     m_layerTreeHostImpl = m_layerTreeHost->createLayerTreeHostImpl(this);
  40 }
  41
  42 CCSingleThreadProxy::~CCSingleThreadProxy()
  43 {
  44     TRACE_EVENT0("cc", "CCSingleThreadProxy::~CCSingleThreadProxy");
  45     ASSERT(CCProxy::isMainThread());
  46     ASSERT(!m_layerTreeHostImpl && !m_layerTreeHost); // make sure stop() got called.
  47 }
  48
  49 bool CCSingleThreadProxy::compositeAndReadback(void *pixels, const IntRect& rect)
  50 {
  51     TRACE_EVENT0("cc", "CCSingleThreadProxy::compositeAndReadback");
  52     ASSERT(CCProxy::isMainThread());
  53
  54     if (!commitAndComposite())
  55         return false;
  56
  57     m_layerTreeHostImpl->readback(pixels, rect);
  58
  59     if (m_layerTreeHostImpl->isContextLost())
  60         return false;
  61
  62     m_layerTreeHostImpl->swapBuffers();
  63     didSwapFrame();
  64
  65     return true;
  66 }
  67
  68 void CCSingleThreadProxy::startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, double duration)
  69 {
  70     m_layerTreeHostImpl->startPageScaleAnimation(targetPosition, useAnchor, scale, monotonicallyIncreasingTime(), duration);
  71 }
  72
  73 void CCSingleThreadProxy::finishAllRendering()
  74 {
  75     ASSERT(CCProxy::isMainThread());
  76     {
  77         DebugScopedSetImplThread impl;
  78         m_layerTreeHostImpl->finishAllRendering();
  79     }
  80 }
  81
  82 bool CCSingleThreadProxy::isStarted() const
  83 {
  84     ASSERT(CCProxy::isMainThread());
  85     return m_layerTreeHostImpl;
  86 }
  87
  88 bool CCSingleThreadProxy::initializeContext()
  89 {
  90     ASSERT(CCProxy::isMainThread());
  91     OwnPtr<CCGraphicsContext> context = m_layerTreeHost->createContext();
  92     if (!context)
  93         return false;
  94     m_contextBeforeInitialization = context.release();
  95     return true;
  96 }
  97
  98 void CCSingleThreadProxy::setSurfaceReady()
  99 {
 100     // Scheduling is controlled by the embedder in the single thread case, so nothing to do.
 101 }
 102
 103 void CCSingleThreadProxy::setVisible(bool visible)
 104 {
 105     DebugScopedSetImplThread impl;
 106     m_layerTreeHostImpl->setVisible(visible);
 107 }
 108
 109 bool CCSingleThreadProxy::initializeRenderer()
 110 {
 111     ASSERT(CCProxy::isMainThread());
 112     ASSERT(m_contextBeforeInitialization);
 113     {
 114         DebugScopedSetImplThread impl;
 115         bool ok = m_layerTreeHostImpl->initializeRenderer(m_contextBeforeInitialization.release(), UnthrottledUploader);
 116         if (ok) {
 117             m_rendererInitialized = true;
 118             m_RendererCapabilitiesForMainThread = m_layerTreeHostImpl->rendererCapabilities();
 119         }
 120
 121         return ok;
 122     }
 123 }
 124
 125 bool CCSingleThreadProxy::recreateContext()
 126 {
 127     TRACE_EVENT0("cc", "CCSingleThreadProxy::recreateContext");
 128     ASSERT(CCProxy::isMainThread());
 129     ASSERT(m_contextLost);
 130
 131     OwnPtr<CCGraphicsContext> context = m_layerTreeHost->createContext();
 132     if (!context)
 133         return false;
 134
 135     bool initialized;
 136     {
 137         DebugScopedSetMainThreadBlocked mainThreadBlocked;
 138         DebugScopedSetImplThread impl;
 139         if (!m_layerTreeHostImpl->contentsTexturesPurged())
 140             m_layerTreeHost->deleteContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
 141         initialized = m_layerTreeHostImpl->initializeRenderer(context.release(), UnthrottledUploader);
 142         if (initialized) {
 143             m_RendererCapabilitiesForMainThread = m_layerTreeHostImpl->rendererCapabilities();
 144         }
 145     }
 146
 147     if (initialized)
 148         m_contextLost = false;
 149
 150     return initialized;
 151 }
 152
 153 void CCSingleThreadProxy::implSideRenderingStats(CCRenderingStats& stats)
 154 {
 155     m_layerTreeHostImpl->renderingStats(stats);
 156 }
 157
 158 const RendererCapabilities& CCSingleThreadProxy::rendererCapabilities() const
 159 {
 160     ASSERT(m_rendererInitialized);
 161     // Note: this gets called during the commit by the "impl" thread
 162     return m_RendererCapabilitiesForMainThread;
 163 }
 164
 165 void CCSingleThreadProxy::loseContext()
 166 {
 167     ASSERT(CCProxy::isMainThread());
 168     m_layerTreeHost->didLoseContext();
 169     m_contextLost = true;
 170 }
 171
 172 void CCSingleThreadProxy::setNeedsAnimate()
 173 {
 174     // CCThread-only feature
 175     ASSERT_NOT_REACHED();
 176 }
 177
 178 void CCSingleThreadProxy::doCommit(CCTextureUpdateQueue& queue)
 179 {
 180     ASSERT(CCProxy::isMainThread());
 181     // Commit immediately
 182     {
 183         DebugScopedSetMainThreadBlocked mainThreadBlocked;
 184         DebugScopedSetImplThread impl;
 185
 186         m_layerTreeHostImpl->beginCommit();
 187
 188         m_layerTreeHost->beginCommitOnImplThread(m_layerTreeHostImpl.get());
 189
 190         // CCTextureUpdateController::updateTextures is non-blocking and will
 191         // return without updating any textures if the uploader is busy. This
 192         // shouldn't be a problem here as the throttled uploader isn't used in
 193         // single thread mode. For correctness, loop until no more updates are
 194         // pending.
 195         while (queue.hasMoreUpdates())
 196             CCTextureUpdateController::updateTextures(m_layerTreeHostImpl->resourceProvider(), m_layerTreeHostImpl->renderer()->textureCopier(), m_layerTreeHostImpl->renderer()->textureUploader(), &queue, maxPartialTextureUpdates());
 197
 198         m_layerTreeHost->finishCommitOnImplThread(m_layerTreeHostImpl.get());
 199
 200         m_layerTreeHostImpl->commitComplete();
 201
 202 #if !ASSERT_DISABLED
 203         // In the single-threaded case, the scroll deltas should never be
 204         // touched on the impl layer tree.
 205         OwnPtr<CCScrollAndScaleSet> scrollInfo = m_layerTreeHostImpl->processScrollDeltas();
 206         ASSERT(!scrollInfo->scrolls.size());
 207 #endif
 208     }
 209     m_layerTreeHost->commitComplete();
 210     m_nextFrameIsNewlyCommittedFrame = true;
 211 }
 212
 213 void CCSingleThreadProxy::setNeedsCommit()
 214 {
 215     ASSERT(CCProxy::isMainThread());
 216     m_layerTreeHost->scheduleComposite();
 217 }
 218
 219 void CCSingleThreadProxy::setNeedsRedraw()
 220 {
 221     // FIXME: Once we move render_widget scheduling into this class, we can
 222     // treat redraw requests more efficiently than commitAndRedraw requests.
 223     m_layerTreeHostImpl->setFullRootLayerDamage();
 224     setNeedsCommit();
 225 }
 226
 227 bool CCSingleThreadProxy::commitRequested() const
 228 {
 229     return false;
 230 }
 231
 232 void CCSingleThreadProxy::didAddAnimation()
 233 {
 234 }
 235
 236 void CCSingleThreadProxy::stop()
 237 {
 238     TRACE_EVENT0("cc", "CCSingleThreadProxy::stop");
 239     ASSERT(CCProxy::isMainThread());
 240     {
 241         DebugScopedSetMainThreadBlocked mainThreadBlocked;
 242         DebugScopedSetImplThread impl;
 243
 244         if (!m_layerTreeHostImpl->contentsTexturesPurged())
 245             m_layerTreeHost->deleteContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
 246         m_layerTreeHostImpl.clear();
 247     }
 248     m_layerTreeHost = 0;
 249 }
 250
 251 void CCSingleThreadProxy::postAnimationEventsToMainThreadOnImplThread(PassOwnPtr<CCAnimationEventsVector> events, double wallClockTime)
 252 {
 253     ASSERT(CCProxy::isImplThread());
 254     DebugScopedSetMainThread main;
 255     m_layerTreeHost->setAnimationEvents(events, wallClockTime);
 256 }
 257
 258 // Called by the legacy scheduling path (e.g. where render_widget does the scheduling)
 259 void CCSingleThreadProxy::compositeImmediately()
 260 {
 261     if (commitAndComposite()) {
 262         m_layerTreeHostImpl->swapBuffers();
 263         didSwapFrame();
 264     }
 265 }
 266
 267 void CCSingleThreadProxy::forceSerializeOnSwapBuffers()
 268 {
 269     {
 270         DebugScopedSetImplThread impl;
 271         if (m_rendererInitialized)
 272             m_layerTreeHostImpl->renderer()->doNoOp();
 273     }
 274 }
 275
 276 bool CCSingleThreadProxy::commitAndComposite()
 277 {
 278     ASSERT(CCProxy::isMainThread());
 279
 280     if (!m_layerTreeHost->initializeRendererIfNeeded())
 281         return false;
 282
 283     if (m_layerTreeHostImpl->contentsTexturesPurged()) {
 284         m_layerTreeHost->unlinkAllContentTextures();
 285         DebugScopedSetImplThreadAndMainThreadBlocked implAndMainBlocked;
 286         m_layerTreeHost->deleteUnlinkedTextures();
 287     }
 288
 289     CCTextureUpdateQueue queue;
 290     m_layerTreeHost->updateLayers(queue, m_layerTreeHostImpl->memoryAllocationLimitBytes());
 291     m_layerTreeHostImpl->resetContentsTexturesPurged();
 292
 293     m_layerTreeHost->willCommit();
 294     doCommit(queue);
 295     bool result = doComposite();
 296     m_layerTreeHost->didBeginFrame();
 297     return result;
 298 }
 299
 300 bool CCSingleThreadProxy::doComposite()
 301 {
 302     ASSERT(!m_contextLost);
 303     {
 304         DebugScopedSetImplThread impl;
 305
 306         if (!m_layerTreeHostImpl->visible())
 307             return false;
 308
 309         double monotonicTime = monotonicallyIncreasingTime();
 310         double wallClockTime = currentTime();
 311         m_layerTreeHostImpl->animate(monotonicTime, wallClockTime);
 312
 313         // We guard prepareToDraw() with canDraw() because it always returns a valid frame, so can only
 314         // be used when such a frame is possible. Since drawLayers() depends on the result of
 315         // prepareToDraw(), it is guarded on canDraw() as well.
 316         if (!m_layerTreeHostImpl->canDraw())
 317             return false;
 318
 319         CCLayerTreeHostImpl::FrameData frame;
 320         m_layerTreeHostImpl->prepareToDraw(frame);
 321         m_layerTreeHostImpl->drawLayers(frame);
 322         m_layerTreeHostImpl->didDrawAllLayers(frame);
 323     }
 324
 325     if (m_layerTreeHostImpl->isContextLost()) {
 326         m_contextLost = true;
 327         m_layerTreeHost->didLoseContext();
 328         return false;
 329     }
 330
 331     return true;
 332 }
 333
 334 void CCSingleThreadProxy::didSwapFrame()
 335 {
 336     if (m_nextFrameIsNewlyCommittedFrame) {
 337         m_nextFrameIsNewlyCommittedFrame = false;
 338         m_layerTreeHost->didCommitAndDrawFrame();
 339     }
 340 }
 341
 342 }