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 468 matching lines @@
     //        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.
     if (!isRootLayer(layer) && subtreeShouldBeSkipped(layer))
         return;
 
+    // As this function proceeds, these are the properties for each layer that
+    // actually get computed.  To avoid unnecessary copies (particularly for
+    // matrices), we do computations directly on these values when possible.
+    DrawProperties<LayerType>& 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 15 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.
         combinedTransform = currentScrollCompensationMatrix * combinedTransform;
     }
 
     // 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.drawTransform = combinedTransform;
     // M[draw] = M[parent] * LT * S[layer2content]
-    drawTransform.Scale(1.0 / layer->contentsScaleX(), 1.0 / layer->contentsScaleY());
+    layerDrawProperties.drawTransform.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.screenSpaceTransform = fullHierarchyMatrix;
     if (!layer->preserves3D())
-        MathUtil::flattenTransformTo2d(layerScreenSpaceTransform);
-    layerScreenSpaceTransform.PreconcatTransform(drawTransform);
-    layer->setScreenSpaceTransform(layerScreenSpaceTransform);
+        MathUtil::flattenTransformTo2d(layerDrawProperties.screenSpaceTransform);
+    layerDrawProperties.screenSpaceTransform.PreconcatTransform(layerDrawProperties.drawTransform);
 
     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 11 matching lines @@
         // The owning layer's draw transform has a scale from content to layer
         // space which 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.drawTransform.MakeIdentity();
+        layerDrawProperties.drawTransform.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.drawOpacity = 1;
+        layerDrawProperties.drawOpacityIsAnimating = false;
 
         renderSurface->setTargetSurfaceTransformsAreAnimating(animatingTransformToTarget);
         renderSurface->setScreenSpaceTransformsAreAnimating(animatingTransformToScreen);
-        animatingTransformToTarget = false;
-        layer->setDrawTransformIsAnimating(animatingTransformToTarget);
-        layer->setScreenSpaceTransformIsAnimating(animatingTransformToScreen);
+        layerDrawProperties.drawTransformIsAnimating = false;
+        layerDrawProperties.screenSpaceTransformIsAnimating = 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>& maskLayerDrawProperties = layer->maskLayer()->drawProperties();
+            maskLayerDrawProperties.renderTarget = layer;
+            maskLayerDrawProperties.visibleContentRect = 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>& replicaMaskDrawProperties = layer->replicaLayer()->maskLayer()->drawProperties();
+            replicaMaskDrawProperties.renderTarget = layer;
+            replicaMaskDrawProperties.visibleContentRect = 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);
+        // layerDrawProperties.drawTransform is computed above, before this if-else statement.
+        layerDrawProperties.drawTransformIsAnimating = animatingTransformToTarget;
+        layerDrawProperties.screenSpaceTransformIsAnimating = animatingTransformToScreen;
+        layerDrawProperties.drawOpacity = accumulatedDrawOpacity;
+        layerDrawProperties.drawOpacityIsAnimating = 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.renderTarget = 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 36 matching lines @@
     }
 
     // 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.drawableContentRect = rectInTargetSpace;
     if (subtreeShouldBeClipped)
-        drawableContentRectOfLayer.Intersect(clipRectForSubtree);
-    layer->setDrawableContentRect(drawableContentRectOfLayer);
+        layerDrawProperties.drawableContentRect.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.isClipped = subtreeShouldBeClipped;
     if (subtreeShouldBeClipped)
-        layer->setClipRect(clipRectForSubtree);
+        layerDrawProperties.clipRect = 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.clipRect = rectInTargetSpace;
     }
 
     // Compute the layer's visible content rect (the rect is in content space)
-    gfx::Rect visibleContentRectOfLayer = calculateVisibleContentRect(layer);
-    layer->setVisibleContentRect(visibleContentRectOfLayer);
+    layerDrawProperties.visibleContentRect = 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 253 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