Tighten the matrix usage in cc/layer_tree_host_common.cpp

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 489 matching lines @@
     bool animatingTransformToScreen = animatingTransformToTarget;
     if (layer->parent()) {
         animatingTransformToTarget |= layer->parent()->drawTransformIsAnimating();
         animatingTransformToScreen |= layer->parent()->screenSpaceTransformIsAnimating();
     }
 
     gfx::Size bounds = layer->bounds();
     gfx::PointF anchorPoint = layer->anchorPoint();
     gfx::PointF position = layer->position() - layer->scrollDelta();
 
-    gfx::Transform layerLocalTransform;
+    gfx::Transform combinedTransform = parentMatrix;
     // LT = Tr[origin] * Tr[origin2anchor]
-    layerLocalTransform.Translate3d(position.x() + anchorPoint.x() * bounds.width(), position.y() + anchorPoint.y() * bounds.height(), layer->anchorPointZ());
+    combinedTransform.Translate3d(position.x() + anchorPoint.x() * bounds.width(), position.y() + anchorPoint.y() * bounds.height(), layer->anchorPointZ());
     // LT = Tr[origin] * Tr[origin2anchor] * M[layer]
-    layerLocalTransform.PreconcatTransform(layer->transform());
+    combinedTransform.PreconcatTransform(layer->transform());
     // LT = Tr[origin] * Tr[origin2anchor] * M[layer] * Tr[anchor2origin]
-    layerLocalTransform.Translate3d(-anchorPoint.x() * bounds.width(), -anchorPoint.y() * bounds.height(), -layer->anchorPointZ());
-
-    gfx::Transform combinedTransform = parentMatrix;
-    combinedTransform.PreconcatTransform(layerLocalTransform);
+    combinedTransform.Translate3d(-anchorPoint.x() * bounds.width(), -anchorPoint.y() * bounds.height(), -layer->anchorPointZ());
 
     // The layer's contentsSize is determined from the combinedTransform, which then informs the
     // layer's drawTransform.
     updateLayerContentsScale(layer, combinedTransform, deviceScaleFactor, pageScaleFactor, animatingTransformToScreen);
 
-    // If there is a tranformation from the impl thread then it should be at the
-    // start of the combinedTransform, but we don't want it to affect the contentsScale.
-    combinedTransform = layer->implTransform() * combinedTransform;
+    // If there is a transformation from the impl thread then it should be at
+    // the start of the combinedTransform, but we don't want it to affect the
+    // computation of contentsScale above.
+    // Note Carefully: this is Concat, not Preconcat (implTransform * combinedTransform).

[danakj, 2012/12/04 18:27:43]

nit: carefully lowercase

+    combinedTransform.ConcatTransform(layer->implTransform());
 
     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;
+        // Note Carefully: this is Concat, not Preconcat (currentScrollCompensation * combinedTransform).

[danakj, 2012/12/04 18:27:43]

same

+        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;
     // M[draw] = M[parent] * LT * S[layer2content]
     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;
@@ skipping 15 matching lines @@
         // Check back-face visibility before continuing with this surface and its subtree
         if (!layer->doubleSided() && transformToParentIsKnown(layer) && isSurfaceBackFaceVisible(layer, combinedTransform))
             return;
 
         if (!layer->renderSurface())
             layer->createRenderSurface();
 
         RenderSurfaceType* renderSurface = layer->renderSurface();
         renderSurface->clearLayerLists();
 
-        // The owning layer's draw transform has a scale from content to layer space which we need to undo and
-        // replace with a scale from the surface's subtree into layer space.
-        drawTransform.Scale(layer->contentsScaleX(), layer->contentsScaleY());
-        drawTransform.Scale(1 / renderSurfaceSublayerScale.x(), 1 / renderSurfaceSublayerScale.y());
-        renderSurface->setDrawTransform(drawTransform);
+        // The owning layer's draw transform has a scale from content to layer
+        // space which do not want; so here we use the combinedTransform

[danakj, 2012/12/04 18:27:43]

nit: "which do not want"

+        // 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());

[danakj, 2012/12/04 18:27:43]

changing the combinedTransform makes me a bit uncomfortable for some reason. i
see it'll work ok for now though, as the other use is only in the else clause.

[shawnsingh, 2012/12/04 18:31:39]

I think this is most likely going to be a non-issue anyway after the
drawProperties patch which will compute the drawTransform in-place.

[danakj, 2012/12/04 18:32:48]

Thanks for the reassurance. :)

+        renderSurface->setDrawTransform(combinedTransform);
 
-        // The origin of the new surface is the upper left corner of the layer.
+        // 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(), renderSurfaceSublayerScale.y());
-        layerDrawTransform.Scale(1.0 / layer->contentsScaleX(), 1.0 / layer->contentsScaleY());
+        layerDrawTransform.Scale(renderSurfaceSublayerScale.x() / layer->contentsScaleX(), renderSurfaceSublayerScale.y() / layer->contentsScaleY());
         layer->setDrawTransform(layerDrawTransform);
 
         // 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.
-        sublayerMatrix.MakeIdentity();
+        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->setDrawOpacityIsAnimating(drawOpacityIsAnimating);
         layer->setDrawOpacity(1);
         layer->setDrawOpacityIsAnimating(false);
 
         renderSurface->setTargetSurfaceTransformsAreAnimating(animatingTransformToTarget);
         renderSurface->setScreenSpaceTransformsAreAnimating(animatingTransformToScreen);
@@ skipping 67 matching lines @@
             clipRectForSubtree.Intersect(rectInTargetSpace);
         } else
             clipRectForSubtree = rectInTargetSpace;
     }
 
     // Flatten to 2D if the layer doesn't preserve 3D.
     if (!layer->preserves3D())
         MathUtil::flattenTransformTo2d(sublayerMatrix);
 
     // Apply the sublayer transform at the center of the layer.
-    sublayerMatrix.Translate(0.5 * bounds.width(), 0.5 * bounds.height());
-    sublayerMatrix.PreconcatTransform(layer->sublayerTransform());
-    sublayerMatrix.Translate(-0.5 * bounds.width(), -0.5 * bounds.height());
+    if (!layer->sublayerTransform().IsIdentity()) {
+        sublayerMatrix.Translate(0.5 * bounds.width(), 0.5 * bounds.height());
+        sublayerMatrix.PreconcatTransform(layer->sublayerTransform());
+        sublayerMatrix.Translate(-0.5 * bounds.width(), -0.5 * bounds.height());
+    }
 
     LayerList& descendants = (layer->renderSurface() ? layer->renderSurface()->layerList() : layerList);
 
     // Any layers that are appended after this point are in the layer's subtree and should be included in the sorting process.
     unsigned sortingStartIndex = descendants.size();
 
     if (!layerShouldBeSkipped(layer))
         descendants.push_back(layer);
 
     gfx::Transform nextScrollCompensationMatrix = computeScrollCompensationMatrixForChildren(layer, parentMatrix, currentScrollCompensationMatrix);;
@@ skipping 69 matching lines @@
         clippedContentRect.set_height(std::min(clippedContentRect.height(), maxTextureSize));
 
         if (clippedContentRect.IsEmpty())
             renderSurface->clearLayerLists();
 
         renderSurface->setContentRect(clippedContentRect);
 
         // The owning layer's screenSpaceTransform has a scale from content to layer space which we need to undo and
         // replace with a scale from the surface's subtree into layer space.
         gfx::Transform screenSpaceTransform = layer->screenSpaceTransform();
-        screenSpaceTransform.Scale(layer->contentsScaleX(), layer->contentsScaleY());
-        screenSpaceTransform.Scale(1 / renderSurfaceSublayerScale.x(), 1 / renderSurfaceSublayerScale.y());
+        screenSpaceTransform.Scale(layer->contentsScaleX() / renderSurfaceSublayerScale.x(), layer->contentsScaleY() / renderSurfaceSublayerScale.y());
         renderSurface->setScreenSpaceTransform(screenSpaceTransform);
 
         if (layer->replicaLayer()) {
             gfx::Transform surfaceOriginToReplicaOriginTransform;
             surfaceOriginToReplicaOriginTransform.Scale(renderSurfaceSublayerScale.x(), renderSurfaceSublayerScale.y());
             surfaceOriginToReplicaOriginTransform.Translate(layer->replicaLayer()->position().x() + layer->replicaLayer()->anchorPoint().x() * bounds.width(),
                                                             layer->replicaLayer()->position().y() + layer->replicaLayer()->anchorPoint().y() * bounds.height());
             surfaceOriginToReplicaOriginTransform.PreconcatTransform(layer->replicaLayer()->transform());
             surfaceOriginToReplicaOriginTransform.Translate(-layer->replicaLayer()->anchorPoint().x() * bounds.width(), -layer->replicaLayer()->anchorPoint().y() * bounds.height());
             surfaceOriginToReplicaOriginTransform.Scale(1 / renderSurfaceSublayerScale.x(), 1 / renderSurfaceSublayerScale.y());
@@ skipping 217 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