Include viewport clip in visible rect of unclipped surfaces (2)

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 3175 matching lines @@
   // Layers that do not draw content should have empty visible content rects.
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface->visible_layer_rect());
 
   // An unclipped surface grows its DrawableContentRect to include all drawable
   // regions of the subtree.
   EXPECT_EQ(gfx::RectF(5.f, 5.f, 170.f, 170.f),
             render_surface->render_surface()->DrawableContentRect());
 
   // All layers that draw content into the unclipped surface are also unclipped.
+  // Only the viewport clip should apply
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_layer_rect());
-  EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child2->visible_layer_rect());
-  EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child3->visible_layer_rect());
+  EXPECT_EQ(gfx::Rect(0, 0, 25, 25), child2->visible_layer_rect());
+  EXPECT_EQ(gfx::Rect(0, 0, 0, 0), child3->visible_layer_rect());
 
   EXPECT_EQ(gfx::Rect(5, 5, 50, 50), child1->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(75, 75, 50, 50), child2->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(125, 125, 50, 50), child3->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        DrawableAndVisibleRectsWhenCannotRenderToSeparateSurface) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* parent = AddChild<LayerImpl>(root);
@@ skipping 24 matching lines @@
 
   root->SetDrawsContent(true);
   parent->SetDrawsContent(true);
   child1->SetDrawsContent(true);
   child2->SetDrawsContent(true);
   grand_child1->SetDrawsContent(true);
   grand_child2->SetDrawsContent(true);
   leaf_node1->SetDrawsContent(true);
   leaf_node2->SetDrawsContent(true);
 
-  // Case 1: No layers clip. Visible rects are clipped by the viewport, but the
-  // viewport clip doesn't apply to layers that draw into unclipped surfaces.
+  // Case 1: No layers clip. Visible rects are clipped by the viewport.
   // Each layer's drawable content rect is its bounds in target space; the only
   // thing that changes with surfaces disabled is that target space is always
   // screen space.
   root->SetHasRenderSurface(true);
   child1->SetHasRenderSurface(true);
   child2->SetHasRenderSurface(true);
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(100, 100), root->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 98, 98), parent->visible_layer_rect());
-  EXPECT_EQ(gfx::Rect(800, 800), child1->visible_layer_rect());
-  EXPECT_EQ(gfx::Rect(800, 800), child2->visible_layer_rect());
-  EXPECT_EQ(gfx::Rect(1500, 1500), grand_child1->visible_layer_rect());
-  EXPECT_EQ(gfx::Rect(1500, 1500), grand_child2->visible_layer_rect());
-  EXPECT_EQ(gfx::Rect(2000, 2000), leaf_node1->visible_layer_rect());
-  EXPECT_EQ(gfx::Rect(2000, 2000), leaf_node2->visible_layer_rect());
+  EXPECT_EQ(gfx::Rect(94, 94), child1->visible_layer_rect());
+  EXPECT_EQ(gfx::Rect(95, 95), child2->visible_layer_rect());
+  EXPECT_EQ(gfx::Rect(86, 86), grand_child1->visible_layer_rect());
+  EXPECT_EQ(gfx::Rect(88, 88), grand_child2->visible_layer_rect());
+  EXPECT_EQ(gfx::Rect(70, 70), leaf_node1->visible_layer_rect());
+  EXPECT_EQ(gfx::Rect(79, 79), leaf_node2->visible_layer_rect());
 
   EXPECT_EQ(gfx::Rect(100, 100), root->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(2, 2, 400, 400), parent->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(800, 800), child1->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(800, 800), child2->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(8, 8, 1500, 1500), grand_child1->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(7, 7, 1500, 1500), grand_child2->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(24, 24, 2000, 2000), leaf_node1->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(16, 16, 2000, 2000), leaf_node2->drawable_content_rect());
 
@@ skipping 69 matching lines @@
   // Case 3: child1 and grand_child2 clip. In this case, descendants of these
   // layers have their visible rects clipped by them; Similarly, descendants of
   // these layers have their drawable content rects clipped by them.
   child1->SetMasksToBounds(true);
   grand_child2->SetMasksToBounds(true);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_EQ(gfx::Rect(100, 100), root->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(98, 98), parent->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(94, 94), child1->visible_layer_rect());
-  EXPECT_EQ(gfx::Rect(800, 800), child2->visible_layer_rect());
+  EXPECT_EQ(gfx::Rect(95, 95), child2->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(86, 86), grand_child1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(88, 88), grand_child2->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(70, 70), leaf_node1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(79, 79), leaf_node2->visible_layer_rect());
 
   EXPECT_EQ(gfx::Rect(100, 100), root->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(2, 2, 400, 400), parent->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(800, 800), child1->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(800, 800), child2->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(8, 8, 792, 792), grand_child1->drawable_content_rect());
@@ skipping 392 matching lines @@
   // regions of the subtree, but also gets clamped by the ancestor's clip.
   EXPECT_EQ(gfx::RectF(5.f, 5.f, 95.f, 95.f),
             render_surface1->render_surface()->DrawableContentRect());
 
   // render_surface1 lives in the "unclipped universe" of render_surface1, and
   // is only implicitly clipped by render_surface1's content rect. So,
   // render_surface2 grows to enclose all drawable content of its subtree.
   EXPECT_EQ(gfx::RectF(5.f, 5.f, 170.f, 170.f),
             render_surface2->render_surface()->DrawableContentRect());
 
-  // All layers that draw content into render_surface2 think they are unclipped.
+  // All layers that draw content into render_surface2 think they are unclipped
+  // by the surface. So, only the viewport clip applies.
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_layer_rect());
-  EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child2->visible_layer_rect());
-  EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child3->visible_layer_rect());
+  EXPECT_EQ(gfx::Rect(0, 0, 25, 25), child2->visible_layer_rect());
+  EXPECT_EQ(gfx::Rect(0, 0, 0, 0), child3->visible_layer_rect());
 
   // DrawableContentRects are also unclipped.
   EXPECT_EQ(gfx::Rect(5, 5, 50, 50), child1->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(75, 75, 50, 50), child2->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(125, 125, 50, 50), child3->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        VisibleRectsForClippedDescendantsOfUnclippedSurfaces) {
   LayerImpl* root = root_layer_for_testing();
@@ skipping 181 matching lines @@
   clip_child->test_properties()->clip_parent = clip_parent;
 
   clipped_surface->SetBounds(gfx::Size(50, 50));
   clipped_surface->SetDrawsContent(true);
   clipped_surface->test_properties()->force_render_surface = true;
 
   clip_parent->SetMasksToBounds(true);
   unclipped_desc_surface->SetMasksToBounds(true);
 
   ExecuteCalculateDrawProperties(root);
-  EXPECT_EQ(gfx::Rect(50, 50), unclipped_surface->visible_layer_rect());
+  EXPECT_EQ(gfx::Rect(10, 10), unclipped_surface->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(10, 10), unclipped_desc_surface->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(10, 10), clipped_surface->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        DrawableAndVisibleContentRectsWithTransformOnUnclippedSurface) {
   // Layers that have non-axis aligned bounds (due to transforms) have an
   // expanded, axis-aligned DrawableContentRect and visible content rect.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface = AddChildToRoot<LayerImpl>();
@@ skipping 137 matching lines @@
   EXPECT_EQ(gfx::Rect(250, 250, 100, 100), child3->drawable_content_rect());
 
   // The root layer does not actually draw content of its own.
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
 
   // All layer visible content rects are not expressed in content space of each
   // layer, so they are not scaled by the device_scale_factor.
   EXPECT_EQ(gfx::Rect(0, 0, 3, 4), render_surface1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 7, 13), render_surface2->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_layer_rect());
-  EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child2->visible_layer_rect());
-  EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child3->visible_layer_rect());
+  EXPECT_EQ(gfx::Rect(0, 0, 15, 15), child2->visible_layer_rect());
+  EXPECT_EQ(gfx::Rect(0, 0, 0, 0), child3->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithoutPreserves3d) {
   // Verify the behavior of back-face culling when there are no preserve-3d
   // layers. Note that 3d transforms still apply in this case, but they are
   // "flattened" to each parent layer according to current W3C spec.
 
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* front_facing_child = AddChildToRoot<LayerImpl>();
   LayerImpl* back_facing_child = AddChildToRoot<LayerImpl>();
@@ skipping 1447 matching lines @@
   DCHECK(!copy_layer->test_properties()->copy_requests.empty());
   ExecuteCalculateDrawProperties(root, device_scale_factor);
   DCHECK(copy_layer->test_properties()->copy_requests.empty());
 
   EXPECT_EQ(gfx::Rect(50, 50), copy_layer->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(10, 10), copy_child->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(10, 10), copy_clipped_child->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(5, 5), copy_surface->visible_layer_rect());
 }
 
-TEST_F(LayerTreeHostCommonTest, VisibleContentRectInsideSurface) {
-  LayerImpl* root = root_layer_for_testing();
-  LayerImpl* surface = AddChild<LayerImpl>(root);
-  LayerImpl* surface_child = AddChild<LayerImpl>(surface);
-
-  root->SetBounds(gfx::Size(50, 50));
-  root->SetDrawsContent(true);
-  surface->SetPosition(gfx::PointF(-10, 20));
-  surface->test_properties()->force_render_surface = true;
-  surface_child->SetBounds(gfx::Size(50, 50));
-  surface_child->SetDrawsContent(true);
-  ExecuteCalculateDrawProperties(root);
-
-  // The visible_layer_rect for the |surface_child| should not be clipped by
-  // the viewport.
-  EXPECT_EQ(gfx::Rect(50, 50), surface_child->visible_layer_rect());
-}
-
 TEST_F(LayerTreeHostCommonTest, TransformedClipParent) {
   // Ensure that a transform between the layer and its render surface is not a
   // problem. Constructs the following layer tree.
   //
   //   root (a render surface)
   //     + render_surface
   //       + clip_parent (scaled)
   //         + intervening_clipping_layer
   //           + clip_child
   //
@@ skipping 3299 matching lines @@
   clip_child->SetDrawsContent(true);
   child->SetBounds(gfx::Size(40, 40));
   child->SetDrawsContent(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(40, 40), child->visible_layer_rect());
+  EXPECT_EQ(gfx::Rect(30, 10), child->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        RenderSurfaceClipsSubtreeAndHasUnclippedDescendants) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface = AddChild<LayerImpl>(clip_parent);
   LayerImpl* test_layer1 = AddChild<LayerImpl>(render_surface);
   LayerImpl* clip_child = AddChild<LayerImpl>(test_layer1);
   LayerImpl* test_layer2 = AddChild<LayerImpl>(clip_child);
@@ skipping 896 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