cc: Move RenderTarget Information to Effect Tree

cc/trees/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/trees/layer_tree_host_common.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <set>
@@ skipping 442 matching lines @@
       parent_composite_transform,
       draw_property_utils::ScreenSpaceTransform(child, tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       parent_composite_transform,
       draw_property_utils::DrawTransform(grand_child, tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       parent_composite_transform,
       draw_property_utils::ScreenSpaceTransform(grand_child, tree));
 }
 
-// Render target should get cleared when subtree is skipped.
-TEST_F(LayerTreeHostCommonTest, ClearRenderTargetForSkippedLayers) {
-  LayerImpl* root = root_layer();
-  LayerImpl* parent = AddChildToRoot<LayerImpl>();
-  LayerImpl* child = AddChild<LayerImpl>(parent);
-  child->SetDrawsContent(true);
-
-  gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(1, 2), true, false,
-                               true);
-  SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(1, 2), true, false,
-                               true);
-  SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(), gfx::Size(1, 2), true, false,
-                               false);
-
-  ExecuteCalculateDrawProperties(root);
-  ASSERT_TRUE(parent->render_surface());
-  EXPECT_EQ(parent, child->render_target());
-
-  // child is skipped when root's opacity is set to 0. So, its render target
-  // should be reset.
-  root->OnOpacityAnimated(0.0f);
-  ExecuteCalculateDrawProperties(root);
-  EXPECT_FALSE(child->render_target());
-}
-
 TEST_F(LayerTreeHostCommonTest, TransformsForSingleRenderSurface) {
   LayerImpl* root = root_layer();
   LayerImpl* parent = AddChildToRoot<LayerImpl>();
   LayerImpl* child = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
   grand_child->SetDrawsContent(true);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false,
@@ skipping 26 matching lines @@
   SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(16, 18), true, false,
                                true);
   SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(8, 10), true, false,
                                false);
   ExecuteCalculateDrawProperties(root);
 
   // Render surface should have been created now.
   ASSERT_TRUE(child->render_surface());
-  ASSERT_EQ(child, child->render_target());
+  ASSERT_EQ(child->render_surface(), child->render_target());
 
   // The child layer's draw transform should refer to its new render surface.
   // The screen-space transform, however, should still refer to the root.
   EXPECT_TRANSFORMATION_MATRIX_EQ(surface_sublayer_transform,
                                   child->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(parent_composite_transform,
                                   child->ScreenSpaceTransform());
 
   // Because the grand_child is the only drawable content, the child's render
   // surface will tighten its bounds to the grand_child.  The scale at which the
   // surface's subtree is drawn must be removed from the composite transform.
-  EXPECT_TRANSFORMATION_MATRIX_EQ(
-      surface_sublayer_composite_transform,
-      child->render_target()->render_surface()->draw_transform());
+  EXPECT_TRANSFORMATION_MATRIX_EQ(surface_sublayer_composite_transform,
+                                  child->render_target()->draw_transform());
 
   // The screen space is the same as the target since the child surface draws
   // into the root.
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       surface_sublayer_composite_transform,
-      child->render_target()->render_surface()->screen_space_transform());
+      child->render_target()->screen_space_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsWhenCannotRenderToSeparateSurface) {
   LayerImpl* root = root_layer();
   LayerImpl* parent = AddChildToRoot<LayerImpl>();
   LayerImpl* child = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
   grand_child->SetDrawsContent(true);
 
   gfx::Transform identity_matrix;
@@ skipping 95 matching lines @@
                                false, false);
   SetLayerPropertiesForTesting(child_replica.get(), replica_layer_transform,
                                gfx::Point3F(), gfx::PointF(), gfx::Size(), true,
                                false, false);
   child->SetReplicaLayer(std::move(child_replica));
 
   ExecuteCalculateDrawProperties(root);
 
   // Render surface should have been created now.
   ASSERT_TRUE(child->render_surface());
-  ASSERT_EQ(child, child->render_target());
+  ASSERT_EQ(child->render_surface(), child->render_target());
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       replica_composite_transform,
-      child->render_target()->render_surface()->replica_draw_transform());
+      child->render_target()->replica_draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(replica_composite_transform,
                                   child->render_target()
-                                      ->render_surface()
                                       ->replica_screen_space_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForRenderSurfaceHierarchy) {
   // This test creates a more complex tree and verifies it all at once. This
   // covers the following cases:
   //   - layers that are described w.r.t. a render surface: should have draw
   //   transforms described w.r.t. that surface
   //   - A render surface described w.r.t. an ancestor render surface: should
   //   have a draw transform described w.r.t. that ancestor surface
@@ skipping 128 matching lines @@
 
   ASSERT_TRUE(render_surface1->render_surface());
   ASSERT_FALSE(child_of_rs1->render_surface());
   ASSERT_FALSE(grand_child_of_rs1->render_surface());
 
   ASSERT_TRUE(render_surface2->render_surface());
   ASSERT_FALSE(child_of_rs2->render_surface());
   ASSERT_FALSE(grand_child_of_rs2->render_surface());
 
   // Verify all render target accessors
-  EXPECT_EQ(root, parent->render_target());
-  EXPECT_EQ(root, child_of_root->render_target());
-  EXPECT_EQ(root, grand_child_of_root->render_target());
+  EXPECT_EQ(root->render_surface(), parent->render_target());
+  EXPECT_EQ(root->render_surface(), child_of_root->render_target());
+  EXPECT_EQ(root->render_surface(), grand_child_of_root->render_target());
 
-  EXPECT_EQ(render_surface1, render_surface1->render_target());
-  EXPECT_EQ(render_surface1, child_of_rs1->render_target());
-  EXPECT_EQ(render_surface1, grand_child_of_rs1->render_target());
+  EXPECT_EQ(render_surface1->render_surface(),
+            render_surface1->render_target());
+  EXPECT_EQ(render_surface1->render_surface(), child_of_rs1->render_target());
+  EXPECT_EQ(render_surface1->render_surface(),
+            grand_child_of_rs1->render_target());
 
-  EXPECT_EQ(render_surface2, render_surface2->render_target());
-  EXPECT_EQ(render_surface2, child_of_rs2->render_target());
-  EXPECT_EQ(render_surface2, grand_child_of_rs2->render_target());
+  EXPECT_EQ(render_surface2->render_surface(),
+            render_surface2->render_target());
+  EXPECT_EQ(render_surface2->render_surface(), child_of_rs2->render_target());
+  EXPECT_EQ(render_surface2->render_surface(),
+            grand_child_of_rs2->render_target());
 
   // Verify layer draw transforms note that draw transforms are described with
   // respect to the nearest ancestor render surface but screen space transforms
   // are described with respect to the root.
   EXPECT_TRANSFORMATION_MATRIX_EQ(A, parent->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(A * A, child_of_root->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(A * A * A,
                                   grand_child_of_root->DrawTransform());
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(SS1, render_surface1->DrawTransform());
@@ skipping 1607 matching lines @@
   grand_child->SetHasRenderSurface(true);
 
   gfx::Transform expected_leaf_draw_transform_with_surfaces;
   expected_leaf_draw_transform_with_surfaces.Translate(16.0, 16.0);
 
   gfx::Transform expected_leaf_draw_transform_without_surfaces;
   expected_leaf_draw_transform_without_surfaces.Translate(30.0, 30.0);
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_FALSE(leaf_node->is_clipped());
-  EXPECT_TRUE(leaf_node->render_target()->render_surface()->is_clipped());
+  EXPECT_TRUE(leaf_node->render_target()->is_clipped());
   EXPECT_EQ(gfx::Rect(16, 16, 2000, 2000), leaf_node->drawable_content_rect());
   EXPECT_EQ(expected_leaf_draw_transform_with_surfaces,
             leaf_node->DrawTransform());
 
   root->SetHasRenderSurface(true);
   child->SetHasRenderSurface(true);
   grand_child->SetHasRenderSurface(true);
 
   ExecuteCalculateDrawPropertiesWithoutSeparateSurfaces(root);
   EXPECT_TRUE(leaf_node->is_clipped());
   EXPECT_EQ(gfx::Rect(6, 6, 396, 396), leaf_node->clip_rect());
   EXPECT_EQ(gfx::Rect(30, 30, 372, 372), leaf_node->drawable_content_rect());
   EXPECT_EQ(expected_leaf_draw_transform_without_surfaces,
             leaf_node->DrawTransform());
 
   root->SetHasRenderSurface(true);
   child->SetHasRenderSurface(true);
   grand_child->SetHasRenderSurface(true);
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_FALSE(leaf_node->is_clipped());
-  EXPECT_TRUE(leaf_node->render_target()->render_surface()->is_clipped());
+  EXPECT_TRUE(leaf_node->render_target()->is_clipped());
   EXPECT_EQ(gfx::Rect(16, 16, 2000, 2000), leaf_node->drawable_content_rect());
   EXPECT_EQ(expected_leaf_draw_transform_with_surfaces,
             leaf_node->DrawTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest, AnimationsForRenderSurfaceHierarchy) {
   LayerImpl* parent = root_layer();
   LayerImpl* render_surface1 = AddChildToRoot<LayerImpl>();
   LayerImpl* child_of_rs1 = AddChild<LayerImpl>(render_surface1);
   LayerImpl* grand_child_of_rs1 = AddChild<LayerImpl>(child_of_rs1);
@@ skipping 73 matching lines @@
 
   ASSERT_TRUE(render_surface1->render_surface());
   ASSERT_FALSE(child_of_rs1->render_surface());
   ASSERT_FALSE(grand_child_of_rs1->render_surface());
 
   ASSERT_TRUE(render_surface2->render_surface());
   ASSERT_FALSE(child_of_rs2->render_surface());
   ASSERT_FALSE(grand_child_of_rs2->render_surface());
 
   // Verify all render target accessors
-  EXPECT_EQ(parent, parent->render_target());
-  EXPECT_EQ(parent, child_of_root->render_target());
-  EXPECT_EQ(parent, grand_child_of_root->render_target());
+  EXPECT_EQ(parent->render_surface(), parent->render_target());
+  EXPECT_EQ(parent->render_surface(), child_of_root->render_target());
+  EXPECT_EQ(parent->render_surface(), grand_child_of_root->render_target());
 
-  EXPECT_EQ(render_surface1, render_surface1->render_target());
-  EXPECT_EQ(render_surface1, child_of_rs1->render_target());
-  EXPECT_EQ(render_surface1, grand_child_of_rs1->render_target());
+  EXPECT_EQ(render_surface1->render_surface(),
+            render_surface1->render_target());
+  EXPECT_EQ(render_surface1->render_surface(), child_of_rs1->render_target());
+  EXPECT_EQ(render_surface1->render_surface(),
+            grand_child_of_rs1->render_target());
 
-  EXPECT_EQ(render_surface2, render_surface2->render_target());
-  EXPECT_EQ(render_surface2, child_of_rs2->render_target());
-  EXPECT_EQ(render_surface2, grand_child_of_rs2->render_target());
+  EXPECT_EQ(render_surface2->render_surface(),
+            render_surface2->render_target());
+  EXPECT_EQ(render_surface2->render_surface(), child_of_rs2->render_target());
+  EXPECT_EQ(render_surface2->render_surface(),
+            grand_child_of_rs2->render_target());
 
   // Verify screen_space_transform_is_animating values
   EXPECT_FALSE(parent->screen_space_transform_is_animating());
   EXPECT_FALSE(child_of_root->screen_space_transform_is_animating());
   EXPECT_TRUE(grand_child_of_root->screen_space_transform_is_animating());
   EXPECT_FALSE(render_surface1->screen_space_transform_is_animating());
   EXPECT_FALSE(child_of_rs1->screen_space_transform_is_animating());
   EXPECT_FALSE(grand_child_of_rs1->screen_space_transform_is_animating());
   EXPECT_TRUE(render_surface2->screen_space_transform_is_animating());
   EXPECT_TRUE(child_of_rs2->screen_space_transform_is_animating());
@@ skipping 6663 matching lines @@
   SetLayerPropertiesForTesting(render_surface, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                true);
   SetLayerPropertiesForTesting(test_layer, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                false);
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(test_layer->is_clipped());
-  EXPECT_FALSE(test_layer->render_target()->render_surface()->is_clipped());
+  EXPECT_FALSE(test_layer->render_target()->is_clipped());
   EXPECT_EQ(gfx::Rect(-2, -2, 30, 30), test_layer->clip_rect());
   EXPECT_EQ(gfx::Rect(28, 28), test_layer->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        RenderSurfaceWithUnclippedDescendantsButDoesntApplyOwnClip) {
   // Ensure that the visible layer rect of a descendant of a surface with
   // unclipped descendants is computed correctly, when the surface doesn't apply
   // a clip.
   LayerImpl* root = root_layer();
@@ skipping 719 matching lines @@
   EXPECT_EQ(scroll_child6.id, grand_child10->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent3->scroll_tree_index());
   EXPECT_EQ(scroll_child7.id, child8->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent4->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, child9->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, grand_child12->scroll_tree_index());
 }
 
 }  // namespace
 }  // namespace cc