Organize internal properties of cc/ layer types

cc/layer_tree_host_common.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_common.h"
 
 #include <algorithm>
 
 #include "cc/layer.h"
 #include "cc/layer_impl.h"
@@ skipping 193 matching lines @@
 
 static inline bool subtreeShouldBeSkipped(Layer* layer)
 {
     // If the opacity is being animated then the opacity on the main thread is unreliable
     // (since the impl thread may be using a different opacity), so it should not be trusted.
     // In particular, it should not cause the subtree to be skipped.
     return !layer->opacity() && !layer->opacityIsAnimating();
 }
 
 // Called on each layer that could be drawn after all information from
-// calcDrawTransforms has been updated on that layer.  May have some false
+// calcDrawProperties has been updated on that layer.  May have some false
 // positives (e.g. layers get this called on them but don't actually get drawn).
 static inline void markLayerAsUpdated(LayerImpl* layer)
 {
     layer->didUpdateTransforms();
 }
 
 static inline void markLayerAsUpdated(Layer* layer)
 {
 }
 
@@ skipping 159 matching lines @@
         maskLayer->setContentsScale(contentsScale);
 
     Layer* replicaMaskLayer = layer->replicaLayer() ? layer->replicaLayer()->maskLayer() : 0;
     if (replicaMaskLayer)
         replicaMaskLayer->setContentsScale(contentsScale);
 }
 
 // Recursively walks the layer tree starting at the given node and computes all the
 // necessary transformations, clipRects, render surfaces, etc.
 template<typename LayerType, typename LayerList, typename RenderSurfaceType, typename LayerSorter>
-static void calculateDrawTransformsInternal(LayerType* layer, const gfx::Transform& parentMatrix,
+static void calculateDrawPropertiesInternal(LayerType* layer, const gfx::Transform& parentMatrix,
     const gfx::Transform& fullHierarchyMatrix, const gfx::Transform& currentScrollCompensationMatrix,
     const gfx::Rect& clipRectFromAncestor, bool ancestorClipsSubtree,
     RenderSurfaceType* nearestAncestorThatMovesPixels, LayerList& renderSurfaceLayerList, LayerList& layerList,
     LayerSorter* layerSorter, int maxTextureSize, float deviceScaleFactor, float pageScaleFactor, gfx::Rect& drawableContentRectOfSubtree)
 {
     // This function computes the new matrix transformations recursively for this
     // layer and all its descendants. It also computes the appropriate render surfaces.
     // Some important points to remember:
     //
     // 0. Here, transforms are notated in Matrix x Vector order, and in words we describe what
@@ skipping 70 matching lines @@
     // The replica draw transform to its target surface origin is:
     //        M[replicaDraw] = S[deviceScale] * M[surfaceDraw] * Tr[replica->position() + replica->anchor()] * Tr[replica] * Tr[origin2anchor].inverse() * S[contentsScale].inverse()
     //
     // The replica draw transform to the root (screen space) origin is:
     //        M[replica2root] = M[surface2root] * Tr[replica->position()] * Tr[replica] * Tr[origin2anchor].inverse()
     //
 
     // If we early-exit anywhere in this function, the drawableContentRect of this subtree should be considered empty.
     drawableContentRectOfSubtree = gfx::Rect();
 
-    // The root layer cannot skip calcDrawTransforms.
+    // The root layer cannot skip calcDrawProperties.
     if (!isRootLayer(layer) && subtreeShouldBeSkipped(layer))
         return;
 
+    // As this function proceeds, these are the properties for the current
+    // layer that actually get computed. To avoid unnecessary copies
+    // (particularly for matrices), we do computations directly on these values
+    // when possible.
+    DrawProperties<LayerType, RenderSurfaceType>& layerDrawProperties = layer->drawProperties();
+
     gfx::Rect clipRectForSubtree;
     bool subtreeShouldBeClipped = false;
 
-    float drawOpacity = layer->opacity();
+    float accumulatedDrawOpacity = layer->opacity();
     bool drawOpacityIsAnimating = layer->opacityIsAnimating();
     if (layer->parent()) {
-        drawOpacity *= layer->parent()->drawOpacity();
+        accumulatedDrawOpacity *= layer->parent()->drawOpacity();
         drawOpacityIsAnimating |= layer->parent()->drawOpacityIsAnimating();
     }
 
     bool animatingTransformToTarget = layer->transformIsAnimating();
     bool animatingTransformToScreen = animatingTransformToTarget;
     if (layer->parent()) {
         animatingTransformToTarget |= layer->parent()->drawTransformIsAnimating();
         animatingTransformToScreen |= layer->parent()->screenSpaceTransformIsAnimating();
     }
 
@@ skipping 22 matching lines @@
     if (layer->fixedToContainerLayer()) {
         // Special case: this layer is a composited fixed-position layer; we need to
         // explicitly compensate for all ancestors' nonzero scrollDeltas to keep this layer
         // fixed correctly.
         // Note carefully: this is Concat, not Preconcat (currentScrollCompensation * combinedTransform).
         combinedTransform.ConcatTransform(currentScrollCompensationMatrix);
     }
 
     // The drawTransform that gets computed below is effectively the layer's drawTransform, unless
     // the layer itself creates a renderSurface. In that case, the renderSurface re-parents the transforms.
-    gfx::Transform drawTransform = combinedTransform;
+    layerDrawProperties.target_space_transform = combinedTransform;
     // M[draw] = M[parent] * LT * S[layer2content]
-    drawTransform.Scale(1.0 / layer->contentsScaleX(), 1.0 / layer->contentsScaleY());
+    layerDrawProperties.target_space_transform.Scale(1.0 / layer->contentsScaleX(), 1.0 / layer->contentsScaleY());
 
     // layerScreenSpaceTransform represents the transform between root layer's "screen space" and local content space.
-    gfx::Transform layerScreenSpaceTransform = fullHierarchyMatrix;
+    layerDrawProperties.screen_space_transform = fullHierarchyMatrix;
     if (!layer->preserves3D())
-        MathUtil::flattenTransformTo2d(layerScreenSpaceTransform);
-    layerScreenSpaceTransform.PreconcatTransform(drawTransform);
-    layer->setScreenSpaceTransform(layerScreenSpaceTransform);
+        MathUtil::flattenTransformTo2d(layerDrawProperties.screen_space_transform);
+    layerDrawProperties.screen_space_transform.PreconcatTransform(layerDrawProperties.target_space_transform);
 
     gfx::RectF contentRect(gfx::PointF(), layer->contentBounds());
 
     // fullHierarchyMatrix is the matrix that transforms objects between screen space (except projection matrix) and the most recent RenderSurfaceImpl's space.
     // nextHierarchyMatrix will only change if this layer uses a new RenderSurfaceImpl, otherwise remains the same.
     gfx::Transform nextHierarchyMatrix = fullHierarchyMatrix;
     gfx::Transform sublayerMatrix;
 
     gfx::Vector2dF renderSurfaceSublayerScale = MathUtil::computeTransform2dScaleComponents(combinedTransform);
 
@@ skipping 10 matching lines @@
 
         // The owning layer's draw transform has a scale from content to layer
         // space which we do not want; so here we use the combinedTransform
         // instead of the drawTransform. However, we do need to add a different
         // scale factor that accounts for the surface's pixel dimensions.
         combinedTransform.Scale(1 / renderSurfaceSublayerScale.x(), 1 / renderSurfaceSublayerScale.y());
         renderSurface->setDrawTransform(combinedTransform);
 
         // The owning layer's transform was re-parented by the surface, so the layer's new drawTransform
         // only needs to scale the layer to surface space.
-        gfx::Transform layerDrawTransform;
-        layerDrawTransform.Scale(renderSurfaceSublayerScale.x() / layer->contentsScaleX(), renderSurfaceSublayerScale.y() / layer->contentsScaleY());
-        layer->setDrawTransform(layerDrawTransform);
+        layerDrawProperties.target_space_transform.MakeIdentity();
+        layerDrawProperties.target_space_transform.Scale(renderSurfaceSublayerScale.x() / layer->contentsScaleX(), renderSurfaceSublayerScale.y() / layer->contentsScaleY());
 
         // Inside the surface's subtree, we scale everything to the owning layer's scale.
         // The sublayer matrix transforms centered layer rects into target
         // surface content space.
         DCHECK(sublayerMatrix.IsIdentity());
         sublayerMatrix.Scale(renderSurfaceSublayerScale.x(), renderSurfaceSublayerScale.y());
 
         // The opacity value is moved from the layer to its surface, so that the entire subtree properly inherits opacity.
-        renderSurface->setDrawOpacity(drawOpacity);
+        renderSurface->setDrawOpacity(accumulatedDrawOpacity);
         renderSurface->setDrawOpacityIsAnimating(drawOpacityIsAnimating);
-        layer->setDrawOpacity(1);
-        layer->setDrawOpacityIsAnimating(false);
+        layerDrawProperties.opacity = 1;
+        layerDrawProperties.opacity_is_animating = false;
 
         renderSurface->setTargetSurfaceTransformsAreAnimating(animatingTransformToTarget);
         renderSurface->setScreenSpaceTransformsAreAnimating(animatingTransformToScreen);
         animatingTransformToTarget = false;
-        layer->setDrawTransformIsAnimating(animatingTransformToTarget);
-        layer->setScreenSpaceTransformIsAnimating(animatingTransformToScreen);
+        layerDrawProperties.target_space_transform_is_animating = animatingTransformToTarget;
+        layerDrawProperties.screen_space_transform_is_animating = animatingTransformToScreen;
 
         // Update the aggregate hierarchy matrix to include the transform of the
         // newly created RenderSurfaceImpl.
         nextHierarchyMatrix.PreconcatTransform(renderSurface->drawTransform());
 
         // The new renderSurface here will correctly clip the entire subtree. So, we do
         // not need to continue propagating the clipping state further down the tree. This
         // way, we can avoid transforming clipRects from ancestor target surface space to
         // current target surface space that could cause more w < 0 headaches.
         subtreeShouldBeClipped = false;
 
         if (layer->maskLayer()) {
-            layer->maskLayer()->setRenderTarget(layer);
-            layer->maskLayer()->setVisibleContentRect(gfx::Rect(gfx::Point(), layer->contentBounds()));
+            DrawProperties<LayerType, RenderSurfaceType>& maskLayerDrawProperties = layer->maskLayer()->drawProperties();
+            maskLayerDrawProperties.render_target = layer;
+            maskLayerDrawProperties.visible_content_rect = gfx::Rect(gfx::Point(), layer->contentBounds());
         }
 
         if (layer->replicaLayer() && layer->replicaLayer()->maskLayer()) {
-            layer->replicaLayer()->maskLayer()->setRenderTarget(layer);
-            layer->replicaLayer()->maskLayer()->setVisibleContentRect(gfx::Rect(gfx::Point(), layer->contentBounds()));
+            DrawProperties<LayerType, RenderSurfaceType>& replicaMaskDrawProperties = layer->replicaLayer()->maskLayer()->drawProperties();
+            replicaMaskDrawProperties.render_target = layer;
+            replicaMaskDrawProperties.visible_content_rect = gfx::Rect(gfx::Point(), layer->contentBounds());
         }
 
         // FIXME:  make this smarter for the SkImageFilter case (check for
         //         pixel-moving filters)
         if (layer->filters().hasFilterThatMovesPixels() || layer->filter())
             nearestAncestorThatMovesPixels = renderSurface;
 
         // The render surface clipRect is expressed in the space where this surface draws, i.e. the same space as clipRectFromAncestor.
         renderSurface->setIsClipped(ancestorClipsSubtree);
         if (ancestorClipsSubtree)
             renderSurface->setClipRect(clipRectFromAncestor);
         else
             renderSurface->setClipRect(gfx::Rect());
 
         renderSurface->setNearestAncestorThatMovesPixels(nearestAncestorThatMovesPixels);
 
         renderSurfaceLayerList.push_back(layer);
     } else {
         DCHECK(layer->parent());
 
-        layer->setDrawTransform(drawTransform);
-        layer->setDrawTransformIsAnimating(animatingTransformToTarget);
-        layer->setScreenSpaceTransformIsAnimating(animatingTransformToScreen);
+        // Note: layerDrawProperties.target_space_transform is computed above,
+        // before this if-else statement.
+        layerDrawProperties.target_space_transform_is_animating = animatingTransformToTarget;
+        layerDrawProperties.screen_space_transform_is_animating = animatingTransformToScreen;
+        layerDrawProperties.opacity = accumulatedDrawOpacity;
+        layerDrawProperties.opacity_is_animating = drawOpacityIsAnimating;
         sublayerMatrix = combinedTransform;
 
-        layer->setDrawOpacity(drawOpacity);
-        layer->setDrawOpacityIsAnimating(drawOpacityIsAnimating);
-
         layer->clearRenderSurface();
 
         // Layers without renderSurfaces directly inherit the ancestor's clip status.
         subtreeShouldBeClipped = ancestorClipsSubtree;
         if (ancestorClipsSubtree)
             clipRectForSubtree = clipRectFromAncestor;
 
         // Layers that are not their own renderTarget will render into the target of their nearest ancestor.
-        layer->setRenderTarget(layer->parent()->renderTarget());
+        layerDrawProperties.render_target = layer->parent()->renderTarget();
     }
 
     gfx::Rect rectInTargetSpace = ToEnclosingRect(MathUtil::mapClippedRect(layer->drawTransform(), contentRect));
 
     if (layerClipsSubtree(layer)) {
         subtreeShouldBeClipped = true;
         if (ancestorClipsSubtree && !layer->renderSurface()) {
             clipRectForSubtree = clipRectFromAncestor;
             clipRectForSubtree.Intersect(rectInTargetSpace);
         } else
@@ skipping 18 matching lines @@
 
     if (!layerShouldBeSkipped(layer))
         descendants.push_back(layer);
 
     gfx::Transform nextScrollCompensationMatrix = computeScrollCompensationMatrixForChildren(layer, parentMatrix, currentScrollCompensationMatrix);;
 
     gfx::Rect accumulatedDrawableContentRectOfChildren;
     for (size_t i = 0; i < layer->children().size(); ++i) {
         LayerType* child = LayerTreeHostCommon::getChildAsRawPtr(layer->children(), i);
         gfx::Rect drawableContentRectOfChildSubtree;
-        calculateDrawTransformsInternal<LayerType, LayerList, RenderSurfaceType, LayerSorter>(child, sublayerMatrix, nextHierarchyMatrix, nextScrollCompensationMatrix,
+        calculateDrawPropertiesInternal<LayerType, LayerList, RenderSurfaceType, LayerSorter>(child, sublayerMatrix, nextHierarchyMatrix, nextScrollCompensationMatrix,
                                                                                               clipRectForSubtree, subtreeShouldBeClipped, nearestAncestorThatMovesPixels,
                                                                                               renderSurfaceLayerList, descendants, layerSorter, maxTextureSize, deviceScaleFactor, pageScaleFactor, drawableContentRectOfChildSubtree);
         if (!drawableContentRectOfChildSubtree.IsEmpty()) {
             accumulatedDrawableContentRectOfChildren.Union(drawableContentRectOfChildSubtree);
             if (child->renderSurface())
                 descendants.push_back(child);
         }
     }
 
     // Compute the total drawableContentRect for this subtree (the rect is in targetSurface space)
     gfx::Rect localDrawableContentRectOfSubtree = accumulatedDrawableContentRectOfChildren;
     if (layer->drawsContent())
         localDrawableContentRectOfSubtree.Union(rectInTargetSpace);
     if (subtreeShouldBeClipped)
         localDrawableContentRectOfSubtree.Intersect(clipRectForSubtree);
 
     // Compute the layer's drawable content rect (the rect is in targetSurface space)
-    gfx::Rect drawableContentRectOfLayer = rectInTargetSpace;
+    layerDrawProperties.drawable_content_rect = rectInTargetSpace;
     if (subtreeShouldBeClipped)
-        drawableContentRectOfLayer.Intersect(clipRectForSubtree);
-    layer->setDrawableContentRect(drawableContentRectOfLayer);
+        layerDrawProperties.drawable_content_rect.Intersect(clipRectForSubtree);
 
     // Tell the layer the rect that is clipped by. In theory we could use a
     // tighter clipRect here (drawableContentRect), but that actually does not
     // reduce how much would be drawn, and instead it would create unnecessary
     // changes to scissor state affecting GPU performance.
-    layer->setIsClipped(subtreeShouldBeClipped);
+    layerDrawProperties.is_clipped = subtreeShouldBeClipped;
     if (subtreeShouldBeClipped)
-        layer->setClipRect(clipRectForSubtree);
+        layerDrawProperties.clip_rect = clipRectForSubtree;
     else {
         // Initialize the clipRect to a safe value that will not clip the
         // layer, just in case clipping is still accidentally used.
-        layer->setClipRect(rectInTargetSpace);
+        layerDrawProperties.clip_rect = rectInTargetSpace;
     }
 
     // Compute the layer's visible content rect (the rect is in content space)
-    gfx::Rect visibleContentRectOfLayer = calculateVisibleContentRect(layer);
-    layer->setVisibleContentRect(visibleContentRectOfLayer);
+    layerDrawProperties.visible_content_rect = calculateVisibleContentRect(layer);
 
     // Compute the remaining properties for the render surface, if the layer has one.
     if (isRootLayer(layer)) {
         // The root layer's surface's contentRect is always the entire viewport.
         DCHECK(layer->renderSurface());
         layer->renderSurface()->setContentRect(clipRectFromAncestor);
     } else if (layer->renderSurface() && !isRootLayer(layer)) {
         RenderSurfaceType* renderSurface = layer->renderSurface();
         gfx::Rect clippedContentRect = localDrawableContentRectOfSubtree;
 
@@ skipping 75 matching lines @@
 
     if (layer->renderSurface())
         drawableContentRectOfSubtree = gfx::ToEnclosingRect(layer->renderSurface()->drawableContentRect());
     else
         drawableContentRectOfSubtree = localDrawableContentRectOfSubtree;
 
     if (layer->hasContributingDelegatedRenderPasses())
         layer->renderTarget()->renderSurface()->addContributingDelegatedRenderPassLayer(layer);
 }
 
-void LayerTreeHostCommon::calculateDrawTransforms(Layer* rootLayer, const gfx::Size& deviceViewportSize, float deviceScaleFactor, float pageScaleFactor, int maxTextureSize, std::vector<scoped_refptr<Layer> >& renderSurfaceLayerList)
+void LayerTreeHostCommon::calculateDrawProperties(Layer* rootLayer, const gfx::Size& deviceViewportSize, float deviceScaleFactor, float pageScaleFactor, int maxTextureSize, std::vector<scoped_refptr<Layer> >& renderSurfaceLayerList)
 {
     gfx::Rect totalDrawableContentRect;
     gfx::Transform identityMatrix;
     gfx::Transform deviceScaleTransform;
     deviceScaleTransform.Scale(deviceScaleFactor, deviceScaleFactor);
     std::vector<scoped_refptr<Layer> > dummyLayerList;
 
     // The root layer's renderSurface should receive the deviceViewport as the initial clipRect.
     bool subtreeShouldBeClipped = true;
     gfx::Rect deviceViewportRect(gfx::Point(), deviceViewportSize);
 
     // This function should have received a root layer.
     DCHECK(isRootLayer(rootLayer));
 
-    cc::calculateDrawTransformsInternal<Layer, std::vector<scoped_refptr<Layer> >, RenderSurface, void>(
+    cc::calculateDrawPropertiesInternal<Layer, std::vector<scoped_refptr<Layer> >, RenderSurface, void>(
         rootLayer, deviceScaleTransform, identityMatrix, identityMatrix,
         deviceViewportRect, subtreeShouldBeClipped, 0, renderSurfaceLayerList,
         dummyLayerList, 0, maxTextureSize,
         deviceScaleFactor, pageScaleFactor, totalDrawableContentRect);
 
     // The dummy layer list should not have been used.
     DCHECK(dummyLayerList.size() == 0);
-    // A root layer renderSurface should always exist after calculateDrawTransforms.
+    // A root layer renderSurface should always exist after calculateDrawProperties.
     DCHECK(rootLayer->renderSurface());
 }
 
-void LayerTreeHostCommon::calculateDrawTransforms(LayerImpl* rootLayer, const gfx::Size& deviceViewportSize, float deviceScaleFactor, float pageScaleFactor, LayerSorter* layerSorter, int maxTextureSize, std::vector<LayerImpl*>& renderSurfaceLayerList)
+void LayerTreeHostCommon::calculateDrawProperties(LayerImpl* rootLayer, const gfx::Size& deviceViewportSize, float deviceScaleFactor, float pageScaleFactor, LayerSorter* layerSorter, int maxTextureSize, std::vector<LayerImpl*>& renderSurfaceLayerList)
 {
     gfx::Rect totalDrawableContentRect;
     gfx::Transform identityMatrix;
     gfx::Transform deviceScaleTransform;
     deviceScaleTransform.Scale(deviceScaleFactor, deviceScaleFactor);
     std::vector<LayerImpl*> dummyLayerList;
 
     // The root layer's renderSurface should receive the deviceViewport as the initial clipRect.
     bool subtreeShouldBeClipped = true;
     gfx::Rect deviceViewportRect(gfx::Point(), deviceViewportSize);
 
     // This function should have received a root layer.
     DCHECK(isRootLayer(rootLayer));
 
-    cc::calculateDrawTransformsInternal<LayerImpl, std::vector<LayerImpl*>, RenderSurfaceImpl, LayerSorter>(
+    cc::calculateDrawPropertiesInternal<LayerImpl, std::vector<LayerImpl*>, RenderSurfaceImpl, LayerSorter>(
         rootLayer, deviceScaleTransform, identityMatrix, identityMatrix,
         deviceViewportRect, subtreeShouldBeClipped, 0, renderSurfaceLayerList,
         dummyLayerList, layerSorter, maxTextureSize,
         deviceScaleFactor, pageScaleFactor, totalDrawableContentRect);
 
     // The dummy layer list should not have been used.
     DCHECK(dummyLayerList.size() == 0);
-    // A root layer renderSurface should always exist after calculateDrawTransforms.
+    // A root layer renderSurface should always exist after calculateDrawProperties.
     DCHECK(rootLayer->renderSurface());
 }
 
 static bool pointHitsRect(const gfx::PointF& screenSpacePoint, const gfx::Transform& localSpaceToScreenSpaceTransform, gfx::RectF localSpaceRect)
 {
     // If the transform is not invertible, then assume that this point doesn't hit this rect.
     if (!localSpaceToScreenSpaceTransform.IsInvertible())
         return false;
 
     // Transform the hit test point from screen space to the local space of the given rect.
@@ skipping 107 matching lines @@
 
         foundLayer = currentLayer;
         break;
     }
 
     // This can potentially return 0, which means the screenSpacePoint did not successfully hit test any layers, not even the root layer.
     return foundLayer;
 }
 
 }  // namespace cc