cc: Chromify the LayerTreeHostImpl class.

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 55 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.activeTree(), 1);
-        scoped_ptr<LayerImpl> child = LayerImpl::Create(m_hostImpl.activeTree(), 2);
+        scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl.active_tree(), 1);
+        scoped_ptr<LayerImpl> child = LayerImpl::Create(m_hostImpl.active_tree(), 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->render_surface()->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.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);
+        scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl.active_tree(), 1);
+        scoped_ptr<LayerImpl> child1 = LayerImpl::Create(m_hostImpl.active_tree(), 2);
+        scoped_ptr<LayerImpl> child2 = LayerImpl::Create(m_hostImpl.active_tree(), 3);
+        scoped_ptr<LayerImpl> grandChild1 = LayerImpl::Create(m_hostImpl.active_tree(), 4);
+        scoped_ptr<LayerImpl> grandChild2 = LayerImpl::Create(m_hostImpl.active_tree(), 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->render_surface()->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.activeTree(), 3);
+        scoped_ptr<LayerImpl> child2 = LayerImpl::Create(m_hostImpl.active_tree(), 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.activeTree(), 3);
+        scoped_ptr<LayerImpl> child2 = LayerImpl::Create(m_hostImpl.active_tree(), 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->update_rect().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->render_surface()->layer_list().size());
 
     gfx::RectF rootDamageRect = root->render_surface()->damage_tracker()->current_damage_rect();
     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.activeTree(), 3);
+        scoped_ptr<LayerImpl> child2 = LayerImpl::Create(m_hostImpl.active_tree(), 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.activeTree(), 6);
+        scoped_ptr<LayerImpl> grandChild3 = LayerImpl::Create(m_hostImpl.active_tree(), 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.activeTree(), 7);
+        scoped_ptr<LayerImpl> grandChild1Replica = LayerImpl::Create(m_hostImpl.active_tree(), 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->render_surface()->damage_tracker()->current_damage_rect();
@@ 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.activeTree(), 3);
+        scoped_ptr<LayerImpl> maskLayer = LayerImpl::Create(m_hostImpl.active_tree(), 3);
         maskLayer->SetPosition(child->position());
         maskLayer->SetAnchorPoint(gfx::PointF());
         maskLayer->SetBounds(child->bounds());
         maskLayer->SetContentBounds(child->bounds());
         child->SetMaskLayer(maskLayer.Pass());
     }
     LayerImpl* maskLayer = child->mask_layer();
 
     // 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.activeTree(), 4);
+        scoped_ptr<LayerImpl> grandChild = LayerImpl::Create(m_hostImpl.active_tree(), 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.activeTree(), 6);
+        scoped_ptr<LayerImpl> grandChild1Replica = LayerImpl::Create(m_hostImpl.active_tree(), 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->replica_layer();
 
     // Set up the mask layer on the replica layer
     {
-        scoped_ptr<LayerImpl> replicaMaskLayer = LayerImpl::Create(m_hostImpl.activeTree(), 7);
+        scoped_ptr<LayerImpl> replicaMaskLayer = LayerImpl::Create(m_hostImpl.active_tree(), 7);
         replicaMaskLayer->SetPosition(gfx::PointF());
         replicaMaskLayer->SetAnchorPoint(gfx::PointF());
         replicaMaskLayer->SetBounds(grandChild1->bounds());
         replicaMaskLayer->SetContentBounds(grandChild1->bounds());
         grandChild1Replica->SetMaskLayer(replicaMaskLayer.Pass());
     }
     LayerImpl* replicaMaskLayer = grandChild1Replica->mask_layer();
 
     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.activeTree(), 6);
+        scoped_ptr<LayerImpl> grandChild1Replica = LayerImpl::Create(m_hostImpl.active_tree(), 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->replica_layer();
 
     // Set up the mask layer on the replica layer
     {
-        scoped_ptr<LayerImpl> replicaMaskLayer = LayerImpl::Create(m_hostImpl.activeTree(), 7);
+        scoped_ptr<LayerImpl> replicaMaskLayer = LayerImpl::Create(m_hostImpl.active_tree(), 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->mask_layer();
 
     emulateDrawingOneFrame(root.get());
 
@@ skipping 33 matching lines @@
     emulateDrawingOneFrame(root.get());
     rootDamageRect = root->render_surface()->damage_tracker()->current_damage_rect();
     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.activeTree(), 1);
+    scoped_ptr<LayerImpl> root = LayerImpl::Create(m_hostImpl.active_tree(), 1);
     root->CreateRenderSurface();
 
     ASSERT_TRUE(root == root->render_target());
     RenderSurfaceImpl* targetSurface = root->render_surface();
     targetSurface->ClearLayerLists();
     targetSurface->damage_tracker()->UpdateDamageTrackingState(targetSurface->layer_list(), targetSurface->OwningLayerId(), false, gfx::Rect(), 0, WebFilterOperations(), 0);
 
     gfx::RectF damageRect = targetSurface->damage_tracker()->current_damage_rect();
     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->render_surface()->damage_tracker()->current_damage_rect();
     EXPECT_TRUE(rootDamageRect.IsEmpty());
 }
 
 }  // namespace
 }  // namespace cc