[cc] Make LayerImpls point at LayerTreeImpl instead of LTHI

cc/damage_tracker_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/damage_tracker.h"
 
 #include "cc/layer_impl.h"
 #include "cc/layer_tree_host_common.h"
 #include "cc/math_util.h"
 #include "cc/single_thread_proxy.h"
@@ skipping 56 matching lines @@
 
 class DamageTrackerTest : public testing::Test {
 public:
     DamageTrackerTest()
         : m_hostImpl(&m_proxy)
     {
     }
 
     scoped_ptr<LayerImpl> createTestTreeWithOneSurface()
     {
-        scoped_ptr<LayerImpl> root = LayerImpl::create(&m_hostImpl, 1);
-        scoped_ptr<LayerImpl> child = LayerImpl::create(&m_hostImpl, 2);
+        scoped_ptr<LayerImpl> root = LayerImpl::create(m_hostImpl.activeTree(), 1);
+        scoped_ptr<LayerImpl> child = LayerImpl::create(m_hostImpl.activeTree(), 2);
 
         root->setPosition(gfx::PointF());
         root->setAnchorPoint(gfx::PointF());
         root->setBounds(gfx::Size(500, 500));
         root->setContentBounds(gfx::Size(500, 500));
         root->setDrawsContent(true);
         root->createRenderSurface();
         root->renderSurface()->setContentRect(gfx::Rect(gfx::Point(), gfx::Size(500, 500)));
 
         child->setPosition(gfx::PointF(100, 100));
         child->setAnchorPoint(gfx::PointF());
         child->setBounds(gfx::Size(30, 30));
         child->setContentBounds(gfx::Size(30, 30));
         child->setDrawsContent(true);
         root->addChild(child.Pass());
 
         return root.Pass();
     }
 
     scoped_ptr<LayerImpl> createTestTreeWithTwoSurfaces()
     {
         // This test tree has two render surfaces: one for the root, and one for
         // child1. Additionally, the root has a second child layer, and child1 has two
         // children of its own.
 
-        scoped_ptr<LayerImpl> root = LayerImpl::create(&m_hostImpl, 1);
-        scoped_ptr<LayerImpl> child1 = LayerImpl::create(&m_hostImpl, 2);
-        scoped_ptr<LayerImpl> child2 = LayerImpl::create(&m_hostImpl, 3);
-        scoped_ptr<LayerImpl> grandChild1 = LayerImpl::create(&m_hostImpl, 4);
-        scoped_ptr<LayerImpl> grandChild2 = LayerImpl::create(&m_hostImpl, 5);
+        scoped_ptr<LayerImpl> root = LayerImpl::create(m_hostImpl.activeTree(), 1);
+        scoped_ptr<LayerImpl> child1 = LayerImpl::create(m_hostImpl.activeTree(), 2);
+        scoped_ptr<LayerImpl> child2 = LayerImpl::create(m_hostImpl.activeTree(), 3);
+        scoped_ptr<LayerImpl> grandChild1 = LayerImpl::create(m_hostImpl.activeTree(), 4);
+        scoped_ptr<LayerImpl> grandChild2 = LayerImpl::create(m_hostImpl.activeTree(), 5);
 
         root->setPosition(gfx::PointF());
         root->setAnchorPoint(gfx::PointF());
         root->setBounds(gfx::Size(500, 500));
         root->setContentBounds(gfx::Size(500, 500));
         root->setDrawsContent(true);
         root->createRenderSurface();
         root->renderSurface()->setContentRect(gfx::Rect(gfx::Point(), gfx::Size(500, 500)));
 
         child1->setPosition(gfx::PointF(100, 100));
@@ skipping 410 matching lines @@
 
 TEST_F(DamageTrackerTest, verifyDamageForAddingAndRemovingLayer)
 {
     scoped_ptr<LayerImpl> root = createAndSetUpTestTreeWithOneSurface();
     LayerImpl* child1 = root->children()[0];
 
     // CASE 1: Adding a new layer should cause the appropriate damage.
     //
     clearDamageForAllSurfaces(root.get());
     {
-        scoped_ptr<LayerImpl> child2 = LayerImpl::create(&m_hostImpl, 3);
+        scoped_ptr<LayerImpl> child2 = LayerImpl::create(m_hostImpl.activeTree(), 3);
         child2->setPosition(gfx::PointF(400, 380));
         child2->setAnchorPoint(gfx::PointF());
         child2->setBounds(gfx::Size(6, 8));
         child2->setContentBounds(gfx::Size(6, 8));
         child2->setDrawsContent(true);
         root->addChild(child2.Pass());
     }
     emulateDrawingOneFrame(root.get());
 
     // Sanity check - all 3 layers should be on the same render surface; render surfaces are tested elsewhere.
@@ skipping 20 matching lines @@
 
 TEST_F(DamageTrackerTest, verifyDamageForNewUnchangedLayer)
 {
     // If child2 is added to the layer tree, but it doesn't have any explicit damage of
     // its own, it should still indeed damage the target surface.
 
     scoped_ptr<LayerImpl> root = createAndSetUpTestTreeWithOneSurface();
 
     clearDamageForAllSurfaces(root.get());
     {
-        scoped_ptr<LayerImpl> child2 = LayerImpl::create(&m_hostImpl, 3);
+        scoped_ptr<LayerImpl> child2 = LayerImpl::create(m_hostImpl.activeTree(), 3);
         child2->setPosition(gfx::PointF(400, 380));
         child2->setAnchorPoint(gfx::PointF());
         child2->setBounds(gfx::Size(6, 8));
         child2->setContentBounds(gfx::Size(6, 8));
         child2->setDrawsContent(true);
         child2->resetAllChangeTrackingForSubtree();
         // Sanity check the initial conditions of the test, if these asserts trigger, it
         // means the test no longer actually covers the intended scenario.
         ASSERT_FALSE(child2->layerPropertyChanged());
         ASSERT_TRUE(child2->updateRect().IsEmpty());
         root->addChild(child2.Pass());
     }
     emulateDrawingOneFrame(root.get());
 
     // Sanity check - all 3 layers should be on the same render surface; render surfaces are tested elsewhere.
     ASSERT_EQ(3u, root->renderSurface()->layerList().size());
 
     gfx::RectF rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
     EXPECT_FLOAT_RECT_EQ(gfx::RectF(400, 380, 6, 8), rootDamageRect);
 }
 
 TEST_F(DamageTrackerTest, verifyDamageForMultipleLayers)
 {
     scoped_ptr<LayerImpl> root = createAndSetUpTestTreeWithOneSurface();
     LayerImpl* child1 = root->children()[0];
 
     // In this test we don't want the above tree manipulation to be considered part of the same frame.
     clearDamageForAllSurfaces(root.get());
     {
-        scoped_ptr<LayerImpl> child2 = LayerImpl::create(&m_hostImpl, 3);
+        scoped_ptr<LayerImpl> child2 = LayerImpl::create(m_hostImpl.activeTree(), 3);
         child2->setPosition(gfx::PointF(400, 380));
         child2->setAnchorPoint(gfx::PointF());
         child2->setBounds(gfx::Size(6, 8));
         child2->setContentBounds(gfx::Size(6, 8));
         child2->setDrawsContent(true);
         root->addChild(child2.Pass());
     }
     LayerImpl* child2 = root->children()[1];
     emulateDrawingOneFrame(root.get());
 
@@ skipping 200 matching lines @@
     LayerImpl* grandChild2 = child1->children()[1];
 
     // Damage on a surface that has a reflection should cause the target surface to
     // receive the surface's damage and the surface's reflected damage.
 
     // For this test case, we modify grandChild2, and add grandChild3 to extend the bounds
     // of child1's surface. This way, we can test reflection changes without changing
     // contentBounds of the surface.
     grandChild2->setPosition(gfx::PointF(180, 180));
     {
-        scoped_ptr<LayerImpl> grandChild3 = LayerImpl::create(&m_hostImpl, 6);
+        scoped_ptr<LayerImpl> grandChild3 = LayerImpl::create(m_hostImpl.activeTree(), 6);
         grandChild3->setPosition(gfx::PointF(240, 240));
         grandChild3->setAnchorPoint(gfx::PointF());
         grandChild3->setBounds(gfx::Size(10, 10));
         grandChild3->setContentBounds(gfx::Size(10, 10));
         grandChild3->setDrawsContent(true);
         child1->addChild(grandChild3.Pass());
     }
     child1->setOpacity(0.5);
     emulateDrawingOneFrame(root.get());
 
     // CASE 1: adding a reflection about the left edge of grandChild1.
     //
     clearDamageForAllSurfaces(root.get());
     {
-        scoped_ptr<LayerImpl> grandChild1Replica = LayerImpl::create(&m_hostImpl, 7);
+        scoped_ptr<LayerImpl> grandChild1Replica = LayerImpl::create(m_hostImpl.activeTree(), 7);
         grandChild1Replica->setPosition(gfx::PointF());
         grandChild1Replica->setAnchorPoint(gfx::PointF());
         gfx::Transform reflection;
         reflection.Scale3d(-1, 1, 1);
         grandChild1Replica->setTransform(reflection);
         grandChild1->setReplicaLayer(grandChild1Replica.Pass());
     }
     emulateDrawingOneFrame(root.get());
 
     gfx::RectF grandChildDamageRect = grandChild1->renderSurface()->damageTracker()->currentDamageRect();
@@ skipping 47 matching lines @@
     scoped_ptr<LayerImpl> root = createAndSetUpTestTreeWithOneSurface();
     LayerImpl* child = root->children()[0];
 
     // In the current implementation of the damage tracker, changes to mask layers should
     // damage the entire corresponding surface.
 
     clearDamageForAllSurfaces(root.get());
 
     // Set up the mask layer.
     {
-        scoped_ptr<LayerImpl> maskLayer = LayerImpl::create(&m_hostImpl, 3);
+        scoped_ptr<LayerImpl> maskLayer = LayerImpl::create(m_hostImpl.activeTree(), 3);
         maskLayer->setPosition(child->position());
         maskLayer->setAnchorPoint(gfx::PointF());
         maskLayer->setBounds(child->bounds());
         maskLayer->setContentBounds(child->bounds());
         child->setMaskLayer(maskLayer.Pass());
     }
     LayerImpl* maskLayer = child->maskLayer();
 
     // Add opacity and a grandChild so that the render surface persists even after we remove the mask.
     child->setOpacity(0.5);
     {
-        scoped_ptr<LayerImpl> grandChild = LayerImpl::create(&m_hostImpl, 4);
+        scoped_ptr<LayerImpl> grandChild = LayerImpl::create(m_hostImpl.activeTree(), 4);
         grandChild->setPosition(gfx::PointF(2, 2));
         grandChild->setAnchorPoint(gfx::PointF());
         grandChild->setBounds(gfx::Size(2, 2));
         grandChild->setContentBounds(gfx::Size(2, 2));
         grandChild->setDrawsContent(true);
         child->addChild(grandChild.Pass());
     }
     emulateDrawingOneFrame(root.get());
 
     // Sanity check that a new surface was created for the child.
@@ skipping 52 matching lines @@
     LayerImpl* child1 = root->children()[0];
     LayerImpl* grandChild1 = child1->children()[0];
 
     // Changes to a replica's mask should not damage the original surface, because it is
     // not masked. But it does damage the ancestor target surface.
 
     clearDamageForAllSurfaces(root.get());
 
     // Create a reflection about the left edge of grandChild1.
     {
-        scoped_ptr<LayerImpl> grandChild1Replica = LayerImpl::create(&m_hostImpl, 6);
+        scoped_ptr<LayerImpl> grandChild1Replica = LayerImpl::create(m_hostImpl.activeTree(), 6);
         grandChild1Replica->setPosition(gfx::PointF());
         grandChild1Replica->setAnchorPoint(gfx::PointF());
         gfx::Transform reflection;
         reflection.Scale3d(-1, 1, 1);
         grandChild1Replica->setTransform(reflection);
         grandChild1->setReplicaLayer(grandChild1Replica.Pass());
     }
     LayerImpl* grandChild1Replica = grandChild1->replicaLayer();
 
     // Set up the mask layer on the replica layer
     {
-        scoped_ptr<LayerImpl> replicaMaskLayer = LayerImpl::create(&m_hostImpl, 7);
+        scoped_ptr<LayerImpl> replicaMaskLayer = LayerImpl::create(m_hostImpl.activeTree(), 7);
         replicaMaskLayer->setPosition(gfx::PointF());
         replicaMaskLayer->setAnchorPoint(gfx::PointF());
         replicaMaskLayer->setBounds(grandChild1->bounds());
         replicaMaskLayer->setContentBounds(grandChild1->bounds());
         grandChild1Replica->setMaskLayer(replicaMaskLayer.Pass());
     }
     LayerImpl* replicaMaskLayer = grandChild1Replica->maskLayer();
 
     emulateDrawingOneFrame(root.get());
 
@@ skipping 29 matching lines @@
     scoped_ptr<LayerImpl> root = createAndSetUpTestTreeWithTwoSurfaces();
     LayerImpl* child1 = root->children()[0];
     LayerImpl* grandChild1 = child1->children()[0];
 
     // Verify that the correct replicaOriginTransform is used for the replicaMask;
     clearDamageForAllSurfaces(root.get());
 
     grandChild1->setAnchorPoint(gfx::PointF(1, 0)); // This is not exactly the anchor being tested, but by convention its expected to be the same as the replica's anchor point.
 
     {
-        scoped_ptr<LayerImpl> grandChild1Replica = LayerImpl::create(&m_hostImpl, 6);
+        scoped_ptr<LayerImpl> grandChild1Replica = LayerImpl::create(m_hostImpl.activeTree(), 6);
         grandChild1Replica->setPosition(gfx::PointF());
         grandChild1Replica->setAnchorPoint(gfx::PointF(1, 0)); // This is the anchor being tested.
         gfx::Transform reflection;
         reflection.Scale3d(-1, 1, 1);
         grandChild1Replica->setTransform(reflection);
         grandChild1->setReplicaLayer(grandChild1Replica.Pass());
     }
     LayerImpl* grandChild1Replica = grandChild1->replicaLayer();
 
     // Set up the mask layer on the replica layer
     {
-        scoped_ptr<LayerImpl> replicaMaskLayer = LayerImpl::create(&m_hostImpl, 7);
+        scoped_ptr<LayerImpl> replicaMaskLayer = LayerImpl::create(m_hostImpl.activeTree(), 7);
         replicaMaskLayer->setPosition(gfx::PointF());
         replicaMaskLayer->setAnchorPoint(gfx::PointF()); // note, this is not the anchor being tested.
         replicaMaskLayer->setBounds(grandChild1->bounds());
         replicaMaskLayer->setContentBounds(grandChild1->bounds());
         grandChild1Replica->setMaskLayer(replicaMaskLayer.Pass());
     }
     LayerImpl* replicaMaskLayer = grandChild1Replica->maskLayer();
 
     emulateDrawingOneFrame(root.get());
 
@@ skipping 33 matching lines @@
     emulateDrawingOneFrame(root.get());
     rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
     EXPECT_FLOAT_RECT_EQ(gfx::RectF(0, 0, 500, 500), rootDamageRect);
 }
 
 TEST_F(DamageTrackerTest, verifyDamageForEmptyLayerList)
 {
     // Though it should never happen, its a good idea to verify that the damage tracker
     // does not crash when it receives an empty layerList.
 
-    scoped_ptr<LayerImpl> root = LayerImpl::create(&m_hostImpl, 1);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(m_hostImpl.activeTree(), 1);
     root->createRenderSurface();
 
     ASSERT_TRUE(root == root->renderTarget());
     RenderSurfaceImpl* targetSurface = root->renderSurface();
     targetSurface->clearLayerLists();
     targetSurface->damageTracker()->updateDamageTrackingState(targetSurface->layerList(), targetSurface->owningLayerId(), false, gfx::Rect(), 0, WebFilterOperations(), 0);
 
     gfx::RectF damageRect = targetSurface->damageTracker()->currentDamageRect();
     EXPECT_TRUE(damageRect.IsEmpty());
 }
@@ skipping 25 matching lines @@
     EXPECT_TRUE(rootDamageRect.IsEmpty());
 
     // Damage should remain empty even after one frame, since there's yet no new damage
     emulateDrawingOneFrame(root.get());
     rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
     EXPECT_TRUE(rootDamageRect.IsEmpty());
 }
 
 }  // namespace
 }  // namespace cc