cc : Reland Move screen space scale factor to root transform node

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 1175 matching lines @@
   LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
 
   // Between grand_child and render_surface, we translate by (10, 10) and scale
   // by a factor of 2.
   gfx::Vector2dF expected_translation(20.0f, 20.0f);
   EXPECT_EQ(grand_child->DrawTransform().To2dTranslation(),
             expected_translation);
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {
-  // Transformations applied at the root of the tree should be forwarded
-  // to child layers instead of applied to the root RenderSurface.
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* child = AddChild<LayerImpl>(root);
 
   root->SetDrawsContent(true);
-  root->SetBounds(gfx::Size(20, 20));
+  root->SetBounds(gfx::Size(100, 100));
   child->SetDrawsContent(true);
   child->SetScrollClipLayer(root->id());
-  child->SetBounds(gfx::Size(20, 20));
+  child->SetBounds(gfx::Size(100, 100));
+  child->SetMasksToBounds(true);
 
   gfx::Transform translate;
   translate.Translate(50, 50);
   {
     LayerImplList render_surface_layer_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root, root->bounds(), translate, &render_surface_layer_list_impl);
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         translate, root->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         translate, child->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                     root->render_surface()->draw_transform());
+    EXPECT_TRANSFORMATION_MATRIX_EQ(translate, child->ScreenSpaceTransform());
+    EXPECT_EQ(gfx::Rect(50, 50, 100, 100), child->clip_rect());
   }
 
   gfx::Transform scale;
   scale.Scale(2, 2);
   {
     LayerImplList render_surface_layer_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root, root->bounds(), scale, &render_surface_layer_list_impl);
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         scale, root->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         scale, child->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                     root->render_surface()->draw_transform());
+    EXPECT_TRANSFORMATION_MATRIX_EQ(scale, child->ScreenSpaceTransform());
+    EXPECT_EQ(gfx::Rect(0, 0, 200, 200), child->clip_rect());
   }
 
   gfx::Transform rotate;
   rotate.Rotate(2);
   {
     LayerImplList render_surface_layer_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root, root->bounds(), rotate, &render_surface_layer_list_impl);
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         rotate, root->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         rotate, child->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                     root->render_surface()->draw_transform());
+    EXPECT_TRANSFORMATION_MATRIX_EQ(rotate, child->ScreenSpaceTransform());
+    EXPECT_EQ(gfx::Rect(-4, 0, 104, 104), child->clip_rect());
   }
 
   gfx::Transform composite;
   composite.ConcatTransform(translate);
   composite.ConcatTransform(scale);
   composite.ConcatTransform(rotate);
   {
     LayerImplList render_surface_layer_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root, root->bounds(), composite, &render_surface_layer_list_impl);
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         composite, root->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         composite, child->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                     root->render_surface()->draw_transform());
+    EXPECT_TRANSFORMATION_MATRIX_EQ(composite, child->ScreenSpaceTransform());
+    EXPECT_EQ(gfx::Rect(89, 103, 208, 208), child->clip_rect());
   }
 
   // Verify it composes correctly with device scale.
   float device_scale_factor = 1.5f;
 
   {
     LayerImplList render_surface_layer_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root, root->bounds(), translate, &render_surface_layer_list_impl);
     inputs.device_scale_factor = device_scale_factor;
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
     gfx::Transform device_scaled_translate = translate;
     device_scaled_translate.Scale(device_scale_factor, device_scale_factor);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         device_scaled_translate,
         root->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         device_scaled_translate,
         child->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                     root->render_surface()->draw_transform());
+    EXPECT_TRANSFORMATION_MATRIX_EQ(device_scaled_translate,
+                                    child->ScreenSpaceTransform());
+    EXPECT_EQ(gfx::Rect(50, 50, 150, 150), child->clip_rect());
   }
 
   // Verify it composes correctly with page scale.
   float page_scale_factor = 2.f;
 
   {
     LayerImplList render_surface_layer_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root, root->bounds(), translate, &render_surface_layer_list_impl);
     inputs.page_scale_factor = page_scale_factor;
     inputs.page_scale_layer = root;
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
     gfx::Transform page_scaled_translate = translate;
     page_scaled_translate.Scale(page_scale_factor, page_scale_factor);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         page_scaled_translate, root->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         page_scaled_translate, child->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                     root->render_surface()->draw_transform());
+    EXPECT_TRANSFORMATION_MATRIX_EQ(page_scaled_translate,
+                                    child->ScreenSpaceTransform());
+    EXPECT_EQ(gfx::Rect(50, 50, 200, 200), child->clip_rect());
   }
 
   // Verify that it composes correctly with transforms directly on root layer.
   root->test_properties()->transform = composite;
 
   {
     LayerImplList render_surface_layer_list_impl;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
         root, root->bounds(), composite, &render_surface_layer_list_impl);
     inputs.property_trees->needs_rebuild = true;
     LayerTreeHostCommon::CalculateDrawPropertiesForTesting(&inputs);
     gfx::Transform compositeSquared = composite;
     compositeSquared.ConcatTransform(composite);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         compositeSquared, root->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         compositeSquared, child->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(gfx::Transform(),
                                     root->render_surface()->draw_transform());
+    EXPECT_TRANSFORMATION_MATRIX_EQ(compositeSquared,
+                                    child->ScreenSpaceTransform());
+    EXPECT_EQ(gfx::Rect(254, 316, 428, 428), child->clip_rect());
   }
 }
 
 TEST_F(LayerTreeHostCommonTest,
        RenderSurfaceListForRenderSurfaceWithClippedLayer) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* render_surface1 = AddChildToRoot<LayerImpl>();
   LayerImpl* child = AddChild<LayerImpl>(render_surface1);
 
   root->SetBounds(gfx::Size(10, 10));
@@ skipping 8126 matching lines @@
   test_layer->SetBounds(gfx::Size(20, 20));
   test_layer->SetDrawsContent(true);
   test_layer->SetTouchEventHandlerRegion(gfx::Rect(0, 0, 20, 20));
   test_layer->test_properties()->opacity = 0.f;
 
   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_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));
+  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);
+
+  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);
+
+  float device_scale_factor = 1.f;
+  ExecuteCalculateDrawProperties(root, device_scale_factor);
+  EXPECT_EQ(gfx::Rect(20, 20), clip_child->clip_rect());
+  EXPECT_EQ(gfx::Rect(20, 20), clip_child->visible_layer_rect());
+
+  device_scale_factor = 2.f;
+  ExecuteCalculateDrawProperties(root, device_scale_factor);
+  EXPECT_EQ(gfx::Rect(40, 40), clip_child->clip_rect());
+  EXPECT_EQ(gfx::Rect(20, 20), clip_child->visible_layer_rect());
+}
+
 TEST_F(LayerTreeHostCommonTest, ClipChildVisibleRect) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface);
 
   root->SetBounds(gfx::Size(30, 30));
   clip_parent->SetBounds(gfx::Size(40, 40));
   clip_parent->SetMasksToBounds(true);
   render_surface->SetBounds(gfx::Size(50, 50));
@@ skipping 630 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