cc: Chromify the LayerTreeHostImpl class.

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/heads_up_display_layer_impl.h"
 #include "cc/layer.h"
@@ skipping 59 matching lines @@
     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, canUseLCDText, dummyRenderSurfaceLayerList, false);
 }
 
 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);
+    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl->active_tree(), 1);
+    scoped_ptr<LayerImpl> child = LayerImpl::Create(hostImpl->active_tree(), 2);
+    scoped_ptr<LayerImpl> grandChild = LayerImpl::Create(hostImpl->active_tree(), 3);
+    scoped_ptr<LayerImpl> greatGrandChild = LayerImpl::Create(hostImpl->active_tree(), 4);
 
     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);
     setLayerPropertiesForTesting(child.get(), IdentityMatrix, IdentityMatrix, anchor, position, bounds, false);
     setLayerPropertiesForTesting(grandChild.get(), IdentityMatrix, IdentityMatrix, anchor, position, bounds, false);
     setLayerPropertiesForTesting(greatGrandChild.get(), IdentityMatrix, IdentityMatrix, anchor, position, bounds, false);
 
@@ skipping 169 matching lines @@
     const gfx::Vector2d kScrollOffset(50, 100);
     const gfx::Vector2dF kScrollDelta(2.34f, 5.67f);
     const gfx::PointF kScrollLayerPosition(-kScrollOffset.x(), -kScrollOffset.y());
     const float kPageScale = 0.888f;
     const float kDeviceScale = 1.666f;
 
     FakeImplProxy proxy;
     FakeLayerTreeHostImpl hostImpl(&proxy);
 
     gfx::Transform identityMatrix;
-    scoped_ptr<LayerImpl> sublayerScopedPtr(LayerImpl::Create(hostImpl.activeTree(), 1));
+    scoped_ptr<LayerImpl> sublayerScopedPtr(LayerImpl::Create(hostImpl.active_tree(), 1));
     LayerImpl* sublayer = sublayerScopedPtr.get();
     sublayer->SetContentsScale(kPageScale * kDeviceScale, kPageScale * kDeviceScale);
     setLayerPropertiesForTesting(sublayer, identityMatrix, identityMatrix, gfx::Point(0, 0), gfx::PointF(0, 0), gfx::Size(500, 500), false);
 
-    scoped_ptr<LayerImpl> scrollLayerScopedPtr(LayerImpl::Create(hostImpl.activeTree(), 2));
+    scoped_ptr<LayerImpl> scrollLayerScopedPtr(LayerImpl::Create(hostImpl.active_tree(), 2));
     LayerImpl* scrollLayer = scrollLayerScopedPtr.get();
     setLayerPropertiesForTesting(scrollLayer, identityMatrix, identityMatrix, gfx::PointF(0, 0), kScrollLayerPosition, gfx::Size(10, 20), false);
     scrollLayer->SetScrollable(true);
     scrollLayer->SetScrollOffset(kScrollOffset);
     scrollLayer->SetScrollDelta(kScrollDelta);
     gfx::Transform implTransform;
     implTransform.Scale(kPageScale, kPageScale);
     scrollLayer->SetImplTransform(implTransform);
     scrollLayer->AddChild(sublayerScopedPtr.Pass());
 
-    scoped_ptr<LayerImpl> root(LayerImpl::Create(hostImpl.activeTree(), 3));
+    scoped_ptr<LayerImpl> root(LayerImpl::Create(hostImpl.active_tree(), 3));
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(3, 4), false);
     root->AddChild(scrollLayerScopedPtr.Pass());
 
     executeCalculateDrawProperties(root.get(), kDeviceScale, kPageScale);
     gfx::Transform expectedTransform = identityMatrix;
     gfx::PointF subLayerScreenPosition = kScrollLayerPosition - kScrollDelta;
     subLayerScreenPosition.Scale(kPageScale * kDeviceScale);
     expectedTransform.Translate(MathUtil::Round(subLayerScreenPosition.x()), MathUtil::Round(subLayerScreenPosition.y()));
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedTransform, sublayer->draw_transform());
     EXPECT_TRANSFORMATION_MATRIX_EQ(expectedTransform, sublayer->screen_space_transform());
@@ skipping 996 matching lines @@
     FakeImplProxy proxy;
     FakeLayerTreeHostImpl hostImpl(&proxy);
     scoped_ptr<LayerImpl> root = createTreeForFixedPositionTests(&hostImpl);
     LayerImpl* child = root->children()[0];
     LayerImpl* grandChild = child->children()[0];
     LayerImpl* greatGrandChild = grandChild->children()[0];
 
     // Add one more layer to the test tree for this scenario.
     {
         gfx::Transform identity;
-        scoped_ptr<LayerImpl> fixedPositionChild = LayerImpl::Create(hostImpl.activeTree(), 5);
+        scoped_ptr<LayerImpl> fixedPositionChild = LayerImpl::Create(hostImpl.active_tree(), 5);
         setLayerPropertiesForTesting(fixedPositionChild.get(), identity, identity, gfx::PointF(0, 0), gfx::PointF(0, 0), gfx::Size(100, 100), false);
         greatGrandChild->AddChild(fixedPositionChild.Pass());
     }
     LayerImpl* fixedPositionChild = greatGrandChild->children()[0];
 
     // Actually set up the scenario here.
     child->SetIsContainerForFixedPositionLayers(true);
     grandChild->SetPosition(gfx::PointF(8, 6));
     grandChild->SetForceRenderSurface(true);
     greatGrandChild->SetPosition(gfx::PointF(40, 60));
@@ skipping 1654 matching lines @@
 
     testPoint = gfx::Point(10, 20);
     resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     EXPECT_FALSE(resultLayer);
 }
 
 TEST(LayerTreeHostCommonTest, verifyHitTestingForSingleLayer)
 {
     FakeImplProxy proxy;
     FakeLayerTreeHostImpl hostImpl(&proxy);
-    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 12345);
+    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 12345);
 
     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;
@@ skipping 21 matching lines @@
     testPoint = gfx::Point(99, 99);
     resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     ASSERT_TRUE(resultLayer);
     EXPECT_EQ(12345, resultLayer->id());
 }
 
 TEST(LayerTreeHostCommonTest, verifyHitTestingForSingleLayerAndHud)
 {
     FakeImplProxy proxy;
     FakeLayerTreeHostImpl hostImpl(&proxy);
-    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 12345);
-    scoped_ptr<HeadsUpDisplayLayerImpl> hud = HeadsUpDisplayLayerImpl::Create(hostImpl.activeTree(), 11111);
+    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 12345);
+    scoped_ptr<HeadsUpDisplayLayerImpl> hud = HeadsUpDisplayLayerImpl::Create(hostImpl.active_tree(), 11111);
 
     gfx::Transform identityMatrix;
     gfx::PointF anchor(0.f, 0.f);
     gfx::PointF position(0.f, 0.f);
     gfx::Size bounds(100, 100);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
     root->SetDrawsContent(true);
 
     // Create hud and add it as a child of root.
     gfx::Size hudBounds(200, 200);
     setLayerPropertiesForTesting(hud.get(), identityMatrix, identityMatrix, anchor, position, hudBounds, false);
     hud->SetDrawsContent(true);
 
-    hostImpl.activeTree()->set_hud_layer(hud.get());
+    hostImpl.active_tree()->set_hud_layer(hud.get());
     root->AddChild(hud.PassAs<LayerImpl>());
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     LayerTreeHostCommon::calculateDrawProperties(root.get(), hudBounds, 1, 1, dummyMaxTextureSize, false, renderSurfaceLayerList, false);
 
     // Sanity check the scenario we just created.
     ASSERT_EQ(1u, renderSurfaceLayerList.size());
     ASSERT_EQ(2u, root->render_surface()->layer_list().size());
 
@@ skipping 15 matching lines @@
     testPoint = gfx::Point(99, 99);
     resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     ASSERT_TRUE(resultLayer);
     EXPECT_EQ(12345, resultLayer->id());
 }
 
 TEST(LayerTreeHostCommonTest, verifyHitTestingForUninvertibleTransform)
 {
     FakeImplProxy proxy;
     FakeLayerTreeHostImpl hostImpl(&proxy);
-    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 12345);
+    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 12345);
 
     gfx::Transform uninvertibleTransform;
     uninvertibleTransform.matrix().setDouble(0, 0, 0);
     uninvertibleTransform.matrix().setDouble(1, 1, 0);
     uninvertibleTransform.matrix().setDouble(2, 2, 0);
     uninvertibleTransform.matrix().setDouble(3, 3, 0);
     ASSERT_FALSE(uninvertibleTransform.IsInvertible());
 
     gfx::Transform identityMatrix;
     gfx::PointF anchor(0, 0);
@@ skipping 40 matching lines @@
 
     testPoint = gfx::Point(-1, -1);
     resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     EXPECT_FALSE(resultLayer);
 }
 
 TEST(LayerTreeHostCommonTest, verifyHitTestingForSinglePositionedLayer)
 {
     FakeImplProxy proxy;
     FakeLayerTreeHostImpl hostImpl(&proxy);
-    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 12345);
+    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 12345);
 
     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;
@@ skipping 22 matching lines @@
     testPoint = gfx::Point(99, 99);
     resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     ASSERT_TRUE(resultLayer);
     EXPECT_EQ(12345, resultLayer->id());
 }
 
 TEST(LayerTreeHostCommonTest, verifyHitTestingForSingleRotatedLayer)
 {
     FakeImplProxy proxy;
     FakeLayerTreeHostImpl hostImpl(&proxy);
-    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 12345);
+    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 12345);
 
     gfx::Transform identityMatrix;
     gfx::Transform rotation45DegreesAboutCenter;
     rotation45DegreesAboutCenter.Translate(50, 50);
     rotation45DegreesAboutCenter.RotateAboutZAxis(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);
@@ skipping 30 matching lines @@
 
     testPoint = gfx::Point(-1, 50);
     resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     ASSERT_FALSE(resultLayer);
 }
 
 TEST(LayerTreeHostCommonTest, verifyHitTestingForSinglePerspectiveLayer)
 {
     FakeImplProxy proxy;
     FakeLayerTreeHostImpl hostImpl(&proxy);
-    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 12345);
+    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 12345);
 
     gfx::Transform identityMatrix;
 
     // perspectiveProjectionAboutCenter * translationByZ is designed so that the 100 x 100 layer becomes 50 x 50, and remains centered at (50, 50).
     gfx::Transform perspectiveProjectionAboutCenter;
     perspectiveProjectionAboutCenter.Translate(50, 50);
     perspectiveProjectionAboutCenter.ApplyPerspectiveDepth(1);
     perspectiveProjectionAboutCenter.Translate(-50, -50);
     gfx::Transform translationByZ;
     translationByZ.Translate3d(0, 0, -1);
@@ skipping 41 matching lines @@
     // test makes sure that hit testing works correctly accounts for the contents scale.
     // A contentsScale that is not 1 effectively forces a non-identity transform between
     // layer's content space and layer's origin space. The hit testing code must take this into account.
     //
     // To test this, the layer is positioned at (25, 25), and is size (50, 50). If
     // contentsScale is ignored, then hit testing will mis-interpret the visibleContentRect
     // as being larger than the actual bounds of the layer.
     //
     FakeImplProxy proxy;
     FakeLayerTreeHostImpl hostImpl(&proxy);
-    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 1);
+    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 1);
 
     gfx::Transform identityMatrix;
     gfx::PointF anchor(0, 0);
 
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, gfx::PointF(0, 0), gfx::Size(100, 100), false);
 
     {
         gfx::PointF position(25, 25);
         gfx::Size bounds(50, 50);
-        scoped_ptr<LayerImpl> testLayer = LayerImpl::Create(hostImpl.activeTree(), 12345);
+        scoped_ptr<LayerImpl> testLayer = LayerImpl::Create(hostImpl.active_tree(), 12345);
         setLayerPropertiesForTesting(testLayer.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
 
         // override contentBounds and contentsScale
         testLayer->SetContentBounds(gfx::Size(100, 100));
         testLayer->SetContentsScale(2, 2);
 
         testLayer->SetDrawsContent(true);
         root->AddChild(testLayer.Pass());
     }
 
@@ skipping 35 matching lines @@
 
 TEST(LayerTreeHostCommonTest, verifyHitTestingForSimpleClippedLayer)
 {
     // Test that hit-testing will only work for the visible portion of a layer, and not
     // the entire layer bounds. Here we just test the simple axis-aligned case.
     gfx::Transform identityMatrix;
     gfx::PointF anchor(0, 0);
 
     FakeImplProxy proxy;
     FakeLayerTreeHostImpl hostImpl(&proxy);
-    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 1);
+    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 1);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, gfx::PointF(0, 0), gfx::Size(100, 100), false);
 
     {
-        scoped_ptr<LayerImpl> clippingLayer = LayerImpl::Create(hostImpl.activeTree(), 123);
+        scoped_ptr<LayerImpl> clippingLayer = LayerImpl::Create(hostImpl.active_tree(), 123);
         gfx::PointF position(25, 25); // this layer is positioned, and hit testing should correctly know where the layer is located.
         gfx::Size bounds(50, 50);
         setLayerPropertiesForTesting(clippingLayer.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
         clippingLayer->SetMasksToBounds(true);
 
-        scoped_ptr<LayerImpl> child = LayerImpl::Create(hostImpl.activeTree(), 456);
+        scoped_ptr<LayerImpl> child = LayerImpl::Create(hostImpl.active_tree(), 456);
         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;
@@ skipping 34 matching lines @@
     // algorithm needs to recognize that multiple parent layers may clip the layer, and
     // should not actually hit those clipped areas.
     //
     // The child and grandChild layers are both initialized to clip the rotatedLeaf. The
     // child layer is rotated about the top-left corner, so that the root + child clips
     // combined create a triangle. The rotatedLeaf will only be visible where it overlaps
     // this triangle.
     //
     FakeImplProxy proxy;
     FakeLayerTreeHostImpl hostImpl(&proxy);
-    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 123);
+    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 123);
 
     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->SetMasksToBounds(true);
 
     {
-        scoped_ptr<LayerImpl> child = LayerImpl::Create(hostImpl.activeTree(), 456);
-        scoped_ptr<LayerImpl> grandChild = LayerImpl::Create(hostImpl.activeTree(), 789);
-        scoped_ptr<LayerImpl> rotatedLeaf = LayerImpl::Create(hostImpl.activeTree(), 2468);
+        scoped_ptr<LayerImpl> child = LayerImpl::Create(hostImpl.active_tree(), 456);
+        scoped_ptr<LayerImpl> grandChild = LayerImpl::Create(hostImpl.active_tree(), 789);
+        scoped_ptr<LayerImpl> rotatedLeaf = LayerImpl::Create(hostImpl.active_tree(), 2468);
 
         position = gfx::PointF(10, 10);
         bounds = gfx::Size(80, 80);
         setLayerPropertiesForTesting(child.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
         child->SetMasksToBounds(true);
 
         gfx::Transform rotation45DegreesAboutCorner;
         rotation45DegreesAboutCorner.RotateAboutZAxis(45);
 
         position = gfx::PointF(0, 0); // remember, positioned with respect to its parent which is already at 10, 10
@@ skipping 70 matching lines @@
 
 TEST(LayerTreeHostCommonTest, verifyHitTestingForNonClippingIntermediateLayer)
 {
     // This test checks that hit testing code does not accidentally clip to layer
     // bounds for a layer that actually does not clip.
     gfx::Transform identityMatrix;
     gfx::PointF anchor(0, 0);
 
     FakeImplProxy proxy;
     FakeLayerTreeHostImpl hostImpl(&proxy);
-    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 1);
+    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 1);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, gfx::PointF(0, 0), gfx::Size(100, 100), false);
 
     {
-        scoped_ptr<LayerImpl> intermediateLayer = LayerImpl::Create(hostImpl.activeTree(), 123);
+        scoped_ptr<LayerImpl> intermediateLayer = LayerImpl::Create(hostImpl.active_tree(), 123);
         gfx::PointF position(10, 10); // this layer is positioned, and hit testing should correctly know where the layer is located.
         gfx::Size bounds(50, 50);
         setLayerPropertiesForTesting(intermediateLayer.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
         // Sanity check the intermediate layer should not clip.
         ASSERT_FALSE(intermediateLayer->masks_to_bounds());
         ASSERT_FALSE(intermediateLayer->mask_layer());
 
         // The child of the intermediateLayer is translated so that it does not overlap intermediateLayer at all.
         // If child is incorrectly clipped, we would not be able to hit it successfully.
-        scoped_ptr<LayerImpl> child = LayerImpl::Create(hostImpl.activeTree(), 456);
+        scoped_ptr<LayerImpl> child = LayerImpl::Create(hostImpl.active_tree(), 456);
         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;
@@ skipping 23 matching lines @@
     resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPoint(testPoint, renderSurfaceLayerList);
     ASSERT_TRUE(resultLayer);
     EXPECT_EQ(456, resultLayer->id());
 }
 
 
 TEST(LayerTreeHostCommonTest, verifyHitTestingForMultipleLayers)
 {
     FakeImplProxy proxy;
     FakeLayerTreeHostImpl hostImpl(&proxy);
-    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 1);
+    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 1);
 
     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);
 
     {
         // child 1 and child2 are initialized to overlap between x=50 and x=60.
         // grandChild is set to overlap both child1 and child2 between y=50 and y=60.
         // The expected stacking order is:
         //   (front) child2, (second) grandChild, (third) child1, and (back) the root layer behind all other layers.
 
-        scoped_ptr<LayerImpl> child1 = LayerImpl::Create(hostImpl.activeTree(), 2);
-        scoped_ptr<LayerImpl> child2 = LayerImpl::Create(hostImpl.activeTree(), 3);
-        scoped_ptr<LayerImpl> grandChild1 = LayerImpl::Create(hostImpl.activeTree(), 4);
+        scoped_ptr<LayerImpl> child1 = LayerImpl::Create(hostImpl.active_tree(), 2);
+        scoped_ptr<LayerImpl> child2 = LayerImpl::Create(hostImpl.active_tree(), 3);
+        scoped_ptr<LayerImpl> grandChild1 = LayerImpl::Create(hostImpl.active_tree(), 4);
 
         position = gfx::PointF(10, 10);
         bounds = gfx::Size(50, 50);
         setLayerPropertiesForTesting(child1.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
         child1->SetDrawsContent(true);
 
         position = gfx::PointF(50, 10);
         bounds = gfx::Size(50, 50);
         setLayerPropertiesForTesting(child2.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
         child2->SetDrawsContent(true);
@@ skipping 67 matching lines @@
 }
 
 TEST(LayerTreeHostCommonTest, verifyHitTestingForMultipleLayerLists)
 {
     //
     // The geometry is set up similarly to the previous case, but
     // all layers are forced to be renderSurfaces now.
     //
     FakeImplProxy proxy;
     FakeLayerTreeHostImpl hostImpl(&proxy);
-    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 1);
+    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 1);
 
     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);
 
     {
         // child 1 and child2 are initialized to overlap between x=50 and x=60.
         // grandChild is set to overlap both child1 and child2 between y=50 and y=60.
         // The expected stacking order is:
         //   (front) child2, (second) grandChild, (third) child1, and (back) the root layer behind all other layers.
 
-        scoped_ptr<LayerImpl> child1 = LayerImpl::Create(hostImpl.activeTree(), 2);
-        scoped_ptr<LayerImpl> child2 = LayerImpl::Create(hostImpl.activeTree(), 3);
-        scoped_ptr<LayerImpl> grandChild1 = LayerImpl::Create(hostImpl.activeTree(), 4);
+        scoped_ptr<LayerImpl> child1 = LayerImpl::Create(hostImpl.active_tree(), 2);
+        scoped_ptr<LayerImpl> child2 = LayerImpl::Create(hostImpl.active_tree(), 3);
+        scoped_ptr<LayerImpl> grandChild1 = LayerImpl::Create(hostImpl.active_tree(), 4);
 
         position = gfx::PointF(10, 10);
         bounds = gfx::Size(50, 50);
         setLayerPropertiesForTesting(child1.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
         child1->SetDrawsContent(true);
         child1->SetForceRenderSurface(true);
 
         position = gfx::PointF(50, 10);
         bounds = gfx::Size(50, 50);
         setLayerPropertiesForTesting(child2.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
@@ skipping 86 matching lines @@
 
     testPoint = gfx::Point(10, 20);
     resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
     EXPECT_FALSE(resultLayer);
 }
 
 TEST(LayerTreeHostCommonTest, verifyHitCheckingTouchHandlerRegionsForSingleLayer)
 {
     FakeImplProxy proxy;
     FakeLayerTreeHostImpl hostImpl(&proxy);
-    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 12345);
+    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 12345);
 
     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;
@@ skipping 37 matching lines @@
     testPoint = gfx::Point(59, 59);
     resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
     ASSERT_TRUE(resultLayer);
     EXPECT_EQ(12345, resultLayer->id());
 }
 
 TEST(LayerTreeHostCommonTest, verifyHitCheckingTouchHandlerRegionsForUninvertibleTransform)
 {
     FakeImplProxy proxy;
     FakeLayerTreeHostImpl hostImpl(&proxy);
-    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 12345);
+    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 12345);
 
     gfx::Transform uninvertibleTransform;
     uninvertibleTransform.matrix().setDouble(0, 0, 0);
     uninvertibleTransform.matrix().setDouble(1, 1, 0);
     uninvertibleTransform.matrix().setDouble(2, 2, 0);
     uninvertibleTransform.matrix().setDouble(3, 3, 0);
     ASSERT_FALSE(uninvertibleTransform.IsInvertible());
 
     gfx::Transform identityMatrix;
     Region touchHandlerRegion(gfx::Rect(10, 10, 50, 50));
@@ skipping 42 matching lines @@
 
     testPoint = gfx::Point(-1, -1);
     resultLayer = LayerTreeHostCommon::findLayerThatIsHitByPointInTouchHandlerRegion(testPoint, renderSurfaceLayerList);
     EXPECT_FALSE(resultLayer);
 }
 
 TEST(LayerTreeHostCommonTest, verifyHitCheckingTouchHandlerRegionsForSinglePositionedLayer)
 {
     FakeImplProxy proxy;
     FakeLayerTreeHostImpl hostImpl(&proxy);
-    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 12345);
+    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 12345);
 
     gfx::Transform identityMatrix;
     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);
 
@@ skipping 39 matching lines @@
     // test makes sure that hit testing works correctly accounts for the contents scale.
     // A contentsScale that is not 1 effectively forces a non-identity transform between
     // layer's content space and layer's origin space. The hit testing code must take this into account.
     //
     // To test this, the layer is positioned at (25, 25), and is size (50, 50). If
     // contentsScale is ignored, then hit checking will mis-interpret the visibleContentRect
     // as being larger than the actual bounds of the layer.
     //
     FakeImplProxy proxy;
     FakeLayerTreeHostImpl hostImpl(&proxy);
-    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 1);
+    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 1);
 
     gfx::Transform identityMatrix;
     gfx::PointF anchor(0, 0);
 
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, gfx::PointF(0, 0), gfx::Size(100, 100), false);
 
     {
         Region touchHandlerRegion(gfx::Rect(10, 10, 30, 30));
         gfx::PointF position(25, 25);
         gfx::Size bounds(50, 50);
-        scoped_ptr<LayerImpl> testLayer = LayerImpl::Create(hostImpl.activeTree(), 12345);
+        scoped_ptr<LayerImpl> testLayer = LayerImpl::Create(hostImpl.active_tree(), 12345);
         setLayerPropertiesForTesting(testLayer.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
 
         // override contentBounds and contentsScale
         testLayer->SetContentBounds(gfx::Size(100, 100));
         testLayer->SetContentsScale(2, 2);
 
         testLayer->SetDrawsContent(true);
         testLayer->SetTouchEventHandlerRegion(touchHandlerRegion);
         root->AddChild(testLayer.Pass());
     }
@@ skipping 42 matching lines @@
     ASSERT_TRUE(resultLayer);
     EXPECT_EQ(12345, resultLayer->id());
 }
 
 TEST(LayerTreeHostCommonTest, verifyHitCheckingTouchHandlerRegionsForSingleLayerWithDeviceScale)
 {
     // The layer's deviceScalefactor and pageScaleFactor should scale the contentRect and we should
     // be able to hit the touch handler region by scaling the points accordingly.
     FakeImplProxy proxy;
     FakeLayerTreeHostImpl hostImpl(&proxy);
-    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 1);
+    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 1);
 
     gfx::Transform identityMatrix;
     gfx::PointF anchor(0, 0);
     // Set the bounds of the root layer big enough to fit the child when scaled.
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, gfx::PointF(0, 0), gfx::Size(100, 100), false);
 
     {
         Region touchHandlerRegion(gfx::Rect(10, 10, 30, 30));
         gfx::PointF position(25, 25);
         gfx::Size bounds(50, 50);
-        scoped_ptr<LayerImpl> testLayer = LayerImpl::Create(hostImpl.activeTree(), 12345);
+        scoped_ptr<LayerImpl> testLayer = LayerImpl::Create(hostImpl.active_tree(), 12345);
         setLayerPropertiesForTesting(testLayer.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
 
         testLayer->SetDrawsContent(true);
         testLayer->SetTouchEventHandlerRegion(touchHandlerRegion);
         root->AddChild(testLayer.Pass());
     }
 
     std::vector<LayerImpl*> renderSurfaceLayerList;
     int dummyMaxTextureSize = 512;
     float deviceScaleFactor = 3.0f;
@@ skipping 56 matching lines @@
 
 TEST(LayerTreeHostCommonTest, verifyHitCheckingTouchHandlerRegionsForSimpleClippedLayer)
 {
     // Test that hit-checking will only work for the visible portion of a layer, and not
     // the entire layer bounds. Here we just test the simple axis-aligned case.
     gfx::Transform identityMatrix;
     gfx::PointF anchor(0, 0);
 
     FakeImplProxy proxy;
     FakeLayerTreeHostImpl hostImpl(&proxy);
-    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.activeTree(), 1);
+    scoped_ptr<LayerImpl> root = LayerImpl::Create(hostImpl.active_tree(), 1);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, gfx::PointF(0, 0), gfx::Size(100, 100), false);
 
     {
-        scoped_ptr<LayerImpl> clippingLayer = LayerImpl::Create(hostImpl.activeTree(), 123);
+        scoped_ptr<LayerImpl> clippingLayer = LayerImpl::Create(hostImpl.active_tree(), 123);
         gfx::PointF position(25, 25); // this layer is positioned, and hit testing should correctly know where the layer is located.
         gfx::Size bounds(50, 50);
         setLayerPropertiesForTesting(clippingLayer.get(), identityMatrix, identityMatrix, anchor, position, bounds, false);
         clippingLayer->SetMasksToBounds(true);
 
-        scoped_ptr<LayerImpl> child = LayerImpl::Create(hostImpl.activeTree(), 456);
+        scoped_ptr<LayerImpl> child = LayerImpl::Create(hostImpl.active_tree(), 456);
         Region touchHandlerRegion(gfx::Rect(10, 10, 50, 50));
         position = gfx::PointF(-50, -50);
         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());
     }
 
@@ skipping 966 matching lines @@
     EXPECT_EQ(m_canUseLCDText, m_grandChild->can_use_lcd_text());
 }
 
 INSTANTIATE_TEST_CASE_P(LayerTreeHostCommonTest,
                         LCDTextTest,
                         testing::Combine(testing::Bool(),
                                          testing::Bool()));
 
 }  // namespace
 }  // namespace cc