Pass accurate contentsScale to LayerImpl.

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 "config.h"
 
 #include "cc/damage_tracker.h"
 
 #include "cc/layer_impl.h"
 #include "cc/layer_sorter.h"
@@ skipping 56 matching lines @@
 }
 
 scoped_ptr<LayerImpl> createTestTreeWithOneSurface()
 {
     scoped_ptr<LayerImpl> root = LayerImpl::create(1);
     scoped_ptr<LayerImpl> child = LayerImpl::create(2);
 
     root->setPosition(FloatPoint::zero());
     root->setAnchorPoint(FloatPoint::zero());
     root->setBounds(IntSize(500, 500));
-    root->setContentBounds(IntSize(500, 500));
     root->setDrawsContent(true);
     root->createRenderSurface();
     root->renderSurface()->setContentRect(IntRect(IntPoint(), IntSize(500, 500)));
 
     child->setPosition(FloatPoint(100, 100));
     child->setAnchorPoint(FloatPoint::zero());
     child->setBounds(IntSize(30, 30));
-    child->setContentBounds(IntSize(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(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);
 
     root->setPosition(FloatPoint::zero());
     root->setAnchorPoint(FloatPoint::zero());
     root->setBounds(IntSize(500, 500));
-    root->setContentBounds(IntSize(500, 500));
     root->setDrawsContent(true);
     root->createRenderSurface();
     root->renderSurface()->setContentRect(IntRect(IntPoint(), IntSize(500, 500)));
 
     child1->setPosition(FloatPoint(100, 100));
     child1->setAnchorPoint(FloatPoint::zero());
     child1->setBounds(IntSize(30, 30));
-    child1->setContentBounds(IntSize(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.
 
     child2->setPosition(FloatPoint(11, 11));
     child2->setAnchorPoint(FloatPoint::zero());
     child2->setBounds(IntSize(18, 18));
-    child2->setContentBounds(IntSize(18, 18));
     child2->setDrawsContent(true);
 
     grandChild1->setPosition(FloatPoint(200, 200));
     grandChild1->setAnchorPoint(FloatPoint::zero());
     grandChild1->setBounds(IntSize(6, 8));
-    grandChild1->setContentBounds(IntSize(6, 8));
     grandChild1->setDrawsContent(true);
 
     grandChild2->setPosition(FloatPoint(190, 190));
     grandChild2->setAnchorPoint(FloatPoint::zero());
     grandChild2->setBounds(IntSize(6, 8));
-    grandChild2->setContentBounds(IntSize(6, 8));
     grandChild2->setDrawsContent(true);
 
     child1->addChild(grandChild1.Pass());
     child1->addChild(grandChild2.Pass());
     root->addChild(child1.Pass());
     root->addChild(child2.Pass());
 
     return root.Pass();
 }
 
@@ skipping 190 matching lines @@
 
     WebTransformationMatrix transform;
     transform.translate3d(500, 500, 0);
     transform.applyPerspective(1);
     transform.rotate3d(0, 45, 0);
     transform.translate3d(-50, -50, 0);
 
     // Set up the child
     child->setPosition(FloatPoint(0, 0));
     child->setBounds(IntSize(100, 100));
-    child->setContentBounds(IntSize(100, 100));
     child->setTransform(transform);
     emulateDrawingOneFrame(root.get());
 
     // Sanity check that the child layer's bounds would actually get clipped by w < 0,
     // otherwise this test is not actually testing the intended scenario.
     FloatQuad testQuad(FloatRect(FloatPoint::zero(), FloatSize(100, 100)));
     bool clipped = false;
     MathUtil::mapQuad(transform, testQuad, clipped);
     EXPECT_TRUE(clipped);
 
@@ skipping 177 matching lines @@
     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);
         child2->setPosition(FloatPoint(400, 380));
         child2->setAnchorPoint(FloatPoint::zero());
         child2->setBounds(IntSize(6, 8));
-        child2->setContentBounds(IntSize(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.
     ASSERT_EQ(3u, root->renderSurface()->layerList().size());
 
     FloatRect rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
     EXPECT_FLOAT_RECT_EQ(FloatRect(400, 380, 6, 8), rootDamageRect);
@@ skipping 19 matching lines @@
     // 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);
         child2->setPosition(FloatPoint(400, 380));
         child2->setAnchorPoint(FloatPoint::zero());
         child2->setBounds(IntSize(6, 8));
-        child2->setContentBounds(IntSize(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());
 
     FloatRect rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
     EXPECT_FLOAT_RECT_EQ(FloatRect(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);
         child2->setPosition(FloatPoint(400, 380));
         child2->setAnchorPoint(FloatPoint::zero());
         child2->setBounds(IntSize(6, 8));
-        child2->setContentBounds(IntSize(6, 8));
         child2->setDrawsContent(true);
         root->addChild(child2.Pass());
     }
     LayerImpl* child2 = root->children()[1];
     emulateDrawingOneFrame(root.get());
 
     // Damaging two layers simultaneously should cause combined damage.
     // - child1 update rect in surface space: FloatRect(100, 100, 1, 2);
     // - child2 update rect in surface space: FloatRect(400, 380, 3, 4);
     clearDamageForAllSurfaces(root.get());
@@ skipping 198 matching lines @@
 
     // 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(FloatPoint(180, 180));
     {
         scoped_ptr<LayerImpl> grandChild3 = LayerImpl::create(6);
         grandChild3->setPosition(FloatPoint(240, 240));
         grandChild3->setAnchorPoint(FloatPoint::zero());
         grandChild3->setBounds(IntSize(10, 10));
-        grandChild3->setContentBounds(IntSize(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());
     {
@@ skipping 62 matching lines @@
     // damage the entire corresponding surface.
 
     clearDamageForAllSurfaces(root.get());
 
     // Set up the mask layer.
     {
         scoped_ptr<LayerImpl> maskLayer = LayerImpl::create(3);
         maskLayer->setPosition(child->position());
         maskLayer->setAnchorPoint(FloatPoint::zero());
         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);
         grandChild->setPosition(FloatPoint(2, 2));
         grandChild->setAnchorPoint(FloatPoint::zero());
         grandChild->setBounds(IntSize(2, 2));
-        grandChild->setContentBounds(IntSize(2, 2));
         grandChild->setDrawsContent(true);
         child->addChild(grandChild.Pass());
     }
     emulateDrawingOneFrame(root.get());
 
     // Sanity check that a new surface was created for the child.
     ASSERT_TRUE(child->renderSurface());
 
     // CASE 1: the updateRect on a mask layer should damage the entire target surface.
     //
@@ skipping 64 matching lines @@
         grandChild1->setReplicaLayer(grandChild1Replica.Pass());
     }
     LayerImpl* grandChild1Replica = grandChild1->replicaLayer();
 
     // Set up the mask layer on the replica layer
     {
         scoped_ptr<LayerImpl> replicaMaskLayer = LayerImpl::create(7);
         replicaMaskLayer->setPosition(FloatPoint::zero());
         replicaMaskLayer->setAnchorPoint(FloatPoint::zero());
         replicaMaskLayer->setBounds(grandChild1->bounds());
-        replicaMaskLayer->setContentBounds(grandChild1->bounds());
         grandChild1Replica->setMaskLayer(replicaMaskLayer.Pass());
     }
     LayerImpl* replicaMaskLayer = grandChild1Replica->maskLayer();
 
     emulateDrawingOneFrame(root.get());
 
     // Sanity check that the appropriate render surfaces were created
     ASSERT_TRUE(grandChild1->renderSurface());
 
     // CASE 1: a property change on the mask should damage only the reflected region on the target surface.
@@ skipping 41 matching lines @@
         grandChild1->setReplicaLayer(grandChild1Replica.Pass());
     }
     LayerImpl* grandChild1Replica = grandChild1->replicaLayer();
 
     // Set up the mask layer on the replica layer
     {
         scoped_ptr<LayerImpl> replicaMaskLayer = LayerImpl::create(7);
         replicaMaskLayer->setPosition(FloatPoint::zero());
         replicaMaskLayer->setAnchorPoint(FloatPoint::zero()); // 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());
 
     // Sanity check that the appropriate render surfaces were created
     ASSERT_TRUE(grandChild1->renderSurface());
 
     // A property change on the replicaMask should damage the reflected region on the target surface.
@@ skipping 74 matching lines @@
     rootDamageRect = root->renderSurface()->damageTracker()->currentDamageRect();
     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