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

cc/layer.cc

 // Copyright 2010 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.h"
 
 #include "cc/active_animation.h"
 #include "cc/animation_events.h"
 #include "cc/layer_animation_controller.h"
 #include "cc/layer_impl.h"
@@ skipping 30 matching lines @@
     , m_anchorPoint(0.5, 0.5)
     , m_backgroundColor(0)
     , m_opacity(1.0)
     , m_anchorPointZ(0)
     , m_isContainerForFixedPositionLayers(false)
     , m_fixedToContainerLayer(false)
     , m_isDrawable(false)
     , m_masksToBounds(false)
     , m_contentsOpaque(false)
     , m_doubleSided(true)
-    , m_useLCDText(false)
+    , m_canUseLCDText(false)
     , m_preserves3D(false)
     , m_useParentBackfaceVisibility(false)
     , m_drawCheckerboardForMissingTiles(false)
     , m_forceRenderSurface(false)
     , m_replicaLayer(0)
     , m_rasterScale(1.0)
     , m_automaticallyComputeRasterScale(false)
     , m_boundsContainPageScale(false)
     , m_layerAnimationDelegate(0)
     , m_layerScrollClient(0)
 {
     if (m_layerId < 0) {
         s_nextLayerId = 1;
         m_layerId = s_nextLayerId++;
     }
 }
 
 Layer::~Layer()
 {
     // Our parent should be holding a reference to us so there should be no
     // way for us to be destroyed while we still have a parent.
     DCHECK(!parent());
 
     // Remove the parent reference from all children.
     removeAllChildren();
 }
 
-void Layer::setUseLCDText(bool useLCDText)
+void Layer::setCanUseLCDText(bool useLCDText)
 {
-    m_useLCDText = useLCDText;
+    if (m_canUseLCDText == useLCDText)
+        return;
+
+    if (!canUseLCDTextWillChange())
+        return;
+
+    m_canUseLCDText = useLCDText;
+    canUseLCDTextDidChange();
 }
 
 void Layer::setLayerTreeHost(LayerTreeHost* host)
 {
     if (m_layerTreeHost == host)
         return;
 
     m_layerTreeHost = host;
 
     for (size_t i = 0; i < m_children.size(); ++i)
@@ skipping 14 matching lines @@
     if (m_layerTreeHost)
         m_layerTreeHost->setNeedsCommit();
 }
 
 void Layer::setNeedsFullTreeSync()
 {
     if (m_layerTreeHost)
         m_layerTreeHost->setNeedsFullTreeSync();
 }
 
+bool Layer::canUseLCDTextWillChange()
+{
+    return true;
+}
+
 gfx::Rect Layer::layerRectToContentRect(const gfx::RectF& layerRect) const
 {
     gfx::RectF contentRect = gfx::ScaleRect(layerRect, contentsScaleX(), contentsScaleY());
     // Intersect with content rect to avoid the extra pixel because for some
     // values x and y, ceil((x / y) * y) may be x + 1.
     contentRect.Intersect(gfx::Rect(gfx::Point(), contentBounds()));
     return gfx::ToEnclosingRect(contentRect);
 }
 
 bool Layer::blocksPendingCommit() const
@@ skipping 434 matching lines @@
     layer->setContentBounds(contentBounds());
     layer->setContentsScale(contentsScaleX(), contentsScaleY());
     layer->setDebugName(m_debugName);
     layer->setDoubleSided(m_doubleSided);
     layer->setDrawCheckerboardForMissingTiles(m_drawCheckerboardForMissingTiles);
     layer->setForceRenderSurface(m_forceRenderSurface);
     layer->setDrawsContent(drawsContent());
     layer->setFilters(filters());
     layer->setFilter(filter());
     layer->setBackgroundFilters(backgroundFilters());
-    layer->setUseLCDText(m_useLCDText);
+    layer->setCanUseLCDText(m_canUseLCDText);
     layer->setMasksToBounds(m_masksToBounds);
     layer->setScrollable(m_scrollable);
     layer->setShouldScrollOnMainThread(m_shouldScrollOnMainThread);
     layer->setHaveWheelEventHandlers(m_haveWheelEventHandlers);
     // Copying a Region is more expensive than most layer properties, since it involves copying two Vectors that may be
     // arbitrarily large depending on page content, so we only push the property if it's changed.
     if (m_nonFastScrollableRegionChanged) {
         layer->setNonFastScrollableRegion(m_nonFastScrollableRegion);
         m_nonFastScrollableRegionChanged = false;
     }
@@ skipping 259 matching lines @@
 {
     return 0;
 }
 
 void sortLayers(std::vector<scoped_refptr<Layer> >::iterator, std::vector<scoped_refptr<Layer> >::iterator, void*)
 {
     // Currently we don't use z-order to decide what to paint, so there's no need to actually sort Layers.
 }
 
 }  // namespace cc