cc/CCLayerTreeHost.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 "CCLayerTreeHost.h"
   8
   9 #include "CCFontAtlas.h"
  10 #include "CCGraphicsContext.h"
  11 #include "CCHeadsUpDisplayLayerImpl.h"
  12 #include "CCLayerAnimationController.h"
  13 #include "CCLayerIterator.h"
  14 #include "CCLayerTreeHostClient.h"
  15 #include "CCLayerTreeHostCommon.h"
  16 #include "CCLayerTreeHostImpl.h"
  17 #include "CCOcclusionTracker.h"
  18 #include "CCOverdrawMetrics.h"
  19 #include "CCSettings.h"
  20 #include "CCSingleThreadProxy.h"
  21 #include "CCThreadProxy.h"
  22 #include "HeadsUpDisplayLayerChromium.h"
  23 #include "LayerChromium.h"
  24 #include "Region.h"
  25 #include "TraceEvent.h"
  26 #include "TreeSynchronizer.h"
  27
  28 using namespace std;
  29 using WebKit::WebTransformationMatrix;
  30
  31 namespace {
  32 static int numLayerTreeInstances;
  33 }
  34
  35 namespace WebCore {
  36
  37 bool CCLayerTreeHost::s_needsFilterContext = false;
  38
  39 bool CCLayerTreeHost::anyLayerTreeHostInstanceExists()
  40 {
  41     return numLayerTreeInstances > 0;
  42 }
  43
  44 PassOwnPtr<CCLayerTreeHost> CCLayerTreeHost::create(CCLayerTreeHostClient* client, const CCLayerTreeSettings& settings)
  45 {
  46     OwnPtr<CCLayerTreeHost> layerTreeHost = adoptPtr(new CCLayerTreeHost(client, settings));
  47     if (!layerTreeHost->initialize())
  48         return nullptr;
  49     return layerTreeHost.release();
  50 }
  51
  52 CCLayerTreeHost::CCLayerTreeHost(CCLayerTreeHostClient* client, const CCLayerTreeSettings& settings)
  53     : m_animating(false)
  54     , m_needsAnimateLayers(false)
  55     , m_client(client)
  56     , m_commitNumber(0)
  57     , m_renderingStats()
  58     , m_rendererInitialized(false)
  59     , m_contextLost(false)
  60     , m_numTimesRecreateShouldFail(0)
  61     , m_numFailedRecreateAttempts(0)
  62     , m_settings(settings)
  63     , m_deviceScaleFactor(1)
  64     , m_visible(true)
  65     , m_pageScaleFactor(1)
  66     , m_minPageScaleFactor(1)
  67     , m_maxPageScaleFactor(1)
  68     , m_triggerIdleUpdates(true)
  69     , m_backgroundColor(SK_ColorWHITE)
  70     , m_hasTransparentBackground(false)
  71     , m_partialTextureUpdateRequests(0)
  72 {
  73     ASSERT(CCProxy::isMainThread());
  74     numLayerTreeInstances++;
  75 }
  76
  77 bool CCLayerTreeHost::initialize()
  78 {
  79     TRACE_EVENT0("cc", "CCLayerTreeHost::initialize");
  80
  81     if (CCProxy::hasImplThread())
  82         m_proxy = CCThreadProxy::create(this);
  83     else
  84         m_proxy = CCSingleThreadProxy::create(this);
  85     m_proxy->start();
  86
  87     return m_proxy->initializeContext();
  88 }
  89
  90 CCLayerTreeHost::~CCLayerTreeHost()
  91 {
  92     if (m_rootLayer)
  93         m_rootLayer->setLayerTreeHost(0);
  94     ASSERT(CCProxy::isMainThread());
  95     TRACE_EVENT0("cc", "CCLayerTreeHost::~CCLayerTreeHost");
  96     ASSERT(m_proxy);
  97     m_proxy->stop();
  98     m_proxy.clear();
  99     numLayerTreeInstances--;
 100     RateLimiterMap::iterator it = m_rateLimiters.begin();
 101     if (it != m_rateLimiters.end())
 102         it->second->stop();
 103 }
 104
 105 void CCLayerTreeHost::setSurfaceReady()
 106 {
 107     m_proxy->setSurfaceReady();
 108 }
 109
 110 void CCLayerTreeHost::initializeRenderer()
 111 {
 112     TRACE_EVENT0("cc", "CCLayerTreeHost::initializeRenderer");
 113     if (!m_proxy->initializeRenderer()) {
 114         // Uh oh, better tell the client that we can't do anything with this context.
 115         m_client->didRecreateOutputSurface(false);
 116         return;
 117     }
 118
 119     // Update m_settings based on capabilities that we got back from the renderer.
 120     m_settings.acceleratePainting = m_proxy->rendererCapabilities().usingAcceleratedPainting;
 121
 122     // Update m_settings based on partial update capability.
 123     m_settings.maxPartialTextureUpdates = min(m_settings.maxPartialTextureUpdates, m_proxy->maxPartialTextureUpdates());
 124
 125     m_contentsTextureManager = CCPrioritizedTextureManager::create(0, m_proxy->rendererCapabilities().maxTextureSize, CCRenderer::ContentPool);
 126     m_surfaceMemoryPlaceholder = m_contentsTextureManager->createTexture(IntSize(), GraphicsContext3D::RGBA);
 127
 128     m_rendererInitialized = true;
 129
 130     m_settings.defaultTileSize = IntSize(min(m_settings.defaultTileSize.width(), m_proxy->rendererCapabilities().maxTextureSize),
 131                                          min(m_settings.defaultTileSize.height(), m_proxy->rendererCapabilities().maxTextureSize));
 132     m_settings.maxUntiledLayerSize = IntSize(min(m_settings.maxUntiledLayerSize.width(), m_proxy->rendererCapabilities().maxTextureSize),
 133                                              min(m_settings.maxUntiledLayerSize.height(), m_proxy->rendererCapabilities().maxTextureSize));
 134 }
 135
 136 CCLayerTreeHost::RecreateResult CCLayerTreeHost::recreateContext()
 137 {
 138     TRACE_EVENT0("cc", "CCLayerTreeHost::recreateContext");
 139     ASSERT(m_contextLost);
 140
 141     bool recreated = false;
 142     if (!m_numTimesRecreateShouldFail)
 143         recreated = m_proxy->recreateContext();
 144     else
 145         m_numTimesRecreateShouldFail--;
 146
 147     if (recreated) {
 148         m_client->didRecreateOutputSurface(true);
 149         m_contextLost = false;
 150         return RecreateSucceeded;
 151     }
 152
 153     // Tolerate a certain number of recreation failures to work around races
 154     // in the context-lost machinery.
 155     m_numFailedRecreateAttempts++;
 156     if (m_numFailedRecreateAttempts < 5) {
 157         // FIXME: The single thread does not self-schedule context
 158         // recreation. So force another recreation attempt to happen by requesting
 159         // another commit.
 160         if (!CCProxy::hasImplThread())
 161             setNeedsCommit();
 162         return RecreateFailedButTryAgain;
 163     }
 164
 165     // We have tried too many times to recreate the context. Tell the host to fall
 166     // back to software rendering.
 167     m_client->didRecreateOutputSurface(false);
 168     return RecreateFailedAndGaveUp;
 169 }
 170
 171 void CCLayerTreeHost::deleteContentsTexturesOnImplThread(CCResourceProvider* resourceProvider)
 172 {
 173     ASSERT(CCProxy::isImplThread());
 174     if (m_rendererInitialized)
 175         m_contentsTextureManager->clearAllMemory(resourceProvider);
 176 }
 177
 178 void CCLayerTreeHost::acquireLayerTextures()
 179 {
 180     ASSERT(CCProxy::isMainThread());
 181     m_proxy->acquireLayerTextures();
 182 }
 183
 184 void CCLayerTreeHost::updateAnimations(double monotonicFrameBeginTime)
 185 {
 186     m_animating = true;
 187     m_client->animate(monotonicFrameBeginTime);
 188     animateLayers(monotonicFrameBeginTime);
 189     m_animating = false;
 190
 191     m_renderingStats.numAnimationFrames++;
 192 }
 193
 194 void CCLayerTreeHost::layout()
 195 {
 196     m_client->layout();
 197 }
 198
 199 void CCLayerTreeHost::beginCommitOnImplThread(CCLayerTreeHostImpl* hostImpl)
 200 {
 201     ASSERT(CCProxy::isImplThread());
 202     TRACE_EVENT0("cc", "CCLayerTreeHost::commitTo");
 203
 204     m_contentsTextureManager->reduceMemory(hostImpl->resourceProvider());
 205 }
 206
 207 // This function commits the CCLayerTreeHost to an impl tree. When modifying
 208 // this function, keep in mind that the function *runs* on the impl thread! Any
 209 // code that is logically a main thread operation, e.g. deletion of a LayerChromium,
 210 // should be delayed until the CCLayerTreeHost::commitComplete, which will run
 211 // after the commit, but on the main thread.
 212 void CCLayerTreeHost::finishCommitOnImplThread(CCLayerTreeHostImpl* hostImpl)
 213 {
 214     ASSERT(CCProxy::isImplThread());
 215
 216     hostImpl->setRootLayer(TreeSynchronizer::synchronizeTrees(rootLayer(), hostImpl->detachLayerTree(), hostImpl));
 217
 218     if (m_rootLayer && m_hudLayer)
 219         hostImpl->setHudLayer(static_cast<CCHeadsUpDisplayLayerImpl*>(CCLayerTreeHostCommon::findLayerInSubtree(hostImpl->rootLayer(), m_hudLayer->id())));
 220     else
 221         hostImpl->setHudLayer(0);
 222
 223     // We may have added an animation during the tree sync. This will cause both layer tree hosts
 224     // to visit their controllers.
 225     if (rootLayer() && m_needsAnimateLayers)
 226         hostImpl->setNeedsAnimateLayers();
 227
 228     hostImpl->setSourceFrameNumber(commitNumber());
 229     hostImpl->setViewportSize(layoutViewportSize(), deviceViewportSize());
 230     hostImpl->setDeviceScaleFactor(deviceScaleFactor());
 231     hostImpl->setPageScaleFactorAndLimits(m_pageScaleFactor, m_minPageScaleFactor, m_maxPageScaleFactor);
 232     hostImpl->setBackgroundColor(m_backgroundColor);
 233     hostImpl->setHasTransparentBackground(m_hasTransparentBackground);
 234
 235     m_commitNumber++;
 236 }
 237
 238 void CCLayerTreeHost::setFontAtlas(PassOwnPtr<CCFontAtlas> fontAtlas)
 239 {
 240     m_fontAtlas = fontAtlas;
 241     setNeedsCommit();
 242 }
 243
 244 void CCLayerTreeHost::willCommit()
 245 {
 246     m_client->willCommit();
 247     if (m_rootLayer && m_settings.showDebugInfo()) {
 248         if (!m_hudLayer)
 249             m_hudLayer = HeadsUpDisplayLayerChromium::create();
 250
 251         if (m_fontAtlas)
 252             m_hudLayer->setFontAtlas(m_fontAtlas.release());
 253
 254         if (!m_hudLayer->parent())
 255             m_rootLayer->addChild(m_hudLayer);
 256     }
 257 }
 258
 259 void CCLayerTreeHost::commitComplete()
 260 {
 261     m_deleteTextureAfterCommitList.clear();
 262     m_client->didCommit();
 263 }
 264
 265 PassOwnPtr<CCGraphicsContext> CCLayerTreeHost::createContext()
 266 {
 267     return m_client->createOutputSurface();
 268 }
 269
 270 PassOwnPtr<CCInputHandler> CCLayerTreeHost::createInputHandler()
 271 {
 272     return m_client->createInputHandler();
 273 }
 274
 275 PassOwnPtr<CCLayerTreeHostImpl> CCLayerTreeHost::createLayerTreeHostImpl(CCLayerTreeHostImplClient* client)
 276 {
 277     return CCLayerTreeHostImpl::create(m_settings, client);
 278 }
 279
 280 void CCLayerTreeHost::didLoseContext()
 281 {
 282     TRACE_EVENT0("cc", "CCLayerTreeHost::didLoseContext");
 283     ASSERT(CCProxy::isMainThread());
 284     m_contextLost = true;
 285     m_numFailedRecreateAttempts = 0;
 286     setNeedsCommit();
 287 }
 288
 289 bool CCLayerTreeHost::compositeAndReadback(void *pixels, const IntRect& rect)
 290 {
 291     m_triggerIdleUpdates = false;
 292     bool ret = m_proxy->compositeAndReadback(pixels, rect);
 293     m_triggerIdleUpdates = true;
 294     return ret;
 295 }
 296
 297 void CCLayerTreeHost::finishAllRendering()
 298 {
 299     if (!m_rendererInitialized)
 300         return;
 301     m_proxy->finishAllRendering();
 302 }
 303
 304 void CCLayerTreeHost::renderingStats(CCRenderingStats& stats) const
 305 {
 306     stats = m_renderingStats;
 307     m_proxy->implSideRenderingStats(stats);
 308 }
 309
 310 const RendererCapabilities& CCLayerTreeHost::rendererCapabilities() const
 311 {
 312     return m_proxy->rendererCapabilities();
 313 }
 314
 315 void CCLayerTreeHost::setNeedsAnimate()
 316 {
 317     ASSERT(CCProxy::hasImplThread());
 318     m_proxy->setNeedsAnimate();
 319 }
 320
 321 void CCLayerTreeHost::setNeedsCommit()
 322 {
 323     m_proxy->setNeedsCommit();
 324 }
 325
 326 void CCLayerTreeHost::setNeedsRedraw()
 327 {
 328     m_proxy->setNeedsRedraw();
 329     if (!CCThreadProxy::implThread())
 330         m_client->scheduleComposite();
 331 }
 332
 333 bool CCLayerTreeHost::commitRequested() const
 334 {
 335     return m_proxy->commitRequested();
 336 }
 337
 338 void CCLayerTreeHost::setAnimationEvents(PassOwnPtr<CCAnimationEventsVector> events, double wallClockTime)
 339 {
 340     ASSERT(CCThreadProxy::isMainThread());
 341     setAnimationEventsRecursive(*events, m_rootLayer.get(), wallClockTime);
 342 }
 343
 344 void CCLayerTreeHost::didAddAnimation()
 345 {
 346     m_needsAnimateLayers = true;
 347     m_proxy->didAddAnimation();
 348 }
 349
 350 void CCLayerTreeHost::setRootLayer(PassRefPtr<LayerChromium> rootLayer)
 351 {
 352     if (m_rootLayer == rootLayer)
 353         return;
 354
 355     if (m_rootLayer)
 356         m_rootLayer->setLayerTreeHost(0);
 357     m_rootLayer = rootLayer;
 358     if (m_rootLayer)
 359         m_rootLayer->setLayerTreeHost(this);
 360
 361     if (m_hudLayer)
 362         m_hudLayer->removeFromParent();
 363
 364     setNeedsCommit();
 365 }
 366
 367 void CCLayerTreeHost::setViewportSize(const IntSize& layoutViewportSize, const IntSize& deviceViewportSize)
 368 {
 369     if (layoutViewportSize == m_layoutViewportSize && deviceViewportSize == m_deviceViewportSize)
 370         return;
 371
 372     m_layoutViewportSize = layoutViewportSize;
 373     m_deviceViewportSize = deviceViewportSize;
 374
 375     setNeedsCommit();
 376 }
 377
 378 void CCLayerTreeHost::setPageScaleFactorAndLimits(float pageScaleFactor, float minPageScaleFactor, float maxPageScaleFactor)
 379 {
 380     if (pageScaleFactor == m_pageScaleFactor && minPageScaleFactor == m_minPageScaleFactor && maxPageScaleFactor == m_maxPageScaleFactor)
 381         return;
 382
 383     m_pageScaleFactor = pageScaleFactor;
 384     m_minPageScaleFactor = minPageScaleFactor;
 385     m_maxPageScaleFactor = maxPageScaleFactor;
 386     setNeedsCommit();
 387 }
 388
 389 void CCLayerTreeHost::setVisible(bool visible)
 390 {
 391     if (m_visible == visible)
 392         return;
 393     m_visible = visible;
 394     m_proxy->setVisible(visible);
 395 }
 396
 397 void CCLayerTreeHost::evictAllContentTextures()
 398 {
 399     ASSERT(CCProxy::isMainThread());
 400     ASSERT(m_contentsTextureManager.get());
 401     m_contentsTextureManager->allBackingTexturesWereDeleted();
 402 }
 403
 404 void CCLayerTreeHost::startPageScaleAnimation(const IntSize& targetPosition, bool useAnchor, float scale, double durationSec)
 405 {
 406     m_proxy->startPageScaleAnimation(targetPosition, useAnchor, scale, durationSec);
 407 }
 408
 409 void CCLayerTreeHost::loseContext(int numTimes)
 410 {
 411     TRACE_EVENT1("cc", "CCLayerTreeHost::loseCompositorContext", "numTimes", numTimes);
 412     m_numTimesRecreateShouldFail = numTimes - 1;
 413     m_proxy->loseContext();
 414 }
 415
 416 CCPrioritizedTextureManager* CCLayerTreeHost::contentsTextureManager() const
 417 {
 418     return m_contentsTextureManager.get();
 419 }
 420
 421 void CCLayerTreeHost::composite()
 422 {
 423     ASSERT(!CCThreadProxy::implThread());
 424     static_cast<CCSingleThreadProxy*>(m_proxy.get())->compositeImmediately();
 425 }
 426
 427 void CCLayerTreeHost::scheduleComposite()
 428 {
 429     m_client->scheduleComposite();
 430 }
 431
 432 bool CCLayerTreeHost::initializeRendererIfNeeded()
 433 {
 434     if (!m_rendererInitialized) {
 435         initializeRenderer();
 436         // If we couldn't initialize, then bail since we're returning to software mode.
 437         if (!m_rendererInitialized)
 438             return false;
 439     }
 440     if (m_contextLost) {
 441         if (recreateContext() != RecreateSucceeded)
 442             return false;
 443     }
 444     return true;
 445 }
 446
 447 void CCLayerTreeHost::updateLayers(CCTextureUpdateQueue& queue, size_t memoryAllocationLimitBytes)
 448 {
 449     ASSERT(m_rendererInitialized);
 450     ASSERT(memoryAllocationLimitBytes);
 451
 452     if (!rootLayer())
 453         return;
 454
 455     if (layoutViewportSize().isEmpty())
 456         return;
 457
 458     m_contentsTextureManager->setMaxMemoryLimitBytes(memoryAllocationLimitBytes);
 459
 460     updateLayers(rootLayer(), queue);
 461 }
 462
 463 static void setScale(LayerChromium* layer, float deviceScaleFactor, float pageScaleFactor)
 464 {
 465     if (layer->boundsContainPageScale())
 466         layer->setContentsScale(deviceScaleFactor);
 467     else
 468         layer->setContentsScale(deviceScaleFactor * pageScaleFactor);
 469 }
 470
 471 static void updateLayerScale(LayerChromium* layer, float deviceScaleFactor, float pageScaleFactor)
 472 {
 473     setScale(layer, deviceScaleFactor, pageScaleFactor);
 474
 475     LayerChromium* maskLayer = layer->maskLayer();
 476     if (maskLayer)
 477         setScale(maskLayer, deviceScaleFactor, pageScaleFactor);
 478
 479     LayerChromium* replicaMaskLayer = layer->replicaLayer() ? layer->replicaLayer()->maskLayer() : 0;
 480     if (replicaMaskLayer)
 481         setScale(replicaMaskLayer, deviceScaleFactor, pageScaleFactor);
 482
 483     const Vector<RefPtr<LayerChromium> >& children = layer->children();
 484     for (unsigned int i = 0; i < children.size(); ++i)
 485         updateLayerScale(children[i].get(), deviceScaleFactor, pageScaleFactor);
 486 }
 487
 488 void CCLayerTreeHost::updateLayers(LayerChromium* rootLayer, CCTextureUpdateQueue& queue)
 489 {
 490     TRACE_EVENT0("cc", "CCLayerTreeHost::updateLayers");
 491
 492     updateLayerScale(rootLayer, m_deviceScaleFactor, m_pageScaleFactor);
 493
 494     LayerList updateList;
 495
 496     {
 497         TRACE_EVENT0("cc", "CCLayerTreeHost::updateLayers::calcDrawEtc");
 498         CCLayerTreeHostCommon::calculateDrawTransforms(rootLayer, deviceViewportSize(), m_deviceScaleFactor, rendererCapabilities().maxTextureSize, updateList);
 499         CCLayerTreeHostCommon::calculateVisibleRects(updateList);
 500     }
 501
 502     // Reset partial texture update requests.
 503     m_partialTextureUpdateRequests = 0;
 504
 505     bool needMoreUpdates = paintLayerContents(updateList, queue);
 506     if (m_triggerIdleUpdates && needMoreUpdates)
 507         setNeedsCommit();
 508
 509     for (size_t i = 0; i < updateList.size(); ++i)
 510         updateList[i]->clearRenderSurface();
 511 }
 512
 513 void CCLayerTreeHost::setPrioritiesForSurfaces(size_t surfaceMemoryBytes)
 514 {
 515     // Surfaces have a place holder for their memory since they are managed
 516     // independantly but should still be tracked and reduce other memory usage.
 517     m_surfaceMemoryPlaceholder->setTextureManager(m_contentsTextureManager.get());
 518     m_surfaceMemoryPlaceholder->setRequestPriority(CCPriorityCalculator::renderSurfacePriority());
 519     m_surfaceMemoryPlaceholder->setToSelfManagedMemoryPlaceholder(surfaceMemoryBytes);
 520 }
 521
 522 void CCLayerTreeHost::setPrioritiesForLayers(const LayerList& updateList)
 523 {
 524     // Use BackToFront since it's cheap and this isn't order-dependent.
 525     typedef CCLayerIterator<LayerChromium, Vector<RefPtr<LayerChromium> >, RenderSurfaceChromium, CCLayerIteratorActions::BackToFront> CCLayerIteratorType;
 526
 527     CCPriorityCalculator calculator;
 528     CCLayerIteratorType end = CCLayerIteratorType::end(&updateList);
 529     for (CCLayerIteratorType it = CCLayerIteratorType::begin(&updateList); it != end; ++it) {
 530         if (it.representsItself())
 531             it->setTexturePriorities(calculator);
 532         else if (it.representsTargetRenderSurface()) {
 533             if (it->maskLayer())
 534                 it->maskLayer()->setTexturePriorities(calculator);
 535             if (it->replicaLayer() && it->replicaLayer()->maskLayer())
 536                 it->replicaLayer()->maskLayer()->setTexturePriorities(calculator);
 537         }
 538     }
 539 }
 540
 541 void CCLayerTreeHost::prioritizeTextures(const LayerList& renderSurfaceLayerList, CCOverdrawMetrics& metrics)
 542 {
 543     m_contentsTextureManager->clearPriorities();
 544
 545     size_t memoryForRenderSurfacesMetric = calculateMemoryForRenderSurfaces(renderSurfaceLayerList);
 546
 547     setPrioritiesForLayers(renderSurfaceLayerList);
 548     setPrioritiesForSurfaces(memoryForRenderSurfacesMetric);
 549
 550     metrics.didUseContentsTextureMemoryBytes(m_contentsTextureManager->memoryAboveCutoffBytes());
 551     metrics.didUseRenderSurfaceTextureMemoryBytes(memoryForRenderSurfacesMetric);
 552
 553     m_contentsTextureManager->prioritizeTextures();
 554 }
 555
 556 size_t CCLayerTreeHost::calculateMemoryForRenderSurfaces(const LayerList& updateList)
 557 {
 558     size_t readbackBytes = 0;
 559     size_t maxBackgroundTextureBytes = 0;
 560     size_t contentsTextureBytes = 0;
 561
 562     // Start iteration at 1 to skip the root surface as it does not have a texture cost.
 563     for (size_t i = 1; i < updateList.size(); ++i) {
 564         LayerChromium* renderSurfaceLayer = updateList[i].get();
 565         RenderSurfaceChromium* renderSurface = renderSurfaceLayer->renderSurface();
 566
 567         size_t bytes = CCTexture::memorySizeBytes(renderSurface->contentRect().size(), GraphicsContext3D::RGBA);
 568         contentsTextureBytes += bytes;
 569
 570         if (renderSurfaceLayer->backgroundFilters().isEmpty())
 571             continue;
 572
 573         if (bytes > maxBackgroundTextureBytes)
 574             maxBackgroundTextureBytes = bytes;
 575         if (!readbackBytes)
 576             readbackBytes = CCTexture::memorySizeBytes(m_deviceViewportSize, GraphicsContext3D::RGBA);
 577     }
 578     return readbackBytes + maxBackgroundTextureBytes + contentsTextureBytes;
 579 }
 580
 581 bool CCLayerTreeHost::paintMasksForRenderSurface(LayerChromium* renderSurfaceLayer, CCTextureUpdateQueue& queue)
 582 {
 583     // Note: Masks and replicas only exist for layers that own render surfaces. If we reach this point
 584     // in code, we already know that at least something will be drawn into this render surface, so the
 585     // mask and replica should be painted.
 586
 587     bool needMoreUpdates = false;
 588     LayerChromium* maskLayer = renderSurfaceLayer->maskLayer();
 589     if (maskLayer) {
 590         maskLayer->update(queue, 0, m_renderingStats);
 591         needMoreUpdates |= maskLayer->needMoreUpdates();
 592     }
 593
 594     LayerChromium* replicaMaskLayer = renderSurfaceLayer->replicaLayer() ? renderSurfaceLayer->replicaLayer()->maskLayer() : 0;
 595     if (replicaMaskLayer) {
 596         replicaMaskLayer->update(queue, 0, m_renderingStats);
 597         needMoreUpdates |= replicaMaskLayer->needMoreUpdates();
 598     }
 599     return needMoreUpdates;
 600 }
 601
 602 bool CCLayerTreeHost::paintLayerContents(const LayerList& renderSurfaceLayerList, CCTextureUpdateQueue& queue)
 603 {
 604     // Use FrontToBack to allow for testing occlusion and performing culling during the tree walk.
 605     typedef CCLayerIterator<LayerChromium, Vector<RefPtr<LayerChromium> >, RenderSurfaceChromium, CCLayerIteratorActions::FrontToBack> CCLayerIteratorType;
 606
 607     bool needMoreUpdates = false;
 608     bool recordMetricsForFrame = true; // FIXME: In the future, disable this when about:tracing is off.
 609     CCOcclusionTracker occlusionTracker(m_rootLayer->renderSurface()->contentRect(), recordMetricsForFrame);
 610     occlusionTracker.setMinimumTrackingSize(m_settings.minimumOcclusionTrackingSize);
 611
 612     prioritizeTextures(renderSurfaceLayerList, occlusionTracker.overdrawMetrics());
 613
 614     CCLayerIteratorType end = CCLayerIteratorType::end(&renderSurfaceLayerList);
 615     for (CCLayerIteratorType it = CCLayerIteratorType::begin(&renderSurfaceLayerList); it != end; ++it) {
 616         occlusionTracker.enterLayer(it);
 617
 618         if (it.representsTargetRenderSurface()) {
 619             ASSERT(it->renderSurface()->drawOpacity() || it->renderSurface()->drawOpacityIsAnimating());
 620             needMoreUpdates |= paintMasksForRenderSurface(*it, queue);
 621         } else if (it.representsItself()) {
 622             ASSERT(!it->bounds().isEmpty());
 623             it->update(queue, &occlusionTracker, m_renderingStats);
 624             needMoreUpdates |= it->needMoreUpdates();
 625         }
 626
 627         occlusionTracker.leaveLayer(it);
 628     }
 629
 630     occlusionTracker.overdrawMetrics().recordMetrics(this);
 631
 632     return needMoreUpdates;
 633 }
 634
 635 static LayerChromium* findFirstScrollableLayer(LayerChromium* layer)
 636 {
 637     if (!layer)
 638         return 0;
 639
 640     if (layer->scrollable())
 641         return layer;
 642
 643     for (size_t i = 0; i < layer->children().size(); ++i) {
 644         LayerChromium* found = findFirstScrollableLayer(layer->children()[i].get());
 645         if (found)
 646             return found;
 647     }
 648
 649     return 0;
 650 }
 651
 652 void CCLayerTreeHost::applyScrollAndScale(const CCScrollAndScaleSet& info)
 653 {
 654     if (!m_rootLayer)
 655         return;
 656
 657     LayerChromium* rootScrollLayer = findFirstScrollableLayer(m_rootLayer.get());
 658     IntSize rootScrollDelta;
 659
 660     for (size_t i = 0; i < info.scrolls.size(); ++i) {
 661         LayerChromium* layer = CCLayerTreeHostCommon::findLayerInSubtree(m_rootLayer.get(), info.scrolls[i].layerId);
 662         if (!layer)
 663             continue;
 664         if (layer == rootScrollLayer)
 665             rootScrollDelta += info.scrolls[i].scrollDelta;
 666         else
 667             layer->setScrollPosition(layer->scrollPosition() + info.scrolls[i].scrollDelta);
 668     }
 669     if (!rootScrollDelta.isZero() || info.pageScaleDelta != 1)
 670         m_client->applyScrollAndScale(rootScrollDelta, info.pageScaleDelta);
 671 }
 672
 673 void CCLayerTreeHost::startRateLimiter(WebKit::WebGraphicsContext3D* context)
 674 {
 675     if (m_animating)
 676         return;
 677
 678     ASSERT(context);
 679     RateLimiterMap::iterator it = m_rateLimiters.find(context);
 680     if (it != m_rateLimiters.end())
 681         it->second->start();
 682     else {
 683         RefPtr<RateLimiter> rateLimiter = RateLimiter::create(context, this);
 684         m_rateLimiters.set(context, rateLimiter);
 685         rateLimiter->start();
 686     }
 687 }
 688
 689 void CCLayerTreeHost::stopRateLimiter(WebKit::WebGraphicsContext3D* context)
 690 {
 691     RateLimiterMap::iterator it = m_rateLimiters.find(context);
 692     if (it != m_rateLimiters.end()) {
 693         it->second->stop();
 694         m_rateLimiters.remove(it);
 695     }
 696 }
 697
 698 void CCLayerTreeHost::rateLimit()
 699 {
 700     // Force a no-op command on the compositor context, so that any ratelimiting commands will wait for the compositing
 701     // context, and therefore for the SwapBuffers.
 702     m_proxy->forceSerializeOnSwapBuffers();
 703 }
 704
 705 bool CCLayerTreeHost::bufferedUpdates()
 706 {
 707     return m_settings.maxPartialTextureUpdates != numeric_limits<size_t>::max();
 708 }
 709
 710 bool CCLayerTreeHost::requestPartialTextureUpdate()
 711 {
 712     if (m_partialTextureUpdateRequests >= m_settings.maxPartialTextureUpdates)
 713         return false;
 714
 715     m_partialTextureUpdateRequests++;
 716     return true;
 717 }
 718
 719 void CCLayerTreeHost::deleteTextureAfterCommit(PassOwnPtr<CCPrioritizedTexture> texture)
 720 {
 721     m_deleteTextureAfterCommitList.append(texture);
 722 }
 723
 724 void CCLayerTreeHost::setDeviceScaleFactor(float deviceScaleFactor)
 725 {
 726     if (deviceScaleFactor ==  m_deviceScaleFactor)
 727         return;
 728     m_deviceScaleFactor = deviceScaleFactor;
 729
 730     setNeedsCommit();
 731 }
 732
 733 void CCLayerTreeHost::animateLayers(double monotonicTime)
 734 {
 735     if (!CCSettings::acceleratedAnimationEnabled() || !m_needsAnimateLayers)
 736         return;
 737
 738     TRACE_EVENT0("cc", "CCLayerTreeHostImpl::animateLayers");
 739     m_needsAnimateLayers = animateLayersRecursive(m_rootLayer.get(), monotonicTime);
 740 }
 741
 742 bool CCLayerTreeHost::animateLayersRecursive(LayerChromium* current, double monotonicTime)
 743 {
 744     if (!current)
 745         return false;
 746
 747     bool subtreeNeedsAnimateLayers = false;
 748     CCLayerAnimationController* currentController = current->layerAnimationController();
 749     currentController->animate(monotonicTime, 0);
 750
 751     // If the current controller still has an active animation, we must continue animating layers.
 752     if (currentController->hasActiveAnimation())
 753          subtreeNeedsAnimateLayers = true;
 754
 755     for (size_t i = 0; i < current->children().size(); ++i) {
 756         if (animateLayersRecursive(current->children()[i].get(), monotonicTime))
 757             subtreeNeedsAnimateLayers = true;
 758     }
 759
 760     return subtreeNeedsAnimateLayers;
 761 }
 762
 763 void CCLayerTreeHost::setAnimationEventsRecursive(const CCAnimationEventsVector& events, LayerChromium* layer, double wallClockTime)
 764 {
 765     if (!layer)
 766         return;
 767
 768     for (size_t eventIndex = 0; eventIndex < events.size(); ++eventIndex) {
 769         if (layer->id() == events[eventIndex].layerId) {
 770             if (events[eventIndex].type == CCAnimationEvent::Started)
 771                 layer->notifyAnimationStarted(events[eventIndex], wallClockTime);
 772             else
 773                 layer->notifyAnimationFinished(wallClockTime);
 774         }
 775     }
 776
 777     for (size_t childIndex = 0; childIndex < layer->children().size(); ++childIndex)
 778         setAnimationEventsRecursive(events, layer->children()[childIndex].get(), wallClockTime);
 779 }
 780
 781 } // namespace WebCore