cc: Use maximum tiling contents scales for picture layer scale

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 371 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;
 }
 
+template<typename LayerType>
+static inline void calculateContentsScale(LayerType* layer, float contentsScale)
+{
+    layer->calculateContentsScale(
+        contentsScale,
+        &layer->drawProperties().contents_scale_x,
+        &layer->drawProperties().contents_scale_y,
+        &layer->drawProperties().content_bounds);
+
+    LayerType* maskLayer = layer->maskLayer();
+    if (maskLayer)
+    {
+        maskLayer->calculateContentsScale(
+            contentsScale,
+            &maskLayer->drawProperties().contents_scale_x,
+            &maskLayer->drawProperties().contents_scale_y,
+            &maskLayer->drawProperties().content_bounds);
+    }
+
+    LayerType* replicaMaskLayer = layer->replicaLayer() ? layer->replicaLayer()->maskLayer() : 0;
+    if (replicaMaskLayer)
+    {
+        replicaMaskLayer->calculateContentsScale(
+            contentsScale,
+            &replicaMaskLayer->drawProperties().contents_scale_x,
+            &replicaMaskLayer->drawProperties().contents_scale_y,
+            &replicaMaskLayer->drawProperties().content_bounds);
+    }
+}
+
 static inline void updateLayerContentsScale(LayerImpl* layer, const gfx::Transform& combinedTransform, float deviceScaleFactor, float pageScaleFactor, bool animatingTransformToScreen)
 {
+    gfx::Vector2dF transformScale = MathUtil::computeTransform2dScaleComponents(combinedTransform, deviceScaleFactor * pageScaleFactor);
+    float contentsScale = std::max(transformScale.x(), transformScale.y());
+    calculateContentsScale(layer, 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, 0.f);
             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->calculateContentsScale(
-        contentsScale,
-        &layer->drawProperties().contents_scale_x,
-        &layer->drawProperties().contents_scale_y,
-        &layer->drawProperties().content_bounds);
 
-    Layer* maskLayer = layer->maskLayer();
-    if (maskLayer)
-    {
-        maskLayer->calculateContentsScale(
-            contentsScale,
-            &maskLayer->drawProperties().contents_scale_x,
-            &maskLayer->drawProperties().contents_scale_y,
-            &maskLayer->drawProperties().content_bounds);
-    }
-
-    Layer* replicaMaskLayer = layer->replicaLayer() ? layer->replicaLayer()->maskLayer() : 0;
-    if (replicaMaskLayer)
-    {
-        replicaMaskLayer->calculateContentsScale(
-            contentsScale,
-            &replicaMaskLayer->drawProperties().contents_scale_x,
-            &replicaMaskLayer->drawProperties().contents_scale_y,
-            &replicaMaskLayer->drawProperties().content_bounds);
-    }
+    calculateContentsScale(layer, contentsScale);
 }
 
 template<typename LayerType, typename LayerList>
 static inline void removeSurfaceForEarlyExit(LayerType* layerToRemove, LayerList& renderSurfaceLayerList)
 {
     DCHECK(layerToRemove->renderSurface());
     // Technically, we know that the layer we want to remove should be
     // at the back of the renderSurfaceLayerList. However, we have had
     // bugs before that added unnecessary layers here
     // (https://bugs.webkit.org/show_bug.cgi?id=74147), but that causes
@@ skipping 674 matching lines @@
 
   // At this point, we think the point does hit the touch event handler region on the layer, but we need to walk up
   // the parents to ensure that the layer was not clipped in such a way that the
   // hit point actually should not hit the layer.
   if (pointIsClippedBySurfaceOrClipRect(screenSpacePoint, layerImpl))
      return false;
 
   return true;
 }
 }  // namespace cc