Use surface contents scale from effect tree (3)

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 187 matching lines @@
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForSingleLayer) {
   gfx::Transform identity_matrix;
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* layer = AddChild<LayerImpl>(root);
 
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false);
 
-  TransformTree& tree =
+  TransformTree& transform_tree =
       host_impl()->active_tree()->property_trees()->transform_tree;
+  EffectTree& effect_tree =
+      host_impl()->active_tree()->property_trees()->effect_tree;
 
   // Case 2: Setting the bounds of the layer should not affect either the draw
   // transform or the screenspace transform.
   gfx::Transform translation_to_center;
   translation_to_center.Translate(5.0, 6.0);
   SetLayerPropertiesForTesting(layer, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 12), true, false);
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      identity_matrix, draw_property_utils::DrawTransform(layer, tree));
+      identity_matrix,
+      draw_property_utils::DrawTransform(layer, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      identity_matrix, draw_property_utils::ScreenSpaceTransform(layer, tree));
+      identity_matrix,
+      draw_property_utils::ScreenSpaceTransform(layer, transform_tree));
 
   // Case 3: The anchor point by itself (without a layer transform) should have
   // no effect on the transforms.
   SetLayerPropertiesForTesting(layer, identity_matrix,
                                gfx::Point3F(2.5f, 3.0f, 0.f), gfx::PointF(),
                                gfx::Size(10, 12), true, false);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      identity_matrix, draw_property_utils::DrawTransform(layer, tree));
+      identity_matrix,
+      draw_property_utils::DrawTransform(layer, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      identity_matrix, draw_property_utils::ScreenSpaceTransform(layer, tree));
+      identity_matrix,
+      draw_property_utils::ScreenSpaceTransform(layer, transform_tree));
 
   // Case 4: A change in actual position affects both the draw transform and
   // screen space transform.
   gfx::Transform position_transform;
   position_transform.Translate(0.f, 1.2f);
   SetLayerPropertiesForTesting(
       layer, identity_matrix, gfx::Point3F(2.5f, 3.0f, 0.f),
       gfx::PointF(0.f, 1.2f), gfx::Size(10, 12), true, false);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      position_transform, draw_property_utils::DrawTransform(layer, tree));
+      position_transform,
+      draw_property_utils::DrawTransform(layer, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       position_transform,
-      draw_property_utils::ScreenSpaceTransform(layer, tree));
+      draw_property_utils::ScreenSpaceTransform(layer, transform_tree));
 
   // Case 5: In the correct sequence of transforms, the layer transform should
   // pre-multiply the translation_to_center. This is easily tested by using a
   // scale transform, because scale and translation are not commutative.
   gfx::Transform layer_transform;
   layer_transform.Scale3d(2.0, 2.0, 1.0);
   SetLayerPropertiesForTesting(layer, layer_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 12), true, false);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      layer_transform, draw_property_utils::DrawTransform(layer, tree));
+      layer_transform,
+      draw_property_utils::DrawTransform(layer, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      layer_transform, draw_property_utils::ScreenSpaceTransform(layer, tree));
+      layer_transform,
+      draw_property_utils::ScreenSpaceTransform(layer, transform_tree));
 
   // Case 6: The layer transform should occur with respect to the anchor point.
   gfx::Transform translation_to_anchor;
   translation_to_anchor.Translate(5.0, 0.0);
   gfx::Transform expected_result =
       translation_to_anchor * layer_transform * Inverse(translation_to_anchor);
   SetLayerPropertiesForTesting(layer, layer_transform,
                                gfx::Point3F(5.0f, 0.f, 0.f), gfx::PointF(),
                                gfx::Size(10, 12), true, false);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      expected_result, draw_property_utils::DrawTransform(layer, tree));
+      expected_result,
+      draw_property_utils::DrawTransform(layer, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      expected_result, draw_property_utils::ScreenSpaceTransform(layer, tree));
+      expected_result,
+      draw_property_utils::ScreenSpaceTransform(layer, transform_tree));
 
   // Case 7: Verify that position pre-multiplies the layer transform.  The
   // current implementation of CalculateDrawProperties does this implicitly, but
   // it is still worth testing to detect accidental regressions.
   expected_result = position_transform * translation_to_anchor *
                     layer_transform * Inverse(translation_to_anchor);
   SetLayerPropertiesForTesting(
       layer, layer_transform, gfx::Point3F(5.0f, 0.f, 0.f),
       gfx::PointF(0.f, 1.2f), gfx::Size(10, 12), true, false);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      expected_result, draw_property_utils::DrawTransform(layer, tree));
+      expected_result,
+      draw_property_utils::DrawTransform(layer, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      expected_result, draw_property_utils::ScreenSpaceTransform(layer, tree));
+      expected_result,
+      draw_property_utils::ScreenSpaceTransform(layer, transform_tree));
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsAboutScrollOffset) {
   const gfx::ScrollOffset kScrollOffset(50, 100);
   const gfx::Vector2dF kScrollDelta(2.34f, 5.67f);
   const gfx::Vector2d kMaxScrollOffset(200, 200);
   const gfx::PointF kScrollLayerPosition(-kScrollOffset.x(),
                                          -kScrollOffset.y());
   float page_scale = 0.888f;
   const float kDeviceScale = 1.666f;
@@ skipping 114 matching lines @@
   gfx::Transform identity_matrix;
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* parent = AddChild<LayerImpl>(root);
   LayerImpl* child = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
 
   // One-time setup of root layer
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false);
 
-  TransformTree& tree =
+  TransformTree& transform_tree =
       host_impl()->active_tree()->property_trees()->transform_tree;
+  EffectTree& effect_tree =
+      host_impl()->active_tree()->property_trees()->effect_tree;
 
   // Case 1: parent's anchor point should not affect child or grand_child.
   SetLayerPropertiesForTesting(parent, identity_matrix,
                                gfx::Point3F(2.5f, 3.0f, 0.f), gfx::PointF(),
                                gfx::Size(10, 12), true, false);
   SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(16, 18), true, false);
   SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(76, 78), true, false);
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(
-      identity_matrix, draw_property_utils::DrawTransform(child, tree));
-  EXPECT_TRANSFORMATION_MATRIX_EQ(
-      identity_matrix, draw_property_utils::ScreenSpaceTransform(child, tree));
-  EXPECT_TRANSFORMATION_MATRIX_EQ(
-      identity_matrix, draw_property_utils::DrawTransform(grand_child, tree));
+      identity_matrix,
+      draw_property_utils::DrawTransform(child, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       identity_matrix,
-      draw_property_utils::ScreenSpaceTransform(grand_child, tree));
+      draw_property_utils::ScreenSpaceTransform(child, transform_tree));
+  EXPECT_TRANSFORMATION_MATRIX_EQ(
+      identity_matrix, draw_property_utils::DrawTransform(
+                           grand_child, transform_tree, effect_tree));
+  EXPECT_TRANSFORMATION_MATRIX_EQ(
+      identity_matrix,
+      draw_property_utils::ScreenSpaceTransform(grand_child, transform_tree));
 
   // Case 2: parent's position affects child and grand_child.
   gfx::Transform parent_position_transform;
   parent_position_transform.Translate(0.f, 1.2f);
   SetLayerPropertiesForTesting(
       parent, identity_matrix, gfx::Point3F(2.5f, 3.0f, 0.f),
       gfx::PointF(0.f, 1.2f), gfx::Size(10, 12), true, false);
   SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(16, 18), true, false);
   SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(76, 78), true, false);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       parent_position_transform,
-      draw_property_utils::DrawTransform(child, tree));
+      draw_property_utils::DrawTransform(child, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       parent_position_transform,
-      draw_property_utils::ScreenSpaceTransform(child, tree));
+      draw_property_utils::ScreenSpaceTransform(child, transform_tree));
+  EXPECT_TRANSFORMATION_MATRIX_EQ(
+      parent_position_transform, draw_property_utils::DrawTransform(
+                                     grand_child, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       parent_position_transform,
-      draw_property_utils::DrawTransform(grand_child, tree));
-  EXPECT_TRANSFORMATION_MATRIX_EQ(
-      parent_position_transform,
-      draw_property_utils::ScreenSpaceTransform(grand_child, tree));
+      draw_property_utils::ScreenSpaceTransform(grand_child, transform_tree));
 
   // Case 3: parent's local transform affects child and grandchild
   gfx::Transform parent_layer_transform;
   parent_layer_transform.Scale3d(2.0, 2.0, 1.0);
   gfx::Transform parent_translation_to_anchor;
   parent_translation_to_anchor.Translate(2.5, 3.0);
   gfx::Transform parent_composite_transform =
       parent_translation_to_anchor * parent_layer_transform *
       Inverse(parent_translation_to_anchor);
   SetLayerPropertiesForTesting(parent, parent_layer_transform,
                                gfx::Point3F(2.5f, 3.0f, 0.f), gfx::PointF(),
                                gfx::Size(10, 12), true, false);
   SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(16, 18), true, false);
   SetLayerPropertiesForTesting(grand_child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(76, 78), true, false);
   host_impl()->active_tree()->property_trees()->needs_rebuild = true;
   ExecuteCalculateDrawProperties(root);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       parent_composite_transform,
-      draw_property_utils::DrawTransform(child, tree));
+      draw_property_utils::DrawTransform(child, transform_tree, effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       parent_composite_transform,
-      draw_property_utils::ScreenSpaceTransform(child, tree));
+      draw_property_utils::ScreenSpaceTransform(child, transform_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       parent_composite_transform,
-      draw_property_utils::DrawTransform(grand_child, tree));
+      draw_property_utils::DrawTransform(grand_child, transform_tree,
+                                         effect_tree));
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       parent_composite_transform,
-      draw_property_utils::ScreenSpaceTransform(grand_child, tree));
+      draw_property_utils::ScreenSpaceTransform(grand_child, transform_tree));
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForSingleRenderSurface) {
   LayerImpl* root = root_layer_for_testing();
   LayerImpl* parent = AddChildToRoot<LayerImpl>();
   LayerImpl* child = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
   grand_child->SetDrawsContent(true);
 
   gfx::Transform identity_matrix;
@@ skipping 6669 matching lines @@
                                false);
   SetLayerPropertiesForTesting(fixed, gfx::Transform(), gfx::Point3F(),
                                gfx::PointF(10.f, 15.f), gfx::Size(50, 50), true,
                                false);
   SetLayerPropertiesForTesting(child, gfx::Transform(), gfx::Point3F(),
                                gfx::PointF(1.f, 2.f), gfx::Size(50, 50), true,
                                false);
 
   ExecuteCalculateDrawProperties(root);
 
-  TransformTree& tree =
+  TransformTree& transform_tree =
       host_impl()->active_tree()->property_trees()->transform_tree;
+  EffectTree& effect_tree =
+      host_impl()->active_tree()->property_trees()->effect_tree;
 
   gfx::Transform expected_fixed_draw_transform;
   expected_fixed_draw_transform.Translate(10.f, 15.f);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_fixed_draw_transform,
-      draw_property_utils::DrawTransform(fixed, tree));
+      draw_property_utils::DrawTransform(fixed, transform_tree, effect_tree));
 
   gfx::Transform expected_fixed_screen_space_transform;
   expected_fixed_screen_space_transform.Translate(17.f, 24.f);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_fixed_screen_space_transform,
-      draw_property_utils::ScreenSpaceTransform(fixed, tree));
+      draw_property_utils::ScreenSpaceTransform(fixed, transform_tree));
 
   gfx::Transform expected_child_draw_transform;
   expected_child_draw_transform.Translate(11.f, 17.f);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_child_draw_transform,
-      draw_property_utils::DrawTransform(child, tree));
+      draw_property_utils::DrawTransform(child, transform_tree, effect_tree));
 
   gfx::Transform expected_child_screen_space_transform;
   expected_child_screen_space_transform.Translate(18.f, 26.f);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_child_screen_space_transform,
-      draw_property_utils::ScreenSpaceTransform(child, tree));
+      draw_property_utils::ScreenSpaceTransform(child, transform_tree));
 }
 
 TEST_F(LayerTreeHostCommonTest, ScrollCompensationWithRounding) {
   // This test verifies that a scrolling layer that gets snapped to
   // integer coordinates doesn't move a fixed position child.
   //
   // + root
   //   + container
   //     + scroller
   //       + fixed
@@ skipping 3292 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