[cc] Change semantics of fixed-pos container layer

cc/layers/layer_position_constraint_unittest.cc

 // Copyright 2013 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/layers/layer_position_constraint.h"
 
 #include <vector>
 
 #include "cc/animation/animation_host.h"
 #include "cc/layers/layer.h"
@@ skipping 100 matching lines @@
     SetLayerPropertiesForTesting(child_.get(), IdentityMatrix, transform_origin,
                                  position, bounds, true);
     SetLayerPropertiesForTesting(grand_child_.get(), IdentityMatrix,
                                  transform_origin, position, bounds, true);
     SetLayerPropertiesForTesting(great_grand_child_.get(), IdentityMatrix,
                                  transform_origin, position, bounds, true);
 
     root_->SetBounds(clip_bounds);
 
     inner_viewport_container_layer_->SetMasksToBounds(true);
+    inner_viewport_container_layer_->SetIsContainerForFixedPositionLayers(true);
     scroll_layer_->SetScrollClipLayerId(inner_viewport_container_layer_->id());
-    scroll_layer_->SetIsContainerForFixedPositionLayers(true);
 
     outer_viewport_container_layer_->SetMasksToBounds(true);
+    outer_viewport_container_layer_->SetIsContainerForFixedPositionLayers(true);
     child_->SetScrollClipLayerId(outer_viewport_container_layer_->id());
     grand_child_->SetScrollClipLayerId(outer_viewport_container_layer_->id());
 
     grand_child_->AddChild(great_grand_child_);
     child_->AddChild(grand_child_);
     child_transform_layer_->AddChild(child_);
     outer_viewport_container_layer_->AddChild(child_transform_layer_);
     scroll_layer_->AddChild(outer_viewport_container_layer_);
     inner_viewport_container_layer_->AddChild(scroll_layer_);
     root_->AddChild(inner_viewport_container_layer_);
@@ skipping 69 matching lines @@
             ->scroll_tree.SetScrollOffsetDeltaForTesting(layer_impl->id(),
                                                          delta))
       layer_impl->layer_tree_impl()->DidUpdateScrollOffset(layer_impl->id());
   }
 };
 
 TEST_F(LayerPositionConstraintTest,
      ScrollCompensationForFixedPositionLayerWithDirectContainer) {
   // This test checks for correct scroll compensation when the fixed-position
   // container is the direct parent of the fixed-position layer.
-  child_->SetIsContainerForFixedPositionLayers(true);
   grand_child_->SetPositionConstraint(fixed_to_top_left_);
 
   CommitAndUpdateImplPointers();
 
   // Case 1: scroll delta of 0, 0
   SetScrollOffsetDelta(child_impl_, gfx::Vector2d(0, 0));
   ExecuteCalculateDrawProperties(root_impl_);
 
   gfx::Transform expected_child_transform;
   gfx::Transform expected_grand_child_transform = expected_child_transform;
@@ skipping 46 matching lines @@
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
                                   grand_child_impl_->DrawTransform());
 }
 
 TEST_F(LayerPositionConstraintTest,
      ScrollCompensationForFixedPositionLayerWithDistantContainer) {
   // This test checks for correct scroll compensation when the fixed-position
   // container is NOT the direct parent of the fixed-position layer.
-  child_->SetIsContainerForFixedPositionLayers(true);
   grand_child_->SetPosition(gfx::PointF(8.f, 6.f));
   great_grand_child_->SetPositionConstraint(fixed_to_top_left_);
 
   CommitAndUpdateImplPointers();
 
   // Case 1: scroll delta of 0, 0
   SetScrollOffsetDelta(child_impl_, gfx::Vector2d(0, 0));
   child_impl_->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root_impl_);
 
@@ skipping 131 matching lines @@
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
                                   great_grand_child_impl_->DrawTransform());
 }
 
 TEST_F(LayerPositionConstraintTest,
      ScrollCompensationForFixedPositionWithIntermediateSurfaceAndTransforms) {
   // This test checks for correct scroll compensation when the fixed-position
   // container contributes to a different render surface than the fixed-position
   // layer. In this case, the surface draw transforms also have to be accounted
   // for when checking the scroll delta.
-  child_->SetIsContainerForFixedPositionLayers(true);
   grand_child_->SetPosition(gfx::PointF(8.f, 6.f));
   grand_child_->SetForceRenderSurfaceForTesting(true);
   great_grand_child_->SetPositionConstraint(fixed_to_top_left_);
 
   gfx::Transform rotation_about_z;
   rotation_about_z.RotateAboutZAxis(90.0);
   great_grand_child_->SetTransform(rotation_about_z);
 
   CommitAndUpdateImplPointers();
 
@@ skipping 105 matching lines @@
 
   // Add one more layer to the test tree for this scenario.
   scoped_refptr<Layer> fixed_position_child =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   SetLayerPropertiesForTesting(fixed_position_child.get(), gfx::Transform(),
                                gfx::Point3F(), gfx::PointF(),
                                gfx::Size(100, 100), true);
   great_grand_child_->AddChild(fixed_position_child);
 
   // Actually set up the scenario here.
-  child_->SetIsContainerForFixedPositionLayers(true);
   grand_child_->SetPosition(gfx::PointF(8.f, 6.f));
   grand_child_->SetForceRenderSurfaceForTesting(true);
   great_grand_child_->SetPosition(gfx::PointF(40.f, 60.f));
   great_grand_child_->SetForceRenderSurfaceForTesting(true);
   fixed_position_child->SetPositionConstraint(fixed_to_top_left_);
 
   // The additional rotation, which is non-commutative with translations, helps
   // to verify that we have correct order-of-operations in the final scroll
   // compensation.  Note that rotating about the center of the layer ensures we
   // do not accidentally clip away layers that we want to test.
@@ skipping 254 matching lines @@
                                   fixed_position_child_impl->DrawTransform());
 }
 
 TEST_F(LayerPositionConstraintTest,
      ScrollCompensationForFixedPositionLayerWithContainerLayerThatHasSurface) {
   // This test checks for correct scroll compensation when the fixed-position
   // container itself has a render surface. In this case, the container layer
   // should be treated like a layer that contributes to a render target, and
   // that render target is completely irrelevant; it should not affect the
   // scroll compensation.
-  child_->SetIsContainerForFixedPositionLayers(true);
   child_->SetForceRenderSurfaceForTesting(true);
   grand_child_->SetPositionConstraint(fixed_to_top_left_);
 
   CommitAndUpdateImplPointers();
 
   // Case 1: scroll delta of 0, 0
   SetScrollOffsetDelta(child_impl_, gfx::Vector2d(0, 0));
   ExecuteCalculateDrawProperties(root_impl_);
 
   gfx::Transform expected_surface_draw_transform;
@@ skipping 61 matching lines @@
                                   child_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
                                   grand_child_impl_->DrawTransform());
 }
 
 TEST_F(LayerPositionConstraintTest,
      ScrollCompensationForFixedPositionLayerThatIsAlsoFixedPositionContainer) {
   // This test checks the scenario where a fixed-position layer also happens to
   // be a container itself for a descendant fixed position layer. In particular,
   // the layer should not accidentally be fixed to itself.
-  child_->SetIsContainerForFixedPositionLayers(true);
   grand_child_->SetPositionConstraint(fixed_to_top_left_);
-
-  // This should not confuse the grand_child. If correct, the grand_child would
-  // still be considered fixed to its container (i.e. "child").
   grand_child_->SetIsContainerForFixedPositionLayers(true);
 
   CommitAndUpdateImplPointers();
 
   // Case 1: scroll delta of 0, 0
   SetScrollOffsetDelta(child_impl_, gfx::Vector2d(0, 0));
   child_impl_->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root_impl_);
 
   gfx::Transform expected_child_transform;
@@ skipping 47 matching lines @@
                                   grand_child_impl_->DrawTransform());
 }
 
 TEST_F(LayerPositionConstraintTest,
      ScrollCompensationForFixedWithinFixedWithSameContainer) {
   // This test checks scroll compensation for a fixed-position layer that is
   // inside of another fixed-position layer and both share the same container.
   // In this situation, the parent fixed-position layer will receive
   // the scroll compensation, and the child fixed-position layer does not
   // need to compensate further.
-  child_->SetIsContainerForFixedPositionLayers(true);
   grand_child_->SetPositionConstraint(fixed_to_top_left_);
 
   // Note carefully - great_grand_child is fixed to bottom right, to test
   // sizeDelta being applied correctly; the compensation skips the grand_child
   // because it is fixed to top left.
   great_grand_child_->SetPositionConstraint(fixed_to_bottom_right_);
 
   CommitAndUpdateImplPointers();
 
   // Case 1: scrollDelta
@@ skipping 43 matching lines @@
   // This test checks scroll compensation for a fixed-position layer that is
   // inside of another fixed-position layer, but they have different fixed
   // position containers. In this situation, the child fixed-position element
   // would still have to compensate with respect to its container.
 
   // Add one more layer to the hierarchy for this test.
   scoped_refptr<Layer> great_great_grand_child =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   great_grand_child_->AddChild(great_great_grand_child);
 
-  child_->SetIsContainerForFixedPositionLayers(true);
   grand_child_->SetPositionConstraint(fixed_to_top_left_);
-  great_grand_child_->SetIsContainerForFixedPositionLayers(true);
+  grand_child_->SetIsContainerForFixedPositionLayers(true);
   great_grand_child_->SetScrollClipLayerId(root_->id());
   great_great_grand_child->SetPositionConstraint(fixed_to_top_left_);
 
   CommitAndUpdateImplPointers();
 
   LayerImpl* container1 = child_impl_;
   LayerImpl* fixed_to_container1 = grand_child_impl_;
   LayerImpl* container2 = great_grand_child_impl_;
   LayerImpl* fixed_to_container2 =
       layer_tree_impl_->LayerById(great_great_grand_child->id());
@@ skipping 79 matching lines @@
   expected_fixed_child_transform.Translate(20.0, 20.0);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_scroll_layer_transform,
                                   scroll_layer_impl_->DrawTransform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_fixed_child_transform,
                                   fixed_child_impl->DrawTransform());
 }
 
 }  // namespace
 }  // namespace cc