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

cc/layer_tree_host_common_unittest.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 "cc/content_layer.h"
 #include "cc/content_layer_client.h"
 #include "cc/layer.h"
 #include "cc/layer_animation_controller.h"
@@ skipping 33 matching lines @@
     setLayerPropertiesForTestingInternal<Layer>(layer, transform, sublayerTransform, anchor, position, bounds, preserves3D);
     layer->setAutomaticallyComputeRasterScale(true);
 }
 
 void setLayerPropertiesForTesting(LayerImpl* layer, const gfx::Transform& transform, const gfx::Transform& sublayerTransform, const gfx::PointF& anchor, const gfx::PointF& position, const gfx::Size& bounds, bool preserves3D)
 {
     setLayerPropertiesForTestingInternal<LayerImpl>(layer, transform, sublayerTransform, anchor, position, bounds, preserves3D);
     layer->setContentBounds(bounds);
 }
 
-void executeCalculateDrawProperties(Layer* rootLayer, float deviceScaleFactor = 1, float pageScaleFactor = 1)
+void executeCalculateDrawProperties(Layer* rootLayer, float deviceScaleFactor = 1, float pageScaleFactor = 1, bool canUseLCDText = false)
 {
     gfx::Transform identityMatrix;
     std::vector<scoped_refptr<Layer> > dummyRenderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     gfx::Size deviceViewportSize = gfx::Size(rootLayer->bounds().width() * deviceScaleFactor, rootLayer->bounds().height() * deviceScaleFactor);
 
     // We are probably not testing what is intended if the rootLayer bounds are empty.
     DCHECK(!rootLayer->bounds().IsEmpty());
-    LayerTreeHostCommon::calculateDrawProperties(rootLayer, deviceViewportSize, deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, dummyRenderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(rootLayer, deviceViewportSize, deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, canUseLCDText, dummyRenderSurfaceLayerList);
 }
 
-void executeCalculateDrawProperties(LayerImpl* rootLayer, float deviceScaleFactor = 1, float pageScaleFactor = 1)
+void executeCalculateDrawProperties(LayerImpl* rootLayer, float deviceScaleFactor = 1, float pageScaleFactor = 1, bool canUseLCDText = false)
 {
     gfx::Transform identityMatrix;
     std::vector<LayerImpl*> dummyRenderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     gfx::Size deviceViewportSize = gfx::Size(rootLayer->bounds().width() * deviceScaleFactor, rootLayer->bounds().height() * deviceScaleFactor);
 
     // We are probably not testing what is intended if the rootLayer bounds are empty.
     DCHECK(!rootLayer->bounds().IsEmpty());
-    LayerTreeHostCommon::calculateDrawProperties(rootLayer, deviceViewportSize, deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, dummyRenderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(rootLayer, deviceViewportSize, deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, canUseLCDText, dummyRenderSurfaceLayerList);
 }
 
 scoped_ptr<LayerImpl> createTreeForFixedPositionTests(LayerTreeHostImpl* hostImpl)
 {
     scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl->activeTree(), 1);
     scoped_ptr<LayerImpl> child = LayerImpl::create(hostImpl->activeTree(), 2);
     scoped_ptr<LayerImpl> grandChild = LayerImpl::create(hostImpl->activeTree(), 3);
     scoped_ptr<LayerImpl> greatGrandChild = LayerImpl::create(hostImpl->activeTree(), 4);
 
     gfx::Transform IdentityMatrix;
@@ skipping 606 matching lines @@
     setLayerPropertiesForTesting(renderSurface1.get(), identityMatrix, identityMatrix, gfx::PointF(), gfx::PointF(), gfx::Size(10, 10), false);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, gfx::PointF(), gfx::PointF(30, 30), gfx::Size(10, 10), false);
 
     parent->addChild(renderSurface1);
     parent->setMasksToBounds(true);
     renderSurface1->addChild(child);
     renderSurface1->setForceRenderSurface(true);
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // The child layer's content is entirely outside the parent's clip rect, so the intermediate
     // render surface should not be listed here, even if it was forced to be created. Render surfaces without children or visible
     // content are unexpected at draw time (e.g. we might try to create a content texture of size 0).
     ASSERT_TRUE(parent->renderSurface());
     ASSERT_FALSE(renderSurface1->renderSurface());
     EXPECT_EQ(1U, renderSurfaceLayerList.size());
 }
 
 TEST(LayerTreeHostCommonTest, verifyRenderSurfaceListForTransparentChild)
 {
     scoped_refptr<Layer> parent = Layer::create();
     scoped_refptr<Layer> renderSurface1 = Layer::create();
     scoped_refptr<LayerWithForcedDrawsContent> child = make_scoped_refptr(new LayerWithForcedDrawsContent());
 
     const gfx::Transform identityMatrix;
     setLayerPropertiesForTesting(renderSurface1.get(), identityMatrix, identityMatrix, gfx::PointF(), gfx::PointF(), gfx::Size(10, 10), false);
     setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, gfx::PointF(), gfx::PointF(), gfx::Size(10, 10), false);
 
     parent->addChild(renderSurface1);
     renderSurface1->addChild(child);
     renderSurface1->setForceRenderSurface(true);
     renderSurface1->setOpacity(0);
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // Since the layer is transparent, renderSurface1->renderSurface() should not have gotten added anywhere.
     // Also, the drawable content rect should not have been extended by the children.
     ASSERT_TRUE(parent->renderSurface());
     EXPECT_EQ(0U, parent->renderSurface()->layerList().size());
     EXPECT_EQ(1U, renderSurfaceLayerList.size());
     EXPECT_EQ(parent->id(), renderSurfaceLayerList[0]->id());
     EXPECT_EQ(gfx::Rect(), parent->drawableContentRect());
 }
 
@@ skipping 11 matching lines @@
 
     parent->addChild(renderSurface1);
     renderSurface1->addChild(child);
 
     // Sanity check before the actual test
     EXPECT_FALSE(parent->renderSurface());
     EXPECT_FALSE(renderSurface1->renderSurface());
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // The root layer always creates a renderSurface
     EXPECT_TRUE(parent->renderSurface());
     EXPECT_TRUE(renderSurface1->renderSurface());
     EXPECT_EQ(2U, renderSurfaceLayerList.size());
 
     renderSurfaceLayerList.clear();
     renderSurface1->setForceRenderSurface(false);
-    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
     EXPECT_TRUE(parent->renderSurface());
     EXPECT_FALSE(renderSurface1->renderSurface());
     EXPECT_EQ(1U, renderSurfaceLayerList.size());
 }
 
 TEST(LayerTreeHostCommonTest, verifyScrollCompensationForFixedPositionLayerWithDirectContainer)
 {
     // This test checks for correct scroll compensation when the fixed-position container
     // is the direct parent of the fixed-position layer.
     FakeImplProxy proxy;
@@ skipping 594 matching lines @@
     setLayerPropertiesForTesting(leafNode2.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(20, 20), false);
 
     child->setMasksToBounds(true);
     child->setOpacity(0.4f);
     child->setForceRenderSurface(true);
     grandChild->setOpacity(0.5);
     greatGrandChild->setOpacity(0.4f);
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     ASSERT_EQ(2U, renderSurfaceLayerList.size());
     EXPECT_EQ(parent->id(), renderSurfaceLayerList[0]->id());
     EXPECT_EQ(child->id(), renderSurfaceLayerList[1]->id());
 }
 
 TEST(LayerTreeHostCommonTest, verifyClipRectCullsSurfaceWithoutVisibleContent)
 {
     // When a renderSurface has a clipRect, it is used to clip the contentRect
     // of the surface. When the renderSurface is animating its transforms, then
@@ skipping 26 matching lines @@
     setLayerPropertiesForTesting(leafNode.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(10, 10), false);
 
     parent->setMasksToBounds(true);
     child->setOpacity(0.4f);
     child->setForceRenderSurface(true);
     grandChild->setOpacity(0.4f);
     grandChild->setForceRenderSurface(true);
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // Without an animation, we should cull child and grandChild from the renderSurfaceLayerList.
     ASSERT_EQ(1U, renderSurfaceLayerList.size());
     EXPECT_EQ(parent->id(), renderSurfaceLayerList[0]->id());
 
     // Now put an animating transform on child.
     addAnimatedTransformToController(*child->layerAnimationController(), 10, 30, 0);
 
     parent->clearRenderSurface();
     child->clearRenderSurface();
     grandChild->clearRenderSurface();
     renderSurfaceLayerList.clear();
 
-    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // With an animating transform, we should keep child and grandChild in the renderSurfaceLayerList.
     ASSERT_EQ(3U, renderSurfaceLayerList.size());
     EXPECT_EQ(parent->id(), renderSurfaceLayerList[0]->id());
     EXPECT_EQ(child->id(), renderSurfaceLayerList[1]->id());
     EXPECT_EQ(grandChild->id(), renderSurfaceLayerList[2]->id());
 }
 
 TEST(LayerTreeHostCommonTest, verifyIsClippedIsSetCorrectly)
 {
@@ skipping 31 matching lines @@
     setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(child1.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(child2.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(grandChild.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(leafNode1.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(leafNode2.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
 
     // Case 1: nothing is clipped except the root renderSurface.
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(root.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     ASSERT_TRUE(root->renderSurface());
     ASSERT_TRUE(child2->renderSurface());
 
     EXPECT_FALSE(root->isClipped());
     EXPECT_TRUE(root->renderSurface()->isClipped());
     EXPECT_FALSE(parent->isClipped());
     EXPECT_FALSE(child1->isClipped());
     EXPECT_FALSE(child2->isClipped());
     EXPECT_FALSE(child2->renderSurface()->isClipped());
     EXPECT_FALSE(grandChild->isClipped());
     EXPECT_FALSE(leafNode1->isClipped());
     EXPECT_FALSE(leafNode2->isClipped());
 
     // Case 2: parent masksToBounds, so the parent, child1, and child2's
     // surface are clipped. But layers that contribute to child2's surface are
     // not clipped explicitly because child2's surface already accounts for
     // that clip.
     renderSurfaceLayerList.clear();
     parent->setMasksToBounds(true);
-    LayerTreeHostCommon::calculateDrawProperties(root.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     ASSERT_TRUE(root->renderSurface());
     ASSERT_TRUE(child2->renderSurface());
 
     EXPECT_FALSE(root->isClipped());
     EXPECT_TRUE(root->renderSurface()->isClipped());
     EXPECT_TRUE(parent->isClipped());
     EXPECT_TRUE(child1->isClipped());
     EXPECT_FALSE(child2->isClipped());
     EXPECT_TRUE(child2->renderSurface()->isClipped());
     EXPECT_TRUE(grandChild->isClipped());
     EXPECT_TRUE(leafNode1->isClipped());
     EXPECT_FALSE(leafNode2->isClipped());
 
     // Case 3: child2 masksToBounds. The layer and subtree are clipped, and
     // child2's renderSurface is not clipped.
     renderSurfaceLayerList.clear();
     parent->setMasksToBounds(false);
     child2->setMasksToBounds(true);
-    LayerTreeHostCommon::calculateDrawProperties(root.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     ASSERT_TRUE(root->renderSurface());
     ASSERT_TRUE(child2->renderSurface());
 
     EXPECT_FALSE(root->isClipped());
     EXPECT_TRUE(root->renderSurface()->isClipped());
     EXPECT_FALSE(parent->isClipped());
     EXPECT_FALSE(child1->isClipped());
     EXPECT_TRUE(child2->isClipped());
     EXPECT_FALSE(child2->renderSurface()->isClipped());
@@ skipping 38 matching lines @@
 
     // Force everyone to be a render surface.
     child->setOpacity(0.4f);
     grandChild1->setOpacity(0.5);
     grandChild2->setOpacity(0.5);
     grandChild3->setOpacity(0.5);
     grandChild4->setOpacity(0.5);
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     EXPECT_RECT_EQ(gfx::Rect(gfx::Point(5, 5), gfx::Size(10, 10)), grandChild1->drawableContentRect());
     EXPECT_RECT_EQ(gfx::Rect(gfx::Point(15, 15), gfx::Size(5, 5)), grandChild3->drawableContentRect());
     EXPECT_RECT_EQ(gfx::Rect(gfx::Point(15, 15), gfx::Size(5, 5)), grandChild3->drawableContentRect());
     EXPECT_TRUE(grandChild4->drawableContentRect().IsEmpty());
 }
 
 TEST(LayerTreeHostCommonTest, verifyClipRectIsPropagatedCorrectlyToSurfaces)
 {
     // Verify that renderSurfaces (and their layers) get the appropriate clipRects when their parent masksToBounds is true.
@@ skipping 49 matching lines @@
     grandChild1->setForceRenderSurface(true);
     grandChild2->setOpacity(0.5);
     grandChild2->setForceRenderSurface(true);
     grandChild3->setOpacity(0.5);
     grandChild3->setForceRenderSurface(true);
     grandChild4->setOpacity(0.5);
     grandChild4->setForceRenderSurface(true);
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     ASSERT_TRUE(grandChild1->renderSurface());
     ASSERT_TRUE(grandChild2->renderSurface());
     ASSERT_TRUE(grandChild3->renderSurface());
     EXPECT_FALSE(grandChild4->renderSurface()); // Because grandChild4 is entirely clipped, it is expected to not have a renderSurface.
 
     // Surfaces are clipped by their parent, but un-affected by the owning layer's masksToBounds.
     EXPECT_RECT_EQ(gfx::Rect(gfx::Point(0, 0), gfx::Size(20, 20)), grandChild1->renderSurface()->clipRect());
     EXPECT_RECT_EQ(gfx::Rect(gfx::Point(0, 0), gfx::Size(20, 20)), grandChild2->renderSurface()->clipRect());
     EXPECT_RECT_EQ(gfx::Rect(gfx::Point(0, 0), gfx::Size(20, 20)), grandChild3->renderSurface()->clipRect());
@@ skipping 821 matching lines @@
     setLayerPropertiesForTesting(backFacingChild.get(), backfaceMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(frontFacingSurface.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(backFacingSurface.get(), backfaceMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(frontFacingChildOfFrontFacingSurface.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(backFacingChildOfFrontFacingSurface.get(), backfaceMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(frontFacingChildOfBackFacingSurface.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(backFacingChildOfBackFacingSurface.get(), backfaceMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // Verify which renderSurfaces were created.
     EXPECT_FALSE(frontFacingChild->renderSurface());
     EXPECT_FALSE(backFacingChild->renderSurface());
     EXPECT_TRUE(frontFacingSurface->renderSurface());
     EXPECT_TRUE(backFacingSurface->renderSurface());
     EXPECT_FALSE(frontFacingChildOfFrontFacingSurface->renderSurface());
     EXPECT_FALSE(backFacingChildOfFrontFacingSurface->renderSurface());
     EXPECT_FALSE(frontFacingChildOfBackFacingSurface->renderSurface());
     EXPECT_FALSE(backFacingChildOfBackFacingSurface->renderSurface());
@@ skipping 78 matching lines @@
     setLayerPropertiesForTesting(backFacingChild.get(), backfaceMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(frontFacingSurface.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), true); // surface transform style is preserve-3d.
     setLayerPropertiesForTesting(backFacingSurface.get(), backfaceMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), true); // surface transform style is preserve-3d.
     setLayerPropertiesForTesting(frontFacingChildOfFrontFacingSurface.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(backFacingChildOfFrontFacingSurface.get(), backfaceMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(frontFacingChildOfBackFacingSurface.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(backFacingChildOfBackFacingSurface.get(), backfaceMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // Verify which renderSurfaces were created.
     EXPECT_FALSE(frontFacingChild->renderSurface());
     EXPECT_FALSE(backFacingChild->renderSurface());
     EXPECT_TRUE(frontFacingSurface->renderSurface());
     EXPECT_FALSE(backFacingSurface->renderSurface());
     EXPECT_FALSE(frontFacingChildOfFrontFacingSurface->renderSurface());
     EXPECT_FALSE(backFacingChildOfFrontFacingSurface->renderSurface());
     EXPECT_FALSE(frontFacingChildOfBackFacingSurface->renderSurface());
     EXPECT_FALSE(backFacingChildOfBackFacingSurface->renderSurface());
@@ skipping 59 matching lines @@
 
     setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(child.get(), backfaceMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(animatingSurface.get(), backfaceMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(childOfAnimatingSurface.get(), backfaceMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(animatingChild.get(), backfaceMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(child2.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     EXPECT_FALSE(child->renderSurface());
     EXPECT_TRUE(animatingSurface->renderSurface());
     EXPECT_FALSE(childOfAnimatingSurface->renderSurface());
     EXPECT_FALSE(animatingChild->renderSurface());
     EXPECT_FALSE(child2->renderSurface());
 
     // Verify that the animatingChild and childOfAnimatingSurface were not culled, but that child was.
     ASSERT_EQ(2u, renderSurfaceLayerList.size());
     EXPECT_EQ(parent->id(), renderSurfaceLayerList[0]->id());
@@ skipping 45 matching lines @@
     backfaceMatrix.Translate(-50, -50);
 
     setLayerPropertiesForTesting(parent.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), true); // parent transform style is preserve3d.
     setLayerPropertiesForTesting(frontFacingSurface.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false); // surface transform style is flat.
     setLayerPropertiesForTesting(backFacingSurface.get(),  backfaceMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false); // surface transform style is flat.
     setLayerPropertiesForTesting(child1.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
     setLayerPropertiesForTesting(child2.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // Verify which renderSurfaces were created.
     EXPECT_TRUE(frontFacingSurface->renderSurface());
     EXPECT_FALSE(backFacingSurface->renderSurface()); // because it should be culled
     EXPECT_FALSE(child1->renderSurface());
     EXPECT_FALSE(child2->renderSurface());
 
     // Verify the renderSurfaceLayerList. The back-facing surface should be culled.
     ASSERT_EQ(2u, renderSurfaceLayerList.size());
     EXPECT_EQ(parent->id(), renderSurfaceLayerList[0]->id());
@@ skipping 31 matching lines @@
 
     gfx::Transform identityMatrix;
     gfx::PointF anchor(0, 0);
     gfx::PointF position(0, 0);
     gfx::Size bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
 
     // Hit testing for a point outside the layer should return a null pointer.
     gfx::Point testPoint(101, 101);
     LayerImpl* resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     EXPECT_FALSE(resultLayer);
 
@@ skipping 28 matching lines @@
 
     gfx::Transform identityMatrix;
     gfx::PointF anchor(0, 0);
     gfx::PointF position(0, 0);
     gfx::Size bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), uninvertibleTransform, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
     ASSERT_FALSE(root->screenSpaceTransform().IsInvertible());
 
     // Hit testing any point should not hit the layer. If the invertible matrix is
     // accidentally ignored and treated like an identity, then the hit testing will
     // incorrectly hit the layer when it shouldn't.
     gfx::Point testPoint(1, 1);
@@ skipping 33 matching lines @@
 
     gfx::Transform identityMatrix;
     gfx::PointF anchor(0, 0);
     gfx::PointF position(50, 50); // this layer is positioned, and hit testing should correctly know where the layer is located.
     gfx::Size bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
 
     // Hit testing for a point outside the layer should return a null pointer.
     gfx::Point testPoint(49, 49);
     LayerImpl* resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     EXPECT_FALSE(resultLayer);
 
@@ skipping 26 matching lines @@
     MathUtil::rotateEulerAngles(&rotation45DegreesAboutCenter, 0, 0, 45);
     rotation45DegreesAboutCenter.Translate(-50, -50);
     gfx::PointF anchor(0, 0);
     gfx::PointF position(0, 0);
     gfx::Size bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), rotation45DegreesAboutCenter, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
 
     // Hit testing for points outside the layer.
     // These corners would have been inside the un-transformed layer, but they should not hit the correctly transformed layer.
     gfx::Point testPoint(99, 99);
     LayerImpl* resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     EXPECT_FALSE(resultLayer);
@@ skipping 35 matching lines @@
     translationByZ.Translate3d(0, 0, -1);
 
     gfx::PointF anchor(0, 0);
     gfx::PointF position(0, 0);
     gfx::Size bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), perspectiveProjectionAboutCenter * translationByZ, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
 
     // Hit testing for points outside the layer.
     // These corners would have been inside the un-transformed layer, but they should not hit the correctly transformed layer.
     gfx::Point testPoint(24, 24);
     LayerImpl* resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     EXPECT_FALSE(resultLayer);
@@ skipping 44 matching lines @@
         // override contentBounds and contentsScale
         testLayer->setContentBounds(gfx::Size(100, 100));
         testLayer->setContentsScale(2, 2);
 
         testLayer->setDrawsContent(true);
         root->addChild(testLayer.Pass());
     }
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     // The visibleContentRect for testLayer is actually 100x100, even though its layout size is 50x50, positioned at 25x25.
     LayerImpl* testLayer = root->children()[0];
     EXPECT_RECT_EQ(gfx::Rect(gfx::Point(), gfx::Size(100, 100)), testLayer->visibleContentRect());
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
 
     // Hit testing for a point outside the layer should return a null pointer (the root layer does not draw content, so it will not be hit tested either).
     gfx::Point testPoint(101, 101);
@@ skipping 43 matching lines @@
         position = gfx::PointF(-50, -50);
         bounds = gfx::Size(300, 300);
         setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
         child->setDrawsContent(true);
         clippingLayer->addChild(child.Pass());
         root->addChild(clippingLayer.Pass());
     }
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
     ASSERT_EQ(456, root->renderSurface()->layerList()[0]->id());
 
     // Hit testing for a point outside the layer should return a null pointer.
     // Despite the child layer being very large, it should be clipped to the root layer's bounds.
     gfx::Point testPoint(24, 24);
     LayerImpl* resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
@@ skipping 69 matching lines @@
         setLayerPropertiesForTesting(rotatedLeaf.get(), rotatedLeafTransform, identityMatrix, anchor, position, bounds, false);
         rotatedLeaf->setDrawsContent(true);
 
         grandChild->addChild(rotatedLeaf.Pass());
         child->addChild(grandChild.Pass());
         root->addChild(child.Pass());
     }
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     // The grandChild is expected to create a renderSurface because it masksToBounds and is not axis aligned.
     ASSERT_EQ(2u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, renderSurfaceLayerList[0]->renderSurface()->layerList().size());
     ASSERT_EQ(789, renderSurfaceLayerList[0]->renderSurface()->layerList()[0]->id()); // grandChild's surface.
     ASSERT_EQ(1u, renderSurfaceLayerList[1]->renderSurface()->layerList().size());
     ASSERT_EQ(2468, renderSurfaceLayerList[1]->renderSurface()->layerList()[0]->id());
 
     // (11, 89) is close to the the bottom left corner within the clip, but it is not inside the layer.
@@ skipping 61 matching lines @@
         position = gfx::PointF(60, 60); // 70, 70 in screen space
         bounds = gfx::Size(20, 20);
         setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
         child->setDrawsContent(true);
         intermediateLayer->addChild(child.Pass());
         root->addChild(intermediateLayer.Pass());
     }
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
     ASSERT_EQ(456, root->renderSurface()->layerList()[0]->id());
 
     // Hit testing for a point outside the layer should return a null pointer.
     gfx::Point testPoint(69, 69);
     LayerImpl* resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     EXPECT_FALSE(resultLayer);
@@ skipping 59 matching lines @@
         root->addChild(child1.Pass());
         root->addChild(child2.Pass());
     }
 
     LayerImpl* child1 = root->children()[0];
     LayerImpl* child2 = root->children()[1];
     LayerImpl* grandChild1 = child1->children()[0];
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     ASSERT_TRUE(child1);
     ASSERT_TRUE(child2);
     ASSERT_TRUE(grandChild1);
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(4u, root->renderSurface()->layerList().size());
     ASSERT_EQ(1, root->renderSurface()->layerList()[0]->id()); // root layer
     ASSERT_EQ(2, root->renderSurface()->layerList()[1]->id()); // child1
     ASSERT_EQ(4, root->renderSurface()->layerList()[2]->id()); // grandChild1
@@ skipping 87 matching lines @@
         root->addChild(child1.Pass());
         root->addChild(child2.Pass());
     }
 
     LayerImpl* child1 = root->children()[0];
     LayerImpl* child2 = root->children()[1];
     LayerImpl* grandChild1 = child1->children()[0];
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     ASSERT_TRUE(child1);
     ASSERT_TRUE(child2);
     ASSERT_TRUE(grandChild1);
     ASSERT_TRUE(child1->renderSurface());
     ASSERT_TRUE(child2->renderSurface());
     ASSERT_TRUE(grandChild1->renderSurface());
     ASSERT_EQ(4u, renderSurfaceLayerList.size());
     ASSERT_EQ(3u, root->renderSurface()->layerList().size()); // The root surface has the root layer, and child1's and child2's renderSurfaces.
@@ skipping 65 matching lines @@
     gfx::Transform identityMatrix;
     Region touchHandlerRegion(gfx::Rect(10, 10, 50, 50));
     gfx::PointF anchor(0, 0);
     gfx::PointF position(0, 0);
     gfx::Size bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
 
     // Hit checking for any point should return a null pointer for a layer without any touch event handler regions.
     gfx::Point testPoint(11, 11);
     LayerImpl* resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
     EXPECT_FALSE(resultLayer);
 
@@ skipping 45 matching lines @@
     Region touchHandlerRegion(gfx::Rect(10, 10, 50, 50));
     gfx::PointF anchor(0, 0);
     gfx::PointF position(0, 0);
     gfx::Size bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), uninvertibleTransform, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
     root->setTouchEventHandlerRegion(touchHandlerRegion);
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
     ASSERT_FALSE(root->screenSpaceTransform().IsInvertible());
 
     // Hit checking any point should not hit the touch handler region on the layer. If the invertible matrix is
     // accidentally ignored and treated like an identity, then the hit testing will
     // incorrectly hit the layer when it shouldn't.
     gfx::Point testPoint(1, 1);
@@ skipping 35 matching lines @@
     Region touchHandlerRegion(gfx::Rect(10, 10, 50, 50));
     gfx::PointF anchor(0, 0);
     gfx::PointF position(50, 50); // this layer is positioned, and hit testing should correctly know where the layer is located.
     gfx::Size bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
     root->setDrawsContent(true);
     root->setTouchEventHandlerRegion(touchHandlerRegion);
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
 
     // Hit checking for a point outside the layer should return a null pointer.
     gfx::Point testPoint(49, 49);
     LayerImpl* resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
     EXPECT_FALSE(resultLayer);
 
@@ skipping 51 matching lines @@
         testLayer->setContentBounds(gfx::Size(100, 100));
         testLayer->setContentsScale(2, 2);
 
         testLayer->setDrawsContent(true);
         testLayer->setTouchEventHandlerRegion(touchHandlerRegion);
         root->addChild(testLayer.Pass());
     }
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     // The visibleContentRect for testLayer is actually 100x100, even though its layout size is 50x50, positioned at 25x25.
     LayerImpl* testLayer = root->children()[0];
     EXPECT_RECT_EQ(gfx::Rect(gfx::Point(), gfx::Size(100, 100)), testLayer->visibleContentRect());
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
 
     // Hit checking for a point outside the layer should return a null pointer (the root layer does not draw content, so it will not be tested either).
     gfx::Point testPoint(76, 76);
@@ skipping 55 matching lines @@
     }
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     float deviceScaleFactor = 3.0f;
     float pageScaleFactor = 5.0f;
     gfx::Transform pageScaleTransform;
     pageScaleTransform.Scale(pageScaleFactor, pageScaleFactor);
     root->setImplTransform(pageScaleTransform); // Applying the pageScaleFactor through implTransform.
     gfx::Size scaledBoundsForRoot = gfx::ToCeiledSize(gfx::ScaleSize(root->bounds(), deviceScaleFactor * pageScaleFactor));
-    LayerTreeHostCommon::calculateDrawProperties(root.get(), scaledBoundsForRoot, deviceScaleFactor, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), scaledBoundsForRoot, deviceScaleFactor, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     // The visibleContentRect for testLayer is actually 100x100, even though its layout size is 50x50, positioned at 25x25.
     LayerImpl* testLayer = root->children()[0];
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
 
     // Check whether the child layer fits into the root after scaled.
     EXPECT_RECT_EQ(gfx::Rect(testLayer->contentBounds()), testLayer->visibleContentRect());;
 
@@ skipping 63 matching lines @@
         bounds = gfx::Size(300, 300);
         setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
         child->setDrawsContent(true);
         child->setTouchEventHandlerRegion(touchHandlerRegion);
         clippingLayer->addChild(child.Pass());
         root->addChild(clippingLayer.Pass());
     }
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
-    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(root.get(), root->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // Sanity check the scenario we just created.
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(1u, root->renderSurface()->layerList().size());
     ASSERT_EQ(456, root->renderSurface()->layerList()[0]->id());
 
     // Hit checking for a point outside the layer should return a null pointer.
     // Despite the child layer being very large, it should be clipped to the root layer's bounds.
     gfx::Point testPoint(24, 24);
     LayerImpl* resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
@@ skipping 62 matching lines @@
     parent->addChild(child);
     parent->addChild(childEmpty);
     parent->addChild(childNoScale);
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
 
     const double deviceScaleFactor = 2.5;
     const double pageScaleFactor = 1;
 
-    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor, parent);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor, child);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor, childEmpty);
     EXPECT_CONTENTS_SCALE_EQ(1, childNoScale);
 
     EXPECT_EQ(1u, renderSurfaceLayerList.size());
 
     // Verify parent transforms
     gfx::Transform expectedParentTransform;
@@ skipping 61 matching lines @@
 
     parent->addChild(child);
     parent->addChild(childNoScale);
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
 
     const float deviceScaleFactor = 1.7f;
     const float pageScaleFactor = 1;
 
-    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor, parent);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor, child);
     EXPECT_CONTENTS_SCALE_EQ(1, childNoScale);
 
     EXPECT_EQ(1u, renderSurfaceLayerList.size());
 
     // Verify parent transforms
     gfx::Transform expectedParentTransform;
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedParentTransform, parent->screenSpaceTransform());
@@ skipping 84 matching lines @@
     int dummyMaxTextureSize = 512;
 
     double deviceScaleFactor = 2.5;
     double pageScaleFactor = 1.5;
 
     // FIXME: Remove this when pageScaleFactor is applied in the compositor.
     gfx::Transform pageScaleMatrix;
     pageScaleMatrix.Scale(pageScaleFactor, pageScaleFactor);
     parent->setSublayerTransform(pageScaleMatrix);
 
-    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * initialParentScale, parent);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, childScale);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, childEmpty);
     EXPECT_CONTENTS_SCALE_EQ(1, childNoScale);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * fixedRasterScale, childNoAutoScale);
 
     // The parent is scaled up and shouldn't need to scale during draw. The child that can scale its contents should
     // also not need to scale during draw. This shouldn't change if the child has empty bounds. The other children should.
     EXPECT_FLOAT_EQ(1, parent->drawTransform().matrix().getDouble(0, 0));
     EXPECT_FLOAT_EQ(1, parent->drawTransform().matrix().getDouble(1, 1));
     EXPECT_FLOAT_EQ(1, childScale->drawTransform().matrix().getDouble(0, 0));
     EXPECT_FLOAT_EQ(1, childScale->drawTransform().matrix().getDouble(1, 1));
     EXPECT_FLOAT_EQ(1, childEmpty->drawTransform().matrix().getDouble(0, 0));
     EXPECT_FLOAT_EQ(1, childEmpty->drawTransform().matrix().getDouble(1, 1));
     EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, childNoScale->drawTransform().matrix().getDouble(0, 0));
     EXPECT_FLOAT_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, childNoScale->drawTransform().matrix().getDouble(1, 1));
     EXPECT_FLOAT_EQ(initialParentScale * initialChildScale / fixedRasterScale, childNoAutoScale->drawTransform().matrix().getDouble(0, 0));
     EXPECT_FLOAT_EQ(initialParentScale * initialChildScale / fixedRasterScale, childNoAutoScale->drawTransform().matrix().getDouble(1, 1));
 
     // If the transform changes, we expect the contentsScale to remain unchanged.
     childScale->setTransform(identityMatrix);
     childEmpty->setTransform(identityMatrix);
 
     renderSurfaceLayerList.clear();
-    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * initialParentScale, parent);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, childScale);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, childEmpty);
     EXPECT_CONTENTS_SCALE_EQ(1, childNoScale);
 
     // But if the deviceScaleFactor or pageScaleFactor changes, then it should be updated, but using the initial transform.
     deviceScaleFactor = 2.25;
     pageScaleFactor = 1.25;
 
     // FIXME: Remove this when pageScaleFactor is applied in the compositor.
     pageScaleMatrix = identityMatrix;
     pageScaleMatrix.Scale(pageScaleFactor, pageScaleFactor);
     parent->setSublayerTransform(pageScaleMatrix);
 
     renderSurfaceLayerList.clear();
-    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * initialParentScale, parent);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, childScale);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, childEmpty);
     EXPECT_CONTENTS_SCALE_EQ(1, childNoScale);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * fixedRasterScale, childNoAutoScale);
 }
 
 TEST(LayerTreeHostCommonTest, verifySmallContentsScale)
 {
@@ skipping 24 matching lines @@
     int dummyMaxTextureSize = 512;
 
     double deviceScaleFactor = 2.5;
     double pageScaleFactor = 0.01;
 
     // FIXME: Remove this when pageScaleFactor is applied in the compositor.
     gfx::Transform pageScaleMatrix;
     pageScaleMatrix.Scale(pageScaleFactor, pageScaleFactor);
     parent->setSublayerTransform(pageScaleMatrix);
 
-    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * initialParentScale, parent);
     // The child's scale is < 1, so we should not save and use that scale factor.
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * 1, childScale);
 
     // When chilld's total scale becomes >= 1, we should save and use that scale factor.
     childScaleMatrix.MakeIdentity();
     const double finalChildScale = 0.75;
     childScaleMatrix.Scale(finalChildScale, finalChildScale);
     childScale->setTransform(childScaleMatrix);
 
     renderSurfaceLayerList.clear();
-    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * initialParentScale, parent);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * finalChildScale, childScale);
 }
 
 TEST(LayerTreeHostCommonTest, verifyContentsScaleForSurfaces)
 {
     MockContentLayerClient delegate;
     gfx::Transform identityMatrix;
 
@@ skipping 63 matching lines @@
     int dummyMaxTextureSize = 512;
 
     double deviceScaleFactor = 5;
     double pageScaleFactor = 7;
 
     // FIXME: Remove this when pageScaleFactor is applied in the compositor.
     gfx::Transform pageScaleMatrix;
     pageScaleMatrix.Scale(pageScaleFactor, pageScaleFactor);
     parent->setSublayerTransform(pageScaleMatrix);
 
-    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), deviceScaleFactor, pageScaleFactor, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * initialParentScale, parent);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale, surfaceScale);
     EXPECT_CONTENTS_SCALE_EQ(1, surfaceNoScale);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * fixedRasterScale, surfaceNoAutoScale);
 
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale * initialChildScale, surfaceScaleChildScale);
     EXPECT_CONTENTS_SCALE_EQ(1, surfaceScaleChildNoScale);
     EXPECT_CONTENTS_SCALE_EQ(deviceScaleFactor * pageScaleFactor * initialParentScale * initialChildScale * initialChildScale, surfaceNoScaleChildScale);
     EXPECT_CONTENTS_SCALE_EQ(1, surfaceNoScaleChildNoScale);
@@ skipping 73 matching lines @@
     setLayerPropertiesForTesting(childScale.get(), childScaleMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(2, 2), gfx::Size(10, 10), true);
 
     parent->addChild(childScale);
 
     // Now put an animating transform on child.
     int animationId = addAnimatedTransformToController(*childScale->layerAnimationController(), 10, 30, 0);
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
 
-    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     EXPECT_CONTENTS_SCALE_EQ(initialParentScale, parent);
     // The layers with animating transforms should not compute a contentsScale other than 1 until they finish animating.
     EXPECT_CONTENTS_SCALE_EQ(1, childScale);
 
     // Remove the animation, now it can save a raster scale.
     childScale->layerAnimationController()->removeAnimation(animationId);
 
-    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     EXPECT_CONTENTS_SCALE_EQ(initialParentScale, parent);
     // The layers with animating transforms should not compute a contentsScale other than 1 until they finish animating.
     EXPECT_CONTENTS_SCALE_EQ(initialParentScale * initialChildScale, childScale);
 }
 
 
 TEST(LayerTreeHostCommonTest, verifyRenderSurfaceTransformsInHighDPI)
 {
     MockContentLayerClient delegate;
@@ skipping 21 matching lines @@
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
 
     const double deviceScaleFactor = 1.5;
     parent->setContentsScale(deviceScaleFactor);
     child->setContentsScale(deviceScaleFactor);
     duplicateChildNonOwner->setContentsScale(deviceScaleFactor);
     replica->setContentsScale(deviceScaleFactor);
 
-    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), deviceScaleFactor, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), deviceScaleFactor, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // We should have two render surfaces. The root's render surface and child's
     // render surface (it needs one because it has a replica layer).
     EXPECT_EQ(2u, renderSurfaceLayerList.size());
 
     gfx::Transform expectedParentTransform;
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedParentTransform, parent->screenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedParentTransform, parent->drawTransform());
 
     gfx::Transform expectedDrawTransform;
@@ skipping 62 matching lines @@
 
     std::vector<scoped_refptr<Layer> > renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
 
     const float deviceScaleFactor = 1.7f;
     parent->setContentsScale(deviceScaleFactor);
     child->setContentsScale(deviceScaleFactor);
     duplicateChildNonOwner->setContentsScale(deviceScaleFactor);
     replica->setContentsScale(deviceScaleFactor);
 
-    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), deviceScaleFactor, 1, dummyMaxTextureSize, renderSurfaceLayerList);
+    LayerTreeHostCommon::calculateDrawProperties(parent.get(), parent->bounds(), deviceScaleFactor, 1, dummyMaxTextureSize, false, renderSurfaceLayerList);
 
     // We should have two render surfaces. The root's render surface and child's
     // render surface (it needs one because it has a replica layer).
     EXPECT_EQ(2u, renderSurfaceLayerList.size());
 
     gfx::Transform identityTransform;
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityTransform, parent->screenSpaceTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityTransform, parent->drawTransform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(identityTransform, child->drawTransform());
@@ skipping 51 matching lines @@
 
     root->addChild(child);
     child->addChild(grandChild);
     child->setOpacity(0.5f);
 
     executeCalculateDrawProperties(root.get());
 
     EXPECT_FALSE(child->renderSurface());
 }
 
+typedef std::tr1::tuple<bool, bool> LCDTextTestParam;
+class LCDTextTest : public testing::TestWithParam<LCDTextTestParam> {
+protected:
+    virtual void SetUp()
+    {
+        m_canUseLCDText = std::tr1::get<0>(GetParam());
+
+        m_root = Layer::create();
+        m_child = Layer::create();
+        m_grandChild = Layer::create();
+        m_child->addChild(m_grandChild.get());
+        m_root->addChild(m_child.get());
+
+        gfx::Transform identityMatrix;
+        setLayerPropertiesForTesting(m_root, identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(1, 1), false);
+        setLayerPropertiesForTesting(m_child, identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(1, 1), false);
+        setLayerPropertiesForTesting(m_grandChild, identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(1, 1), false);
+
+        m_child->setForceRenderSurface(std::tr1::get<1>(GetParam()));
+    }
+
+    bool m_canUseLCDText;
+    scoped_refptr<Layer> m_root;
+    scoped_refptr<Layer> m_child;
+    scoped_refptr<Layer> m_grandChild;
+};
+
+TEST_P(LCDTextTest, verifyCanUseLCDText)
+{
+    // Case 1: Identity transform.
+    gfx::Transform identityMatrix;
+    executeCalculateDrawProperties(m_root, 1, 1, m_canUseLCDText);
+    EXPECT_EQ(m_canUseLCDText, m_root->canUseLCDText());
+    EXPECT_EQ(m_canUseLCDText, m_child->canUseLCDText());
+    EXPECT_EQ(m_canUseLCDText, m_grandChild->canUseLCDText());
+
+    // Case 2: Integral translation.
+    gfx::Transform integralTranslation;
+    integralTranslation.Translate(1, 2);
+    m_child->setTransform(integralTranslation);
+    executeCalculateDrawProperties(m_root, 1, 1, m_canUseLCDText);
+    EXPECT_EQ(m_canUseLCDText, m_root->canUseLCDText());
+    EXPECT_EQ(m_canUseLCDText, m_child->canUseLCDText());
+    EXPECT_EQ(m_canUseLCDText, m_grandChild->canUseLCDText());
+
+    // Case 3: Non-integral translation.
+    gfx::Transform nonIntegralTranslation;
+    nonIntegralTranslation.Translate(1.5, 2.5);
+    m_child->setTransform(nonIntegralTranslation);
+    executeCalculateDrawProperties(m_root, 1, 1, m_canUseLCDText);
+    EXPECT_EQ(m_canUseLCDText, m_root->canUseLCDText());
+    EXPECT_FALSE(m_child->canUseLCDText());
+    EXPECT_FALSE(m_grandChild->canUseLCDText());
+
+    // Case 4: Rotation.
+    gfx::Transform rotation;
+    rotation.Rotate(10);
+    m_child->setTransform(rotation);
+    executeCalculateDrawProperties(m_root, 1, 1, m_canUseLCDText);
+    EXPECT_EQ(m_canUseLCDText, m_root->canUseLCDText());
+    EXPECT_FALSE(m_child->canUseLCDText());
+    EXPECT_FALSE(m_grandChild->canUseLCDText());
+
+    // Case 5: Scale.
+    gfx::Transform scale;
+    scale.Scale(2, 2);
+    m_child->setTransform(scale);
+    executeCalculateDrawProperties(m_root, 1, 1, m_canUseLCDText);
+    EXPECT_EQ(m_canUseLCDText, m_root->canUseLCDText());
+    EXPECT_FALSE(m_child->canUseLCDText());
+    EXPECT_FALSE(m_grandChild->canUseLCDText());
+
+    // Case 6: Skew.
+    gfx::Transform skew;
+    skew.SkewX(10);
+    m_child->setTransform(skew);
+    executeCalculateDrawProperties(m_root, 1, 1, m_canUseLCDText);
+    EXPECT_EQ(m_canUseLCDText, m_root->canUseLCDText());
+    EXPECT_FALSE(m_child->canUseLCDText());
+    EXPECT_FALSE(m_grandChild->canUseLCDText());
+
+    // Case 7: Translucent.
+    m_child->setTransform(identityMatrix);
+    m_child->setOpacity(0.5);
+    executeCalculateDrawProperties(m_root, 1, 1, m_canUseLCDText);
+    EXPECT_EQ(m_canUseLCDText, m_root->canUseLCDText());
+    EXPECT_FALSE(m_child->canUseLCDText());
+    EXPECT_FALSE(m_grandChild->canUseLCDText());
+
+    // Case 8: Sanity check: restore transform and opacity.
+    m_child->setTransform(identityMatrix);
+    m_child->setOpacity(1);
+    executeCalculateDrawProperties(m_root, 1, 1, m_canUseLCDText);
+    EXPECT_EQ(m_canUseLCDText, m_root->canUseLCDText());
+    EXPECT_EQ(m_canUseLCDText, m_child->canUseLCDText());
+    EXPECT_EQ(m_canUseLCDText, m_grandChild->canUseLCDText());
+}
+
+TEST_P(LCDTextTest, verifyCanUseLCDTextWithAnimation)
+{
+    // Sanity check: Make sure m_canUseLCDText is set on each node.
+    executeCalculateDrawProperties(m_root, 1, 1, m_canUseLCDText);
+    EXPECT_EQ(m_canUseLCDText, m_root->canUseLCDText());
+    EXPECT_EQ(m_canUseLCDText, m_child->canUseLCDText());
+    EXPECT_EQ(m_canUseLCDText, m_grandChild->canUseLCDText());
+
+    // Add opacity animation.
+    m_child->setOpacity(0.9f);
+    addOpacityTransitionToController(*(m_child->layerAnimationController()), 10, 0.9f, 0.1f, false);
+
+    executeCalculateDrawProperties(m_root, 1, 1, m_canUseLCDText);
+    // Text AA should not be adjusted while animation is active.
+    // Make sure LCD text AA setting remains unchanged.
+    EXPECT_EQ(m_canUseLCDText, m_root->canUseLCDText());
+    EXPECT_EQ(m_canUseLCDText, m_child->canUseLCDText());
+    EXPECT_EQ(m_canUseLCDText, m_grandChild->canUseLCDText());
+}
+
+INSTANTIATE_TEST_CASE_P(LayerTreeHostCommonTest,
+                        LCDTextTest,
+                        testing::Combine(testing::Bool(),
+                                         testing::Bool()));
+
 }  // namespace
 }  // namespace cc