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