[cc] Make LayerImpls point at LayerTreeImpl instead of LTHI

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 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, dummyRenderSurfaceLayerList);
 }
 
 scoped_ptr<LayerImpl> createTreeForFixedPositionTests(LayerTreeHostImpl* hostImpl)
 {
-    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl, 1);
-    scoped_ptr<LayerImpl> child = LayerImpl::create(hostImpl, 2);
-    scoped_ptr<LayerImpl> grandChild = LayerImpl::create(hostImpl, 3);
-    scoped_ptr<LayerImpl> greatGrandChild = LayerImpl::create(hostImpl, 4);
+    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;
     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 1011 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, 5);
+        scoped_ptr<LayerImpl> fixedPositionChild = LayerImpl::create(hostImpl.activeTree(), 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 1660 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, 12345);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 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, verifyHitTestingForUninvertibleTransform)
 {
     FakeImplProxy proxy;
     FakeLayerTreeHostImpl hostImpl(&proxy);
-    scoped_ptr<LayerImpl> root = LayerImpl::create(&hostImpl, 12345);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 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, 12345);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 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, 12345);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 12345);
 
     gfx::Transform identityMatrix;
     gfx::Transform rotation45DegreesAboutCenter;
     rotation45DegreesAboutCenter.Translate(50, 50);
     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);
@@ 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, 12345);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 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, 1);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 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, 12345);
+        scoped_ptr<LayerImpl> testLayer = LayerImpl::create(hostImpl.activeTree(), 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, 1);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 1);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, gfx::PointF(0, 0), gfx::Size(100, 100), false);
 
     {
-        scoped_ptr<LayerImpl> clippingLayer = LayerImpl::create(&hostImpl, 123);
+        scoped_ptr<LayerImpl> clippingLayer = LayerImpl::create(hostImpl.activeTree(), 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, 456);
+        scoped_ptr<LayerImpl> child = LayerImpl::create(hostImpl.activeTree(), 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, 123);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 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, 456);
-        scoped_ptr<LayerImpl> grandChild = LayerImpl::create(&hostImpl, 789);
-        scoped_ptr<LayerImpl> rotatedLeaf = LayerImpl::create(&hostImpl, 2468);
+        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);
 
         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;
         MathUtil::rotateEulerAngles(&rotation45DegreesAboutCorner, 0, 0, 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, 1);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 1);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, gfx::PointF(0, 0), gfx::Size(100, 100), false);
 
     {
-        scoped_ptr<LayerImpl> intermediateLayer = LayerImpl::create(&hostImpl, 123);
+        scoped_ptr<LayerImpl> intermediateLayer = LayerImpl::create(hostImpl.activeTree(), 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->masksToBounds());
         ASSERT_FALSE(intermediateLayer->maskLayer());
 
         // 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, 456);
+        scoped_ptr<LayerImpl> child = LayerImpl::create(hostImpl.activeTree(), 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, 1);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 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, 2);
-        scoped_ptr<LayerImpl> child2 = LayerImpl::create(&hostImpl, 3);
-        scoped_ptr<LayerImpl> grandChild1 = LayerImpl::create(&hostImpl, 4);
+        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);
 
         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, 1);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 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, 2);
-        scoped_ptr<LayerImpl> child2 = LayerImpl::create(&hostImpl, 3);
-        scoped_ptr<LayerImpl> grandChild1 = LayerImpl::create(&hostImpl, 4);
+        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);
 
         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, 12345);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 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, 12345);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 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, 12345);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 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, 1);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 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, 12345);
+        scoped_ptr<LayerImpl> testLayer = LayerImpl::create(hostImpl.activeTree(), 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, 1);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 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, 12345);
+        scoped_ptr<LayerImpl> testLayer = LayerImpl::create(hostImpl.activeTree(), 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, 1);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(hostImpl.activeTree(), 1);
     setLayerPropertiesForTesting(root.get(), identityMatrix, identityMatrix, anchor, gfx::PointF(0, 0), gfx::Size(100, 100), false);
 
     {
-        scoped_ptr<LayerImpl> clippingLayer = LayerImpl::create(&hostImpl, 123);
+        scoped_ptr<LayerImpl> clippingLayer = LayerImpl::create(hostImpl.activeTree(), 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, 456);
+        scoped_ptr<LayerImpl> child = LayerImpl::create(hostImpl.activeTree(), 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 749 matching lines @@
     child->addChild(grandChild);
     child->setOpacity(0.5f);
 
     executeCalculateDrawProperties(root.get());
 
     EXPECT_FALSE(child->renderSurface());
 }
 
 }  // namespace
 }  // namespace cc