cc: Split out calcDrawEtc from drawLayers

cc/layer_tree_host_impl.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/layer_tree_host_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
@@ skipping 203 matching lines @@
     , m_deviceScaleFactor(1)
     , m_visible(true)
     , m_contentsTexturesPurged(false)
     , m_managedMemoryPolicy(PrioritizedResourceManager::defaultMemoryAllocationLimit(),
                             PriorityCalculator::allowEverythingCutoff(),
                             0,
                             PriorityCalculator::allowNothingCutoff())
     , m_backgroundColor(0)
     , m_hasTransparentBackground(false)
     , m_needsAnimateLayers(false)
+    , m_needsUpdateLayers(false)
     , m_pinchGestureActive(false)
     , m_fpsCounter(FrameRateCounter::create(m_proxy->hasImplThread()))
     , m_debugRectHistory(DebugRectHistory::create())
     , m_numImplThreadScrolls(0)
     , m_numMainThreadScrolls(0)
     , m_cumulativeNumLayersDrawn(0)
 {
     DCHECK(m_proxy->isImplThread());
     didVisibilityChange(this, m_visible);
 }
 
 LayerTreeHostImpl::~LayerTreeHostImpl()
 {
     DCHECK(m_proxy->isImplThread());
     TRACE_EVENT0("cc", "LayerTreeHostImpl::~LayerTreeHostImpl()");
 
     if (m_rootLayerImpl)
         clearRenderSurfaces();
 }
 
 void LayerTreeHostImpl::beginCommit()
 {
 }
 
 void LayerTreeHostImpl::commitComplete()
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::commitComplete");
+
+    // Impl-side painting needs an update immediately post-commit to have the
+    // opportunity to create tilings.  Other paths can call updateLayers
+    // more lazily when needed prior to drawing.
+    setNeedsUpdateLayers();
+    if (m_settings.implSidePainting)
+        updateLayers();
+
     // Recompute max scroll position; must be after layer content bounds are
     // updated.
     updateMaxScrollOffset();
     m_client->sendManagedMemoryStats();
 }
 
 bool LayerTreeHostImpl::canDraw()
 {
     // Note: If you are changing this function or any other function that might
     // affect the result of canDraw, make sure to call m_client->onCanDrawStateChanged
@@ skipping 57 matching lines @@
         if (!m_settings.pageScalePinchZoomEnabled)
             anchor.Scale(1 / pageScale);
         m_pageScaleAnimation->zoomWithAnchor(anchor, pageScale, duration.InSecondsF());
     } else {
         gfx::Vector2dF scaledTargetOffset = targetOffset;
         if (!m_settings.pageScalePinchZoomEnabled)
             scaledTargetOffset.Scale(1 / pageScale);
         m_pageScaleAnimation->zoomTo(scaledTargetOffset, pageScale, duration.InSecondsF());
     }
 
+    setNeedsUpdateLayers();
     m_client->setNeedsRedrawOnImplThread();
     m_client->setNeedsCommitOnImplThread();
 }
 
 void LayerTreeHostImpl::scheduleAnimation()
 {
     m_client->setNeedsRedrawOnImplThread();
 }
 
 bool LayerTreeHostImpl::haveTouchEventHandlersAt(const gfx::Point& viewportPoint)
@@ skipping 22 matching lines @@
         RenderSurfaceImpl* renderSurface = renderSurfaceLayer->renderSurface();
         DCHECK(renderSurface);
         renderSurface->damageTracker()->updateDamageTrackingState(renderSurface->layerList(), renderSurfaceLayer->id(), renderSurface->surfacePropertyChangedOnlyFromDescendant(), renderSurface->contentRect(), renderSurfaceLayer->maskLayer(), renderSurfaceLayer->filters(), renderSurfaceLayer->filter().get());
     }
 }
 
 void LayerTreeHostImpl::updateRootScrollLayerImplTransform()
 {
     if (m_rootScrollLayerImpl) {
         m_rootScrollLayerImpl->setImplTransform(implTransform());
+        setNeedsUpdateLayers();

[danakj, 2012/12/06 03:23:04]

The layer will do this.

     }
 }
 
+void LayerTreeHostImpl::updateLayers()
+{
+    if (!needsUpdateLayers())

[danakj, 2012/12/06 03:23:04]

m_

[enne (OOO), 2012/12/06 17:20:23]

Why?

[danakj, 2012/12/06 17:38:50]

Cuz we always generally do this. Less indirection/uncertainty about what's being
read.

+        return;
+
+    m_renderSurfaceLayerList.clear();
+    m_needsUpdateLayers = false;
+
+    if (!m_rootLayerImpl)
+        return;
+
+    calculateRenderSurfaceLayerList(m_renderSurfaceLayerList);
+}
+
 void LayerTreeHostImpl::calculateRenderSurfaceLayerList(LayerList& renderSurfaceLayerList)
 {
     DCHECK(renderSurfaceLayerList.empty());
     DCHECK(m_rootLayerImpl);
     DCHECK(m_renderer); // For maxTextureSize.
-
     {
         updateRootScrollLayerImplTransform();
 
         TRACE_EVENT0("cc", "LayerTreeHostImpl::calcDrawEtc");
         float pageScaleFactor = m_pinchZoomViewport.pageScaleFactor();
         LayerTreeHostCommon::calculateDrawProperties(m_rootLayerImpl.get(), deviceViewportSize(), m_deviceScaleFactor, pageScaleFactor, &m_layerSorter, rendererCapabilities().maxTextureSize, renderSurfaceLayerList);
 
-        trackDamageForAllSurfaces(m_rootLayerImpl.get(), renderSurfaceLayerList);
     }
 }
 
 void LayerTreeHostImpl::FrameData::appendRenderPass(scoped_ptr<RenderPass> renderPass)
 {
     RenderPass* pass = renderPass.get();
     renderPasses.push_back(pass);
     renderPassesById.set(pass->id, renderPass.Pass());
 }
 
@@ skipping 78 matching lines @@
         // occlusion checks.
         scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
         quad->SetNew(sharedQuadState, layerRect, screenBackgroundColor);
         quadCuller.append(quad.PassAs<DrawQuad>(), appendQuadsData);
     }
 }
 
 bool LayerTreeHostImpl::calculateRenderPasses(FrameData& frame)
 {
     DCHECK(frame.renderPasses.empty());
+    if (!m_rootLayerImpl)

[danakj, 2012/12/06 03:23:04]

This is DCHECKed in prepareToDraw, by asking canDraw()

+        return false;
 
-    calculateRenderSurfaceLayerList(*frame.renderSurfaceLayerList);
+    trackDamageForAllSurfaces(m_rootLayerImpl.get(), *frame.renderSurfaceLayerList);
 
     TRACE_EVENT1("cc", "LayerTreeHostImpl::calculateRenderPasses", "renderSurfaceLayerList.size()", static_cast<long long unsigned>(frame.renderSurfaceLayerList->size()));
 
     // Create the render passes in dependency order.
     for (int surfaceIndex = frame.renderSurfaceLayerList->size() - 1; surfaceIndex >= 0 ; --surfaceIndex) {
         LayerImpl* renderSurfaceLayer = (*frame.renderSurfaceLayerList)[surfaceIndex];
         renderSurfaceLayer->renderSurface()->appendRenderPasses(frame);
     }
 
     bool recordMetricsForFrame = m_settings.showOverdrawInTracing && base::debug::TraceLog::GetInstance() && base::debug::TraceLog::GetInstance()->IsEnabled();
@@ skipping 25 matching lines @@
         if (it.representsContributingRenderSurface()) {
             RenderPass::Id contributingRenderPassId = it->renderSurface()->renderPassId();
             RenderPass* contributingRenderPass = frame.renderPassesById.get(contributingRenderPassId);
             appendQuadsForRenderSurfaceLayer(targetRenderPass, *it, contributingRenderPass, occlusionTracker, appendQuadsData);
         } else if (it.representsItself() && !it->visibleContentRect().IsEmpty()) {
             bool hasOcclusionFromOutsideTargetSurface;
             bool implDrawTransformIsUnknown = false;
             if (occlusionTracker.occluded(it->renderTarget(), it->visibleContentRect(), it->drawTransform(), implDrawTransformIsUnknown, it->drawableContentRect(), &hasOcclusionFromOutsideTargetSurface))
                 appendQuadsData.hadOcclusionFromOutsideTargetSurface |= hasOcclusionFromOutsideTargetSurface;
             else {
+                DCHECK(it->layerTreeHostImpl());
                 it->willDraw(m_resourceProvider.get());
                 frame.willDrawLayers.push_back(*it);
 
                 if (it->hasContributingDelegatedRenderPasses()) {
                     RenderPass::Id contributingRenderPassId = it->firstContributingRenderPassId();
                     while (frame.renderPassesById.contains(contributingRenderPassId)) {
                         RenderPass* renderPass = frame.renderPassesById.get(contributingRenderPassId);
   
                         AppendQuadsData appendQuadsData(renderPass->id);
                         appendQuadsForLayer(renderPass, *it, occlusionTracker, appendQuadsData);
@@ skipping 188 matching lines @@
             DCHECK(it >= 0);
         }
     }
 }
 
 bool LayerTreeHostImpl::prepareToDraw(FrameData& frame)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::prepareToDraw");
     DCHECK(canDraw());
 
+    updateLayers();
     frame.renderSurfaceLayerList = &m_renderSurfaceLayerList;
     frame.renderPasses.clear();
     frame.renderPassesById.clear();
-    frame.renderSurfaceLayerList->clear();
     frame.willDrawLayers.clear();
 
     if (!calculateRenderPasses(frame))
         return false;
 
     // If we return true, then we expect drawLayers() to be called before this function is called again.
     return true;
 }
 
 void LayerTreeHostImpl::enforceManagedMemoryPolicy(const ManagedMemoryPolicy& policy)
@@ skipping 185 matching lines @@
         return layerImpl->parent();
 
     return 0;
 }
 
 void LayerTreeHostImpl::setRootLayer(scoped_ptr<LayerImpl> layer)
 {
     m_rootLayerImpl = layer.Pass();
     m_rootScrollLayerImpl = findRootScrollLayer(m_rootLayerImpl.get());
     m_currentlyScrollingLayerImpl = 0;
+    setNeedsUpdateLayers();
 
     if (m_rootLayerImpl && m_scrollingLayerIdFromPreviousTree != -1)
         m_currentlyScrollingLayerImpl = LayerTreeHostCommon::findLayerInSubtree(m_rootLayerImpl.get(), m_scrollingLayerIdFromPreviousTree);
 
     m_scrollingLayerIdFromPreviousTree = -1;
 
     m_client->onCanDrawStateChanged(canDraw());
 }
 
 scoped_ptr<LayerImpl> LayerTreeHostImpl::detachLayerTree()
 {
     // Clear all data structures that have direct references to the layer tree.
     m_scrollingLayerIdFromPreviousTree = m_currentlyScrollingLayerImpl ? m_currentlyScrollingLayerImpl->id() : -1;
     m_currentlyScrollingLayerImpl = 0;
     m_renderSurfaceLayerList.clear();
+    setNeedsUpdateLayers();
 
     return m_rootLayerImpl.Pass();
 }
 
 void LayerTreeHostImpl::setVisible(bool visible)
 {
     DCHECK(m_proxy->isImplThread());
 
     if (m_visible == visible)
         return;
@@ skipping 114 matching lines @@
 }
 
 void LayerTreeHostImpl::setPageScaleFactorAndLimits(float pageScaleFactor, float minPageScaleFactor, float maxPageScaleFactor)
 {
     if (!pageScaleFactor)
       return;
 
     float pageScaleChange = pageScaleFactor / m_pinchZoomViewport.pageScaleFactor();
     m_pinchZoomViewport.setPageScaleFactorAndLimits(pageScaleFactor, minPageScaleFactor, maxPageScaleFactor);
 
-    if (!m_settings.pageScalePinchZoomEnabled) {
-        if (pageScaleChange != 1)
-            adjustScrollsForPageScaleChange(m_rootScrollLayerImpl, pageScaleChange);
+    if (!m_settings.pageScalePinchZoomEnabled && pageScaleChange != 1) {
+        adjustScrollsForPageScaleChange(m_rootScrollLayerImpl, pageScaleChange);
     }
 
     // Clamp delta to limits and refresh display matrix.
     setPageScaleDelta(m_pinchZoomViewport.pageScaleDelta() / m_pinchZoomViewport.sentPageScaleDelta());
     m_pinchZoomViewport.setSentPageScaleDelta(1);
 }
 
 void LayerTreeHostImpl::setPageScaleDelta(float delta)
 {
     m_pinchZoomViewport.setPageScaleDelta(delta);
@@ skipping 48 matching lines @@
         return false;
 
     // We need both a non-empty render surface layer list and a root render
     // surface to be able to iterate over the visible layers.
     if (m_renderSurfaceLayerList.size() && m_rootLayerImpl->renderSurface())
         return true;
 
     // If we are called after setRootLayer() but before prepareToDraw(), we need
     // to recalculate the visible layers. This prevents being unable to scroll
     // during part of a commit.
-    m_renderSurfaceLayerList.clear();
-    calculateRenderSurfaceLayerList(m_renderSurfaceLayerList);
+    updateLayers();
 
     return m_renderSurfaceLayerList.size();
 }
 
 InputHandlerClient::ScrollStatus LayerTreeHostImpl::scrollBegin(gfx::Point viewportPoint, InputHandlerClient::ScrollInputType type)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::scrollBegin");
 
     DCHECK(!m_currentlyScrollingLayerImpl);
     clearCurrentlyScrollingLayer();
@@ skipping 32 matching lines @@
             potentiallyScrollingLayerImpl = scrollLayerImpl;
     }
 
     if (potentiallyScrollingLayerImpl) {
         m_currentlyScrollingLayerImpl = potentiallyScrollingLayerImpl;
         // Gesture events need to be transformed from viewport coordinates to local layer coordinates
         // so that the scrolling contents exactly follow the user's finger. In contrast, wheel
         // events are already in local layer coordinates so we can just apply them directly.
         m_scrollDeltaIsInViewportSpace = (type == Gesture);
         m_numImplThreadScrolls++;
+        setNeedsUpdateLayers();
         return ScrollStarted;
     }
     return ScrollIgnored;
 }
 
 static gfx::Vector2dF scrollLayerWithViewportSpaceDelta(PinchZoomViewport* viewport, LayerImpl& layerImpl, float scaleFromViewportToScreenSpace, gfx::PointF viewportPoint, gfx::Vector2dF viewportDelta)
 {
     // Layers with non-invertible screen space transforms should not have passed the scroll hit
     // test in the first place.
     DCHECK(layerImpl.screenSpaceTransform().IsInvertible());
@@ skipping 92 matching lines @@
         gfx::Vector2dF perpendicularAxis(-appliedDelta.y(), appliedDelta.x());
         pendingDelta = MathUtil::projectVector(pendingDelta, perpendicularAxis);
 
         if (gfx::ToFlooredVector2d(pendingDelta).IsZero())
             break;
     }
 
     if (didScroll) {
         m_client->setNeedsCommitOnImplThread();
         m_client->setNeedsRedrawOnImplThread();
+        setNeedsUpdateLayers();
     }
     return didScroll;
 }
 
 void LayerTreeHostImpl::clearCurrentlyScrollingLayer()
 {
     m_currentlyScrollingLayerImpl = 0;
     m_scrollingLayerIdFromPreviousTree = -1;
 }
 
@@ skipping 35 matching lines @@
     }
 
     gfx::Vector2dF scrollOverflow = m_settings.pageScalePinchZoomEnabled ? m_pinchZoomViewport.applyScroll(move) : move;
     m_rootScrollLayerImpl->scrollBy(scrollOverflow);
 
     if (m_rootScrollLayerImpl->scrollbarAnimationController())
         m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureUpdate();
 
     m_client->setNeedsCommitOnImplThread();
     m_client->setNeedsRedrawOnImplThread();
+    setNeedsUpdateLayers();
 }
 
 void LayerTreeHostImpl::pinchGestureEnd()
 {
     m_pinchGestureActive = false;
 
     if (m_rootScrollLayerImpl && m_rootScrollLayerImpl->scrollbarAnimationController())
         m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureEnd();
 
     m_client->setNeedsCommitOnImplThread();
@@ skipping 116 matching lines @@
     double monotonicTime = (time - base::TimeTicks()).InSecondsF();
     gfx::Vector2dF scrollTotal = m_rootScrollLayerImpl->scrollOffset() + m_rootScrollLayerImpl->scrollDelta();
 
     setPageScaleDelta(m_pageScaleAnimation->pageScaleFactorAtTime(monotonicTime) / m_pinchZoomViewport.pageScaleFactor());
     gfx::Vector2dF nextScroll = m_pageScaleAnimation->scrollOffsetAtTime(monotonicTime);
 
     if (!m_settings.pageScalePinchZoomEnabled)
         nextScroll.Scale(m_pinchZoomViewport.pageScaleFactor());
     m_rootScrollLayerImpl->scrollBy(nextScroll - scrollTotal);
     m_client->setNeedsRedrawOnImplThread();
+    setNeedsUpdateLayers();
 
     if (m_pageScaleAnimation->isAnimationCompleteAtTime(monotonicTime)) {
         m_pageScaleAnimation.reset();
         m_client->setNeedsCommitOnImplThread();
     }
 }
 
 void LayerTreeHostImpl::animateLayers(base::TimeTicks monotonicTime, base::Time wallClockTime)
 {
     if (!m_settings.acceleratedAnimationEnabled || !m_needsAnimateLayers || !m_rootLayerImpl)
         return;
 
     TRACE_EVENT0("cc", "LayerTreeHostImpl::animateLayers");
 
     scoped_ptr<AnimationEventsVector> events(make_scoped_ptr(new AnimationEventsVector));
 
     bool didAnimate = false;
     animateLayersRecursive(m_rootLayerImpl.get(), monotonicTime, wallClockTime, events.get(), didAnimate, m_needsAnimateLayers);
 
     if (!events->empty())
         m_client->postAnimationEventsToMainThreadOnImplThread(events.Pass(), wallClockTime);
 
-    if (didAnimate)
+    if (didAnimate) {
         m_client->setNeedsRedrawOnImplThread();
+        setNeedsUpdateLayers();
+    }
 
     setBackgroundTickingEnabled(!m_visible && m_needsAnimateLayers);
 }
 
 base::TimeDelta LayerTreeHostImpl::lowFrequencyAnimationInterval() const
 {
     return base::TimeDelta::FromSeconds(1);
 }
 
 void LayerTreeHostImpl::sendDidLoseContextRecursive(LayerImpl* current)
@@ skipping 13 matching lines @@
     DCHECK(current);
     for (size_t i = 0; i < current->children().size(); ++i)
         clearRenderSurfacesOnLayerImplRecursive(current->children()[i]);
     current->clearRenderSurface();
 }
 
 void LayerTreeHostImpl::clearRenderSurfaces()
 {
     clearRenderSurfacesOnLayerImplRecursive(m_rootLayerImpl.get());
     m_renderSurfaceLayerList.clear();
+    setNeedsUpdateLayers();
 }
 
 std::string LayerTreeHostImpl::layerTreeAsText() const
 {
     std::string str;
     if (m_rootLayerImpl) {
         str = m_rootLayerImpl->layerTreeAsText();
         str +=  "RenderSurfaces:\n";
         dumpRenderSurfaces(&str, 1, m_rootLayerImpl.get());
     }
@@ skipping 39 matching lines @@
     ScrollbarAnimationController* scrollbarController = layer->scrollbarAnimationController();
     double monotonicTime = (time - base::TimeTicks()).InSecondsF();
     if (scrollbarController && scrollbarController->animate(monotonicTime))
         m_client->setNeedsRedrawOnImplThread();
 
     for (size_t i = 0; i < layer->children().size(); ++i)
         animateScrollbarsRecursive(layer->children()[i], time);
 }
 
 }  // namespace cc