cc : Compute render surface is_clipped outside property tree building

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 <memory>
@@ skipping 85 matching lines @@
                              layer_impl->layer_tree_impl())
         .starting_animation_scale;
   }
 
   void ExecuteCalculateDrawProperties(Layer* root_layer,
                                       float device_scale_factor,
                                       float page_scale_factor,
                                       Layer* page_scale_layer,
                                       Layer* inner_viewport_scroll_layer,
                                       Layer* outer_viewport_scroll_layer) {
-    PropertyTreeBuilder::PreCalculateMetaInformation(root_layer);
-
     EXPECT_TRUE(page_scale_layer || (page_scale_factor == 1.f));
     gfx::Size device_viewport_size =
         gfx::Size(root_layer->bounds().width() * device_scale_factor,
                   root_layer->bounds().height() * device_scale_factor);
 
     // We are probably not testing what is intended if the root_layer bounds are
     // empty.
     DCHECK(!root_layer->bounds().IsEmpty());
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
         root_layer, device_viewport_size);
@@ skipping 59 matching lines @@
     LayerType* outer_viewport_scroll_layer = nullptr;
     ExecuteCalculateDrawProperties(
         root_layer, device_scale_factor, 1.f, page_scale_application_layer,
         inner_viewport_scroll_layer, outer_viewport_scroll_layer);
   }
 
   const LayerList* GetUpdateLayerList() { return &update_layer_list_; }
 
   void ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(Layer* root_layer) {
     DCHECK(root_layer->layer_tree_host());
-    PropertyTreeBuilder::PreCalculateMetaInformation(root_layer);
-
     bool can_render_to_separate_surface = true;
 
     const Layer* page_scale_layer =
         root_layer->layer_tree_host()->page_scale_layer();
     Layer* inner_viewport_scroll_layer =
         root_layer->layer_tree_host()->inner_viewport_scroll_layer();
     Layer* outer_viewport_scroll_layer =
         root_layer->layer_tree_host()->outer_viewport_scroll_layer();
     const Layer* overscroll_elasticity_layer =
         root_layer->layer_tree_host()->overscroll_elasticity_layer();
@@ skipping 15 matching lines @@
     draw_property_utils::UpdatePropertyTrees(root_layer->layer_tree_host(),
                                              property_trees,
                                              can_render_to_separate_surface);
     draw_property_utils::FindLayersThatNeedUpdates(
         root_layer->layer_tree_host(), property_trees, &update_layer_list_);
   }
 
   void ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(
       LayerImpl* root_layer) {
     DCHECK(root_layer->layer_tree_impl());
-    PropertyTreeBuilder::PreCalculateMetaInformationForTesting(root_layer);
-
     bool can_render_to_separate_surface = true;
 
     const LayerImpl* page_scale_layer = nullptr;
     LayerImpl* inner_viewport_scroll_layer =
         root_layer->layer_tree_impl()->InnerViewportScrollLayer();
     LayerImpl* outer_viewport_scroll_layer =
         root_layer->layer_tree_impl()->OuterViewportScrollLayer();
     const LayerImpl* overscroll_elasticity_layer =
         root_layer->layer_tree_impl()->OverscrollElasticityLayer();
     gfx::Vector2dF elastic_overscroll =
@@ skipping 3767 matching lines @@
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(20, 20), render_surface1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(50, 50), clip_child->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(50, 50), render_surface2->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClipRectOfSurfaceWhoseParentIsAClipChild) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
-  LayerImpl* render_surface1 = AddChild<LayerImpl>(clip_parent);
+  LayerImpl* clip_layer = AddChild<LayerImpl>(clip_parent);
+  LayerImpl* render_surface1 = AddChild<LayerImpl>(clip_layer);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface1);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(clip_child);
 
   root->SetBounds(gfx::Size(100, 100));
 
   clip_parent->SetPosition(gfx::PointF(2.f, 2.f));
   clip_parent->SetBounds(gfx::Size(50, 50));
   clip_parent->test_properties()->clip_children =
       base::MakeUnique<std::set<LayerImpl*>>();
   clip_parent->test_properties()->clip_children->insert(clip_child);
 
+  clip_layer->SetBounds(gfx::Size(50, 50));
+
   render_surface1->SetBounds(gfx::Size(20, 20));
   render_surface1->SetDrawsContent(true);
   render_surface1->test_properties()->force_render_surface = true;
 
   clip_child->SetBounds(gfx::Size(60, 60));
   clip_child->SetDrawsContent(true);
   clip_child->test_properties()->clip_parent = clip_parent;
 
   render_surface2->SetBounds(gfx::Size(60, 60));
   render_surface2->SetDrawsContent(true);
   render_surface2->test_properties()->force_render_surface = true;
 
   clip_parent->SetMasksToBounds(true);
+  clip_layer->SetMasksToBounds(true);
   render_surface1->SetMasksToBounds(true);
 
   float device_scale_factor = 1.f;
   ExecuteCalculateDrawProperties(root, device_scale_factor);
   EXPECT_EQ(gfx::Rect(50, 50),
             render_surface2->GetRenderSurface()->clip_rect());
   device_scale_factor = 2.f;
   ExecuteCalculateDrawProperties(root, device_scale_factor);
   EXPECT_EQ(gfx::Rect(100, 100),
             render_surface2->GetRenderSurface()->clip_rect());
@@ skipping 1760 matching lines @@
   render_surface2->SetBounds(gfx::Size(10, 10));
   render_surface2->test_properties()->force_render_surface = true;
   clip_child->SetPosition(gfx::PointF(-10.f, -10.f));
   clip_child->SetBounds(gfx::Size(60, 60));
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(root->GetRenderSurface());
   EXPECT_TRUE(render_surface1->GetRenderSurface());
   EXPECT_TRUE(render_surface2->GetRenderSurface());
 
-  // Since the render surfaces could have expanded, they should not clip (their
-  // bounds would no longer be reliable). We should resort to layer clipping
-  // in this case.
-  EXPECT_EQ(gfx::Rect(0, 0, 0, 0),
+  // render_surface1 should apply the clip from clip_parent. Though there is a
+  // clip child, render_surface1 can apply the clip as there are no clips
+  // between the clip parent and render_surface1
+  EXPECT_EQ(gfx::Rect(1, 1, 40, 40),
             render_surface1->GetRenderSurface()->clip_rect());
-  EXPECT_FALSE(render_surface1->GetRenderSurface()->is_clipped());
+  EXPECT_TRUE(render_surface1->GetRenderSurface()->is_clipped());
+  EXPECT_EQ(gfx::Rect(), render_surface1->clip_rect());
+  EXPECT_FALSE(render_surface1->is_clipped());
+
+  // render_surface2 could have expanded, as there is a clip between
+  // clip_child's clip (clip_parent) and render_surface2's clip (intervening).
+  // So, it should not be clipped (their bounds would no longer be reliable).
+  // We should resort to layer clipping in this case.
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0),
             render_surface2->GetRenderSurface()->clip_rect());
   EXPECT_FALSE(render_surface2->GetRenderSurface()->is_clipped());
 
-  // NB: clip rects are in target space.
-  EXPECT_EQ(gfx::Rect(0, 0, 40, 40), render_surface1->clip_rect());
-  EXPECT_TRUE(render_surface1->is_clipped());
-
   // This value is inherited from the clipping ancestor layer, 'intervening'.
   EXPECT_EQ(gfx::Rect(0, 0, 5, 5), render_surface2->clip_rect());
   EXPECT_TRUE(render_surface2->is_clipped());
 
-  // The content rects of both render surfaces should both have expanded to
-  // contain the clip child.
+  // The content rects of render_surface2 should have expanded to contain the
+  // clip child.
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40),
             render_surface1->GetRenderSurface()->content_rect());
-  EXPECT_EQ(gfx::Rect(-1, -1, 40, 40),
+  EXPECT_EQ(gfx::Rect(-10, -10, 60, 60),
             render_surface2->GetRenderSurface()->content_rect());
 
   // 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), clip_child->clip_rect());
+  // the right space, of course), but as render_surface1 already applies that
+  // clip, clip_child need not apply it again.
+  EXPECT_EQ(gfx::Rect(), clip_child->clip_rect());
   EXPECT_EQ(gfx::Rect(9, 9, 40, 40), clip_child->visible_layer_rect());
-  EXPECT_TRUE(clip_child->is_clipped());
+  EXPECT_FALSE(clip_child->is_clipped());
 }
 
 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 32 matching lines @@
   render_surface2->SetBounds(gfx::Size(10, 10));
   render_surface2->test_properties()->force_render_surface = true;
   clip_child->SetPosition(gfx::PointF(-10.f, -10.f));
   clip_child->SetBounds(gfx::Size(60, 60));
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(root->GetRenderSurface());
   EXPECT_TRUE(render_surface1->GetRenderSurface());
   EXPECT_TRUE(render_surface2->GetRenderSurface());
 
-  // Since the render surfaces could have expanded, they should not clip (their
-  // bounds would no longer be reliable). We should resort to layer clipping
-  // in this case.
-  EXPECT_EQ(gfx::Rect(0, 0, 0, 0),
+  // render_surface1 should apply the clip from clip_parent. Though there is a
+  // clip child, render_surface1 can apply the clip as there are no clips
+  // between the clip parent and render_surface1
+  EXPECT_EQ(gfx::Rect(3, 3, 40, 40),
             render_surface1->GetRenderSurface()->clip_rect());
-  EXPECT_FALSE(render_surface1->GetRenderSurface()->is_clipped());
+  EXPECT_TRUE(render_surface1->GetRenderSurface()->is_clipped());
+  EXPECT_EQ(gfx::Rect(), render_surface1->clip_rect());
+  EXPECT_FALSE(render_surface1->is_clipped());
+
+  // render_surface2 could have expanded, as there is a clip between
+  // clip_child's clip (clip_parent) and render_surface2's clip (intervening).
+  // So, it should not be clipped (their bounds would no longer be reliable).
+  // We should resort to layer clipping in this case.
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0),
             render_surface2->GetRenderSurface()->clip_rect());
   EXPECT_FALSE(render_surface2->GetRenderSurface()->is_clipped());
-
-  // NB: clip rects are in target space.
-  EXPECT_EQ(gfx::Rect(0, 0, 40, 40), render_surface1->clip_rect());
-  EXPECT_TRUE(render_surface1->is_clipped());
-
   // This value is inherited from the clipping ancestor layer, 'intervening'.
-  EXPECT_EQ(gfx::Rect(2, 2, 3, 3), render_surface2->clip_rect());
+  EXPECT_EQ(gfx::Rect(0, 0, 5, 5), render_surface2->clip_rect());
   EXPECT_TRUE(render_surface2->is_clipped());
 
-  // The content rects of both render surfaces should both have expanded to
-  // contain the clip child.
+  // The content rects of render_surface2 should have expanded to contain the
+  // clip child.
   EXPECT_EQ(gfx::Rect(0, 0, 40, 40),
             render_surface1->GetRenderSurface()->content_rect());
-  EXPECT_EQ(gfx::Rect(2, 2, 40, 40),
+  EXPECT_EQ(gfx::Rect(-10, -10, 60, 60),
             render_surface2->GetRenderSurface()->content_rect());
 
   // 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), clip_child->clip_rect());
+  // the right space, of course), but as render_surface1 already applies that
+  // clip, clip_child need not apply it again.
+  EXPECT_EQ(gfx::Rect(), clip_child->clip_rect());
   EXPECT_EQ(gfx::Rect(12, 12, 40, 40), clip_child->visible_layer_rect());
-  EXPECT_TRUE(clip_child->is_clipped());
+  EXPECT_FALSE(clip_child->is_clipped());
 }
 
 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 31 matching lines @@
   EXPECT_TRUE(child->is_clipped());
 }
 
 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
-  //        + clip_child
-  //      + render_surface2
-  //        + non_clip_child
+  //      + clip_layer (masks to bounds)
+  //        + render_surface1
+  //          + clip_child
+  //        + render_surface2
+  //          + non_clip_child
   //
   // In this example render_surface2 should be unaffected by clip_child.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
-  LayerImpl* render_surface1 = AddChild<LayerImpl>(clip_parent);
+  LayerImpl* clip_layer = AddChild<LayerImpl>(clip_parent);
+  LayerImpl* render_surface1 = AddChild<LayerImpl>(clip_layer);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface1);
-  LayerImpl* render_surface2 = AddChild<LayerImpl>(clip_parent);
+  LayerImpl* render_surface2 = AddChild<LayerImpl>(clip_layer);
   LayerImpl* non_clip_child = AddChild<LayerImpl>(render_surface2);
 
   clip_child->test_properties()->clip_parent = clip_parent;
   clip_parent->test_properties()->clip_children =
       base::MakeUnique<std::set<LayerImpl*>>();
   clip_parent->test_properties()->clip_children->insert(clip_child);
 
   clip_parent->SetMasksToBounds(true);
-  render_surface1->SetMasksToBounds(true);
+  clip_layer->SetMasksToBounds(true);
 
   render_surface1->SetDrawsContent(true);
   clip_child->SetDrawsContent(true);
   render_surface2->SetDrawsContent(true);
   non_clip_child->SetDrawsContent(true);
 
   root->SetBounds(gfx::Size(15, 15));
   clip_parent->SetBounds(gfx::Size(10, 10));
+  clip_layer->SetBounds(gfx::Size(10, 10));
   render_surface1->SetPosition(gfx::PointF(5, 5));
   render_surface1->SetBounds(gfx::Size(5, 5));
   render_surface1->test_properties()->force_render_surface = true;
   render_surface2->SetBounds(gfx::Size(5, 5));
   render_surface2->test_properties()->force_render_surface = true;
   clip_child->SetPosition(gfx::PointF(-1, 1));
   clip_child->SetBounds(gfx::Size(10, 10));
   non_clip_child->SetBounds(gfx::Size(5, 5));
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRUE(root->GetRenderSurface());
   EXPECT_TRUE(render_surface1->GetRenderSurface());
   EXPECT_TRUE(render_surface2->GetRenderSurface());
 
-  EXPECT_EQ(gfx::Rect(0, 0, 5, 5), render_surface1->clip_rect());
+  EXPECT_EQ(gfx::Rect(-5, -5, 10, 10), render_surface1->clip_rect());
   EXPECT_TRUE(render_surface1->is_clipped());
 
   // 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),
             render_surface1->GetRenderSurface()->clip_rect());
   EXPECT_FALSE(render_surface1->GetRenderSurface()->is_clipped());
 
   // That said, it should have grown to accomodate the unclipped descendant and
   // its own size.
   EXPECT_EQ(gfx::Rect(-1, 0, 6, 5),
             render_surface1->GetRenderSurface()->content_rect());
 
   // This render surface should clip. It has no unclipped descendants.
   EXPECT_EQ(gfx::Rect(0, 0, 10, 10),
             render_surface2->GetRenderSurface()->clip_rect());
   EXPECT_TRUE(render_surface2->GetRenderSurface()->is_clipped());
   EXPECT_FALSE(render_surface2->is_clipped());
 
   // It also shouldn't have grown to accomodate the clip child.
   EXPECT_EQ(gfx::Rect(0, 0, 5, 5),
             render_surface2->GetRenderSurface()->content_rect());
-
-  // Sanity check our num_unclipped_descendants values.
-  EXPECT_EQ(1u, render_surface1->test_properties()->num_unclipped_descendants);
-  EXPECT_EQ(0u, render_surface2->test_properties()->num_unclipped_descendants);
 }
 
 TEST_F(LayerTreeHostCommonTest,
        CreateRenderSurfaceWhenFlattenInsideRenderingContext) {
   // Verifies that Render Surfaces are created at the edge of rendering context.
 
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child1 = AddChildToRoot<LayerImpl>();
   LayerImpl* child2 = AddChild<LayerImpl>(child1);
   LayerImpl* child3 = AddChild<LayerImpl>(child2);
@@ skipping 54 matching lines @@
   child3->test_properties()->sorting_context_id = 1;
 
   child2->test_properties()->AddChild(std::move(child3));
   child1->test_properties()->AddChild(std::move(child2));
   root->test_properties()->AddChild(std::move(child1));
   LayerImpl* root_layer = root.get();
   root_layer->layer_tree_impl()->SetRootLayerForTesting(std::move(root));
 
   {
     LayerImplList render_surface_layer_list;
-    FakeLayerTreeHostImpl::RecursiveUpdateNumChildren(root_layer);
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root_layer, root_layer->bounds(), &render_surface_layer_list);
     inputs.can_render_to_separate_surface = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
     EXPECT_EQ(2u, render_surface_layer_list.size());
 
     int count_represents_target_render_surface = 0;
     int count_represents_contributing_render_surface = 0;
     int count_represents_itself = 0;
@@ skipping 3619 matching lines @@
   child->SetClipParent(root.get());
 
   root->AddChild(parent);
   parent->AddChild(child);
   host()->SetRootLayer(root);
 
   child->RequestCopyOfOutput(
       CopyOutputRequest::CreateRequest(base::Bind(&EmptyCopyOutputCallback)));
 
   ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
-  EXPECT_EQ(parent->num_unclipped_descendants(), 1u);
+  EXPECT_GT(root->num_copy_requests_in_target_subtree(), 0);
 
-  EXPECT_GT(root->num_copy_requests_in_target_subtree(), 0);
   ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root.get());
   EXPECT_GT(root->num_copy_requests_in_target_subtree(), 0);
 }
 
 TEST_F(LayerTreeHostCommonTest, ResetPropertyTreeIndices) {
   scoped_refptr<Layer> root = Layer::Create();
   root->SetBounds(gfx::Size(800, 800));
 
   gfx::Transform translate_z;
   translate_z.Translate3d(0, 0, 10);
@@ skipping 109 matching lines @@
 
   gfx::Transform translate;
   translate.Translate(2.0, 2.0);
 
   root->SetBounds(gfx::Size(30, 30));
   clip_parent->test_properties()->transform = translate;
   clip_parent->SetBounds(gfx::Size(30, 30));
   clip_parent->SetMasksToBounds(true);
   between_clip_parent_and_child->test_properties()->transform = translate;
   between_clip_parent_and_child->SetBounds(gfx::Size(30, 30));
+  between_clip_parent_and_child->SetMasksToBounds(true);
   render_surface->SetBounds(gfx::Size(30, 30));
   render_surface->test_properties()->force_render_surface = true;
   test_layer->SetBounds(gfx::Size(30, 30));
   test_layer->SetDrawsContent(true);
 
   render_surface->test_properties()->clip_parent = clip_parent;
   clip_parent->test_properties()->clip_children =
       base::MakeUnique<std::set<LayerImpl*>>();
   clip_parent->test_properties()->clip_children->insert(render_surface);
 
@@ skipping 99 matching lines @@
   EXPECT_FALSE(clip_child->is_clipped());
 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceContentRectWithMultipleSurfaces) {
   // Tests the value of render surface content rect when we have multiple types
   // of surfaces : unclipped surfaces, surfaces with unclipped surfaces and
   // clipped surfaces.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* unclipped_surface = AddChildToRoot<LayerImpl>();
   LayerImpl* clip_parent = AddChild<LayerImpl>(unclipped_surface);
-  LayerImpl* unclipped_desc_surface = AddChild<LayerImpl>(clip_parent);
+  LayerImpl* clip_layer = AddChild<LayerImpl>(clip_parent);
+  LayerImpl* unclipped_desc_surface = AddChild<LayerImpl>(clip_layer);
   LayerImpl* unclipped_desc_surface2 =
       AddChild<LayerImpl>(unclipped_desc_surface);
   LayerImpl* clip_child = AddChild<LayerImpl>(unclipped_desc_surface2);
   LayerImpl* clipped_surface = AddChild<LayerImpl>(clip_child);
 
   root->SetBounds(gfx::Size(80, 80));
   unclipped_surface->SetBounds(gfx::Size(50, 50));
   unclipped_surface->SetMasksToBounds(true);
   unclipped_surface->SetDrawsContent(true);
   unclipped_surface->test_properties()->force_render_surface = true;
   clip_parent->SetBounds(gfx::Size(50, 50));
   clip_parent->SetMasksToBounds(true);
+  clip_layer->SetMasksToBounds(true);
+  clip_layer->SetBounds(gfx::Size(100, 100));
   unclipped_desc_surface->SetBounds(gfx::Size(100, 100));
-  unclipped_desc_surface->SetMasksToBounds(true);
   unclipped_desc_surface->SetDrawsContent(true);
   unclipped_desc_surface->test_properties()->force_render_surface = true;
   unclipped_desc_surface2->SetBounds(gfx::Size(60, 60));
   unclipped_desc_surface2->SetDrawsContent(true);
   unclipped_desc_surface2->test_properties()->force_render_surface = true;
   clip_child->SetBounds(gfx::Size(100, 100));
   clipped_surface->SetBounds(gfx::Size(70, 70));
   clipped_surface->SetDrawsContent(true);
   clipped_surface->test_properties()->force_render_surface = true;
 
   clip_child->test_properties()->clip_parent = clip_parent;
   clip_parent->test_properties()->clip_children =
       base::MakeUnique<std::set<LayerImpl*>>();
   clip_parent->test_properties()->clip_children->insert(clip_child);
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(50, 50),
             unclipped_surface->GetRenderSurface()->content_rect());
   EXPECT_EQ(gfx::Rect(50, 50),
             unclipped_desc_surface->GetRenderSurface()->content_rect());
-  EXPECT_EQ(gfx::Rect(50, 50),
+  EXPECT_EQ(gfx::Rect(60, 60),
             unclipped_desc_surface2->GetRenderSurface()->content_rect());
   EXPECT_EQ(gfx::Rect(50, 50),
             clipped_surface->GetRenderSurface()->content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClipBetweenClipChildTargetAndClipParentTarget) {
   // Tests the value of render surface content rect when we have a layer that
   // clips between the clip parent's target and clip child's target.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* surface = AddChildToRoot<LayerImpl>();
@@ skipping 90 matching lines @@
 
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRANSFORMATION_MATRIX_EQ(translation,
                                   test_layer->ScreenSpaceTransform());
 }
 
 TEST_F(LayerTreeHostCommonTest, ClipParentDrawsIntoScaledRootSurface) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_layer = AddChild<LayerImpl>(root);
   LayerImpl* clip_parent = AddChild<LayerImpl>(clip_layer);
-  LayerImpl* unclipped_desc_surface = AddChild<LayerImpl>(clip_parent);
+  LayerImpl* clip_parent_child = AddChild<LayerImpl>(clip_parent);
+  LayerImpl* unclipped_desc_surface = AddChild<LayerImpl>(clip_parent_child);
   LayerImpl* clip_child = AddChild<LayerImpl>(unclipped_desc_surface);
 
   root->SetBounds(gfx::Size(100, 100));
   clip_layer->SetBounds(gfx::Size(20, 20));
   clip_layer->SetMasksToBounds(true);
   clip_parent->SetBounds(gfx::Size(50, 50));
+  clip_parent_child->SetBounds(gfx::Size(20, 20));
+  clip_parent_child->SetMasksToBounds(true);
   unclipped_desc_surface->SetBounds(gfx::Size(100, 100));
   unclipped_desc_surface->SetDrawsContent(true);
   unclipped_desc_surface->test_properties()->force_render_surface = true;
   clip_child->SetBounds(gfx::Size(100, 100));
   clip_child->SetDrawsContent(true);
   gfx::Transform translate;
   translate.Translate(10, 10);
   unclipped_desc_surface->test_properties()->transform = translate;
 
   clip_child->test_properties()->clip_parent = clip_parent;
@@ skipping 77 matching lines @@
   EXPECT_TRUE(test->IsHidden());
 
   hidden->test_properties()->hide_layer_and_subtree = false;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_FALSE(test->IsHidden());
 }
 
 TEST_F(LayerTreeHostCommonTest, TwoUnclippedRenderSurfaces) {
   LayerImpl* root = root_layer_for_testing();
-  LayerImpl* render_surface1 = AddChild<LayerImpl>(root);
+  LayerImpl* clip_layer = AddChild<LayerImpl>(root);
+  LayerImpl* render_surface1 = AddChild<LayerImpl>(clip_layer);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(render_surface1);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface2);
 
   root->SetBounds(gfx::Size(30, 30));
   root->SetMasksToBounds(true);
+  clip_layer->SetBounds(gfx::Size(30, 30));
+  clip_layer->SetMasksToBounds(true);
   render_surface1->SetPosition(gfx::PointF(10, 10));
   render_surface1->SetBounds(gfx::Size(30, 30));
   render_surface1->SetDrawsContent(true);
   render_surface1->test_properties()->force_render_surface = true;
   render_surface2->SetBounds(gfx::Size(30, 30));
   render_surface2->SetDrawsContent(true);
   render_surface2->test_properties()->force_render_surface = true;
   clip_child->SetBounds(gfx::Size(30, 30));
+  clip_child->SetDrawsContent(true);
 
   clip_child->test_properties()->clip_parent = root;
   root->test_properties()->clip_children =
       base::MakeUnique<std::set<LayerImpl*>>();
   root->test_properties()->clip_children->insert(clip_child);
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::Rect(-10, -10, 30, 30), render_surface2->clip_rect());
 }
@@ skipping 514 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