cc/single_thread_proxy.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/single_thread_proxy.h"
   6
   7 #include "base/debug/trace_event.h"
   8 #include "cc/draw_quad.h"
   9 #include "cc/graphics_context.h"
  10 #include "cc/layer_tree_host.h"
  11 #include "cc/resource_update_controller.h"
  12 #include "cc/thread.h"
  13
  14 namespace cc {
  15
  16 scoped_ptr<Proxy> SingleThreadProxy::create(LayerTreeHost* layerTreeHost)
  17 {
  18     return make_scoped_ptr(new SingleThreadProxy(layerTreeHost)).PassAs<Proxy>();
  19 }
  20
  21 SingleThreadProxy::SingleThreadProxy(LayerTreeHost* layerTreeHost)
  22     : Proxy(scoped_ptr<Thread>(NULL))
  23     , m_layerTreeHost(layerTreeHost)
  24     , m_contextLost(false)
  25     , m_rendererInitialized(false)
  26     , m_nextFrameIsNewlyCommittedFrame(false)
  27     , m_totalCommitCount(0)
  28 {
  29     TRACE_EVENT0("cc", "SingleThreadProxy::SingleThreadProxy");
  30     DCHECK(Proxy::isMainThread());
  31 }
  32
  33 void SingleThreadProxy::start()
  34 {
  35     DebugScopedSetImplThread impl(this);
  36     m_layerTreeHostImpl = m_layerTreeHost->createLayerTreeHostImpl(this);
  37 }
  38
  39 SingleThreadProxy::~SingleThreadProxy()
  40 {
  41     TRACE_EVENT0("cc", "SingleThreadProxy::~SingleThreadProxy");
  42     DCHECK(Proxy::isMainThread());
  43     DCHECK(!m_layerTreeHostImpl.get() && !m_layerTreeHost); // make sure stop() got called.
  44 }
  45
  46 bool SingleThreadProxy::compositeAndReadback(void *pixels, const gfx::Rect& rect)
  47 {
  48     TRACE_EVENT0("cc", "SingleThreadProxy::compositeAndReadback");
  49     DCHECK(Proxy::isMainThread());
  50
  51     if (!commitAndComposite())
  52         return false;
  53
  54     m_layerTreeHostImpl->readback(pixels, rect);
  55
  56     if (m_layerTreeHostImpl->isContextLost())
  57         return false;
  58
  59     m_layerTreeHostImpl->swapBuffers();
  60     didSwapFrame();
  61
  62     return true;
  63 }
  64
  65 void SingleThreadProxy::startPageScaleAnimation(gfx::Vector2d targetOffset, bool useAnchor, float scale, base::TimeDelta duration)
  66 {
  67     m_layerTreeHostImpl->startPageScaleAnimation(targetOffset, useAnchor, scale, base::TimeTicks::Now(), duration);
  68 }
  69
  70 void SingleThreadProxy::finishAllRendering()
  71 {
  72     DCHECK(Proxy::isMainThread());
  73     {
  74         DebugScopedSetImplThread impl(this);
  75         m_layerTreeHostImpl->finishAllRendering();
  76     }
  77 }
  78
  79 bool SingleThreadProxy::isStarted() const
  80 {
  81     DCHECK(Proxy::isMainThread());
  82     return m_layerTreeHostImpl.get();
  83 }
  84
  85 bool SingleThreadProxy::initializeContext()
  86 {
  87     DCHECK(Proxy::isMainThread());
  88     scoped_ptr<GraphicsContext> context = m_layerTreeHost->createContext();
  89     if (!context.get())
  90         return false;
  91     m_contextBeforeInitialization = context.Pass();
  92     return true;
  93 }
  94
  95 void SingleThreadProxy::setSurfaceReady()
  96 {
  97     // Scheduling is controlled by the embedder in the single thread case, so nothing to do.
  98 }
  99
 100 void SingleThreadProxy::setVisible(bool visible)
 101 {
 102     DebugScopedSetImplThread impl(this);
 103     m_layerTreeHostImpl->setVisible(visible);
 104 }
 105
 106 bool SingleThreadProxy::initializeRenderer()
 107 {
 108     DCHECK(Proxy::isMainThread());
 109     DCHECK(m_contextBeforeInitialization.get());
 110     {
 111         DebugScopedSetImplThread impl(this);
 112         bool ok = m_layerTreeHostImpl->initializeRenderer(m_contextBeforeInitialization.Pass());
 113         if (ok) {
 114             m_rendererInitialized = true;
 115             m_RendererCapabilitiesForMainThread = m_layerTreeHostImpl->rendererCapabilities();
 116         }
 117
 118         return ok;
 119     }
 120 }
 121
 122 bool SingleThreadProxy::recreateContext()
 123 {
 124     TRACE_EVENT0("cc", "SingleThreadProxy::recreateContext");
 125     DCHECK(Proxy::isMainThread());
 126     DCHECK(m_contextLost);
 127
 128     scoped_ptr<GraphicsContext> context = m_layerTreeHost->createContext();
 129     if (!context.get())
 130         return false;
 131
 132     bool initialized;
 133     {
 134         DebugScopedSetMainThreadBlocked mainThreadBlocked(this);
 135         DebugScopedSetImplThread impl(this);
 136         if (!m_layerTreeHostImpl->contentsTexturesPurged())
 137             m_layerTreeHost->deleteContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
 138         initialized = m_layerTreeHostImpl->initializeRenderer(context.Pass());
 139         if (initialized) {
 140             m_RendererCapabilitiesForMainThread = m_layerTreeHostImpl->rendererCapabilities();
 141         }
 142     }
 143
 144     if (initialized)
 145         m_contextLost = false;
 146
 147     return initialized;
 148 }
 149
 150 void SingleThreadProxy::renderingStats(RenderingStats* stats)
 151 {
 152     stats->totalCommitTimeInSeconds = m_totalCommitTime.InSecondsF();
 153     stats->totalCommitCount = m_totalCommitCount;
 154     m_layerTreeHostImpl->renderingStats(stats);
 155 }
 156
 157 const RendererCapabilities& SingleThreadProxy::rendererCapabilities() const
 158 {
 159     DCHECK(m_rendererInitialized);
 160     // Note: this gets called during the commit by the "impl" thread
 161     return m_RendererCapabilitiesForMainThread;
 162 }
 163
 164 void SingleThreadProxy::loseContext()
 165 {
 166     DCHECK(Proxy::isMainThread());
 167     m_layerTreeHost->didLoseContext();
 168     m_contextLost = true;
 169 }
 170
 171 void SingleThreadProxy::setNeedsAnimate()
 172 {
 173     // Thread-only feature
 174     NOTREACHED();
 175 }
 176
 177 void SingleThreadProxy::doCommit(scoped_ptr<ResourceUpdateQueue> queue)
 178 {
 179     DCHECK(Proxy::isMainThread());
 180     // Commit immediately
 181     {
 182         DebugScopedSetMainThreadBlocked mainThreadBlocked(this);
 183         DebugScopedSetImplThread impl(this);
 184
 185         base::TimeTicks startTime = base::TimeTicks::HighResNow();
 186         m_layerTreeHostImpl->beginCommit();
 187
 188         m_layerTreeHost->contentsTextureManager()->pushTexturePrioritiesToBackings();
 189         m_layerTreeHost->beginCommitOnImplThread(m_layerTreeHostImpl.get());
 190
 191         scoped_ptr<ResourceUpdateController> updateController =
 192             ResourceUpdateController::create(
 193                 NULL,
 194                 Proxy::mainThread(),
 195                 queue.Pass(),
 196                 m_layerTreeHostImpl->resourceProvider(),
 197                 hasImplThread());
 198         updateController->finalize();
 199
 200         m_layerTreeHost->finishCommitOnImplThread(m_layerTreeHostImpl.get());
 201
 202         m_layerTreeHostImpl->commitComplete();
 203
 204 #ifndef NDEBUG
 205         // In the single-threaded case, the scroll deltas should never be
 206         // touched on the impl layer tree.
 207         scoped_ptr<ScrollAndScaleSet> scrollInfo = m_layerTreeHostImpl->processScrollDeltas();
 208         DCHECK(!scrollInfo->scrolls.size());
 209 #endif
 210
 211         base::TimeTicks endTime = base::TimeTicks::HighResNow();
 212         m_totalCommitTime += endTime - startTime;
 213         m_totalCommitCount++;
 214     }
 215     m_layerTreeHost->commitComplete();
 216     m_nextFrameIsNewlyCommittedFrame = true;
 217 }
 218
 219 void SingleThreadProxy::setNeedsCommit()
 220 {
 221     DCHECK(Proxy::isMainThread());
 222     m_layerTreeHost->scheduleComposite();
 223 }
 224
 225 void SingleThreadProxy::setNeedsRedraw()
 226 {
 227     // FIXME: Once we move render_widget scheduling into this class, we can
 228     // treat redraw requests more efficiently than commitAndRedraw requests.
 229     m_layerTreeHostImpl->setFullRootLayerDamage();
 230     setNeedsCommit();
 231 }
 232
 233 void SingleThreadProxy::setDeferCommits(bool deferCommits)
 234 {
 235     // Thread-only feature.
 236     NOTREACHED();
 237 }
 238
 239 bool SingleThreadProxy::commitRequested() const
 240 {
 241     return false;
 242 }
 243
 244 void SingleThreadProxy::didAddAnimation()
 245 {
 246 }
 247
 248 size_t SingleThreadProxy::maxPartialTextureUpdates() const
 249 {
 250     return std::numeric_limits<size_t>::max();
 251 }
 252
 253 void SingleThreadProxy::stop()
 254 {
 255     TRACE_EVENT0("cc", "SingleThreadProxy::stop");
 256     DCHECK(Proxy::isMainThread());
 257     {
 258         DebugScopedSetMainThreadBlocked mainThreadBlocked(this);
 259         DebugScopedSetImplThread impl(this);
 260
 261         if (!m_layerTreeHostImpl->contentsTexturesPurged())
 262             m_layerTreeHost->deleteContentsTexturesOnImplThread(m_layerTreeHostImpl->resourceProvider());
 263         m_layerTreeHostImpl.reset();
 264     }
 265     m_layerTreeHost = 0;
 266 }
 267
 268 void SingleThreadProxy::setNeedsRedrawOnImplThread()
 269 {
 270     m_layerTreeHost->scheduleComposite();
 271 }
 272
 273 void SingleThreadProxy::setNeedsCommitOnImplThread()
 274 {
 275     m_layerTreeHost->scheduleComposite();
 276 }
 277
 278 void SingleThreadProxy::postAnimationEventsToMainThreadOnImplThread(scoped_ptr<AnimationEventsVector> events, base::Time wallClockTime)
 279 {
 280     DCHECK(Proxy::isImplThread());
 281     DebugScopedSetMainThread main(this);
 282     m_layerTreeHost->setAnimationEvents(events.Pass(), wallClockTime);
 283 }
 284
 285 bool SingleThreadProxy::reduceContentsTextureMemoryOnImplThread(size_t limitBytes, int priorityCutoff)
 286 {
 287     DCHECK(isImplThread());
 288     if (!m_layerTreeHost->contentsTextureManager())
 289         return false;
 290
 291     return m_layerTreeHost->contentsTextureManager()->reduceMemoryOnImplThread(limitBytes, priorityCutoff, m_layerTreeHostImpl->resourceProvider());
 292 }
 293
 294 void SingleThreadProxy::sendManagedMemoryStats()
 295 {
 296     DCHECK(Proxy::isImplThread());
 297     if (!m_layerTreeHostImpl.get())
 298         return;
 299     if (!m_layerTreeHostImpl->renderer())
 300         return;
 301     if (!m_layerTreeHost->contentsTextureManager())
 302         return;
 303
 304     m_layerTreeHostImpl->renderer()->sendManagedMemoryStats(
 305         m_layerTreeHost->contentsTextureManager()->memoryVisibleBytes(),
 306         m_layerTreeHost->contentsTextureManager()->memoryVisibleAndNearbyBytes(),
 307         m_layerTreeHost->contentsTextureManager()->memoryUseBytes());
 308 }
 309
 310 // Called by the legacy scheduling path (e.g. where render_widget does the scheduling)
 311 void SingleThreadProxy::compositeImmediately()
 312 {
 313     if (commitAndComposite()) {
 314         m_layerTreeHostImpl->swapBuffers();
 315         didSwapFrame();
 316     }
 317 }
 318
 319 void SingleThreadProxy::forceSerializeOnSwapBuffers()
 320 {
 321     {
 322         DebugScopedSetImplThread impl(this);
 323         if (m_rendererInitialized)
 324             m_layerTreeHostImpl->renderer()->doNoOp();
 325     }
 326 }
 327
 328 void SingleThreadProxy::onSwapBuffersCompleteOnImplThread()
 329 {
 330     NOTREACHED();
 331 }
 332
 333 bool SingleThreadProxy::commitAndComposite()
 334 {
 335     DCHECK(Proxy::isMainThread());
 336
 337     if (!m_layerTreeHost->initializeRendererIfNeeded())
 338         return false;
 339
 340     // Unlink any texture backings that were deleted
 341     PrioritizedResourceManager::BackingList evictedContentsTexturesBackings;
 342     {
 343         DebugScopedSetImplThread impl(this);
 344         m_layerTreeHost->contentsTextureManager()->getEvictedBackings(evictedContentsTexturesBackings);
 345     }
 346     m_layerTreeHost->contentsTextureManager()->unlinkEvictedBackings(evictedContentsTexturesBackings);
 347
 348     scoped_ptr<ResourceUpdateQueue> queue = make_scoped_ptr(new ResourceUpdateQueue);
 349     m_layerTreeHost->updateLayers(*(queue.get()), m_layerTreeHostImpl->memoryAllocationLimitBytes());
 350
 351     if (m_layerTreeHostImpl->contentsTexturesPurged())
 352         m_layerTreeHostImpl->resetContentsTexturesPurged();
 353
 354     m_layerTreeHost->willCommit();
 355     doCommit(queue.Pass());
 356     bool result = doComposite();
 357     m_layerTreeHost->didBeginFrame();
 358     return result;
 359 }
 360
 361 bool SingleThreadProxy::doComposite()
 362 {
 363     DCHECK(!m_contextLost);
 364     {
 365         DebugScopedSetImplThread impl(this);
 366
 367         if (!m_layerTreeHostImpl->visible())
 368             return false;
 369
 370         m_layerTreeHostImpl->animate(base::TimeTicks::Now(), base::Time::Now());
 371
 372         // We guard prepareToDraw() with canDraw() because it always returns a valid frame, so can only
 373         // be used when such a frame is possible. Since drawLayers() depends on the result of
 374         // prepareToDraw(), it is guarded on canDraw() as well.
 375         if (!m_layerTreeHostImpl->canDraw())
 376             return false;
 377
 378         LayerTreeHostImpl::FrameData frame;
 379         m_layerTreeHostImpl->prepareToDraw(frame);
 380         m_layerTreeHostImpl->drawLayers(frame);
 381         m_layerTreeHostImpl->didDrawAllLayers(frame);
 382     }
 383
 384     if (m_layerTreeHostImpl->isContextLost()) {
 385         m_contextLost = true;
 386         m_layerTreeHost->didLoseContext();
 387         return false;
 388     }
 389
 390     return true;
 391 }
 392
 393 void SingleThreadProxy::didSwapFrame()
 394 {
 395     if (m_nextFrameIsNewlyCommittedFrame) {
 396         m_nextFrameIsNewlyCommittedFrame = false;
 397         m_layerTreeHost->didCommitAndDrawFrame();
 398     }
 399 }
 400
 401 }  // namespace cc