cc/layers/layer_position_constraint_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/layers/layer_position_constraint.h"
   6
   7 #include <vector>
   8
   9 #include "cc/layers/layer_impl.h"
  10 #include "cc/test/fake_impl_proxy.h"
  11 #include "cc/test/fake_layer_tree_host_impl.h"
  12 #include "cc/test/geometry_test_utils.h"
  13 #include "cc/trees/layer_tree_host_common.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 namespace cc {
  17 namespace {
  18
  19 void SetLayerPropertiesForTesting(LayerImpl* layer,
  20                                   const gfx::Transform& transform,
  21                                   const gfx::Transform& sublayer_transform,
  22                                   gfx::PointF anchor,
  23                                   gfx::PointF position,
  24                                   gfx::Size bounds,
  25                                   bool preserves3d) {
  26   layer->SetTransform(transform);
  27   layer->SetSublayerTransform(sublayer_transform);
  28   layer->SetAnchorPoint(anchor);
  29   layer->SetPosition(position);
  30   layer->SetBounds(bounds);
  31   layer->SetPreserves3d(preserves3d);
  32   layer->SetContentBounds(bounds);
  33 }
  34
  35 void ExecuteCalculateDrawProperties(LayerImpl* root_layer,
  36                                     float device_scale_factor,
  37                                     float page_scale_factor,
  38                                     LayerImpl* page_scale_application_layer,
  39                                     bool can_use_lcd_text) {
  40   gfx::Transform identity_matrix;
  41   std::vector<LayerImpl*> dummy_render_surface_layer_list;
  42   gfx::Size device_viewport_size =
  43       gfx::Size(root_layer->bounds().width() * device_scale_factor,
  44                 root_layer->bounds().height() * device_scale_factor);
  45
  46   // We are probably not testing what is intended if the root_layer bounds are
  47   // empty.
  48   DCHECK(!root_layer->bounds().IsEmpty());
  49   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
  50       root_layer, device_viewport_size, &dummy_render_surface_layer_list);
  51   inputs.device_scale_factor = device_scale_factor;
  52   inputs.page_scale_factor = page_scale_factor;
  53   inputs.page_scale_application_layer = page_scale_application_layer;
  54   inputs.can_use_lcd_text = can_use_lcd_text;
  55   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
  56 }
  57
  58 void ExecuteCalculateDrawProperties(LayerImpl* root_layer) {
  59   LayerImpl* page_scale_application_layer = NULL;
  60   ExecuteCalculateDrawProperties(
  61       root_layer, 1.f, 1.f, page_scale_application_layer, false);
  62 }
  63
  64 class LayerPositionConstraintTest : public testing::Test {
  65  public:
  66   LayerPositionConstraintTest()
  67       : host_impl_(&proxy_) {
  68     root_ = CreateTreeForTest();
  69     fixed_to_top_left_.set_is_fixed_position(true);
  70     fixed_to_bottom_right_.set_is_fixed_position(true);
  71     fixed_to_bottom_right_.set_is_fixed_to_right_edge(true);
  72     fixed_to_bottom_right_.set_is_fixed_to_bottom_edge(true);
  73   }
  74
  75   scoped_ptr<LayerImpl> CreateTreeForTest() {
  76     scoped_ptr<LayerImpl> root =
  77         LayerImpl::Create(host_impl_.active_tree(), 1);
  78     scoped_ptr<LayerImpl> child =
  79         LayerImpl::Create(host_impl_.active_tree(), 2);
  80     scoped_ptr<LayerImpl> grand_child =
  81         LayerImpl::Create(host_impl_.active_tree(), 3);
  82     scoped_ptr<LayerImpl> great_grand_child =
  83         LayerImpl::Create(host_impl_.active_tree(), 4);
  84
  85     gfx::Transform IdentityMatrix;
  86     gfx::PointF anchor;
  87     gfx::PointF position;
  88     gfx::Size bounds(100, 100);
  89     SetLayerPropertiesForTesting(root.get(),
  90                                  IdentityMatrix,
  91                                  IdentityMatrix,
  92                                  anchor,
  93                                  position,
  94                                  bounds,
  95                                  false);
  96     SetLayerPropertiesForTesting(child.get(),
  97                                  IdentityMatrix,
  98                                  IdentityMatrix,
  99                                  anchor,
 100                                  position,
 101                                  bounds,
 102                                  false);
 103     SetLayerPropertiesForTesting(grand_child.get(),
 104                                  IdentityMatrix,
 105                                  IdentityMatrix,
 106                                  anchor,
 107                                  position,
 108                                  bounds,
 109                                  false);
 110     SetLayerPropertiesForTesting(great_grand_child.get(),
 111                                  IdentityMatrix,
 112                                  IdentityMatrix,
 113                                  anchor,
 114                                  position,
 115                                  bounds,
 116                                  false);
 117
 118     root->SetMaxScrollOffset(gfx::Vector2d(100, 100));
 119     root->SetScrollable(true);
 120     child->SetMaxScrollOffset(gfx::Vector2d(100, 100));
 121     child->SetScrollable(true);
 122     grand_child->SetMaxScrollOffset(gfx::Vector2d(100, 100));
 123     grand_child->SetScrollable(true);
 124
 125     grand_child->AddChild(great_grand_child.Pass());
 126     child->AddChild(grand_child.Pass());
 127     root->AddChild(child.Pass());
 128
 129     return root.Pass();
 130   }
 131
 132  protected:
 133   FakeImplProxy proxy_;
 134   FakeLayerTreeHostImpl host_impl_;
 135   scoped_ptr<LayerImpl> root_;
 136
 137   LayerPositionConstraint fixed_to_top_left_;
 138   LayerPositionConstraint fixed_to_bottom_right_;
 139 };
 140
 141 TEST_F(LayerPositionConstraintTest,
 142      ScrollCompensationForFixedPositionLayerWithDirectContainer) {
 143   // This test checks for correct scroll compensation when the fixed-position
 144   // container is the direct parent of the fixed-position layer.
 145   LayerImpl* child = root_->children()[0];
 146   LayerImpl* grand_child = child->children()[0];
 147
 148   child->SetIsContainerForFixedPositionLayers(true);
 149   grand_child->SetPositionConstraint(fixed_to_top_left_);
 150
 151   // Case 1: scroll delta of 0, 0
 152   child->SetScrollDelta(gfx::Vector2d(0, 0));
 153   ExecuteCalculateDrawProperties(root_.get());
 154
 155   gfx::Transform expected_child_transform;
 156   gfx::Transform expected_grand_child_transform = expected_child_transform;
 157
 158   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 159                                   child->draw_transform());
 160   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 161                                   grand_child->draw_transform());
 162
 163   // Case 2: scroll delta of 10, 10
 164   child->SetScrollDelta(gfx::Vector2d(10, 10));
 165   ExecuteCalculateDrawProperties(root_.get());
 166
 167   // Here the child is affected by scroll delta, but the fixed position
 168   // grand_child should not be affected.
 169   expected_child_transform.MakeIdentity();
 170   expected_child_transform.Translate(-10.0, -10.0);
 171
 172   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 173                                   child->draw_transform());
 174   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 175                                   grand_child->draw_transform());
 176
 177   // Case 3: fixed-container size delta of 20, 20
 178   child->SetFixedContainerSizeDelta(gfx::Vector2d(20, 20));
 179   ExecuteCalculateDrawProperties(root_.get());
 180
 181   // Top-left fixed-position layer should not be affected by container size.
 182   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 183                                   child->draw_transform());
 184   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 185                                   grand_child->draw_transform());
 186
 187   // Case 4: Bottom-right fixed-position layer.
 188   grand_child->SetPositionConstraint(fixed_to_bottom_right_);
 189   ExecuteCalculateDrawProperties(root_.get());
 190
 191   // Bottom-right fixed-position layer moves as container resizes.
 192   expected_grand_child_transform.MakeIdentity();
 193   // Apply size delta from the child(container) layer.
 194   expected_grand_child_transform.Translate(20.0, 20.0);
 195
 196   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 197                                   child->draw_transform());
 198   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 199                                   grand_child->draw_transform());
 200 }
 201
 202 TEST_F(LayerPositionConstraintTest,
 203      ScrollCompensationForFixedPositionLayerWithTransformedDirectContainer) {
 204   // This test checks for correct scroll compensation when the fixed-position
 205   // container is the direct parent of the fixed-position layer, but that
 206   // container is transformed.  In this case, the fixed position element
 207   // inherits the container's transform, but the scroll delta that has to be
 208   // undone should not be affected by that transform.
 209   //
 210   // Transforms are in general non-commutative; using something like a
 211   // non-uniform scale helps to verify that translations and non-uniform scales
 212   // are applied in the correct order.
 213   LayerImpl* child = root_->children()[0];
 214   LayerImpl* grand_child = child->children()[0];
 215
 216   // This scale will cause child and grand_child to be effectively 200 x 800
 217   // with respect to the render target.
 218   gfx::Transform non_uniform_scale;
 219   non_uniform_scale.Scale(2.0, 8.0);
 220   child->SetTransform(non_uniform_scale);
 221
 222   child->SetIsContainerForFixedPositionLayers(true);
 223   grand_child->SetPositionConstraint(fixed_to_top_left_);
 224
 225   // Case 1: scroll delta of 0, 0
 226   child->SetScrollDelta(gfx::Vector2d(0, 0));
 227   ExecuteCalculateDrawProperties(root_.get());
 228
 229   gfx::Transform expected_child_transform;
 230   expected_child_transform.PreconcatTransform(non_uniform_scale);
 231
 232   gfx::Transform expected_grand_child_transform = expected_child_transform;
 233
 234   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 235                                   child->draw_transform());
 236   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 237                                   grand_child->draw_transform());
 238
 239   // Case 2: scroll delta of 10, 20
 240   child->SetScrollDelta(gfx::Vector2d(10, 20));
 241   ExecuteCalculateDrawProperties(root_.get());
 242
 243   // The child should be affected by scroll delta, but the fixed position
 244   // grand_child should not be affected.
 245   expected_child_transform.MakeIdentity();
 246   expected_child_transform.Translate(-10.0, -20.0);  // scroll delta
 247   expected_child_transform.PreconcatTransform(non_uniform_scale);
 248
 249   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 250                                   child->draw_transform());
 251   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 252                                   grand_child->draw_transform());
 253
 254   // Case 3: fixed-container size delta of 20, 20
 255   child->SetFixedContainerSizeDelta(gfx::Vector2d(20, 20));
 256   ExecuteCalculateDrawProperties(root_.get());
 257
 258   // Top-left fixed-position layer should not be affected by container size.
 259   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 260                                   child->draw_transform());
 261   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 262                                   grand_child->draw_transform());
 263
 264   // Case 4: Bottom-right fixed-position layer.
 265   grand_child->SetPositionConstraint(fixed_to_bottom_right_);
 266   ExecuteCalculateDrawProperties(root_.get());
 267
 268   // Bottom-right fixed-position layer moves as container resizes.
 269   expected_grand_child_transform.MakeIdentity();
 270   // Apply child layer transform.
 271   expected_grand_child_transform.PreconcatTransform(non_uniform_scale);
 272   // Apply size delta from the child(container) layer.
 273   expected_grand_child_transform.Translate(20.0, 20.0);
 274
 275   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 276                                   child->draw_transform());
 277   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 278                                   grand_child->draw_transform());
 279 }
 280
 281 TEST_F(LayerPositionConstraintTest,
 282      ScrollCompensationForFixedPositionLayerWithDistantContainer) {
 283   // This test checks for correct scroll compensation when the fixed-position
 284   // container is NOT the direct parent of the fixed-position layer.
 285   LayerImpl* child = root_->children()[0];
 286   LayerImpl* grand_child = child->children()[0];
 287   LayerImpl* great_grand_child = grand_child->children()[0];
 288
 289   child->SetIsContainerForFixedPositionLayers(true);
 290   grand_child->SetPosition(gfx::PointF(8.f, 6.f));
 291   great_grand_child->SetPositionConstraint(fixed_to_top_left_);
 292
 293   // Case 1: scroll delta of 0, 0
 294   child->SetScrollDelta(gfx::Vector2d(0, 0));
 295   ExecuteCalculateDrawProperties(root_.get());
 296
 297   gfx::Transform expected_child_transform;
 298   gfx::Transform expected_grand_child_transform;
 299   expected_grand_child_transform.Translate(8.0, 6.0);
 300
 301   gfx::Transform expected_great_grand_child_transform =
 302       expected_grand_child_transform;
 303
 304   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 305                                   child->draw_transform());
 306   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 307                                   grand_child->draw_transform());
 308   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
 309                                   great_grand_child->draw_transform());
 310
 311   // Case 2: scroll delta of 10, 10
 312   child->SetScrollDelta(gfx::Vector2d(10, 10));
 313   ExecuteCalculateDrawProperties(root_.get());
 314
 315   // Here the child and grand_child are affected by scroll delta, but the fixed
 316   // position great_grand_child should not be affected.
 317   expected_child_transform.MakeIdentity();
 318   expected_child_transform.Translate(-10.0, -10.0);
 319   expected_grand_child_transform.MakeIdentity();
 320   expected_grand_child_transform.Translate(-2.0, -4.0);
 321   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 322                                   child->draw_transform());
 323   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 324                                   grand_child->draw_transform());
 325   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
 326                                   great_grand_child->draw_transform());
 327
 328   // Case 3: fixed-container size delta of 20, 20
 329   child->SetFixedContainerSizeDelta(gfx::Vector2d(20, 20));
 330   ExecuteCalculateDrawProperties(root_.get());
 331
 332   // Top-left fixed-position layer should not be affected by container size.
 333   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 334                                   child->draw_transform());
 335   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 336                                   grand_child->draw_transform());
 337   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
 338                                   great_grand_child->draw_transform());
 339
 340   // Case 4: Bottom-right fixed-position layer.
 341   great_grand_child->SetPositionConstraint(fixed_to_bottom_right_);
 342   ExecuteCalculateDrawProperties(root_.get());
 343
 344   // Bottom-right fixed-position layer moves as container resizes.
 345   expected_great_grand_child_transform.MakeIdentity();
 346   // Apply size delta from the child(container) layer.
 347   expected_great_grand_child_transform.Translate(20.0, 20.0);
 348   // Apply layer position from the grand child layer.
 349   expected_great_grand_child_transform.Translate(8.0, 6.0);
 350
 351   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 352                                   child->draw_transform());
 353   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 354                                   grand_child->draw_transform());
 355   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
 356                                   great_grand_child->draw_transform());
 357 }
 358
 359 TEST_F(LayerPositionConstraintTest,
 360      ScrollCompensationForFixedPositionLayerWithDistantContainerAndTransforms) {
 361   // This test checks for correct scroll compensation when the fixed-position
 362   // container is NOT the direct parent of the fixed-position layer, and the
 363   // hierarchy has various transforms that have to be processed in the correct
 364   // order.
 365   LayerImpl* child = root_->children()[0];
 366   LayerImpl* grand_child = child->children()[0];
 367   LayerImpl* great_grand_child = grand_child->children()[0];
 368
 369   gfx::Transform rotation_about_z;
 370   rotation_about_z.RotateAboutZAxis(90.0);
 371
 372   child->SetIsContainerForFixedPositionLayers(true);
 373   child->SetTransform(rotation_about_z);
 374   grand_child->SetPosition(gfx::PointF(8.f, 6.f));
 375   grand_child->SetTransform(rotation_about_z);
 376   // great_grand_child is positioned upside-down with respect to the render
 377   // target.
 378   great_grand_child->SetPositionConstraint(fixed_to_top_left_);
 379
 380   // Case 1: scroll delta of 0, 0
 381   child->SetScrollDelta(gfx::Vector2d(0, 0));
 382   ExecuteCalculateDrawProperties(root_.get());
 383
 384   gfx::Transform expected_child_transform;
 385   expected_child_transform.PreconcatTransform(rotation_about_z);
 386
 387   gfx::Transform expected_grand_child_transform;
 388   expected_grand_child_transform.PreconcatTransform(
 389       rotation_about_z);  // child's local transform is inherited
 390   // translation because of position occurs before layer's local transform.
 391   expected_grand_child_transform.Translate(8.0, 6.0);
 392   expected_grand_child_transform.PreconcatTransform(
 393       rotation_about_z);  // grand_child's local transform
 394
 395   gfx::Transform expected_great_grand_child_transform =
 396       expected_grand_child_transform;
 397
 398   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 399                                   child->draw_transform());
 400   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 401                                   grand_child->draw_transform());
 402   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
 403                                   great_grand_child->draw_transform());
 404
 405   // Case 2: scroll delta of 10, 20
 406   child->SetScrollDelta(gfx::Vector2d(10, 20));
 407   ExecuteCalculateDrawProperties(root_.get());
 408
 409   // Here the child and grand_child are affected by scroll delta, but the fixed
 410   // position great_grand_child should not be affected.
 411   expected_child_transform.MakeIdentity();
 412   expected_child_transform.Translate(-10.0, -20.0);  // scroll delta
 413   expected_child_transform.PreconcatTransform(rotation_about_z);
 414
 415   expected_grand_child_transform.MakeIdentity();
 416   expected_grand_child_transform.Translate(
 417       -10.0, -20.0);      // child's scroll delta is inherited
 418   expected_grand_child_transform.PreconcatTransform(
 419       rotation_about_z);  // child's local transform is inherited
 420   // translation because of position occurs before layer's local transform.
 421   expected_grand_child_transform.Translate(8.0, 6.0);
 422   expected_grand_child_transform.PreconcatTransform(
 423       rotation_about_z);  // grand_child's local transform
 424
 425   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 426                                   child->draw_transform());
 427   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 428                                   grand_child->draw_transform());
 429   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
 430                                   great_grand_child->draw_transform());
 431
 432   // Case 3: fixed-container size delta of 20, 20
 433   child->SetFixedContainerSizeDelta(gfx::Vector2d(20, 20));
 434   ExecuteCalculateDrawProperties(root_.get());
 435
 436   // Top-left fixed-position layer should not be affected by container size.
 437   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 438                                   child->draw_transform());
 439   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 440                                   grand_child->draw_transform());
 441   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
 442                                   great_grand_child->draw_transform());
 443
 444   // Case 4: Bottom-right fixed-position layer.
 445   great_grand_child->SetPositionConstraint(fixed_to_bottom_right_);
 446   ExecuteCalculateDrawProperties(root_.get());
 447
 448   // Bottom-right fixed-position layer moves as container resizes.
 449   expected_great_grand_child_transform.MakeIdentity();
 450   // Apply child layer transform.
 451   expected_great_grand_child_transform.PreconcatTransform(rotation_about_z);
 452   // Apply size delta from the child(container) layer.
 453   expected_great_grand_child_transform.Translate(20.0, 20.0);
 454   // Apply layer position from the grand child layer.
 455   expected_great_grand_child_transform.Translate(8.0, 6.0);
 456   // Apply grand child layer transform.
 457   expected_great_grand_child_transform.PreconcatTransform(rotation_about_z);
 458
 459   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 460                                   child->draw_transform());
 461   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 462                                   grand_child->draw_transform());
 463   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
 464                                   great_grand_child->draw_transform());
 465 }
 466
 467 TEST_F(LayerPositionConstraintTest,
 468      ScrollCompensationForFixedPositionLayerWithMultipleScrollDeltas) {
 469   // This test checks for correct scroll compensation when the fixed-position
 470   // container has multiple ancestors that have nonzero scroll delta before
 471   // reaching the space where the layer is fixed.  In this test, each scroll
 472   // delta occurs in a different space because of each layer's local transform.
 473   // This test checks for correct scroll compensation when the fixed-position
 474   // container is NOT the direct parent of the fixed-position layer, and the
 475   // hierarchy has various transforms that have to be processed in the correct
 476   // order.
 477   LayerImpl* child = root_->children()[0];
 478   LayerImpl* grand_child = child->children()[0];
 479   LayerImpl* great_grand_child = grand_child->children()[0];
 480
 481   gfx::Transform rotation_about_z;
 482   rotation_about_z.RotateAboutZAxis(90.0);
 483
 484   child->SetIsContainerForFixedPositionLayers(true);
 485   child->SetTransform(rotation_about_z);
 486   grand_child->SetPosition(gfx::PointF(8.f, 6.f));
 487   grand_child->SetTransform(rotation_about_z);
 488   // great_grand_child is positioned upside-down with respect to the render
 489   // target.
 490   great_grand_child->SetPositionConstraint(fixed_to_top_left_);
 491
 492   // Case 1: scroll delta of 0, 0
 493   child->SetScrollDelta(gfx::Vector2d(0, 0));
 494   ExecuteCalculateDrawProperties(root_.get());
 495
 496   gfx::Transform expected_child_transform;
 497   expected_child_transform.PreconcatTransform(rotation_about_z);
 498
 499   gfx::Transform expected_grand_child_transform;
 500   expected_grand_child_transform.PreconcatTransform(
 501       rotation_about_z);  // child's local transform is inherited
 502   // translation because of position occurs before layer's local transform.
 503   expected_grand_child_transform.Translate(8.0, 6.0);
 504   expected_grand_child_transform.PreconcatTransform(
 505       rotation_about_z);  // grand_child's local transform
 506
 507   gfx::Transform expected_great_grand_child_transform =
 508       expected_grand_child_transform;
 509
 510   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 511                                   child->draw_transform());
 512   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 513                                   grand_child->draw_transform());
 514   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
 515                                   great_grand_child->draw_transform());
 516
 517   // Case 2: scroll delta of 10, 20
 518   child->SetScrollDelta(gfx::Vector2d(10, 0));
 519   grand_child->SetScrollDelta(gfx::Vector2d(5, 0));
 520   ExecuteCalculateDrawProperties(root_.get());
 521
 522   // Here the child and grand_child are affected by scroll delta, but the fixed
 523   // position great_grand_child should not be affected.
 524   expected_child_transform.MakeIdentity();
 525   expected_child_transform.Translate(-10.0, 0.0);  // scroll delta
 526   expected_child_transform.PreconcatTransform(rotation_about_z);
 527
 528   expected_grand_child_transform.MakeIdentity();
 529   expected_grand_child_transform.Translate(
 530       -10.0, 0.0);        // child's scroll delta is inherited
 531   expected_grand_child_transform.PreconcatTransform(
 532       rotation_about_z);  // child's local transform is inherited
 533   expected_grand_child_transform.Translate(-5.0,
 534                                            0.0);  // grand_child's scroll delta
 535   // translation because of position occurs before layer's local transform.
 536   expected_grand_child_transform.Translate(8.0, 6.0);
 537   expected_grand_child_transform.PreconcatTransform(
 538       rotation_about_z);  // grand_child's local transform
 539
 540   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 541                                   child->draw_transform());
 542   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 543                                   grand_child->draw_transform());
 544   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
 545                                   great_grand_child->draw_transform());
 546
 547   // Case 3: fixed-container size delta of 20, 20
 548   child->SetFixedContainerSizeDelta(gfx::Vector2d(20, 20));
 549   ExecuteCalculateDrawProperties(root_.get());
 550
 551   // Top-left fixed-position layer should not be affected by container size.
 552   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 553                                   child->draw_transform());
 554   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 555                                   grand_child->draw_transform());
 556   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
 557                                   great_grand_child->draw_transform());
 558
 559   // Case 4: Bottom-right fixed-position layer.
 560   great_grand_child->SetPositionConstraint(fixed_to_bottom_right_);
 561   ExecuteCalculateDrawProperties(root_.get());
 562
 563   // Bottom-right fixed-position layer moves as container resizes.
 564   expected_great_grand_child_transform.MakeIdentity();
 565   // Apply child layer transform.
 566   expected_great_grand_child_transform.PreconcatTransform(rotation_about_z);
 567   // Apply size delta from the child(container) layer.
 568   expected_great_grand_child_transform.Translate(20.0, 20.0);
 569   // Apply layer position from the grand child layer.
 570   expected_great_grand_child_transform.Translate(8.0, 6.0);
 571   // Apply grand child layer transform.
 572   expected_great_grand_child_transform.PreconcatTransform(rotation_about_z);
 573
 574   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 575                                   child->draw_transform());
 576   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 577                                   grand_child->draw_transform());
 578   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
 579                                   great_grand_child->draw_transform());
 580 }
 581
 582 TEST_F(LayerPositionConstraintTest,
 583      ScrollCompensationForFixedPositionWithIntermediateSurfaceAndTransforms) {
 584   // This test checks for correct scroll compensation when the fixed-position
 585   // container contributes to a different render surface than the fixed-position
 586   // layer. In this case, the surface draw transforms also have to be accounted
 587   // for when checking the scroll delta.
 588   LayerImpl* child = root_->children()[0];
 589   LayerImpl* grand_child = child->children()[0];
 590   LayerImpl* great_grand_child = grand_child->children()[0];
 591
 592   child->SetIsContainerForFixedPositionLayers(true);
 593   grand_child->SetPosition(gfx::PointF(8.f, 6.f));
 594   grand_child->SetForceRenderSurface(true);
 595   great_grand_child->SetPositionConstraint(fixed_to_top_left_);
 596   great_grand_child->SetDrawsContent(true);
 597
 598   gfx::Transform rotation_about_z;
 599   rotation_about_z.RotateAboutZAxis(90.0);
 600   grand_child->SetTransform(rotation_about_z);
 601
 602   // Case 1: scroll delta of 0, 0
 603   child->SetScrollDelta(gfx::Vector2d(0, 0));
 604   ExecuteCalculateDrawProperties(root_.get());
 605
 606   gfx::Transform expected_child_transform;
 607   gfx::Transform expected_surface_draw_transform;
 608   expected_surface_draw_transform.Translate(8.0, 6.0);
 609   expected_surface_draw_transform.PreconcatTransform(rotation_about_z);
 610   gfx::Transform expected_grand_child_transform;
 611   gfx::Transform expected_great_grand_child_transform;
 612   ASSERT_TRUE(grand_child->render_surface());
 613   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 614                                   child->draw_transform());
 615   EXPECT_TRANSFORMATION_MATRIX_EQ(
 616       expected_surface_draw_transform,
 617       grand_child->render_surface()->draw_transform());
 618   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 619                                   grand_child->draw_transform());
 620   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
 621                                   great_grand_child->draw_transform());
 622
 623   // Case 2: scroll delta of 10, 30
 624   child->SetScrollDelta(gfx::Vector2d(10, 30));
 625   ExecuteCalculateDrawProperties(root_.get());
 626
 627   // Here the grand_child remains unchanged, because it scrolls along with the
 628   // render surface, and the translation is actually in the render surface. But,
 629   // the fixed position great_grand_child is more awkward: its actually being
 630   // drawn with respect to the render surface, but it needs to remain fixed with
 631   // resepct to a container beyond that surface. So, the net result is that,
 632   // unlike previous tests where the fixed position layer's transform remains
 633   // unchanged, here the fixed position layer's transform explicitly contains
 634   // the translation that cancels out the scroll.
 635   expected_child_transform.MakeIdentity();
 636   expected_child_transform.Translate(-10.0, -30.0);  // scroll delta
 637
 638   expected_surface_draw_transform.MakeIdentity();
 639   expected_surface_draw_transform.Translate(-10.0, -30.0);  // scroll delta
 640   expected_surface_draw_transform.Translate(8.0, 6.0);
 641   expected_surface_draw_transform.PreconcatTransform(rotation_about_z);
 642
 643   // The rotation and its inverse are needed to place the scroll delta
 644   // compensation in the correct space. This test will fail if the
 645   // rotation/inverse are backwards, too, so it requires perfect order of
 646   // operations.
 647   expected_great_grand_child_transform.MakeIdentity();
 648   expected_great_grand_child_transform.PreconcatTransform(
 649       Inverse(rotation_about_z));
 650   // explicit canceling out the scroll delta that gets embedded in the fixed
 651   // position layer's surface.
 652   expected_great_grand_child_transform.Translate(10.0, 30.0);
 653   expected_great_grand_child_transform.PreconcatTransform(rotation_about_z);
 654
 655   ASSERT_TRUE(grand_child->render_surface());
 656   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 657                                   child->draw_transform());
 658   EXPECT_TRANSFORMATION_MATRIX_EQ(
 659       expected_surface_draw_transform,
 660       grand_child->render_surface()->draw_transform());
 661   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 662                                   grand_child->draw_transform());
 663   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
 664                                   great_grand_child->draw_transform());
 665
 666   // Case 3: fixed-container size delta of 20, 20
 667   child->SetFixedContainerSizeDelta(gfx::Vector2d(20, 20));
 668   ExecuteCalculateDrawProperties(root_.get());
 669
 670   // Top-left fixed-position layer should not be affected by container size.
 671   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 672                                   child->draw_transform());
 673   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 674                                   grand_child->draw_transform());
 675   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
 676                                   great_grand_child->draw_transform());
 677
 678   // Case 4: Bottom-right fixed-position layer.
 679   great_grand_child->SetPositionConstraint(fixed_to_bottom_right_);
 680   ExecuteCalculateDrawProperties(root_.get());
 681
 682   // Bottom-right fixed-position layer moves as container resizes.
 683   expected_great_grand_child_transform.MakeIdentity();
 684   // The rotation and its inverse are needed to place the scroll delta
 685   // compensation in the correct space. This test will fail if the
 686   // rotation/inverse are backwards, too, so it requires perfect order of
 687   // operations.
 688   expected_great_grand_child_transform.PreconcatTransform(
 689       Inverse(rotation_about_z));
 690   // explicit canceling out the scroll delta that gets embedded in the fixed
 691   // position layer's surface.
 692   expected_great_grand_child_transform.Translate(10.0, 30.0);
 693   // Also apply size delta in the child(container) layer space.
 694   expected_great_grand_child_transform.Translate(20.0, 20.0);
 695   expected_great_grand_child_transform.PreconcatTransform(rotation_about_z);
 696
 697   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 698                                   child->draw_transform());
 699   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 700                                   grand_child->draw_transform());
 701   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
 702                                   great_grand_child->draw_transform());
 703 }
 704
 705 TEST_F(LayerPositionConstraintTest,
 706      ScrollCompensationForFixedPositionLayerWithMultipleIntermediateSurfaces) {
 707   // This test checks for correct scroll compensation when the fixed-position
 708   // container contributes to a different render surface than the fixed-position
 709   // layer, with additional render surfaces in-between. This checks that the
 710   // conversion to ancestor surfaces is accumulated properly in the final matrix
 711   // transform.
 712   LayerImpl* child = root_->children()[0];
 713   LayerImpl* grand_child = child->children()[0];
 714   LayerImpl* great_grand_child = grand_child->children()[0];
 715
 716   // Add one more layer to the test tree for this scenario.
 717   {
 718     gfx::Transform identity;
 719     scoped_ptr<LayerImpl> fixed_position_child =
 720         LayerImpl::Create(host_impl_.active_tree(), 5);
 721     SetLayerPropertiesForTesting(fixed_position_child.get(),
 722                                  identity,
 723                                  identity,
 724                                  gfx::PointF(),
 725                                  gfx::PointF(),
 726                                  gfx::Size(100, 100),
 727                                  false);
 728     great_grand_child->AddChild(fixed_position_child.Pass());
 729   }
 730   LayerImpl* fixed_position_child = great_grand_child->children()[0];
 731
 732   // Actually set up the scenario here.
 733   child->SetIsContainerForFixedPositionLayers(true);
 734   grand_child->SetPosition(gfx::PointF(8.f, 6.f));
 735   grand_child->SetForceRenderSurface(true);
 736   great_grand_child->SetPosition(gfx::PointF(40.f, 60.f));
 737   great_grand_child->SetForceRenderSurface(true);
 738   fixed_position_child->SetPositionConstraint(fixed_to_top_left_);
 739   fixed_position_child->SetDrawsContent(true);
 740
 741   // The additional rotations, which are non-commutative with translations, help
 742   // to verify that we have correct order-of-operations in the final scroll
 743   // compensation.  Note that rotating about the center of the layer ensures we
 744   // do not accidentally clip away layers that we want to test.
 745   gfx::Transform rotation_about_z;
 746   rotation_about_z.Translate(50.0, 50.0);
 747   rotation_about_z.RotateAboutZAxis(90.0);
 748   rotation_about_z.Translate(-50.0, -50.0);
 749   grand_child->SetTransform(rotation_about_z);
 750   great_grand_child->SetTransform(rotation_about_z);
 751
 752   // Case 1: scroll delta of 0, 0
 753   child->SetScrollDelta(gfx::Vector2d(0, 0));
 754   ExecuteCalculateDrawProperties(root_.get());
 755
 756   gfx::Transform expected_child_transform;
 757
 758   gfx::Transform expected_grand_child_surface_draw_transform;
 759   expected_grand_child_surface_draw_transform.Translate(8.0, 6.0);
 760   expected_grand_child_surface_draw_transform.PreconcatTransform(
 761       rotation_about_z);
 762
 763   gfx::Transform expected_grand_child_transform;
 764
 765   gfx::Transform expected_great_grand_child_surface_draw_transform;
 766   expected_great_grand_child_surface_draw_transform.Translate(40.0, 60.0);
 767   expected_great_grand_child_surface_draw_transform.PreconcatTransform(
 768       rotation_about_z);
 769
 770   gfx::Transform expected_great_grand_child_transform;
 771
 772   gfx::Transform expected_fixed_position_child_transform;
 773
 774   ASSERT_TRUE(grand_child->render_surface());
 775   ASSERT_TRUE(great_grand_child->render_surface());
 776   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 777                                   child->draw_transform());
 778   EXPECT_TRANSFORMATION_MATRIX_EQ(
 779       expected_grand_child_surface_draw_transform,
 780       grand_child->render_surface()->draw_transform());
 781   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 782                                   grand_child->draw_transform());
 783   EXPECT_TRANSFORMATION_MATRIX_EQ(
 784       expected_great_grand_child_surface_draw_transform,
 785       great_grand_child->render_surface()->draw_transform());
 786   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
 787                                   great_grand_child->draw_transform());
 788   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_fixed_position_child_transform,
 789                                   fixed_position_child->draw_transform());
 790
 791   // Case 2: scroll delta of 10, 30
 792   child->SetScrollDelta(gfx::Vector2d(10, 30));
 793   ExecuteCalculateDrawProperties(root_.get());
 794
 795   expected_child_transform.MakeIdentity();
 796   expected_child_transform.Translate(-10.0, -30.0);  // scroll delta
 797
 798   expected_grand_child_surface_draw_transform.MakeIdentity();
 799   expected_grand_child_surface_draw_transform.Translate(-10.0,
 800                                                         -30.0);  // scroll delta
 801   expected_grand_child_surface_draw_transform.Translate(8.0, 6.0);
 802   expected_grand_child_surface_draw_transform.PreconcatTransform(
 803       rotation_about_z);
 804
 805   // grand_child, great_grand_child, and great_grand_child's surface are not
 806   // expected to change, since they are all not fixed, and they are all drawn
 807   // with respect to grand_child's surface that already has the scroll delta
 808   // accounted for.
 809
 810   // But the great-great grandchild, "fixed_position_child", should have a
 811   // transform that explicitly cancels out the scroll delta.  The expected
 812   // transform is: compound_draw_transform.Inverse() * translate(positive scroll
 813   // delta) * compound_origin_transform from great_grand_childSurface's origin
 814   // to the root surface.
 815   gfx::Transform compound_draw_transform;
 816   compound_draw_transform.Translate(8.0,
 817                                     6.0);  // origin translation of grand_child
 818   compound_draw_transform.PreconcatTransform(
 819       rotation_about_z);                   // rotation of grand_child
 820   compound_draw_transform.Translate(
 821       40.0, 60.0);        // origin translation of great_grand_child
 822   compound_draw_transform.PreconcatTransform(
 823       rotation_about_z);  // rotation of great_grand_child
 824
 825   expected_fixed_position_child_transform.MakeIdentity();
 826   expected_fixed_position_child_transform.PreconcatTransform(
 827       Inverse(compound_draw_transform));
 828   // explicit canceling out the scroll delta that gets embedded in the fixed
 829   // position layer's surface.
 830   expected_fixed_position_child_transform.Translate(10.0, 30.0);
 831   expected_fixed_position_child_transform.PreconcatTransform(
 832       compound_draw_transform);
 833
 834   ASSERT_TRUE(grand_child->render_surface());
 835   ASSERT_TRUE(great_grand_child->render_surface());
 836   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 837                                   child->draw_transform());
 838   EXPECT_TRANSFORMATION_MATRIX_EQ(
 839       expected_grand_child_surface_draw_transform,
 840       grand_child->render_surface()->draw_transform());
 841   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 842                                   grand_child->draw_transform());
 843   EXPECT_TRANSFORMATION_MATRIX_EQ(
 844       expected_great_grand_child_surface_draw_transform,
 845       great_grand_child->render_surface()->draw_transform());
 846   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
 847                                   great_grand_child->draw_transform());
 848   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_fixed_position_child_transform,
 849                                   fixed_position_child->draw_transform());
 850
 851
 852   // Case 3: fixed-container size delta of 20, 20
 853   child->SetFixedContainerSizeDelta(gfx::Vector2d(20, 20));
 854   ExecuteCalculateDrawProperties(root_.get());
 855
 856   // Top-left fixed-position layer should not be affected by container size.
 857   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 858                                   child->draw_transform());
 859   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 860                                   grand_child->draw_transform());
 861   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
 862                                   great_grand_child->draw_transform());
 863   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_fixed_position_child_transform,
 864                                   fixed_position_child->draw_transform());
 865
 866   // Case 4: Bottom-right fixed-position layer.
 867   fixed_position_child->SetPositionConstraint(fixed_to_bottom_right_);
 868   ExecuteCalculateDrawProperties(root_.get());
 869
 870   // Bottom-right fixed-position layer moves as container resizes.
 871   expected_fixed_position_child_transform.MakeIdentity();
 872   expected_fixed_position_child_transform.PreconcatTransform(
 873       Inverse(compound_draw_transform));
 874   // explicit canceling out the scroll delta that gets embedded in the fixed
 875   // position layer's surface.
 876   expected_fixed_position_child_transform.Translate(10.0, 30.0);
 877   // Also apply size delta in the child(container) layer space.
 878   expected_fixed_position_child_transform.Translate(20.0, 20.0);
 879   expected_fixed_position_child_transform.PreconcatTransform(
 880       compound_draw_transform);
 881
 882   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 883                                   child->draw_transform());
 884   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 885                                   grand_child->draw_transform());
 886   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
 887                                   great_grand_child->draw_transform());
 888   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_fixed_position_child_transform,
 889                                   fixed_position_child->draw_transform());
 890 }
 891
 892 TEST_F(LayerPositionConstraintTest,
 893      ScrollCompensationForFixedPositionLayerWithContainerLayerThatHasSurface) {
 894   // This test checks for correct scroll compensation when the fixed-position
 895   // container itself has a render surface. In this case, the container layer
 896   // should be treated like a layer that contributes to a render target, and
 897   // that render target is completely irrelevant; it should not affect the
 898   // scroll compensation.
 899   LayerImpl* child = root_->children()[0];
 900   LayerImpl* grand_child = child->children()[0];
 901
 902   child->SetIsContainerForFixedPositionLayers(true);
 903   child->SetForceRenderSurface(true);
 904   grand_child->SetPositionConstraint(fixed_to_top_left_);
 905   grand_child->SetDrawsContent(true);
 906
 907   // Case 1: scroll delta of 0, 0
 908   child->SetScrollDelta(gfx::Vector2d(0, 0));
 909   ExecuteCalculateDrawProperties(root_.get());
 910
 911   gfx::Transform expected_surface_draw_transform;
 912   expected_surface_draw_transform.Translate(0.0, 0.0);
 913   gfx::Transform expected_child_transform;
 914   gfx::Transform expected_grand_child_transform;
 915   ASSERT_TRUE(child->render_surface());
 916   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_surface_draw_transform,
 917                                   child->render_surface()->draw_transform());
 918   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 919                                   child->draw_transform());
 920   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 921                                   grand_child->draw_transform());
 922
 923   // Case 2: scroll delta of 10, 10
 924   child->SetScrollDelta(gfx::Vector2d(10, 10));
 925   ExecuteCalculateDrawProperties(root_.get());
 926
 927   // The surface is translated by scroll delta, the child transform doesn't
 928   // change because it scrolls along with the surface, but the fixed position
 929   // grand_child needs to compensate for the scroll translation.
 930   expected_surface_draw_transform.MakeIdentity();
 931   expected_surface_draw_transform.Translate(-10.0, -10.0);
 932   expected_grand_child_transform.MakeIdentity();
 933   expected_grand_child_transform.Translate(10.0, 10.0);
 934
 935   ASSERT_TRUE(child->render_surface());
 936   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_surface_draw_transform,
 937                                   child->render_surface()->draw_transform());
 938   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 939                                   child->draw_transform());
 940   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 941                                   grand_child->draw_transform());
 942
 943   // Case 3: fixed-container size delta of 20, 20
 944   child->SetFixedContainerSizeDelta(gfx::Vector2d(20, 20));
 945   ExecuteCalculateDrawProperties(root_.get());
 946
 947   // Top-left fixed-position layer should not be affected by container size.
 948   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 949                                   child->draw_transform());
 950   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 951                                   grand_child->draw_transform());
 952
 953   // Case 4: Bottom-right fixed-position layer.
 954   grand_child->SetPositionConstraint(fixed_to_bottom_right_);
 955   ExecuteCalculateDrawProperties(root_.get());
 956
 957   // Bottom-right fixed-position layer moves as container resizes.
 958   expected_grand_child_transform.MakeIdentity();
 959   // The surface is translated by scroll delta, the child transform doesn't
 960   // change because it scrolls along with the surface, but the fixed position
 961   // grand_child needs to compensate for the scroll translation.
 962   expected_grand_child_transform.Translate(10.0, 10.0);
 963   // Apply size delta from the child(container) layer.
 964   expected_grand_child_transform.Translate(20.0, 20.0);
 965
 966   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 967                                   child->draw_transform());
 968   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 969                                   grand_child->draw_transform());
 970 }
 971
 972 TEST_F(LayerPositionConstraintTest,
 973      ScrollCompensationForFixedPositionLayerThatIsAlsoFixedPositionContainer) {
 974   // This test checks the scenario where a fixed-position layer also happens to
 975   // be a container itself for a descendant fixed position layer. In particular,
 976   // the layer should not accidentally be fixed to itself.
 977   LayerImpl* child = root_->children()[0];
 978   LayerImpl* grand_child = child->children()[0];
 979
 980   child->SetIsContainerForFixedPositionLayers(true);
 981   grand_child->SetPositionConstraint(fixed_to_top_left_);
 982
 983   // This should not confuse the grand_child. If correct, the grand_child would
 984   // still be considered fixed to its container (i.e. "child").
 985   grand_child->SetIsContainerForFixedPositionLayers(true);
 986
 987   // Case 1: scroll delta of 0, 0
 988   child->SetScrollDelta(gfx::Vector2d(0, 0));
 989   ExecuteCalculateDrawProperties(root_.get());
 990
 991   gfx::Transform expected_child_transform;
 992   gfx::Transform expected_grand_child_transform;
 993   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
 994                                   child->draw_transform());
 995   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
 996                                   grand_child->draw_transform());
 997
 998   // Case 2: scroll delta of 10, 10
 999   child->SetScrollDelta(gfx::Vector2d(10, 10));
1000   ExecuteCalculateDrawProperties(root_.get());
1001
1002   // Here the child is affected by scroll delta, but the fixed position
1003   // grand_child should not be affected.
1004   expected_child_transform.MakeIdentity();
1005   expected_child_transform.Translate(-10.0, -10.0);
1006   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
1007                                   child->draw_transform());
1008   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
1009                                   grand_child->draw_transform());
1010
1011   // Case 3: fixed-container size delta of 20, 20
1012   child->SetFixedContainerSizeDelta(gfx::Vector2d(20, 20));
1013   ExecuteCalculateDrawProperties(root_.get());
1014
1015   // Top-left fixed-position layer should not be affected by container size.
1016   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
1017                                   child->draw_transform());
1018   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
1019                                   grand_child->draw_transform());
1020
1021   // Case 4: Bottom-right fixed-position layer.
1022   grand_child->SetPositionConstraint(fixed_to_bottom_right_);
1023   ExecuteCalculateDrawProperties(root_.get());
1024
1025   // Bottom-right fixed-position layer moves as container resizes.
1026   expected_grand_child_transform.MakeIdentity();
1027   // Apply size delta from the child(container) layer.
1028   expected_grand_child_transform.Translate(20.0, 20.0);
1029
1030   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
1031                                   child->draw_transform());
1032   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
1033                                   grand_child->draw_transform());
1034 }
1035
1036 TEST_F(LayerPositionConstraintTest,
1037      ScrollCompensationForFixedPositionLayerThatHasNoContainer) {
1038   // This test checks scroll compensation when a fixed-position layer does not
1039   // find any ancestor that is a "containerForFixedPositionLayers". In this
1040   // situation, the layer should be fixed to the root layer.
1041   LayerImpl* child = root_->children()[0];
1042   LayerImpl* grand_child = child->children()[0];
1043
1044   gfx::Transform rotation_by_z;
1045   rotation_by_z.RotateAboutZAxis(90.0);
1046
1047   root_->SetTransform(rotation_by_z);
1048   grand_child->SetPositionConstraint(fixed_to_top_left_);
1049
1050   // Case 1: root scroll delta of 0, 0
1051   root_->SetScrollDelta(gfx::Vector2d(0, 0));
1052   ExecuteCalculateDrawProperties(root_.get());
1053
1054   gfx::Transform identity_matrix;
1055
1056   EXPECT_TRANSFORMATION_MATRIX_EQ(rotation_by_z, child->draw_transform());
1057   EXPECT_TRANSFORMATION_MATRIX_EQ(rotation_by_z,
1058                                   grand_child->draw_transform());
1059
1060   // Case 2: root scroll delta of 10, 10
1061   root_->SetScrollDelta(gfx::Vector2d(10, 20));
1062   ExecuteCalculateDrawProperties(root_.get());
1063
1064   gfx::Transform expected_child_transform;
1065   expected_child_transform.Translate(-10.0, -20.0);
1066   expected_child_transform.PreconcatTransform(rotation_by_z);
1067
1068   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
1069                                   child->draw_transform());
1070   EXPECT_TRANSFORMATION_MATRIX_EQ(rotation_by_z,
1071                                   grand_child->draw_transform());
1072
1073   // Case 3: fixed-container size delta of 20, 20
1074   root_->SetFixedContainerSizeDelta(gfx::Vector2d(20, 20));
1075   ExecuteCalculateDrawProperties(root_.get());
1076
1077   // Top-left fixed-position layer should not be affected by container size.
1078   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
1079                                   child->draw_transform());
1080   EXPECT_TRANSFORMATION_MATRIX_EQ(rotation_by_z,
1081                                   grand_child->draw_transform());
1082
1083   // Case 4: Bottom-right fixed-position layer.
1084   grand_child->SetPositionConstraint(fixed_to_bottom_right_);
1085   ExecuteCalculateDrawProperties(root_.get());
1086
1087   gfx::Transform expected_grand_child_transform;
1088   expected_grand_child_transform.Translate(-20.0, 20.0);
1089   expected_grand_child_transform.PreconcatTransform(rotation_by_z);
1090
1091   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
1092                                   child->draw_transform());
1093   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
1094                                   grand_child->draw_transform());
1095 }
1096
1097 TEST_F(LayerPositionConstraintTest,
1098      ScrollCompensationForFixedWithinFixedWithSameContainer) {
1099   // This test checks scroll compensation for a fixed-position layer that is
1100   // inside of another fixed-position layer and both share the same container.
1101   // In this situation, the parent fixed-position layer will receive
1102   // the scroll compensation, and the child fixed-position layer does not
1103   // need to compensate further.
1104
1105   LayerImpl* child = root_->children()[0];
1106   LayerImpl* grand_child = child->children()[0];
1107   LayerImpl* great_grand_child = grand_child->children()[0];
1108
1109   child->SetIsContainerForFixedPositionLayers(true);
1110   grand_child->SetPositionConstraint(fixed_to_top_left_);
1111
1112   // Note carefully - great_grand_child is fixed to bottom right, to test
1113   // sizeDelta being applied correctly; the compensation skips the grand_child
1114   // because it is fixed to top left.
1115   great_grand_child->SetPositionConstraint(fixed_to_bottom_right_);
1116
1117   // Case 1: scrollDelta
1118   child->SetScrollDelta(gfx::Vector2d(10, 10));
1119   ExecuteCalculateDrawProperties(root_.get());
1120
1121   // Here the child is affected by scroll delta, but the fixed position
1122   // grand_child should not be affected.
1123   gfx::Transform expected_child_transform;
1124   expected_child_transform.Translate(-10.0, -10.0);
1125
1126   gfx::Transform expected_grand_child_transform;
1127   gfx::Transform expected_great_grand_child_transform;
1128
1129   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
1130                                   child->draw_transform());
1131   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
1132                                   grand_child->draw_transform());
1133   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
1134                                   great_grand_child->draw_transform());
1135
1136   // Case 2: sizeDelta
1137   child->SetScrollDelta(gfx::Vector2d(0, 0));
1138   child->SetFixedContainerSizeDelta(gfx::Vector2d(20, 20));
1139   ExecuteCalculateDrawProperties(root_.get());
1140
1141   expected_child_transform.MakeIdentity();
1142
1143   expected_grand_child_transform.MakeIdentity();
1144
1145   // Fixed to bottom-right, size-delta compensation is applied.
1146   expected_great_grand_child_transform.MakeIdentity();
1147   expected_great_grand_child_transform.Translate(20.0, 20.0);
1148
1149   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
1150                                   child->draw_transform());
1151   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
1152                                   grand_child->draw_transform());
1153   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
1154                                   great_grand_child->draw_transform());
1155 }
1156
1157 TEST_F(LayerPositionConstraintTest,
1158      ScrollCompensationForFixedWithinFixedWithInterveningContainer) {
1159   // This test checks scroll compensation for a fixed-position layer that is
1160   // inside of another fixed-position layer, but they have different fixed
1161   // position containers. In this situation, the child fixed-position element
1162   // would still have to compensate with respect to its container.
1163
1164   LayerImpl* container1 = root_->children()[0];
1165   LayerImpl* fixed_to_container1 = container1->children()[0];
1166   LayerImpl* container2 = fixed_to_container1->children()[0];
1167
1168   {
1169     // Add one more layer to the hierarchy for this test.
1170     scoped_ptr<LayerImpl> fixed_to_container2_ptr =
1171         LayerImpl::Create(host_impl_.active_tree(), 5);
1172     container2->AddChild(fixed_to_container2_ptr.Pass());
1173   }
1174
1175   LayerImpl* fixed_to_container2 = container2->children()[0];
1176
1177   container1->SetIsContainerForFixedPositionLayers(true);
1178   fixed_to_container1->SetPositionConstraint(fixed_to_top_left_);
1179   container2->SetIsContainerForFixedPositionLayers(true);
1180   fixed_to_container2->SetPositionConstraint(fixed_to_top_left_);
1181
1182   container1->SetScrollDelta(gfx::Vector2d(0, 15));
1183   container2->SetScrollDelta(gfx::Vector2d(30, 0));
1184   ExecuteCalculateDrawProperties(root_.get());
1185
1186   gfx::Transform expected_container1_transform;
1187   expected_container1_transform.Translate(0.0, -15.0);
1188
1189   gfx::Transform expected_fixed_to_container1_transform;
1190
1191   // Since the container is a descendant of the fixed layer above,
1192   // the expected draw transform for container2 would not
1193   // include the scrollDelta that was applied to container1.
1194   gfx::Transform expected_container2_transform;
1195   expected_container2_transform.Translate(-30.0, 0.0);
1196
1197   gfx::Transform expected_fixed_to_container2_transform;
1198
1199   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_container1_transform,
1200                                   container1->draw_transform());
1201
1202   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_fixed_to_container1_transform,
1203                                   fixed_to_container1->draw_transform());
1204
1205   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_container2_transform,
1206                                   container2->draw_transform());
1207
1208   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_fixed_to_container2_transform,
1209                                   fixed_to_container2->draw_transform());
1210 }
1211
1212 }  // namespace
1213 }  // namespace cc