cc: Apply the layer's initial CSS scale to the contentsScale to render text at the right resolution.

cc/CCLayerTreeHostCommon.cpp

 // 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 "CCLayerTreeHostCommon.h"
 
 #include "CCLayerImpl.h"
@@ skipping 315 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 = layer->renderSurface()->drawTransform().inverse() * nextScrollCompensationMatrix * layer->renderSurface()->drawTransform();
 
     return nextScrollCompensationMatrix;
 }
 
+// There is no contentsScale on impl thread.
+static inline void updateLayerContentsScale(CCLayerImpl*, const WebTransformationMatrix&, float, float) { }
+
+static inline void updateLayerContentsScale(LayerChromium* layer, const WebTransformationMatrix& combinedTransform, float deviceScaleFactor, float pageScaleFactor)
+{
+    float cssScale = layer->initialCssScale();
+    if (!cssScale) {
+        FloatPoint transformScale = CCMathUtil::computeTransform2dScaleComponents(combinedTransform);
+        float combinedScale = fmaxf(transformScale.x(), transformScale.y());
+        cssScale = combinedScale / deviceScaleFactor;
+        if (!layer->boundsContainPageScale())
+            cssScale /= pageScaleFactor;
+        layer->setInitialCssScale(cssScale);
+    }
+
+    float contentsScale = cssScale * deviceScaleFactor;
+    if (!layer->boundsContainPageScale())
+        contentsScale *= pageScaleFactor;
+    layer->setContentsScale(contentsScale);
+
+    LayerChromium* maskLayer = layer->maskLayer();
+    if (maskLayer)
+        maskLayer->setContentsScale(contentsScale);
+
+    LayerChromium* replicaMaskLayer = layer->replicaLayer() ? layer->replicaLayer()->maskLayer() : 0;
+    if (replicaMaskLayer)
+        replicaMaskLayer->setContentsScale(contentsScale);
+}
+
 // Should be called just before the recursive calculateDrawTransformsInternal().
 template<typename LayerType, typename LayerList>
 void setupRootLayerAndSurfaceForRecursion(LayerType* rootLayer, LayerList& renderSurfaceLayerList, const IntSize& deviceViewportSize)
 {
     if (!rootLayer->renderSurface())
         rootLayer->createRenderSurface();
 
     rootLayer->renderSurface()->setContentRect(IntRect(IntPoint::zero(), deviceViewportSize));
     rootLayer->renderSurface()->clearLayerLists();
 
     ASSERT(renderSurfaceLayerList.isEmpty());
     renderSurfaceLayerList.append(rootLayer);
 }
 
 // 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, typename LayerSorter>
 static void calculateDrawTransformsInternal(LayerType* layer, LayerType* rootLayer, const WebTransformationMatrix& parentMatrix,
     const WebTransformationMatrix& fullHierarchyMatrix, const WebTransformationMatrix& currentScrollCompensationMatrix,
     const IntRect& clipRectFromAncestor, bool ancestorClipsSubtree,
     RenderSurfaceType* nearestAncestorThatMovesPixels, LayerList& renderSurfaceLayerList, LayerList& layerList,
-    LayerSorter* layerSorter, int maxTextureSize, float deviceScaleFactor, IntRect& drawableContentRectOfSubtree)
+    LayerSorter* layerSorter, int maxTextureSize, float deviceScaleFactor, float pageScaleFactor, IntRect& drawableContentRectOfSubtree)
 {
     // This function computes the new matrix transformations recursively for this
     // layer and all its descendants. It also computes the appropriate render surfaces.
     // Some important points to remember:
     //
     // 0. Here, transforms are notated in Matrix x Vector order, and in words we describe what
     //    the transform does from left to right.
     //
     // 1. In our terminology, the "layer origin" refers to the top-left corner of a layer, and the
     //    positive Y-axis points downwards. This interpretation is valid because the orthographic
@@ skipping 112 matching lines @@
     WebTransformationMatrix combinedTransform = parentMatrix;
     combinedTransform.multiply(layerLocalTransform);
 
     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 layer's contentsSize is determined from the combinedTransform, which then informs the
+    // layer's drawTransform.
+    updateLayerContentsScale(layer, combinedTransform, deviceScaleFactor, pageScaleFactor);
+
     // 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;
     // M[draw] = M[parent] * LT * Tr[anchor2center] * Tr[center2origin]
     drawTransform.translate(-layer->bounds().width() / 2.0, -layer->bounds().height() / 2.0);
     if (!layer->contentBounds().isEmpty() && !layer->bounds().isEmpty()) {
         // M[draw] = M[parent] * LT * Tr[anchor2origin] * S[layer2content]
         drawTransform.scaleNonUniform(layer->bounds().width() / static_cast<double>(layer->contentBounds().width()),
                                       layer->bounds().height() / static_cast<double>(layer->contentBounds().height()));
     }
@@ skipping 23 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 origin of the new surface is the upper left corner of the layer.
+        // The origin of the new surface is the upper left corner of the layer. The contents of the
+        // the render surface match the scale of the owning layer.
         renderSurface->setDrawTransform(drawTransform);
         WebTransformationMatrix layerDrawTransform;
-        layerDrawTransform.scale(deviceScaleFactor);

[enne (OOO), 2012/10/03 19:52:38]

This block of code is highly intentional.

The "contentsScale" of the render surface should not always be equal to the
contentsScale of the owning layer.  What if the owning layer is a video and
doesn't needContentsScale(), but DSF != 1? What if the owning layer is an image
layer with gigantic contentBounds() but tiny bounds()?

This line right here is basically saying "If this surface were drawn with an
identity transform, the pixels in this surface are 1:1 with device pixels."

My intention was that in the future we could adjust this so that we could scale
the content size of the surface based on the amount of pixels that it actually
takes up to dynamically make better memory/quality trade-offs.

Can you add a unit test where the contentBounds / bounds ratio of a layer is
*not* the scale that we want to create the surface at?

-        if (!layer->contentBounds().isEmpty() && !layer->bounds().isEmpty()) {
-            layerDrawTransform.scaleNonUniform(layer->bounds().width() / static_cast<double>(layer->contentBounds().width()),
-                                               layer->bounds().height() / static_cast<double>(layer->contentBounds().height()));
-        }
         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();
-        sublayerMatrix.scale(deviceScaleFactor);
+        if (!layer->contentBounds().isEmpty() && !layer->bounds().isEmpty()) {
+            sublayerMatrix.scaleNonUniform(layer->contentBounds().width() / static_cast<double>(layer->bounds().width()),
+                                           layer->contentBounds().height() / static_cast<double>(layer->bounds().height()));
+        }
         sublayerMatrix.translate(0.5 * bounds.width(), 0.5 * bounds.height());
 
         // 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 83 matching lines @@
         descendants.append(layer);
 
     WebTransformationMatrix nextScrollCompensationMatrix = computeScrollCompensationMatrixForChildren(layer, parentMatrix, currentScrollCompensationMatrix);;
 
     IntRect accumulatedDrawableContentRectOfChildren;
     for (size_t i = 0; i < layer->children().size(); ++i) {
         LayerType* child = CCLayerTreeHostCommon::getChildAsRawPtr(layer->children(), i);
         IntRect drawableContentRectOfChildSubtree;
         calculateDrawTransformsInternal<LayerType, LayerList, RenderSurfaceType, LayerSorter>(child, rootLayer, sublayerMatrix, nextHierarchyMatrix, nextScrollCompensationMatrix,
                                                                                               clipRectForSubtree, subtreeShouldBeClipped, nearestAncestorThatMovesPixels,
-                                                                                              renderSurfaceLayerList, descendants, layerSorter, maxTextureSize, deviceScaleFactor, drawableContentRectOfChildSubtree);
+                                                                                              renderSurfaceLayerList, descendants, layerSorter, maxTextureSize, deviceScaleFactor, pageScaleFactor, drawableContentRectOfChildSubtree);
         if (!drawableContentRectOfChildSubtree.isEmpty()) {
             accumulatedDrawableContentRectOfChildren.unite(drawableContentRectOfChildSubtree);
             if (child->renderSurface())
                 descendants.append(child);
         }
     }
 
     // Compute the total drawableContentRect for this subtree (the rect is in targetSurface space)
     IntRect localDrawableContentRectOfSubtree = accumulatedDrawableContentRectOfChildren;
     if (layer->drawsContent())
@@ skipping 36 matching lines @@
         clippedContentRect.setHeight(std::min(clippedContentRect.height(), maxTextureSize));
 
         if (clippedContentRect.isEmpty())
             renderSurface->clearLayerLists();
 
         renderSurface->setContentRect(clippedContentRect);
         renderSurface->setScreenSpaceTransform(layer->screenSpaceTransform());
 
         if (layer->replicaLayer()) {
             WebTransformationMatrix surfaceOriginToReplicaOriginTransform;
-            surfaceOriginToReplicaOriginTransform.scale(deviceScaleFactor);
+            if (!layer->contentBounds().isEmpty() && !layer->bounds().isEmpty()) {
+                surfaceOriginToReplicaOriginTransform.scaleNonUniform(layer->contentBounds().width() / static_cast<double>(layer->bounds().width()),
+                                                                      layer->contentBounds().height() / static_cast<double>(layer->bounds().height()));
+            }
+
             surfaceOriginToReplicaOriginTransform.translate(layer->replicaLayer()->position().x() + layer->replicaLayer()->anchorPoint().x() * bounds.width(),
                                                             layer->replicaLayer()->position().y() + layer->replicaLayer()->anchorPoint().y() * bounds.height());
             surfaceOriginToReplicaOriginTransform.multiply(layer->replicaLayer()->transform());
             surfaceOriginToReplicaOriginTransform.translate(-layer->replicaLayer()->anchorPoint().x() * bounds.width(), -layer->replicaLayer()->anchorPoint().y() * bounds.height());
-            surfaceOriginToReplicaOriginTransform.scale(1 / deviceScaleFactor);
+
+            if (!layer->contentBounds().isEmpty() && !layer->bounds().isEmpty()) {
+                surfaceOriginToReplicaOriginTransform.scaleNonUniform(layer->bounds().width() / static_cast<double>(layer->contentBounds().width()),
+                                                                      layer->bounds().height() / static_cast<double>(layer->contentBounds().height()));
+            }
 
             // Compute the replica's "originTransform" that maps from the replica's origin space to the target surface origin space.
             WebTransformationMatrix replicaOriginTransform = layer->renderSurface()->drawTransform() * surfaceOriginToReplicaOriginTransform;
             renderSurface->setReplicaDrawTransform(replicaOriginTransform);
 
             // Compute the replica's "screenSpaceTransform" that maps from the replica's origin space to the screen's origin space.
             WebTransformationMatrix replicaScreenSpaceTransform = layer->renderSurface()->screenSpaceTransform() * surfaceOriginToReplicaOriginTransform;
             renderSurface->setReplicaScreenSpaceTransform(replicaScreenSpaceTransform);
         }
 
@@ skipping 52 matching lines @@
             LayerType* replicaMaskLayer = it->replicaLayer() ? it->replicaLayer()->maskLayer() : 0;
             if (replicaMaskLayer)
                 replicaMaskLayer->setVisibleContentRect(IntRect(IntPoint(), it->contentBounds()));
         } else if (it.representsItself()) {
             IntRect visibleContentRect = calculateVisibleContentRect(*it);
             it->setVisibleContentRect(visibleContentRect);
         }
     }
 }
 
-void CCLayerTreeHostCommon::calculateDrawTransforms(LayerChromium* rootLayer, const IntSize& deviceViewportSize, float deviceScaleFactor, int maxTextureSize, Vector<RefPtr<LayerChromium> >& renderSurfaceLayerList)
+void CCLayerTreeHostCommon::calculateDrawTransforms(LayerChromium* rootLayer, const IntSize& deviceViewportSize, float deviceScaleFactor, float pageScaleFactor, int maxTextureSize, Vector<RefPtr<LayerChromium> >& renderSurfaceLayerList)
 {
     IntRect totalDrawableContentRect;
     WebTransformationMatrix identityMatrix;
     WebTransformationMatrix deviceScaleTransform;
     deviceScaleTransform.scale(deviceScaleFactor);
 
     setupRootLayerAndSurfaceForRecursion<LayerChromium, Vector<RefPtr<LayerChromium> > >(rootLayer, renderSurfaceLayerList, deviceViewportSize);
 
     cc::calculateDrawTransformsInternal<LayerChromium, Vector<RefPtr<LayerChromium> >, RenderSurfaceChromium, void>(rootLayer, rootLayer, deviceScaleTransform, identityMatrix, identityMatrix,
-                                                                                                                         rootLayer->renderSurface()->contentRect(), true, 0, renderSurfaceLayerList,
-                                                                                                                         rootLayer->renderSurface()->layerList(), 0, maxTextureSize, deviceScaleFactor, totalDrawableContentRect);
+                                                                                                                    rootLayer->renderSurface()->contentRect(), true, 0, renderSurfaceLayerList,
+                                                                                                                    rootLayer->renderSurface()->layerList(), 0, maxTextureSize, deviceScaleFactor, pageScaleFactor, totalDrawableContentRect);
 }
 
-void CCLayerTreeHostCommon::calculateDrawTransforms(CCLayerImpl* rootLayer, const IntSize& deviceViewportSize, float deviceScaleFactor, CCLayerSorter* layerSorter, int maxTextureSize, Vector<CCLayerImpl*>& renderSurfaceLayerList)
+void CCLayerTreeHostCommon::calculateDrawTransforms(CCLayerImpl* rootLayer, const IntSize& deviceViewportSize, float deviceScaleFactor, float pageScaleFactor, CCLayerSorter* layerSorter, int maxTextureSize, Vector<CCLayerImpl*>& renderSurfaceLayerList)
 {
     IntRect totalDrawableContentRect;
     WebTransformationMatrix identityMatrix;
     WebTransformationMatrix deviceScaleTransform;
     deviceScaleTransform.scale(deviceScaleFactor);
 
     setupRootLayerAndSurfaceForRecursion<CCLayerImpl, Vector<CCLayerImpl*> >(rootLayer, renderSurfaceLayerList, deviceViewportSize);
 
     cc::calculateDrawTransformsInternal<CCLayerImpl, Vector<CCLayerImpl*>, CCRenderSurface, CCLayerSorter>(rootLayer, rootLayer, deviceScaleTransform, identityMatrix, identityMatrix,
-                                                                                                                rootLayer->renderSurface()->contentRect(), true, 0, renderSurfaceLayerList,
-                                                                                                                rootLayer->renderSurface()->layerList(), layerSorter, maxTextureSize, deviceScaleFactor, totalDrawableContentRect);
+                                                                                                           rootLayer->renderSurface()->contentRect(), true, 0, renderSurfaceLayerList,
+                                                                                                           rootLayer->renderSurface()->layerList(), layerSorter, maxTextureSize, deviceScaleFactor, pageScaleFactor, totalDrawableContentRect);
 }
 
 void CCLayerTreeHostCommon::calculateVisibleRects(Vector<RefPtr<LayerChromium> >& renderSurfaceLayerList)
 {
     calculateVisibleRectsInternal<LayerChromium, Vector<RefPtr<LayerChromium> >, RenderSurfaceChromium>(renderSurfaceLayerList);
 }
 
 void CCLayerTreeHostCommon::calculateVisibleRects(Vector<CCLayerImpl*>& renderSurfaceLayerList)
 {
     calculateVisibleRectsInternal<CCLayerImpl, Vector<CCLayerImpl*>, CCRenderSurface>(renderSurfaceLayerList);
@@ skipping 64 matching lines @@
 
         foundLayer = currentLayer;
         break;
     }
 
     // This can potentially return 0, which means the viewportPoint did not successfully hit test any layers, not even the root layer.
     return foundLayer;
 }
 
 } // namespace cc