Organize internal properties of cc/ layer types

cc/layer_tree_host_common.cc

Index: cc/layer_tree_host_common.cc
diff --git a/cc/layer_tree_host_common.cc b/cc/layer_tree_host_common.cc
index 5979d078cb9e0b3f2de21aeac67b77f2528bfbbc..b271a5d6e6146cb4ec9cf71d3a6c69701685531c 100644
--- a/cc/layer_tree_host_common.cc
+++ b/cc/layer_tree_host_common.cc
@@ -486,13 +486,18 @@ static void calculateDrawTransformsInternal(LayerType* layer, const gfx::Transfo
     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();
     }
 
@@ -528,16 +533,15 @@ static void calculateDrawTransformsInternal(LayerType* layer, const gfx::Transfo
 
     // 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());
 
@@ -569,8 +573,8 @@ static void calculateDrawTransformsInternal(LayerType* layer, const gfx::Transfo
         // 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
@@ -579,16 +583,15 @@ static void calculateDrawTransformsInternal(LayerType* layer, const gfx::Transfo
         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.
@@ -601,13 +604,15 @@ static void calculateDrawTransformsInternal(LayerType* layer, const gfx::Transfo
         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
@@ -628,14 +633,13 @@ static void calculateDrawTransformsInternal(LayerType* layer, const gfx::Transfo
     } 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.
@@ -644,7 +648,7 @@ static void calculateDrawTransformsInternal(LayerType* layer, const gfx::Transfo
             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));
@@ -701,27 +705,25 @@ static void calculateDrawTransformsInternal(LayerType* layer, const gfx::Transfo
         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)) {