cc: Do not save the rasterScale for layers until they are finished animating transforms.

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 "config.h"
 
 #include "cc/layer_tree_host_common.h"
 
 #include "cc/layer.h"
 #include "cc/layer_impl.h"
@@ skipping 331 matching lines @@
     //  Step 1 (right-most in the math): transform from the new surface to the original ancestor surface
     //  Step 2: apply the scroll compensation
     //  Step 3: transform back to the new surface.
     if (layer->renderSurface() && !nextScrollCompensationMatrix.isIdentity())
         nextScrollCompensationMatrix = layer->renderSurface()->drawTransform().inverse() * nextScrollCompensationMatrix * layer->renderSurface()->drawTransform();
 
     return nextScrollCompensationMatrix;
 }
 
 // There is no contentsScale on impl thread.
-static inline void updateLayerContentsScale(LayerImpl*, const WebTransformationMatrix&, float, float) { }
+static inline void updateLayerContentsScale(LayerImpl*, const WebTransformationMatrix&, float, float, bool) { }
 
-static inline void updateLayerContentsScale(Layer* layer, const WebTransformationMatrix& combinedTransform, float deviceScaleFactor, float pageScaleFactor)
+static inline void updateLayerContentsScale(Layer* layer, const WebTransformationMatrix& combinedTransform, float deviceScaleFactor, float pageScaleFactor, bool animatingTransformToScreen)
 {
     float rasterScale = layer->rasterScale();
     if (!rasterScale) {
         rasterScale = 1;
 
-        if (layer->automaticallyComputeRasterScale()) {
+        if (!animatingTransformToScreen && layer->automaticallyComputeRasterScale()) {
             gfx::Vector2dF transformScale = MathUtil::computeTransform2dScaleComponents(combinedTransform);
             float combinedScale = std::max(transformScale.x(), transformScale.y());
             rasterScale = combinedScale / deviceScaleFactor;
             if (!layer->boundsContainPageScale())
                 rasterScale /= pageScaleFactor;
             layer->setRasterScale(rasterScale);
         }
     }
 
     float contentsScale = rasterScale * deviceScaleFactor;
@@ skipping 111 matching lines @@
     gfx::Rect clipRectForSubtree;
     bool subtreeShouldBeClipped = false;
     
     float drawOpacity = layer->opacity();
     bool drawOpacityIsAnimating = layer->opacityIsAnimating();
     if (layer->parent() && layer->parent()->preserves3D()) {
         drawOpacity *= 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();
+    }
+
     gfx::Size bounds = layer->bounds();
     gfx::PointF anchorPoint = layer->anchorPoint();
     gfx::PointF position = layer->position() - layer->scrollDelta();
 
     WebTransformationMatrix layerLocalTransform;
     // LT = Tr[origin] * Tr[origin2anchor]
     layerLocalTransform.translate3d(position.x() + anchorPoint.x() * bounds.width(), position.y() + anchorPoint.y() * bounds.height(), layer->anchorPointZ());
     // LT = Tr[origin] * Tr[origin2anchor] * M[layer]
     layerLocalTransform.multiply(layer->transform());
     // LT = Tr[origin] * Tr[origin2anchor] * M[layer] * Tr[anchor2origin]
     layerLocalTransform.translate3d(-anchorPoint.x() * bounds.width(), -anchorPoint.y() * bounds.height(), -layer->anchorPointZ());
 
     WebTransformationMatrix combinedTransform = parentMatrix;
     combinedTransform.multiply(layerLocalTransform);
 
     // The layer's contentsSize is determined from the combinedTransform, which then informs the
     // layer's drawTransform.
-    updateLayerContentsScale(layer, combinedTransform, deviceScaleFactor, pageScaleFactor);
+    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 (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.
     WebTransformationMatrix drawTransform = combinedTransform;
     if (!layer->contentBounds().IsEmpty() && !layer->bounds().IsEmpty()) {
         // M[draw] = M[parent] * LT * S[layer2content]
         drawTransform.scaleNonUniform(1.0 / layer->contentsScaleX(),
                                       1.0 / layer->contentsScaleY());
     }
 
     // layerScreenSpaceTransform represents the transform between root layer's "screen space" and local content space.
     WebTransformationMatrix layerScreenSpaceTransform = fullHierarchyMatrix;
     if (!layer->preserves3D())
         MathUtil::flattenTransformTo2d(layerScreenSpaceTransform);
     layerScreenSpaceTransform.multiply(drawTransform);
     layer->setScreenSpaceTransform(layerScreenSpaceTransform);
 
-    bool animatingTransformToTarget = layer->transformIsAnimating();
-    bool animatingTransformToScreen = animatingTransformToTarget;
-    if (layer->parent()) {
-        animatingTransformToTarget |= layer->parent()->drawTransformIsAnimating();
-        animatingTransformToScreen |= layer->parent()->screenSpaceTransformIsAnimating();
-    }
-
     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.
     WebTransformationMatrix nextHierarchyMatrix = fullHierarchyMatrix;
     WebTransformationMatrix sublayerMatrix;
 
     gfx::Vector2dF renderSurfaceSublayerScale = MathUtil::computeTransform2dScaleComponents(combinedTransform);
 
     if (subtreeShouldRenderToSeparateSurface(layer, isScaleOrTranslation(combinedTransform))) {
@@ skipping 369 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