Pinch/Zoom Infrastructure & Plumbing CL

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/layers/layer_impl.h"
 #include "cc/test/fake_impl_proxy.h"
@@ skipping 21 matching lines @@
   layer->SetContentBounds(bounds);
 }
 
 void ExecuteCalculateDrawProperties(LayerImpl* root_layer,
                                     float device_scale_factor,
                                     float page_scale_factor,
                                     LayerImpl* page_scale_application_layer,
                                     bool can_use_lcd_text) {
   gfx::Transform identity_matrix;
   std::vector<LayerImpl*> dummy_render_surface_layer_list;
+  LayerImpl* scroll_layer = root_layer->children()[0];
   gfx::Size device_viewport_size =
       gfx::Size(root_layer->bounds().width() * device_scale_factor,
                 root_layer->bounds().height() * device_scale_factor);
 
-  // We are probably not testing what is intended if the root_layer bounds are
+  // We are probably not testing what is intended if the scroll_layer bounds are
   // empty.
-  DCHECK(!root_layer->bounds().IsEmpty());
+  DCHECK(!scroll_layer->bounds().IsEmpty());
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root_layer, device_viewport_size, &dummy_render_surface_layer_list);
   inputs.device_scale_factor = device_scale_factor;
   inputs.page_scale_factor = page_scale_factor;
   inputs.page_scale_application_layer = page_scale_application_layer;
   inputs.can_use_lcd_text = can_use_lcd_text;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 }
 
 void ExecuteCalculateDrawProperties(LayerImpl* root_layer) {
   LayerImpl* page_scale_application_layer = NULL;
   ExecuteCalculateDrawProperties(
       root_layer, 1.f, 1.f, page_scale_application_layer, false);
 }
 
 class LayerPositionConstraintTest : public testing::Test {
  public:
   LayerPositionConstraintTest()
       : host_impl_(&proxy_) {
     root_ = CreateTreeForTest();
+    scroll_ = root_->children()[0];
     fixed_to_top_left_.set_is_fixed_position(true);
     fixed_to_bottom_right_.set_is_fixed_position(true);
     fixed_to_bottom_right_.set_is_fixed_to_right_edge(true);
     fixed_to_bottom_right_.set_is_fixed_to_bottom_edge(true);
   }
 
   scoped_ptr<LayerImpl> CreateTreeForTest() {
     scoped_ptr<LayerImpl> root =
+        LayerImpl::Create(host_impl_.active_tree(), 42);
+    scoped_ptr<LayerImpl> scroll_layer =
         LayerImpl::Create(host_impl_.active_tree(), 1);
     scoped_ptr<LayerImpl> child =
         LayerImpl::Create(host_impl_.active_tree(), 2);
     scoped_ptr<LayerImpl> grand_child =
         LayerImpl::Create(host_impl_.active_tree(), 3);
     scoped_ptr<LayerImpl> great_grand_child =
         LayerImpl::Create(host_impl_.active_tree(), 4);
 
     gfx::Transform IdentityMatrix;
     gfx::PointF anchor;
     gfx::PointF position;
-    gfx::Size bounds(100, 100);
-    SetLayerPropertiesForTesting(root.get(),
+    gfx::Size bounds(200, 200);
+    gfx::Size clip_bounds(100, 100);
+    SetLayerPropertiesForTesting(scroll_layer.get(),
                                  IdentityMatrix,
                                  IdentityMatrix,
                                  anchor,
                                  position,
                                  bounds,
                                  false);
     SetLayerPropertiesForTesting(child.get(),
                                  IdentityMatrix,
                                  IdentityMatrix,
                                  anchor,
                                  position,
                                  bounds,
                                  false);
     SetLayerPropertiesForTesting(grand_child.get(),
                                  IdentityMatrix,
                                  IdentityMatrix,
                                  anchor,
                                  position,
                                  bounds,
                                  false);
     SetLayerPropertiesForTesting(great_grand_child.get(),
                                  IdentityMatrix,
                                  IdentityMatrix,
                                  anchor,
                                  position,
                                  bounds,
                                  false);
 
-    root->SetMaxScrollOffset(gfx::Vector2d(100, 100));
-    root->SetScrollable(true);
-    child->SetMaxScrollOffset(gfx::Vector2d(100, 100));
-    child->SetScrollable(true);
-    grand_child->SetMaxScrollOffset(gfx::Vector2d(100, 100));
-    grand_child->SetScrollable(true);
+    root->SetBounds(clip_bounds);
+    scroll_layer->SetScrollClipLayer(root->id());
+    child->SetScrollClipLayer(root->id());
+    grand_child->SetScrollClipLayer(root->id());
 
     grand_child->AddChild(great_grand_child.Pass());
     child->AddChild(grand_child.Pass());
-    root->AddChild(child.Pass());
+    scroll_layer->AddChild(child.Pass());
+    root->AddChild(scroll_layer.Pass());
 
     return root.Pass();
   }
 
  protected:
   FakeImplProxy proxy_;
   FakeLayerTreeHostImpl host_impl_;
   scoped_ptr<LayerImpl> root_;
+  LayerImpl* scroll_;
 
   LayerPositionConstraint fixed_to_top_left_;
   LayerPositionConstraint fixed_to_bottom_right_;
 };
 
 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.
-  LayerImpl* child = root_->children()[0];
+  LayerImpl* child = scroll_->children()[0];
   LayerImpl* grand_child = child->children()[0];
 
   child->SetIsContainerForFixedPositionLayers(true);
   grand_child->SetPositionConstraint(fixed_to_top_left_);
 
   // Case 1: scroll delta of 0, 0
   child->SetScrollDelta(gfx::Vector2d(0, 0));
   ExecuteCalculateDrawProperties(root_.get());
 
   gfx::Transform expected_child_transform;
@@ skipping 47 matching lines @@
      ScrollCompensationForFixedPositionLayerWithTransformedDirectContainer) {
   // This test checks for correct scroll compensation when the fixed-position
   // container is the direct parent of the fixed-position layer, but that
   // container is transformed.  In this case, the fixed position element
   // inherits the container's transform, but the scroll delta that has to be
   // undone should not be affected by that transform.
   //
   // Transforms are in general non-commutative; using something like a
   // non-uniform scale helps to verify that translations and non-uniform scales
   // are applied in the correct order.
-  LayerImpl* child = root_->children()[0];
+  LayerImpl* child = scroll_->children()[0];
   LayerImpl* grand_child = child->children()[0];
 
   // This scale will cause child and grand_child to be effectively 200 x 800
   // with respect to the render target.
   gfx::Transform non_uniform_scale;
   non_uniform_scale.Scale(2.0, 8.0);
   child->SetTransform(non_uniform_scale);
 
   child->SetIsContainerForFixedPositionLayers(true);
   grand_child->SetPositionConstraint(fixed_to_top_left_);
@@ skipping 51 matching lines @@
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
                                   grand_child->draw_transform());
 }
 
 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.
-  LayerImpl* child = root_->children()[0];
+  LayerImpl* child = scroll_->children()[0];
   LayerImpl* grand_child = child->children()[0];
   LayerImpl* great_grand_child = grand_child->children()[0];
 
   child->SetIsContainerForFixedPositionLayers(true);
   grand_child->SetPosition(gfx::PointF(8.f, 6.f));
   great_grand_child->SetPositionConstraint(fixed_to_top_left_);
 
   // Case 1: scroll delta of 0, 0
   child->SetScrollDelta(gfx::Vector2d(0, 0));
   ExecuteCalculateDrawProperties(root_.get());
@@ skipping 59 matching lines @@
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
                                   great_grand_child->draw_transform());
 }
 
 TEST_F(LayerPositionConstraintTest,
      ScrollCompensationForFixedPositionLayerWithDistantContainerAndTransforms) {
   // This test checks for correct scroll compensation when the fixed-position
   // container is NOT the direct parent of the fixed-position layer, and the
   // hierarchy has various transforms that have to be processed in the correct
   // order.
-  LayerImpl* child = root_->children()[0];
+  LayerImpl* child = scroll_->children()[0];
   LayerImpl* grand_child = child->children()[0];
   LayerImpl* great_grand_child = grand_child->children()[0];
 
   gfx::Transform rotation_about_z;
   rotation_about_z.RotateAboutZAxis(90.0);
 
   child->SetIsContainerForFixedPositionLayers(true);
   child->SetTransform(rotation_about_z);
   grand_child->SetPosition(gfx::PointF(8.f, 6.f));
   grand_child->SetTransform(rotation_about_z);
@@ skipping 91 matching lines @@
 TEST_F(LayerPositionConstraintTest,
      ScrollCompensationForFixedPositionLayerWithMultipleScrollDeltas) {
   // This test checks for correct scroll compensation when the fixed-position
   // container has multiple ancestors that have nonzero scroll delta before
   // reaching the space where the layer is fixed.  In this test, each scroll
   // delta occurs in a different space because of each layer's local transform.
   // This test checks for correct scroll compensation when the fixed-position
   // container is NOT the direct parent of the fixed-position layer, and the
   // hierarchy has various transforms that have to be processed in the correct
   // order.
-  LayerImpl* child = root_->children()[0];
+  LayerImpl* child = scroll_->children()[0];
   LayerImpl* grand_child = child->children()[0];
   LayerImpl* great_grand_child = grand_child->children()[0];
 
   gfx::Transform rotation_about_z;
   rotation_about_z.RotateAboutZAxis(90.0);
 
   child->SetIsContainerForFixedPositionLayers(true);
   child->SetTransform(rotation_about_z);
   grand_child->SetPosition(gfx::PointF(8.f, 6.f));
   grand_child->SetTransform(rotation_about_z);
@@ skipping 90 matching lines @@
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
                                   great_grand_child->draw_transform());
 }
 
 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.
-  LayerImpl* child = root_->children()[0];
+  LayerImpl* child = scroll_->children()[0];
   LayerImpl* grand_child = child->children()[0];
   LayerImpl* great_grand_child = grand_child->children()[0];
 
   child->SetIsContainerForFixedPositionLayers(true);
   grand_child->SetPosition(gfx::PointF(8.f, 6.f));
   grand_child->SetForceRenderSurface(true);
   great_grand_child->SetPositionConstraint(fixed_to_top_left_);
   great_grand_child->SetDrawsContent(true);
 
   gfx::Transform rotation_about_z;
@@ skipping 103 matching lines @@
                                   great_grand_child->draw_transform());
 }
 
 TEST_F(LayerPositionConstraintTest,
      ScrollCompensationForFixedPositionLayerWithMultipleIntermediateSurfaces) {
   // This test checks for correct scroll compensation when the fixed-position
   // container contributes to a different render surface than the fixed-position
   // layer, with additional render surfaces in-between. This checks that the
   // conversion to ancestor surfaces is accumulated properly in the final matrix
   // transform.
-  LayerImpl* child = root_->children()[0];
+  LayerImpl* child = scroll_->children()[0];
   LayerImpl* grand_child = child->children()[0];
   LayerImpl* great_grand_child = grand_child->children()[0];
 
   // Add one more layer to the test tree for this scenario.
   {
     gfx::Transform identity;
     scoped_ptr<LayerImpl> fixed_position_child =
         LayerImpl::Create(host_impl_.active_tree(), 5);
     SetLayerPropertiesForTesting(fixed_position_child.get(),
                                  identity,
@@ skipping 166 matching lines @@
                                   fixed_position_child->draw_transform());
 }
 
 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.
-  LayerImpl* child = root_->children()[0];
+  LayerImpl* child = scroll_->children()[0];
   LayerImpl* grand_child = child->children()[0];
 
   child->SetIsContainerForFixedPositionLayers(true);
   child->SetForceRenderSurface(true);
   grand_child->SetPositionConstraint(fixed_to_top_left_);
   grand_child->SetDrawsContent(true);
 
   // Case 1: scroll delta of 0, 0
   child->SetScrollDelta(gfx::Vector2d(0, 0));
   ExecuteCalculateDrawProperties(root_.get());
@@ skipping 57 matching lines @@
                                   child->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
                                   grand_child->draw_transform());
 }
 
 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.
-  LayerImpl* child = root_->children()[0];
+  LayerImpl* child = scroll_->children()[0];
   LayerImpl* grand_child = child->children()[0];
 
   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);
 
   // Case 1: scroll delta of 0, 0
@@ skipping 43 matching lines @@
                                   child->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
                                   grand_child->draw_transform());
 }
 
 TEST_F(LayerPositionConstraintTest,
      ScrollCompensationForFixedPositionLayerThatHasNoContainer) {
   // This test checks scroll compensation when a fixed-position layer does not
   // find any ancestor that is a "containerForFixedPositionLayers". In this
   // situation, the layer should be fixed to the root layer.
-  LayerImpl* child = root_->children()[0];
+  LayerImpl* child = scroll_->children()[0];
   LayerImpl* grand_child = child->children()[0];
 
   gfx::Transform rotation_by_z;
   rotation_by_z.RotateAboutZAxis(90.0);
 
-  root_->SetTransform(rotation_by_z);
+  scroll_->SetTransform(rotation_by_z);
   grand_child->SetPositionConstraint(fixed_to_top_left_);
 
   // Case 1: root scroll delta of 0, 0
-  root_->SetScrollDelta(gfx::Vector2d(0, 0));
+  scroll_->SetScrollDelta(gfx::Vector2d(0, 0));
   ExecuteCalculateDrawProperties(root_.get());
 
   gfx::Transform identity_matrix;
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(rotation_by_z, child->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(rotation_by_z,
                                   grand_child->draw_transform());
 
   // Case 2: root scroll delta of 10, 10
-  root_->SetScrollDelta(gfx::Vector2d(10, 20));
+  scroll_->SetScrollDelta(gfx::Vector2d(10, 20));
   ExecuteCalculateDrawProperties(root_.get());
 
   gfx::Transform expected_child_transform;
   expected_child_transform.Translate(-10.0, -20.0);
   expected_child_transform.PreconcatTransform(rotation_by_z);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(rotation_by_z,
                                   grand_child->draw_transform());
 
   // Case 3: fixed-container size delta of 20, 20
   root_->SetFixedContainerSizeDelta(gfx::Vector2d(20, 20));
   ExecuteCalculateDrawProperties(root_.get());
 
   // Top-left fixed-position layer should not be affected by container size.
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(rotation_by_z,
                                   grand_child->draw_transform());
 
   // Case 4: Bottom-right fixed-position layer.
   grand_child->SetPositionConstraint(fixed_to_bottom_right_);
   ExecuteCalculateDrawProperties(root_.get());
 
   gfx::Transform expected_grand_child_transform;
-  expected_grand_child_transform.Translate(-20.0, 20.0);
+  // TODO(wjmaclean) Not sure why this used to be (-20, 20), is this right?
+  expected_grand_child_transform.Translate(20.0, 20.0);
   expected_grand_child_transform.PreconcatTransform(rotation_by_z);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
                                   grand_child->draw_transform());
 }
 
 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.
 
-  LayerImpl* child = root_->children()[0];
+  LayerImpl* child = scroll_->children()[0];
   LayerImpl* grand_child = child->children()[0];
   LayerImpl* great_grand_child = grand_child->children()[0];
 
   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_);
@@ skipping 38 matching lines @@
                                   great_grand_child->draw_transform());
 }
 
 TEST_F(LayerPositionConstraintTest,
      ScrollCompensationForFixedWithinFixedWithInterveningContainer) {
   // 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.
 
-  LayerImpl* container1 = root_->children()[0];
+  LayerImpl* container1 = scroll_->children()[0];
   LayerImpl* fixed_to_container1 = container1->children()[0];
   LayerImpl* container2 = fixed_to_container1->children()[0];
 
   {
     // Add one more layer to the hierarchy for this test.
     scoped_ptr<LayerImpl> fixed_to_container2_ptr =
         LayerImpl::Create(host_impl_.active_tree(), 5);
     container2->AddChild(fixed_to_container2_ptr.Pass());
   }
 
@@ skipping 29 matching lines @@
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_container2_transform,
                                   container2->draw_transform());
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_fixed_to_container2_transform,
                                   fixed_to_container2->draw_transform());
 }
 
 }  // namespace
 }  // namespace cc