cc : Don't draw animating layers with singular screen space transform

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 8981 matching lines @@
       animated->element_id(), timeline_impl(), 10.0, 0.f, 1.f, false);
   animated->test_properties()->opacity_can_animate = true;
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);
 
   EXPECT_FALSE(animated->visible_layer_rect().IsEmpty());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        VisibleContentRectForAnimatedLayerWithSingularTransform) {
-  LayerImpl* root = root_layer_for_testing();
-  LayerImpl* clip = AddChild<LayerImpl>(root);
-  LayerImpl* animated = AddChild<LayerImpl>(clip);
-  LayerImpl* surface = AddChild<LayerImpl>(animated);
-  LayerImpl* descendant_of_animation = AddChild<LayerImpl>(surface);
+  host_impl()->CreatePendingTree();
+  std::unique_ptr<LayerImpl> root_ptr =
+      LayerImpl::Create(host_impl()->pending_tree(), 1);
+  LayerImpl* root = root_ptr.get();
+  host_impl()->pending_tree()->SetRootLayerForTesting(std::move(root_ptr));
+  std::unique_ptr<LayerImpl> clip_ptr =
+      LayerImpl::Create(host_impl()->pending_tree(), 2);
+  LayerImpl* clip = clip_ptr.get();
+  root->test_properties()->AddChild(std::move(clip_ptr));
+  std::unique_ptr<LayerImpl> animated_ptr =
+      LayerImpl::Create(host_impl()->pending_tree(), 3);
+  LayerImpl* animated = animated_ptr.get();
+  clip->test_properties()->AddChild(std::move(animated_ptr));
+  std::unique_ptr<LayerImpl> surface_ptr =
+      LayerImpl::Create(host_impl()->pending_tree(), 4);
+  LayerImpl* surface = surface_ptr.get();
+  animated->test_properties()->AddChild(std::move(surface_ptr));
+  std::unique_ptr<LayerImpl> descendant_of_animation_ptr =
+      LayerImpl::Create(host_impl()->pending_tree(), 5);
+  LayerImpl* descendant_of_animation = descendant_of_animation_ptr.get();
+  surface->test_properties()->AddChild(std::move(descendant_of_animation_ptr));
 
-  SetElementIdsForTesting();
+  host_impl()->pending_tree()->SetElementIdsForTesting();
 
+  root->SetDrawsContent(true);
   animated->SetDrawsContent(true);
   surface->SetDrawsContent(true);
   descendant_of_animation->SetDrawsContent(true);
 
   gfx::Transform uninvertible_matrix;
   uninvertible_matrix.Scale3d(6.f, 6.f, 0.f);
 
   root->SetBounds(gfx::Size(100, 100));
   clip->SetBounds(gfx::Size(10, 10));
   clip->SetMasksToBounds(true);
   animated->test_properties()->transform = uninvertible_matrix;
   animated->SetBounds(gfx::Size(120, 120));
   surface->SetBounds(gfx::Size(100, 100));
   surface->test_properties()->force_render_surface = true;
   descendant_of_animation->SetBounds(gfx::Size(200, 200));
 
   TransformOperations start_transform_operations;
   start_transform_operations.AppendMatrix(uninvertible_matrix);
   TransformOperations end_transform_operations;
 
   AddAnimatedTransformToElementWithPlayer(
       animated->element_id(), timeline_impl(), 10.0, start_transform_operations,
       end_transform_operations);
-  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);
+  ExecuteCalculateDrawProperties(root);
+  // Since animated has singular transform, it is not be part of render
+  // surface layer list but should be rastered.
+  EXPECT_FALSE(animated->is_drawn_render_surface_layer_list_member());
+  EXPECT_TRUE(animated->raster_even_if_not_in_rsll());
 
   // The animated layer has a singular transform and maps to a non-empty rect in
   // clipped target space, so is treated as fully visible.
   EXPECT_EQ(gfx::Rect(120, 120), animated->visible_layer_rect());
 
   // The singular transform on |animated| is flattened when inherited by
   // |surface|, and this happens to make it invertible.
   EXPECT_EQ(gfx::Rect(2, 2), surface->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(2, 2), descendant_of_animation->visible_layer_rect());
 
   gfx::Transform zero_matrix;
   zero_matrix.Scale3d(0.f, 0.f, 0.f);
   root->layer_tree_impl()->SetTransformMutated(animated->element_id(),
                                                zero_matrix);
-  ExecuteCalculateDrawPropertiesAndSaveUpdateLayerList(root);
+  ExecuteCalculateDrawProperties(root);
 
   // The animated layer will be treated as fully visible when we combine clips
   // in screen space.
   EXPECT_EQ(gfx::Rect(120, 120), animated->visible_layer_rect());
 
   // This time, flattening does not make |animated|'s transform invertible. This
   // means the clip cannot be projected into |surface|'s space, so we treat
   // |surface| and layers that draw into it as having empty visible rect.
   EXPECT_EQ(gfx::Rect(100, 100), surface->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(200, 200), descendant_of_animation->visible_layer_rect());
+
+  host_impl()->ActivateSyncTree();
+  LayerImpl* active_root = host_impl()->active_tree()->LayerById(root->id());
+  ExecuteCalculateDrawProperties(active_root);
+
+  // Since the animated has singular transform, it is not be part of render
+  // surface layer list.
+  LayerImpl* active_animated =
+      host_impl()->active_tree()->LayerById(animated->id());
+  EXPECT_TRUE(active_root->is_drawn_render_surface_layer_list_member());
+  EXPECT_FALSE(active_animated->is_drawn_render_surface_layer_list_member());
+
+  // Since animated has singular transform, it is not be part of render
+  // surface layer list but should be rastered.
+  EXPECT_TRUE(animated->raster_even_if_not_in_rsll());
+  EXPECT_EQ(gfx::Rect(120, 120), active_animated->visible_layer_rect());
 }
 
 // Verify that having animated opacity but current opacity 1 still creates
 // a render surface.
 TEST_F(LayerTreeHostCommonTest, AnimatedOpacityCreatesRenderSurface) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
   LayerImpl* grandchild = AddChild<LayerImpl>(child);
 
   root->SetBounds(gfx::Size(50, 50));
@@ skipping 1796 matching lines @@
 
   // Check child layer draw properties.
   EXPECT_EQ(gfx::Rect(10, 10), child->visible_layer_rect());
   EXPECT_EQ(gfx::Transform(), child->DrawTransform());
   EXPECT_EQ(gfx::Rect(10, 10), child->clip_rect());
   EXPECT_EQ(gfx::Rect(10, 10), child->drawable_content_rect());
 }
 
 }  // namespace
 }  // namespace cc