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

cc/layer_impl.h

 // 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.
 
 #ifndef CC_LAYER_IMPL_H_
 #define CC_LAYER_IMPL_H_
 
 #include <string>
 
 #include "base/logging.h"
@@ skipping 121 matching lines @@
 
     void setFixedToContainerLayer(bool fixedToContainerLayer = true) { m_fixedToContainerLayer = fixedToContainerLayer;}
     bool fixedToContainerLayer() const { return m_fixedToContainerLayer; }
 
     void setPreserves3D(bool);
     bool preserves3D() const { return m_preserves3D; }
 
     void setUseParentBackfaceVisibility(bool useParentBackfaceVisibility) { m_useParentBackfaceVisibility = useParentBackfaceVisibility; }
     bool useParentBackfaceVisibility() const { return m_useParentBackfaceVisibility; }
 
-    void setUseLCDText(bool useLCDText) { m_useLCDText = useLCDText; }
-    bool useLCDText() const { return m_useLCDText; }
+    void setCanUseLCDText(bool useLCDText) { m_canUseLCDText = useLCDText; }
+    bool useCanLCDText() const { return m_canUseLCDText; }
 
     void setSublayerTransform(const WebKit::WebTransformationMatrix&);
     const WebKit::WebTransformationMatrix& sublayerTransform() const { return m_sublayerTransform; }
 
     // Debug layer border - visual effect only, do not change geometry/clipping/etc.
     void setDebugBorderColor(SkColor);
     SkColor debugBorderColor() const { return m_debugBorderColor; }
     void setDebugBorderWidth(float);
     float debugBorderWidth() const { return m_debugBorderWidth; }
     bool hasDebugBorders() const;
 
     // Debug layer name.
     void setDebugName(const std::string& debugName) { m_debugName = debugName; }
     std::string debugName() const { return m_debugName; }
 
     RenderSurfaceImpl* renderSurface() const { return m_renderSurface.get(); }
     void createRenderSurface();
     void clearRenderSurface() { m_renderSurface.reset(); }
 
     float drawOpacity() const { return m_drawOpacity; }
     void setDrawOpacity(float opacity) { m_drawOpacity = opacity; }
 
     bool drawOpacityIsAnimating() const { return m_drawOpacityIsAnimating; }
     void setDrawOpacityIsAnimating(bool drawOpacityIsAnimating) { m_drawOpacityIsAnimating = drawOpacityIsAnimating; }
+    bool screenSpaceOpacityIsAnimating() const { return m_screenSpaceOpacityIsAnimating; }
+    void setScreenSpaceOpacityIsAnimating(bool animating) { m_screenSpaceOpacityIsAnimating = animating; }
 
     LayerImpl* renderTarget() const { DCHECK(!m_renderTarget || m_renderTarget->renderSurface()); return m_renderTarget; }
     void setRenderTarget(LayerImpl* target) { m_renderTarget = target; }
 
     // The client should be responsible for setting bounds, contentBounds and
     // contentsScale to appropriate values. LayerImpl doesn't calculate any of
     // them from the other values.
 
     void setBounds(const gfx::Size&);
     const gfx::Size& bounds() const { return m_bounds; }
@@ skipping 163 matching lines @@
     gfx::Rect m_visibleContentRect;
     bool m_masksToBounds;
     bool m_contentsOpaque;
     float m_opacity;
     gfx::PointF m_position;
     bool m_preserves3D;
     bool m_useParentBackfaceVisibility;
     bool m_drawCheckerboardForMissingTiles;
     WebKit::WebTransformationMatrix m_sublayerTransform;
     WebKit::WebTransformationMatrix m_transform;
-    bool m_useLCDText;
+    bool m_canUseLCDText;
 
     bool m_drawsContent;
     bool m_forceRenderSurface;
 
     // Set for the layer that other layers are fixed to.
     bool m_isContainerForFixedPositionLayers;
     // This is true if the layer should be fixed to the closest ancestor container.
     bool m_fixedToContainerLayer;
 
     gfx::Vector2dF m_scrollDelta;
     gfx::Vector2d m_sentScrollDelta;
     gfx::Vector2d m_maxScrollOffset;
     WebKit::WebTransformationMatrix m_implTransform;
 
     // The layer whose coordinate space this layer draws into. This can be
     // either the same layer (m_renderTarget == this) or an ancestor of this
     // layer.
     LayerImpl* m_renderTarget;
 
     // The global depth value of the center of the layer. This value is used
     // to sort layers from back to front.
     float m_drawDepth;
     float m_drawOpacity;
     bool m_drawOpacityIsAnimating;
+    bool m_screenSpaceOpacityIsAnimating;
 
     // Debug borders.
     SkColor m_debugBorderColor;
     float m_debugBorderWidth;
 
     // Debug layer name.
     std::string m_debugName;
 
     WebKit::WebFilterOperations m_filters;
     WebKit::WebFilterOperations m_backgroundFilters;
@@ skipping 28 matching lines @@
     scoped_ptr<ScrollbarAnimationController> m_scrollbarAnimationController;
 
     DISALLOW_COPY_AND_ASSIGN(LayerImpl);
 };
 
 void sortLayers(std::vector<LayerImpl*>::iterator first, std::vector<LayerImpl*>::iterator end, LayerSorter*);
 
 }
 
 #endif  // CC_LAYER_IMPL_H_