cc: Split out calcDrawEtc from drawLayers

cc/layer_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_impl.h"
 
 #include "base/debug/trace_event.h"
 #include "base/stringprintf.h"
 #include "cc/debug_border_draw_quad.h"
 #include "cc/debug_colors.h"
@@ skipping 48 matching lines @@
 LayerImpl::~LayerImpl()
 {
 #ifndef NDEBUG
     DCHECK(!m_betweenWillDrawAndDidDraw);
 #endif
 }
 
 void LayerImpl::addChild(scoped_ptr<LayerImpl> child)
 {
     child->setParent(this);
+    child->setLayerTreeHostImpl(layerTreeHostImpl());
     m_children.append(child.Pass());
+
+    if (m_layerTreeHostImpl)
+        m_layerTreeHostImpl->setNeedsUpdateDrawProperties();
 }
 
 void LayerImpl::removeFromParent()
 {
     if (!m_parent)
         return;
 
     LayerImpl* parent = m_parent;
     m_parent = 0;
 
     for (size_t i = 0; i < parent->m_children.size(); ++i) {
         if (parent->m_children[i] == this) {
             parent->m_children.remove(i);
+            if (m_layerTreeHostImpl)
+                m_layerTreeHostImpl->setNeedsUpdateDrawProperties();
             return;
         }
     }
 }
 
 void LayerImpl::removeAllChildren()
 {
     while (m_children.size())
         m_children[0]->removeFromParent();
 }
 
 void LayerImpl::clearChildList()
 {
     m_children.clear();
+    if (m_layerTreeHostImpl)
+        m_layerTreeHostImpl->setNeedsUpdateDrawProperties();
 }
 
 void LayerImpl::createRenderSurface()
 {
     DCHECK(!m_drawProperties.render_surface);
     m_drawProperties.render_surface = make_scoped_ptr(new RenderSurfaceImpl(this));
     m_drawProperties.render_target = this;
 }
 
 int LayerImpl::descendantsDrawContent()
 {
     int result = 0;
     for (size_t i = 0; i < m_children.size(); ++i) {
         if (m_children[i]->drawsContent())
             ++result;
         result += m_children[i]->descendantsDrawContent();
         if (result > 1)
             return result;
     }
     return result;
 }
 
+void LayerImpl::setLayerTreeHostImpl(LayerTreeHostImpl* hostImpl)
+{
+    if (m_layerTreeHostImpl == hostImpl)
+        return;
+
+    m_layerTreeHostImpl = hostImpl;
+
+    for (size_t i = 0; i < m_children.size(); ++i)
+        m_children[i]->setLayerTreeHostImpl(hostImpl);
+
+    if (m_maskLayer)
+        m_maskLayer->setLayerTreeHostImpl(hostImpl);
+    if (m_replicaLayer)
+        m_replicaLayer->setLayerTreeHostImpl(hostImpl);
+
+    if (m_layerTreeHostImpl)
+        m_layerTreeHostImpl->setNeedsUpdateDrawProperties();
+}
+
 scoped_ptr<SharedQuadState> LayerImpl::createSharedQuadState() const
 {
   scoped_ptr<SharedQuadState> state = SharedQuadState::Create();
   state->SetAll(m_drawProperties.target_space_transform,
                 m_drawProperties.visible_content_rect,
                 m_drawProperties.drawable_content_rect,
                 m_drawProperties.clip_rect,
                 m_drawProperties.is_clipped,
                 m_drawProperties.opacity);
   return state.Pass();
@@ skipping 239 matching lines @@
     LayerImpl* current = this->m_parent;
     while (current && !current->m_drawProperties.render_surface) {
         if (current->m_layerSurfacePropertyChanged)
             return true;
         current = current->m_parent;
     }
 
     return false;
 }
 
+void LayerImpl::noteLayerSurfacePropertyChanged()
+{
+    m_layerSurfacePropertyChanged = true;
+    if (m_layerTreeHostImpl)
+        m_layerTreeHostImpl->setNeedsUpdateDrawProperties();
+}
+
+void LayerImpl::noteLayerPropertyChanged()
+{
+    m_layerPropertyChanged = true;
+    if (m_layerTreeHostImpl)
+        m_layerTreeHostImpl->setNeedsUpdateDrawProperties();
+}
+
 void LayerImpl::noteLayerPropertyChangedForSubtree()
 {
-    m_layerPropertyChanged = true;
+    noteLayerPropertyChanged();
     noteLayerPropertyChangedForDescendants();
 }
 
 void LayerImpl::noteLayerPropertyChangedForDescendants()
 {
     for (size_t i = 0; i < m_children.size(); ++i)
         m_children[i]->noteLayerPropertyChangedForSubtree();
 }
 
 const char* LayerImpl::layerTypeAsString() const
@@ skipping 54 matching lines @@
 void LayerImpl::setBounds(const gfx::Size& bounds)
 {
     if (m_bounds == bounds)
         return;
 
     m_bounds = bounds;
 
     if (masksToBounds())
         noteLayerPropertyChangedForSubtree();
     else
-        m_layerPropertyChanged = true;
+        noteLayerPropertyChanged();
 }
 
 void LayerImpl::setMaskLayer(scoped_ptr<LayerImpl> maskLayer)
 {
     m_maskLayer = maskLayer.Pass();
 
     int newLayerId = m_maskLayer ? m_maskLayer->id() : -1;
     if (newLayerId == m_maskLayerId)
         return;
 
@@ skipping 12 matching lines @@
     m_replicaLayerId = newLayerId;
     noteLayerPropertyChangedForSubtree();
 }
 
 void LayerImpl::setDrawsContent(bool drawsContent)
 {
     if (m_drawsContent == drawsContent)
         return;
 
     m_drawsContent = drawsContent;
-    m_layerPropertyChanged = true;
+    noteLayerPropertyChanged();
 }
 
 void LayerImpl::setAnchorPoint(const gfx::PointF& anchorPoint)
 {
     if (m_anchorPoint == anchorPoint)
         return;
 
     m_anchorPoint = anchorPoint;
     noteLayerPropertyChangedForSubtree();
 }
 
 void LayerImpl::setAnchorPointZ(float anchorPointZ)
 {
     if (m_anchorPointZ == anchorPointZ)
         return;
 
     m_anchorPointZ = anchorPointZ;
     noteLayerPropertyChangedForSubtree();
 }
 
 void LayerImpl::setBackgroundColor(SkColor backgroundColor)
 {
     if (m_backgroundColor == backgroundColor)
         return;
 
     m_backgroundColor = backgroundColor;
-    m_layerPropertyChanged = true;
+    noteLayerPropertyChanged();
 }
 
 void LayerImpl::setFilters(const WebKit::WebFilterOperations& filters)
 {
     if (m_filters == filters)
         return;
 
     DCHECK(!m_filter);
     m_filters = filters;
     noteLayerPropertyChangedForSubtree();
 }
 
 void LayerImpl::setBackgroundFilters(const WebKit::WebFilterOperations& backgroundFilters)
 {
     if (m_backgroundFilters == backgroundFilters)
         return;
 
     m_backgroundFilters = backgroundFilters;
-    m_layerPropertyChanged = true;
+    noteLayerPropertyChanged();
 }
 
 void LayerImpl::setFilter(const skia::RefPtr<SkImageFilter>& filter)
 {
     if (m_filter.get() == filter.get())
         return;
 
     DCHECK(m_filters.isEmpty());
     m_filter = filter;
     noteLayerPropertyChangedForSubtree();
@@ skipping 16 matching lines @@
     m_contentsOpaque = opaque;
     noteLayerPropertyChangedForSubtree();
 }
 
 void LayerImpl::setOpacity(float opacity)
 {
     if (m_opacity == opacity)
         return;
 
     m_opacity = opacity;
-    m_layerSurfacePropertyChanged = true;
+    noteLayerSurfacePropertyChanged();
 }
 
 bool LayerImpl::opacityIsAnimating() const
 {
     return m_layerAnimationController->isAnimatingProperty(ActiveAnimation::Opacity);
 }
 
 void LayerImpl::setPosition(const gfx::PointF& position)
 {
     if (m_position == position)
@@ skipping 21 matching lines @@
     // sublayer transform does not affect the current layer; it affects only its children.
     noteLayerPropertyChangedForDescendants();
 }
 
 void LayerImpl::setTransform(const gfx::Transform& transform)
 {
     if (m_transform == transform)
         return;
 
     m_transform = transform;
-    m_layerSurfacePropertyChanged = true;
+    noteLayerSurfacePropertyChanged();
 }
 
 bool LayerImpl::transformIsAnimating() const
 {
     return m_layerAnimationController->isAnimatingProperty(ActiveAnimation::Transform);
 }
 
 void LayerImpl::setContentBounds(const gfx::Size& contentBounds)
 {
     if (m_contentBounds == contentBounds)
         return;
 
     m_contentBounds = contentBounds;
-    m_layerPropertyChanged = true;
+    noteLayerPropertyChanged();
 }
 
 void LayerImpl::setContentsScale(float contentsScaleX, float contentsScaleY)
 {
     if (m_contentsScaleX == contentsScaleX && m_contentsScaleY == contentsScaleY)
         return;
 
     m_contentsScaleX = contentsScaleX;
     m_contentsScaleY = contentsScaleY;
-    m_layerPropertyChanged = true;
+    noteLayerPropertyChanged();
 }
 
 void LayerImpl::setScrollOffset(gfx::Vector2d scrollOffset)
 {
     if (m_scrollOffset == scrollOffset)
         return;
 
     m_scrollOffset = scrollOffset;
     noteLayerPropertyChangedForSubtree();
 }
@@ skipping 75 matching lines @@
 
 void LayerImpl::setVerticalScrollbarLayer(ScrollbarLayerImpl* scrollbarLayer)
 {
     if (!m_scrollbarAnimationController)
         m_scrollbarAnimationController = ScrollbarAnimationController::create(this);
     m_scrollbarAnimationController->setVerticalScrollbarLayer(scrollbarLayer);
     m_scrollbarAnimationController->updateScrollOffset(this);
 }
 
 }  // namespace cc