Mark layers that can use LCD text based on layer transform and opacity.

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 390 matching lines @@
         replicaMaskLayer->setContentsScale(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)
+    LayerSorter* layerSorter, int maxTextureSize, float deviceScaleFactor, float pageScaleFactor, bool subtreeCanUseLCDText,
+    gfx::Rect& 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 80 matching lines @@
     // As this function proceeds, these are the properties for the current
     // layer that actually get computed. To avoid unnecessary copies
     // (particularly for matrices), we do computations directly on these values
     // when possible.
     DrawProperties<LayerType, RenderSurfaceType>& layerDrawProperties = layer->drawProperties();
 
     gfx::Rect clipRectForSubtree;
     bool subtreeShouldBeClipped = false;
 
     float accumulatedDrawOpacity = layer->opacity();
-    bool drawOpacityIsAnimating = layer->opacityIsAnimating();
+    bool animatingOpacityToTarget = layer->opacityIsAnimating();
+    bool animatingOpacityToScreen = animatingOpacityToTarget;
     if (layer->parent()) {
         accumulatedDrawOpacity *= layer->parent()->drawOpacity();
-        drawOpacityIsAnimating |= layer->parent()->drawOpacityIsAnimating();
+        animatingOpacityToTarget |= layer->parent()->drawOpacityIsAnimating();
+        animatingOpacityToScreen |= layer->parent()->screenSpaceOpacityIsAnimating();
     }
 
     bool animatingTransformToTarget = layer->transformIsAnimating();
     bool animatingTransformToScreen = animatingTransformToTarget;
     if (layer->parent()) {
         animatingTransformToTarget |= layer->parent()->drawTransformIsAnimating();
         animatingTransformToScreen |= layer->parent()->screenSpaceTransformIsAnimating();
     }
 
     gfx::Size bounds = layer->bounds();
@@ skipping 31 matching lines @@
     layerDrawProperties.target_space_transform = combinedTransform;
     // M[draw] = M[parent] * LT * S[layer2content]
     layerDrawProperties.target_space_transform.Scale(1.0 / layer->contentsScaleX(), 1.0 / layer->contentsScaleY());
 
     // layerScreenSpaceTransform represents the transform between root layer's "screen space" and local content space.
     layerDrawProperties.screen_space_transform = fullHierarchyMatrix;
     if (!layer->preserves3D())
         MathUtil::flattenTransformTo2d(layerDrawProperties.screen_space_transform);
     layerDrawProperties.screen_space_transform.PreconcatTransform(layerDrawProperties.target_space_transform);
 
+    // Adjusting text AA method during animation may cause repaints, which in-turn causes jank.
+    bool adjustTextAA = !animatingOpacityToScreen && !animatingTransformToScreen;
+    // To avoid color fringing, LCD text should only be used on opaque layers with just integral translation.
+    bool layerCanUseLCDText = subtreeCanUseLCDText &&
+                              (accumulatedDrawOpacity == 1.0) &&
+                              layerDrawProperties.target_space_transform.IsIdentityOrIntegerTranslation();
+
     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.
     gfx::Transform nextHierarchyMatrix = fullHierarchyMatrix;
     gfx::Transform sublayerMatrix;
 
     gfx::Vector2dF renderSurfaceSublayerScale = MathUtil::computeTransform2dScaleComponents(combinedTransform);
 
     if (subtreeShouldRenderToSeparateSurface(layer, combinedTransform.IsScaleOrTranslation())) {
@@ skipping 20 matching lines @@
         layerDrawProperties.target_space_transform.Scale(renderSurfaceSublayerScale.x() / layer->contentsScaleX(), renderSurfaceSublayerScale.y() / layer->contentsScaleY());
 
         // 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.
         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(accumulatedDrawOpacity);
-        renderSurface->setDrawOpacityIsAnimating(drawOpacityIsAnimating);
+        renderSurface->setDrawOpacityIsAnimating(animatingOpacityToTarget);
+        animatingOpacityToTarget = false;
         layerDrawProperties.opacity = 1;
-        layerDrawProperties.opacity_is_animating = false;
+        layerDrawProperties.opacity_is_animating = animatingOpacityToTarget;
+        layerDrawProperties.screen_space_opacity_is_animating = animatingOpacityToScreen;
 
         renderSurface->setTargetSurfaceTransformsAreAnimating(animatingTransformToTarget);
         renderSurface->setScreenSpaceTransformsAreAnimating(animatingTransformToScreen);
         animatingTransformToTarget = false;
         layerDrawProperties.target_space_transform_is_animating = animatingTransformToTarget;
         layerDrawProperties.screen_space_transform_is_animating = animatingTransformToScreen;
 
         // Update the aggregate hierarchy matrix to include the transform of the
         // newly created RenderSurfaceImpl.
         nextHierarchyMatrix.PreconcatTransform(renderSurface->drawTransform());
@@ skipping 23 matching lines @@
 
         // The render surface clipRect is expressed in the space where this surface draws, i.e. the same space as clipRectFromAncestor.
         renderSurface->setIsClipped(ancestorClipsSubtree);
         if (ancestorClipsSubtree)
             renderSurface->setClipRect(clipRectFromAncestor);
         else
             renderSurface->setClipRect(gfx::Rect());
 
         renderSurface->setNearestAncestorThatMovesPixels(nearestAncestorThatMovesPixels);
 
+        // If the new render surface is drawn translucent or with a non-integral translation
+        // then the subtree that gets drawn on this render surface cannot use LCD text.
+        subtreeCanUseLCDText = layerCanUseLCDText;
+
         renderSurfaceLayerList.push_back(layer);
     } else {
         DCHECK(layer->parent());
 
         // Note: layerDrawProperties.target_space_transform is computed above,
         // before this if-else statement.
         layerDrawProperties.target_space_transform_is_animating = animatingTransformToTarget;
         layerDrawProperties.screen_space_transform_is_animating = animatingTransformToScreen;
         layerDrawProperties.opacity = accumulatedDrawOpacity;
-        layerDrawProperties.opacity_is_animating = drawOpacityIsAnimating;
+        layerDrawProperties.opacity_is_animating = animatingOpacityToTarget;
+        layerDrawProperties.screen_space_opacity_is_animating = animatingOpacityToScreen;
         sublayerMatrix = combinedTransform;
 
         layer->clearRenderSurface();
 
         // Layers without renderSurfaces directly inherit the ancestor's clip status.
         subtreeShouldBeClipped = ancestorClipsSubtree;
         if (ancestorClipsSubtree)
             clipRectForSubtree = clipRectFromAncestor;
 
         // Layers that are not their own renderTarget will render into the target of their nearest ancestor.
         layerDrawProperties.render_target = layer->parent()->renderTarget();
     }
 
+    if (adjustTextAA)
+        layer->setCanUseLCDText(layerCanUseLCDText);
+
     gfx::Rect rectInTargetSpace = ToEnclosingRect(MathUtil::mapClippedRect(layer->drawTransform(), contentRect));
 
     if (layerClipsSubtree(layer)) {
         subtreeShouldBeClipped = true;
         if (ancestorClipsSubtree && !layer->renderSurface()) {
             clipRectForSubtree = clipRectFromAncestor;
             clipRectForSubtree.Intersect(rectInTargetSpace);
         } else
             clipRectForSubtree = rectInTargetSpace;
     }
@@ skipping 18 matching lines @@
         descendants.push_back(layer);
 
     gfx::Transform nextScrollCompensationMatrix = computeScrollCompensationMatrixForChildren(layer, parentMatrix, currentScrollCompensationMatrix);;
 
     gfx::Rect accumulatedDrawableContentRectOfChildren;
     for (size_t i = 0; i < layer->children().size(); ++i) {
         LayerType* child = LayerTreeHostCommon::getChildAsRawPtr(layer->children(), i);
         gfx::Rect drawableContentRectOfChildSubtree;
         calculateDrawPropertiesInternal<LayerType, LayerList, RenderSurfaceType>(child, sublayerMatrix, nextHierarchyMatrix, nextScrollCompensationMatrix,
                                                                                  clipRectForSubtree, subtreeShouldBeClipped, nearestAncestorThatMovesPixels,
-                                                                                 renderSurfaceLayerList, descendants, layerSorter, maxTextureSize, deviceScaleFactor, pageScaleFactor, drawableContentRectOfChildSubtree);
+                                                                                 renderSurfaceLayerList, descendants, layerSorter, maxTextureSize, deviceScaleFactor, pageScaleFactor,
+                                                                                 subtreeCanUseLCDText, drawableContentRectOfChildSubtree);
         if (!drawableContentRectOfChildSubtree.IsEmpty()) {
             accumulatedDrawableContentRectOfChildren.Union(drawableContentRectOfChildSubtree);
             if (child->renderSurface())
                 descendants.push_back(child);
         }
     }
 
     // Compute the total drawableContentRect for this subtree (the rect is in targetSurface space)
     gfx::Rect localDrawableContentRectOfSubtree = accumulatedDrawableContentRectOfChildren;
     if (layer->drawsContent())
@@ skipping 109 matching lines @@
 
     if (layer->renderSurface())
         drawableContentRectOfSubtree = gfx::ToEnclosingRect(layer->renderSurface()->drawableContentRect());
     else
         drawableContentRectOfSubtree = localDrawableContentRectOfSubtree;
 
     if (layer->hasContributingDelegatedRenderPasses())
         layer->renderTarget()->renderSurface()->addContributingDelegatedRenderPassLayer(layer);
 }
 
-void LayerTreeHostCommon::calculateDrawProperties(Layer* rootLayer, const gfx::Size& deviceViewportSize, float deviceScaleFactor, float pageScaleFactor, int maxTextureSize, std::vector<scoped_refptr<Layer> >& renderSurfaceLayerList)
+void LayerTreeHostCommon::calculateDrawProperties(Layer* rootLayer, const gfx::Size& deviceViewportSize, float deviceScaleFactor, float pageScaleFactor, int maxTextureSize, bool canUseLCDText, std::vector<scoped_refptr<Layer> >& renderSurfaceLayerList)
 {
     gfx::Rect totalDrawableContentRect;
     gfx::Transform identityMatrix;
     gfx::Transform deviceScaleTransform;
     deviceScaleTransform.Scale(deviceScaleFactor, deviceScaleFactor);
     std::vector<scoped_refptr<Layer> > dummyLayerList;
 
     // The root layer's renderSurface should receive the deviceViewport as the initial clipRect.
     bool subtreeShouldBeClipped = true;
     gfx::Rect deviceViewportRect(gfx::Point(), deviceViewportSize);
 
     // This function should have received a root layer.
     DCHECK(isRootLayer(rootLayer));
 
     cc::calculateDrawPropertiesInternal<Layer, std::vector<scoped_refptr<Layer> >, RenderSurface>(
         rootLayer, deviceScaleTransform, identityMatrix, identityMatrix,
         deviceViewportRect, subtreeShouldBeClipped, 0, renderSurfaceLayerList,
         dummyLayerList, 0, maxTextureSize,
-        deviceScaleFactor, pageScaleFactor, totalDrawableContentRect);
+        deviceScaleFactor, pageScaleFactor, canUseLCDText, totalDrawableContentRect);
 
     // The dummy layer list should not have been used.
     DCHECK(dummyLayerList.size() == 0);
     // A root layer renderSurface should always exist after calculateDrawProperties.
     DCHECK(rootLayer->renderSurface());
 }
 
-void LayerTreeHostCommon::calculateDrawProperties(LayerImpl* rootLayer, const gfx::Size& deviceViewportSize, float deviceScaleFactor, float pageScaleFactor, int maxTextureSize, std::vector<LayerImpl*>& renderSurfaceLayerList)
+void LayerTreeHostCommon::calculateDrawProperties(LayerImpl* rootLayer, const gfx::Size& deviceViewportSize, float deviceScaleFactor, float pageScaleFactor, int maxTextureSize, bool canUseLCDText, std::vector<LayerImpl*>& renderSurfaceLayerList)
 {
     gfx::Rect totalDrawableContentRect;
     gfx::Transform identityMatrix;
     gfx::Transform deviceScaleTransform;
     deviceScaleTransform.Scale(deviceScaleFactor, deviceScaleFactor);
     std::vector<LayerImpl*> dummyLayerList;
     LayerSorter layerSorter;
     
     // The root layer's renderSurface should receive the deviceViewport as the initial clipRect.
     bool subtreeShouldBeClipped = true;
     gfx::Rect deviceViewportRect(gfx::Point(), deviceViewportSize);
 
     // This function should have received a root layer.
     DCHECK(isRootLayer(rootLayer));
 
     cc::calculateDrawPropertiesInternal<LayerImpl, std::vector<LayerImpl*>, RenderSurfaceImpl>(
         rootLayer, deviceScaleTransform, identityMatrix, identityMatrix,
         deviceViewportRect, subtreeShouldBeClipped, 0, renderSurfaceLayerList,
         dummyLayerList, &layerSorter, maxTextureSize,
-        deviceScaleFactor, pageScaleFactor, totalDrawableContentRect);
+        deviceScaleFactor, pageScaleFactor, canUseLCDText, totalDrawableContentRect);
 
     // The dummy layer list should not have been used.
     DCHECK(dummyLayerList.size() == 0);
     // A root layer renderSurface should always exist after calculateDrawProperties.
     DCHECK(rootLayer->renderSurface());
 }
 
 static bool pointHitsRect(const gfx::PointF& screenSpacePoint, const gfx::Transform& localSpaceToScreenSpaceTransform, gfx::RectF localSpaceRect)
 {
     // If the transform is not invertible, then assume that this point doesn't hit this rect.
@@ skipping 111 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