cc: Pass LayerTreeHostImpl to LayerImpl constructor

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"
+#include "cc/test/fake_impl_proxy.h"
+#include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/geometry_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/effects/SkBlurImageFilter.h"
 #include "ui/gfx/quad_f.h"
 #include <public/WebFilterOperation.h>
 #include <public/WebFilterOperations.h>
 
 using namespace WebKit;
 using namespace WebKitTests;
 
@@ skipping 35 matching lines @@
 
     // Iterate back-to-front, so that damage correctly propagates from descendant surfaces to ancestors.
     for (int i = renderSurfaceLayerList.size() - 1; i >= 0; --i) {
         RenderSurfaceImpl* targetSurface = renderSurfaceLayerList[i]->renderSurface();
         targetSurface->damageTracker()->updateDamageTrackingState(targetSurface->layerList(), targetSurface->owningLayerId(), targetSurface->surfacePropertyChangedOnlyFromDescendant(), targetSurface->contentRect(), renderSurfaceLayerList[i]->maskLayer(), renderSurfaceLayerList[i]->filters(), renderSurfaceLayerList[i]->filter().get());
     }
 
     root->resetAllChangeTrackingForSubtree();
 }
 
-scoped_ptr<LayerImpl> createTestTreeWithOneSurface()
-{
-    scoped_ptr<LayerImpl> root = LayerImpl::create(1);
-    scoped_ptr<LayerImpl> child = LayerImpl::create(2);
+class DamageTrackerTest : public testing::Test {
+public:
+    DamageTrackerTest()
+        : m_hostImpl(&m_proxy)
+    {
+    }
 
-    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)));
+    scoped_ptr<LayerImpl> createTestTreeWithOneSurface()
+    {
+        scoped_ptr<LayerImpl> root = LayerImpl::create(&m_hostImpl, 1);
+        scoped_ptr<LayerImpl> child = LayerImpl::create(&m_hostImpl, 2);
 
-    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());
+        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)));
 
-    return root.Pass();
-}
+        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());
 
-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.
+        return root.Pass();
+    }
 
-    scoped_ptr<LayerImpl> root = LayerImpl::create(1);
-    scoped_ptr<LayerImpl> child1 = LayerImpl::create(2);
-    scoped_ptr<LayerImpl> child2 = LayerImpl::create(3);
-    scoped_ptr<LayerImpl> grandChild1 = LayerImpl::create(4);
-    scoped_ptr<LayerImpl> grandChild2 = LayerImpl::create(5);
+    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.
 
-    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)));
+        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);
 
-    child1->setPosition(gfx::PointF(100, 100));
-    child1->setAnchorPoint(gfx::PointF());
-    child1->setBounds(gfx::Size(30, 30));
-    child1->setContentBounds(gfx::Size(30, 30));
-    child1->setOpacity(0.5); // with a child that drawsContent, this will cause the layer to create its own renderSurface.
-    child1->setDrawsContent(false); // this layer does not draw, but is intended to create its own renderSurface.
-    child1->setForceRenderSurface(true);
+        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)));
 
-    child2->setPosition(gfx::PointF(11, 11));
-    child2->setAnchorPoint(gfx::PointF());
-    child2->setBounds(gfx::Size(18, 18));
-    child2->setContentBounds(gfx::Size(18, 18));
-    child2->setDrawsContent(true);
+        child1->setPosition(gfx::PointF(100, 100));
+        child1->setAnchorPoint(gfx::PointF());
+        child1->setBounds(gfx::Size(30, 30));
+        child1->setContentBounds(gfx::Size(30, 30));
+        child1->setOpacity(0.5); // with a child that drawsContent, this will cause the layer to create its own renderSurface.
+        child1->setDrawsContent(false); // this layer does not draw, but is intended to create its own renderSurface.
+        child1->setForceRenderSurface(true);
 
-    grandChild1->setPosition(gfx::PointF(200, 200));
-    grandChild1->setAnchorPoint(gfx::PointF());
-    grandChild1->setBounds(gfx::Size(6, 8));
-    grandChild1->setContentBounds(gfx::Size(6, 8));
-    grandChild1->setDrawsContent(true);
+        child2->setPosition(gfx::PointF(11, 11));
+        child2->setAnchorPoint(gfx::PointF());
+        child2->setBounds(gfx::Size(18, 18));
+        child2->setContentBounds(gfx::Size(18, 18));
+        child2->setDrawsContent(true);
 
-    grandChild2->setPosition(gfx::PointF(190, 190));
-    grandChild2->setAnchorPoint(gfx::PointF());
-    grandChild2->setBounds(gfx::Size(6, 8));
-    grandChild2->setContentBounds(gfx::Size(6, 8));
-    grandChild2->setDrawsContent(true);
+        grandChild1->setPosition(gfx::PointF(200, 200));
+        grandChild1->setAnchorPoint(gfx::PointF());
+        grandChild1->setBounds(gfx::Size(6, 8));
+        grandChild1->setContentBounds(gfx::Size(6, 8));
+        grandChild1->setDrawsContent(true);
 
-    child1->addChild(grandChild1.Pass());
-    child1->addChild(grandChild2.Pass());
-    root->addChild(child1.Pass());
-    root->addChild(child2.Pass());
+        grandChild2->setPosition(gfx::PointF(190, 190));
+        grandChild2->setAnchorPoint(gfx::PointF());
+        grandChild2->setBounds(gfx::Size(6, 8));
+        grandChild2->setContentBounds(gfx::Size(6, 8));
+        grandChild2->setDrawsContent(true);
 
-    return root.Pass();
-}
+        child1->addChild(grandChild1.Pass());
+        child1->addChild(grandChild2.Pass());
+        root->addChild(child1.Pass());
+        root->addChild(child2.Pass());
 
-scoped_ptr<LayerImpl> createAndSetUpTestTreeWithOneSurface()
-{
-    scoped_ptr<LayerImpl> root = createTestTreeWithOneSurface();
+        return root.Pass();
+    }
 
-    // Setup includes going past the first frame which always damages everything, so
-    // that we can actually perform specific tests.
-    emulateDrawingOneFrame(root.get());
+    scoped_ptr<LayerImpl> createAndSetUpTestTreeWithOneSurface()
+    {
+        scoped_ptr<LayerImpl> root = createTestTreeWithOneSurface();
 
-    return root.Pass();
-}
+        // Setup includes going past the first frame which always damages everything, so
+        // that we can actually perform specific tests.
+        emulateDrawingOneFrame(root.get());
 
-scoped_ptr<LayerImpl> createAndSetUpTestTreeWithTwoSurfaces()
-{
-    scoped_ptr<LayerImpl> root = createTestTreeWithTwoSurfaces();
+        return root.Pass();
+    }
 
-    // Setup includes going past the first frame which always damages everything, so
-    // that we can actually perform specific tests.
-    emulateDrawingOneFrame(root.get());
+    scoped_ptr<LayerImpl> createAndSetUpTestTreeWithTwoSurfaces()
+    {
+        scoped_ptr<LayerImpl> root = createTestTreeWithTwoSurfaces();
 
-    return root.Pass();
-}
+        // Setup includes going past the first frame which always damages everything, so
+        // that we can actually perform specific tests.
+        emulateDrawingOneFrame(root.get());
 
-class DamageTrackerTest : public testing::Test {
+        return root.Pass();
+    }
+
+protected:
+    FakeImplProxy m_proxy;
+    FakeLayerTreeHostImpl m_hostImpl;
 };
 
 TEST_F(DamageTrackerTest, sanityCheckTestTreeWithOneSurface)
 {
     // Sanity check that the simple test tree will actually produce the expected render
     // surfaces and layer lists.
 
     scoped_ptr<LayerImpl> root = createAndSetUpTestTreeWithOneSurface();
 
     EXPECT_EQ(2u, root->renderSurface()->layerList().size());
@@ skipping 342 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(3);
+        scoped_ptr<LayerImpl> child2 = LayerImpl::create(&m_hostImpl, 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 19 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(3);
+        scoped_ptr<LayerImpl> child2 = LayerImpl::create(&m_hostImpl, 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(3);
+        scoped_ptr<LayerImpl> child2 = LayerImpl::create(&m_hostImpl, 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(6);
+        scoped_ptr<LayerImpl> grandChild3 = LayerImpl::create(&m_hostImpl, 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(7);
+        scoped_ptr<LayerImpl> grandChild1Replica = LayerImpl::create(&m_hostImpl, 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(3);
+        scoped_ptr<LayerImpl> maskLayer = LayerImpl::create(&m_hostImpl, 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(4);
+        scoped_ptr<LayerImpl> grandChild = LayerImpl::create(&m_hostImpl, 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(6);
+        scoped_ptr<LayerImpl> grandChild1Replica = LayerImpl::create(&m_hostImpl, 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(7);
+        scoped_ptr<LayerImpl> replicaMaskLayer = LayerImpl::create(&m_hostImpl, 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(6);
+        scoped_ptr<LayerImpl> grandChild1Replica = LayerImpl::create(&m_hostImpl, 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(7);
+        scoped_ptr<LayerImpl> replicaMaskLayer = LayerImpl::create(&m_hostImpl, 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(1);
+    scoped_ptr<LayerImpl> root = LayerImpl::create(&m_hostImpl, 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