Compute if a layer is clipped outside CalcDrawProps

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 <algorithm>
 #include <set>
 
 #include "cc/animation/layer_animation_controller.h"
@@ skipping 1807 matching lines @@
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
         root.get(), parent->bounds(), &render_surface_layer_list);
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     ASSERT_TRUE(root->render_surface());
     ASSERT_TRUE(child2->render_surface());
 
-    EXPECT_FALSE(root->is_clipped());
+    EXPECT_FALSE(root->is_clipped_from_property_tree());
     EXPECT_TRUE(root->render_surface()->is_clipped());
-    EXPECT_FALSE(parent->is_clipped());
-    EXPECT_FALSE(child1->is_clipped());
-    EXPECT_FALSE(child2->is_clipped());
+    EXPECT_FALSE(parent->is_clipped_from_property_tree());
+    EXPECT_FALSE(child1->is_clipped_from_property_tree());
+    EXPECT_FALSE(child2->is_clipped_from_property_tree());
     EXPECT_FALSE(child2->render_surface()->is_clipped());
-    EXPECT_FALSE(grand_child->is_clipped());
-    EXPECT_FALSE(leaf_node1->is_clipped());
-    EXPECT_FALSE(leaf_node2->is_clipped());
+    EXPECT_FALSE(grand_child->is_clipped_from_property_tree());
+    EXPECT_FALSE(leaf_node1->is_clipped_from_property_tree());
+    EXPECT_FALSE(leaf_node2->is_clipped_from_property_tree());
   }
 
   // Case 2: parent masksToBounds, so the parent, child1, and child2's
   // surface are clipped. But layers that contribute to child2's surface are
   // not clipped explicitly because child2's surface already accounts for
   // that clip.
   {
     RenderSurfaceLayerList render_surface_layer_list;
     parent->SetMasksToBounds(true);
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
         root.get(), parent->bounds(), &render_surface_layer_list);
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     ASSERT_TRUE(root->render_surface());
     ASSERT_TRUE(child2->render_surface());
 
-    EXPECT_FALSE(root->is_clipped());
+    EXPECT_FALSE(root->is_clipped_from_property_tree());
     EXPECT_TRUE(root->render_surface()->is_clipped());
-    EXPECT_TRUE(parent->is_clipped());
-    EXPECT_TRUE(child1->is_clipped());
-    EXPECT_FALSE(child2->is_clipped());
+    EXPECT_TRUE(parent->is_clipped_from_property_tree());
+    EXPECT_TRUE(child1->is_clipped_from_property_tree());
+    EXPECT_FALSE(child2->is_clipped_from_property_tree());
     EXPECT_TRUE(child2->render_surface()->is_clipped());
-    EXPECT_TRUE(grand_child->is_clipped());
-    EXPECT_TRUE(leaf_node1->is_clipped());
-    EXPECT_FALSE(leaf_node2->is_clipped());
+    EXPECT_TRUE(grand_child->is_clipped_from_property_tree());
+    EXPECT_TRUE(leaf_node1->is_clipped_from_property_tree());
+    EXPECT_FALSE(leaf_node2->is_clipped_from_property_tree());
   }
 
   // Case 3: child2 masksToBounds. The layer and subtree are clipped, and
   // child2's render surface is not clipped.
   {
     RenderSurfaceLayerList render_surface_layer_list;
     parent->SetMasksToBounds(false);
     child2->SetMasksToBounds(true);
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
         root.get(), parent->bounds(), &render_surface_layer_list);
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     ASSERT_TRUE(root->render_surface());
     ASSERT_TRUE(child2->render_surface());
 
-    EXPECT_FALSE(root->is_clipped());
+    EXPECT_FALSE(root->is_clipped_from_property_tree());
     EXPECT_TRUE(root->render_surface()->is_clipped());
-    EXPECT_FALSE(parent->is_clipped());
-    EXPECT_FALSE(child1->is_clipped());
-    EXPECT_TRUE(child2->is_clipped());
+    EXPECT_FALSE(parent->is_clipped_from_property_tree());
+    EXPECT_FALSE(child1->is_clipped_from_property_tree());
+    EXPECT_TRUE(child2->is_clipped_from_property_tree());
     EXPECT_FALSE(child2->render_surface()->is_clipped());
-    EXPECT_FALSE(grand_child->is_clipped());
-    EXPECT_FALSE(leaf_node1->is_clipped());
-    EXPECT_TRUE(leaf_node2->is_clipped());
+    EXPECT_FALSE(grand_child->is_clipped_from_property_tree());
+    EXPECT_FALSE(leaf_node1->is_clipped_from_property_tree());
+    EXPECT_TRUE(leaf_node2->is_clipped_from_property_tree());
   }
 }
 
 TEST_F(LayerTreeHostCommonTest, DrawableContentRectForLayers) {
   // Verify that layers get the appropriate DrawableContentRect when their
   // parent masksToBounds is true.
   //
   //   grand_child1 - completely inside the region; DrawableContentRect should
   //   be the layer rect expressed in target space.
   //   grand_child2 - partially clipped but NOT masksToBounds; the clip rect
@@ skipping 1034 matching lines @@
                                gfx::PointF(125.f, 125.f), gfx::Size(50, 50),
                                true, false);
 
   RenderSurfaceLayerList render_surface_layer_list;
   // Now set the root render surface an empty clip.
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       root.get(), gfx::Size(), &render_surface_layer_list);
 
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
   ASSERT_TRUE(root->render_surface());
-  EXPECT_FALSE(root->is_clipped());
+  EXPECT_FALSE(root->is_clipped_from_property_tree());
 
   gfx::Rect empty;
   EXPECT_EQ(empty, root->render_surface()->clip_rect());
   EXPECT_TRUE(root->render_surface()->is_clipped());
 
   // Visible content rect calculation will check if the target surface is
   // clipped or not. An empty clip rect does not indicate the render surface
   // is unclipped.
   EXPECT_EQ(empty, child1->visible_layer_rect());
   EXPECT_EQ(empty, child2->visible_layer_rect());
@@ skipping 2820 matching lines @@
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0).ToString(),
             render_surface1->render_surface()->clip_rect().ToString());
   EXPECT_FALSE(render_surface1->render_surface()->is_clipped());
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0).ToString(),
             render_surface2->render_surface()->clip_rect().ToString());
   EXPECT_FALSE(render_surface2->render_surface()->is_clipped());
 
   // NB: clip rects are in target space.
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40).ToString(),
             render_surface1->clip_rect().ToString());
-  EXPECT_TRUE(render_surface1->is_clipped());
+  EXPECT_TRUE(render_surface1->is_clipped_from_property_tree());
 
   // This value is inherited from the clipping ancestor layer, 'intervening'.
   EXPECT_EQ(gfx::Rect(0, 0, 5, 5).ToString(),
             render_surface2->clip_rect().ToString());
-  EXPECT_TRUE(render_surface2->is_clipped());
+  EXPECT_TRUE(render_surface2->is_clipped_from_property_tree());
 
   // The content rects of both render surfaces should both have expanded to
   // contain the clip child.
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40).ToString(),
             render_surface1->render_surface()->content_rect().ToString());
   EXPECT_EQ(gfx::Rect(-1, -1, 40, 40).ToString(),
             render_surface2->render_surface()->content_rect().ToString());
 
   // The clip child should have inherited the clip parent's clip (projected to
   // the right space, of course), and should have the correctly sized visible
   // content rect.
   EXPECT_EQ(gfx::Rect(-1, -1, 40, 40).ToString(),
             clip_child->clip_rect().ToString());
   EXPECT_EQ(gfx::Rect(9, 9, 40, 40).ToString(),
             clip_child->visible_layer_rect().ToString());
-  EXPECT_TRUE(clip_child->is_clipped());
+  EXPECT_TRUE(clip_child->is_clipped_from_property_tree());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClipParentScrolledInterveningLayer) {
   // Ensure that intervening render surfaces are not a problem, even if there
   // is a scroll involved. Note, we do _not_ have to consider any other sort
   // of transform.
   //
   //   root (a render surface)
   //    + clip_parent (masks to bounds)
   //      + render_surface1 (sets opacity)
@@ skipping 86 matching lines @@
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0).ToString(),
             render_surface1->render_surface()->clip_rect().ToString());
   EXPECT_FALSE(render_surface1->render_surface()->is_clipped());
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0).ToString(),
             render_surface2->render_surface()->clip_rect().ToString());
   EXPECT_FALSE(render_surface2->render_surface()->is_clipped());
 
   // NB: clip rects are in target space.
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40).ToString(),
             render_surface1->clip_rect().ToString());
-  EXPECT_TRUE(render_surface1->is_clipped());
+  EXPECT_TRUE(render_surface1->is_clipped_from_property_tree());
 
   // This value is inherited from the clipping ancestor layer, 'intervening'.
   EXPECT_EQ(gfx::Rect(2, 2, 3, 3).ToString(),
             render_surface2->clip_rect().ToString());
-  EXPECT_TRUE(render_surface2->is_clipped());
+  EXPECT_TRUE(render_surface2->is_clipped_from_property_tree());
 
   // The content rects of both render surfaces should both have expanded to
   // contain the clip child.
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40).ToString(),
             render_surface1->render_surface()->content_rect().ToString());
   EXPECT_EQ(gfx::Rect(2, 2, 40, 40).ToString(),
             render_surface2->render_surface()->content_rect().ToString());
 
   // The clip child should have inherited the clip parent's clip (projected to
   // the right space, of course), and should have the correctly sized visible
   // content rect.
   EXPECT_EQ(gfx::Rect(2, 2, 40, 40).ToString(),
             clip_child->clip_rect().ToString());
   EXPECT_EQ(gfx::Rect(12, 12, 40, 40).ToString(),
             clip_child->visible_layer_rect().ToString());
-  EXPECT_TRUE(clip_child->is_clipped());
+  EXPECT_TRUE(clip_child->is_clipped_from_property_tree());
 }
 
 TEST_F(LayerTreeHostCommonTest, DescendantsOfClipChildren) {
   // Ensures that descendants of the clip child inherit the correct clip.
   //
   //   root (a render surface)
   //    + clip_parent (masks to bounds)
   //      + intervening (masks to bounds)
   //        + clip_child
   //          + child
@@ skipping 55 matching lines @@
   host()->SetRootLayer(root);
 
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_TRUE(root->render_surface());
 
   // Neither the clip child nor its descendant should have inherited the clip
   // from |intervening|.
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40).ToString(),
             clip_child->clip_rect().ToString());
-  EXPECT_TRUE(clip_child->is_clipped());
+  EXPECT_TRUE(clip_child->is_clipped_from_property_tree());
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40).ToString(),
             child->visible_layer_rect().ToString());
-  EXPECT_TRUE(child->is_clipped());
+  EXPECT_TRUE(child->is_clipped_from_property_tree());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        SurfacesShouldBeUnaffectedByNonDescendantClipChildren) {
   // Ensures that non-descendant clip children in the tree do not affect
   // render surfaces.
   //
   //   root (a render surface)
   //    + clip_parent (masks to bounds)
   //      + render_surface1
@@ skipping 72 matching lines @@
   host()->SetRootLayer(root);
 
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_TRUE(root->render_surface());
   EXPECT_TRUE(render_surface1->render_surface());
   EXPECT_TRUE(render_surface2->render_surface());
 
   EXPECT_EQ(gfx::Rect(0, 0, 5, 5).ToString(),
             render_surface1->clip_rect().ToString());
-  EXPECT_TRUE(render_surface1->is_clipped());
+  EXPECT_TRUE(render_surface1->is_clipped_from_property_tree());
 
   // The render surface should not clip (it has unclipped descendants), instead
   // it should rely on layer clipping.
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0).ToString(),
             render_surface1->render_surface()->clip_rect().ToString());
   EXPECT_FALSE(render_surface1->render_surface()->is_clipped());
 
   // That said, it should have grown to accomodate the unclipped descendant.
   EXPECT_EQ(gfx::Rect(-1, 1, 6, 4).ToString(),
             render_surface1->render_surface()->content_rect().ToString());
@@ skipping 234 matching lines @@
                                false);
 
   host()->SetRootLayer(root);
 
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_TRUE(root->render_surface());
 
   EXPECT_EQ(gfx::Rect(0, 0, 30, 30).ToString(),
             scroll_child->clip_rect().ToString());
-  EXPECT_TRUE(scroll_child->is_clipped());
+  EXPECT_TRUE(scroll_child->is_clipped_from_property_tree());
 }
 
 TEST_F(LayerTreeHostCommonTest, SingularTransformSubtreesDoNotDraw) {
   scoped_refptr<LayerWithForcedDrawsContent> root =
       make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> parent =
       make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
   scoped_refptr<LayerWithForcedDrawsContent> child =
       make_scoped_refptr(new LayerWithForcedDrawsContent(layer_settings()));
 
@@ skipping 94 matching lines @@
   SetLayerPropertiesForTesting(scroll_child, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                false);
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(root->render_surface());
 
   EXPECT_EQ(gfx::Rect(0, 0, 30, 30).ToString(),
             scroll_child->clip_rect().ToString());
-  EXPECT_TRUE(scroll_child->is_clipped());
+  EXPECT_TRUE(scroll_child->is_clipped_from_property_tree());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClippedByOutOfOrderScrollGrandparent) {
   // Checks that clipping by a scroll parent and scroll grandparent that follow
   // you in paint order still results in correct clipping.
   //
   // + root
   //   + scroll_child
   //   + scroll_parent_border
   //   | + scroll_parent_clip
@@ skipping 54 matching lines @@
   SetLayerPropertiesForTesting(scroll_child, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                false);
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(root->render_surface());
 
   EXPECT_EQ(gfx::Rect(0, 0, 20, 20).ToString(),
             scroll_child->clip_rect().ToString());
-  EXPECT_TRUE(scroll_child->is_clipped());
+  EXPECT_TRUE(scroll_child->is_clipped_from_property_tree());
 
   // Despite the fact that we visited the above layers out of order to get the
   // correct clip, the layer lists should be unaffected.
   EXPECT_EQ(3u, root->render_surface()->layer_list().size());
   EXPECT_EQ(scroll_child, root->render_surface()->layer_list().at(0));
   EXPECT_EQ(scroll_parent, root->render_surface()->layer_list().at(1));
   EXPECT_EQ(scroll_grandparent, root->render_surface()->layer_list().at(2));
 }
 
 TEST_F(LayerTreeHostCommonTest, OutOfOrderClippingRequiresRSLLSorting) {
@@ skipping 75 matching lines @@
   SetLayerPropertiesForTesting(scroll_child, identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                false);
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(root->render_surface());
 
   EXPECT_EQ(gfx::Rect(0, 0, 20, 20).ToString(),
             scroll_child->clip_rect().ToString());
-  EXPECT_TRUE(scroll_child->is_clipped());
+  EXPECT_TRUE(scroll_child->is_clipped_from_property_tree());
 
   // Despite the fact that we had to process the layers out of order to get the
   // right clip, our render_surface_layer_list's order should be unaffected.
   EXPECT_EQ(3u, render_surface_layer_list_impl()->size());
   EXPECT_EQ(root, render_surface_layer_list_impl()->at(0));
   EXPECT_EQ(render_surface2, render_surface_layer_list_impl()->at(1));
   EXPECT_EQ(render_surface1, render_surface_layer_list_impl()->at(2));
   EXPECT_TRUE(render_surface_layer_list_impl()->at(0)->render_surface());
   EXPECT_TRUE(render_surface_layer_list_impl()->at(1)->render_surface());
   EXPECT_TRUE(render_surface_layer_list_impl()->at(2)->render_surface());
@@ skipping 654 matching lines @@
 
   expected.clear();
   expected.insert(grand_child2_raw);
 
   actual.clear();
   GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
   EXPECT_EQ(expected, actual);
 
   // Add a mask layer to child.
   child_raw->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 6).Pass());
+  child_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
   member_id = render_surface_layer_list_count();
 
   EXPECT_NE(member_id, membership_id(grand_parent_raw));
   EXPECT_NE(member_id, membership_id(parent_raw));
   EXPECT_NE(member_id, membership_id(child_raw));
   EXPECT_EQ(member_id, membership_id(child_raw->mask_layer()));
   EXPECT_NE(member_id, membership_id(grand_child1_raw));
   EXPECT_EQ(member_id, membership_id(grand_child2_raw));
@@ skipping 71 matching lines @@
   EXPECT_NE(member_id, membership_id(grand_child2_raw));
 
   expected.clear();
   expected.insert(child_raw);
   expected.insert(child_raw->mask_layer());
   actual.clear();
   GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
   EXPECT_EQ(expected, actual);
 
   child_raw->TakeMaskLayer();
+  child_raw->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   // Now everyone's a member!
   grand_parent_raw->SetDrawsContent(true);
   parent_raw->SetDrawsContent(true);
   child_raw->SetDrawsContent(true);
   grand_child1_raw->SetDrawsContent(true);
   grand_child2_raw->SetDrawsContent(true);
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
   member_id = render_surface_layer_list_count();
@@ skipping 1191 matching lines @@
   EXPECT_FALSE(root->layer_or_descendant_is_drawn());
   EXPECT_FALSE(root->visited());
   EXPECT_FALSE(root->sorted_for_recursion());
   EXPECT_FALSE(child->layer_or_descendant_is_drawn());
   EXPECT_FALSE(child->visited());
   EXPECT_FALSE(child->sorted_for_recursion());
 }
 
 }  // namespace
 }  // namespace cc