cc: Refactor content scale/bounds into draw properties

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 "base/debug/trace_event.h"
 #include "cc/layer.h"
@@ skipping 346 matching lines @@
     // The adjustment allows us to continue using the scrollCompensation on the next surface.
     //  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 = MathUtil::inverse(layer->renderSurface()->drawTransform()) * nextScrollCompensationMatrix * layer->renderSurface()->drawTransform();
 
     return nextScrollCompensationMatrix;
 }
 
-// There is no contentsScale on impl thread.
-static inline void updateLayerContentsScale(LayerImpl*, const gfx::Transform&, float, float, bool) { }
+static inline void updateLayerContentsScale(LayerImpl* layer, const gfx::Transform& combinedTransform, float deviceScaleFactor, float pageScaleFactor, bool animatingTransformToScreen)

[shawnsingh, 2012/12/11 21:54:05]

"update" was actually a word that really made me fumble at first.   It suddenly
makes the code feel not-so-one-way flow of data.

Could we please rename this (and the main thread version of this function) to
something like "calculateLayerContentsScale"?

[enne (OOO), 2012/12/11 23:23:44]

Sure, I can rename this.  Why is the word update problematic for you?

+{
+    gfx::Vector2dF transformScale = MathUtil::computeTransform2dScaleComponents(combinedTransform);
+    float contentsScale = std::max(transformScale.x(), transformScale.y());
+    layer->setIdealContentsScale(contentsScale);
+
+    LayerImpl* maskLayer = layer->maskLayer();
+    if (maskLayer)
+        maskLayer->setIdealContentsScale(contentsScale);
+
+    LayerImpl* replicaMaskLayer = layer->replicaLayer() ? layer->replicaLayer()->maskLayer() : 0;
+    if (replicaMaskLayer)
+        replicaMaskLayer->setIdealContentsScale(contentsScale);
+}
 
 static inline void updateLayerContentsScale(Layer* layer, const gfx::Transform& combinedTransform, float deviceScaleFactor, float pageScaleFactor, bool animatingTransformToScreen)
 {
     float rasterScale = layer->rasterScale();
     if (!rasterScale) {
         rasterScale = 1;
 
         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;
             // Prevent scale factors below 1 from being used or saved.
             if (rasterScale < 1)
                 rasterScale = 1;
             else
                 layer->setRasterScale(rasterScale);
         }
     }
 
     float contentsScale = rasterScale * deviceScaleFactor;
     if (!layer->boundsContainPageScale())
         contentsScale *= pageScaleFactor;
-    layer->setContentsScale(contentsScale);
+    layer->setIdealContentsScale(contentsScale);
 
     Layer* maskLayer = layer->maskLayer();
     if (maskLayer)
-        maskLayer->setContentsScale(contentsScale);
+        maskLayer->setIdealContentsScale(contentsScale);
 
     Layer* replicaMaskLayer = layer->replicaLayer() ? layer->replicaLayer()->maskLayer() : 0;
     if (replicaMaskLayer)
-        replicaMaskLayer->setContentsScale(contentsScale);
+        replicaMaskLayer->setIdealContentsScale(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>
 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)
@@ skipping 601 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