cc/trees/layer_tree_host_common_unittest.cc

   1 // Copyright 2011 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/trees/layer_tree_host_common.h"
   6
   7 #include <algorithm>
   8 #include <set>
   9
  10 #include "cc/animation/layer_animation_controller.h"
  11 #include "cc/animation/transform_operations.h"
  12 #include "cc/base/math_util.h"
  13 #include "cc/layers/content_layer.h"
  14 #include "cc/layers/content_layer_client.h"
  15 #include "cc/layers/layer.h"
  16 #include "cc/layers/layer_client.h"
  17 #include "cc/layers/layer_impl.h"
  18 #include "cc/layers/layer_iterator.h"
  19 #include "cc/layers/render_surface.h"
  20 #include "cc/layers/render_surface_impl.h"
  21 #include "cc/output/copy_output_request.h"
  22 #include "cc/output/copy_output_result.h"
  23 #include "cc/test/animation_test_common.h"
  24 #include "cc/test/fake_impl_proxy.h"
  25 #include "cc/test/fake_layer_tree_host.h"
  26 #include "cc/test/fake_layer_tree_host_impl.h"
  27 #include "cc/test/fake_picture_layer.h"
  28 #include "cc/test/fake_picture_layer_impl.h"
  29 #include "cc/test/geometry_test_utils.h"
  30 #include "cc/test/layer_tree_host_common_test.h"
  31 #include "cc/test/test_task_graph_runner.h"
  32 #include "cc/trees/layer_tree_impl.h"
  33 #include "cc/trees/proxy.h"
  34 #include "cc/trees/single_thread_proxy.h"
  35 #include "testing/gmock/include/gmock/gmock.h"
  36 #include "testing/gtest/include/gtest/gtest.h"
  37 #include "ui/gfx/geometry/quad_f.h"
  38 #include "ui/gfx/geometry/vector2d_conversions.h"
  39 #include "ui/gfx/transform.h"
  40
  41 namespace cc {
  42 namespace {
  43
  44 class LayerWithForcedDrawsContent : public Layer {
  45  public:
  46   LayerWithForcedDrawsContent() {}
  47
  48   bool DrawsContent() const override;
  49
  50  private:
  51   ~LayerWithForcedDrawsContent() override {}
  52 };
  53
  54 bool LayerWithForcedDrawsContent::DrawsContent() const { return true; }
  55
  56 class MockContentLayerClient : public ContentLayerClient {
  57  public:
  58   MockContentLayerClient() {}
  59   ~MockContentLayerClient() override {}
  60   void PaintContents(SkCanvas* canvas,
  61                      const gfx::Rect& clip,
  62                      PaintingControlSetting picture_control) override {}
  63   scoped_refptr<DisplayItemList> PaintContentsToDisplayList(
  64       const gfx::Rect& clip,
  65       PaintingControlSetting picture_control) override {
  66     NOTIMPLEMENTED();
  67     return DisplayItemList::Create();
  68   }
  69   bool FillsBoundsCompletely() const override { return false; }
  70 };
  71
  72 scoped_refptr<FakePictureLayer> CreateDrawablePictureLayer(
  73     ContentLayerClient* delegate) {
  74   scoped_refptr<FakePictureLayer> to_return =
  75       FakePictureLayer::Create(delegate);
  76   to_return->SetIsDrawable(true);
  77   return to_return;
  78 }
  79
  80 scoped_refptr<ContentLayer> CreateDrawableContentLayer(
  81     ContentLayerClient* delegate) {
  82   scoped_refptr<ContentLayer> to_return = ContentLayer::Create(delegate);
  83   to_return->SetIsDrawable(true);
  84   return to_return;
  85 }
  86
  87 #define EXPECT_CONTENTS_SCALE_EQ(expected, layer)         \
  88   do {                                                    \
  89     EXPECT_FLOAT_EQ(expected, layer->contents_scale_x()); \
  90     EXPECT_FLOAT_EQ(expected, layer->contents_scale_y()); \
  91   } while (false)
  92
  93 #define EXPECT_IDEAL_SCALE_EQ(expected, layer)                                \
  94   do {                                                                        \
  95     EXPECT_FLOAT_EQ(expected, layer->draw_properties().ideal_contents_scale); \
  96   } while (false)
  97
  98 TEST_F(LayerTreeHostCommonTest, TransformsForNoOpLayer) {
  99   // Sanity check: For layers positioned at zero, with zero size,
 100   // and with identity transforms, then the draw transform,
 101   // screen space transform, and the hierarchy passed on to children
 102   // layers should also be identity transforms.
 103
 104   scoped_refptr<Layer> parent = Layer::Create();
 105   scoped_refptr<Layer> child = Layer::Create();
 106   scoped_refptr<Layer> grand_child = Layer::Create();
 107   parent->AddChild(child);
 108   child->AddChild(grand_child);
 109
 110   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
 111   host->SetRootLayer(parent);
 112
 113   gfx::Transform identity_matrix;
 114   SetLayerPropertiesForTesting(parent.get(),
 115                                identity_matrix,
 116                                gfx::Point3F(),
 117                                gfx::PointF(),
 118                                gfx::Size(100, 100),
 119                                true,
 120                                false);
 121   SetLayerPropertiesForTesting(child.get(),
 122                                identity_matrix,
 123                                gfx::Point3F(),
 124                                gfx::PointF(),
 125                                gfx::Size(),
 126                                true,
 127                                false);
 128   SetLayerPropertiesForTesting(grand_child.get(),
 129                                identity_matrix,
 130                                gfx::Point3F(),
 131                                gfx::PointF(),
 132                                gfx::Size(),
 133                                true,
 134                                false);
 135
 136   ExecuteCalculateDrawProperties(parent.get());
 137
 138   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->draw_transform());
 139   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
 140                                   child->screen_space_transform());
 141   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
 142                                   grand_child->draw_transform());
 143   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
 144                                   grand_child->screen_space_transform());
 145 }
 146
 147 TEST_F(LayerTreeHostCommonTest, DoNotSkipLayersWithHandlers) {
 148   scoped_refptr<Layer> parent = Layer::Create();
 149   scoped_refptr<Layer> child = Layer::Create();
 150   scoped_refptr<Layer> grand_child = Layer::Create();
 151   parent->AddChild(child);
 152   child->AddChild(grand_child);
 153
 154   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
 155   host->SetRootLayer(parent);
 156
 157   gfx::Transform identity_matrix;
 158   SetLayerPropertiesForTesting(parent.get(),
 159                                identity_matrix,
 160                                gfx::Point3F(),
 161                                gfx::PointF(),
 162                                gfx::Size(100, 100),
 163                                true,
 164                                false);
 165   SetLayerPropertiesForTesting(child.get(),
 166                                identity_matrix,
 167                                gfx::Point3F(),
 168                                gfx::PointF(10, 10),
 169                                gfx::Size(100, 100),
 170                                true,
 171                                false);
 172   // This would have previously caused us to skip our subtree, but this would be
 173   // wrong; we need up-to-date draw properties to do hit testing on the layers
 174   // with handlers.
 175   child->SetOpacity(0.f);
 176   SetLayerPropertiesForTesting(grand_child.get(),
 177                                identity_matrix,
 178                                gfx::Point3F(),
 179                                gfx::PointF(10, 10),
 180                                gfx::Size(100, 100),
 181                                true,
 182                                false);
 183   grand_child->SetTouchEventHandlerRegion(gfx::Rect(0, 0, 100, 100));
 184
 185   ExecuteCalculateDrawProperties(parent.get());
 186
 187   // Check that we've computed draw properties for the subtree rooted at
 188   // |child|.
 189   EXPECT_FALSE(child->draw_transform().IsIdentity());
 190   EXPECT_FALSE(grand_child->draw_transform().IsIdentity());
 191 }
 192
 193 TEST_F(LayerTreeHostCommonTest, TransformsForSingleLayer) {
 194   gfx::Transform identity_matrix;
 195   scoped_refptr<Layer> layer = Layer::Create();
 196
 197   scoped_refptr<Layer> root = Layer::Create();
 198   SetLayerPropertiesForTesting(root.get(),
 199                                identity_matrix,
 200                                gfx::Point3F(),
 201                                gfx::PointF(),
 202                                gfx::Size(1, 2),
 203                                true,
 204                                false);
 205   root->AddChild(layer);
 206
 207   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
 208   host->SetRootLayer(root);
 209
 210   // Case 2: Setting the bounds of the layer should not affect either the draw
 211   // transform or the screenspace transform.
 212   gfx::Transform translation_to_center;
 213   translation_to_center.Translate(5.0, 6.0);
 214   SetLayerPropertiesForTesting(layer.get(),
 215                                identity_matrix,
 216                                gfx::Point3F(),
 217                                gfx::PointF(),
 218                                gfx::Size(10, 12),
 219                                true,
 220                                false);
 221   ExecuteCalculateDrawProperties(root.get());
 222   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, layer->draw_transform());
 223   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
 224                                   layer->screen_space_transform());
 225
 226   // Case 3: The anchor point by itself (without a layer transform) should have
 227   // no effect on the transforms.
 228   SetLayerPropertiesForTesting(layer.get(),
 229                                identity_matrix,
 230                                gfx::Point3F(2.5f, 3.0f, 0.f),
 231                                gfx::PointF(),
 232                                gfx::Size(10, 12),
 233                                true,
 234                                false);
 235   ExecuteCalculateDrawProperties(root.get());
 236   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, layer->draw_transform());
 237   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
 238                                   layer->screen_space_transform());
 239
 240   // Case 4: A change in actual position affects both the draw transform and
 241   // screen space transform.
 242   gfx::Transform position_transform;
 243   position_transform.Translate(0.f, 1.2f);
 244   SetLayerPropertiesForTesting(layer.get(),
 245                                identity_matrix,
 246                                gfx::Point3F(2.5f, 3.0f, 0.f),
 247                                gfx::PointF(0.f, 1.2f),
 248                                gfx::Size(10, 12),
 249                                true,
 250                                false);
 251   ExecuteCalculateDrawProperties(root.get());
 252   EXPECT_TRANSFORMATION_MATRIX_EQ(position_transform, layer->draw_transform());
 253   EXPECT_TRANSFORMATION_MATRIX_EQ(position_transform,
 254                                   layer->screen_space_transform());
 255
 256   // Case 5: In the correct sequence of transforms, the layer transform should
 257   // pre-multiply the translation_to_center. This is easily tested by using a
 258   // scale transform, because scale and translation are not commutative.
 259   gfx::Transform layer_transform;
 260   layer_transform.Scale3d(2.0, 2.0, 1.0);
 261   SetLayerPropertiesForTesting(layer.get(),
 262                                layer_transform,
 263                                gfx::Point3F(),
 264                                gfx::PointF(),
 265                                gfx::Size(10, 12),
 266                                true,
 267                                false);
 268   ExecuteCalculateDrawProperties(root.get());
 269   EXPECT_TRANSFORMATION_MATRIX_EQ(layer_transform, layer->draw_transform());
 270   EXPECT_TRANSFORMATION_MATRIX_EQ(layer_transform,
 271                                   layer->screen_space_transform());
 272
 273   // Case 6: The layer transform should occur with respect to the anchor point.
 274   gfx::Transform translation_to_anchor;
 275   translation_to_anchor.Translate(5.0, 0.0);
 276   gfx::Transform expected_result =
 277       translation_to_anchor * layer_transform * Inverse(translation_to_anchor);
 278   SetLayerPropertiesForTesting(layer.get(),
 279                                layer_transform,
 280                                gfx::Point3F(5.0f, 0.f, 0.f),
 281                                gfx::PointF(),
 282                                gfx::Size(10, 12),
 283                                true,
 284                                false);
 285   ExecuteCalculateDrawProperties(root.get());
 286   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_result, layer->draw_transform());
 287   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_result,
 288                                   layer->screen_space_transform());
 289
 290   // Case 7: Verify that position pre-multiplies the layer transform.  The
 291   // current implementation of CalculateDrawProperties does this implicitly, but
 292   // it is still worth testing to detect accidental regressions.
 293   expected_result = position_transform * translation_to_anchor *
 294                     layer_transform * Inverse(translation_to_anchor);
 295   SetLayerPropertiesForTesting(layer.get(),
 296                                layer_transform,
 297                                gfx::Point3F(5.0f, 0.f, 0.f),
 298                                gfx::PointF(0.f, 1.2f),
 299                                gfx::Size(10, 12),
 300                                true,
 301                                false);
 302   ExecuteCalculateDrawProperties(root.get());
 303   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_result, layer->draw_transform());
 304   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_result,
 305                                   layer->screen_space_transform());
 306 }
 307
 308 TEST_F(LayerTreeHostCommonTest, TransformsAboutScrollOffset) {
 309   const gfx::ScrollOffset kScrollOffset(50, 100);
 310   const gfx::Vector2dF kScrollDelta(2.34f, 5.67f);
 311   const gfx::Vector2d kMaxScrollOffset(200, 200);
 312   const gfx::PointF kScrollLayerPosition(-kScrollOffset.x(),
 313                                          -kScrollOffset.y());
 314   const float kPageScale = 0.888f;
 315   const float kDeviceScale = 1.666f;
 316
 317   FakeImplProxy proxy;
 318   TestSharedBitmapManager shared_bitmap_manager;
 319   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager, nullptr);
 320
 321   gfx::Transform identity_matrix;
 322   scoped_ptr<LayerImpl> sublayer_scoped_ptr(
 323       LayerImpl::Create(host_impl.active_tree(), 1));
 324   LayerImpl* sublayer = sublayer_scoped_ptr.get();
 325   sublayer->SetContentsScale(kPageScale * kDeviceScale,
 326                              kPageScale * kDeviceScale);
 327   SetLayerPropertiesForTesting(sublayer, identity_matrix, gfx::Point3F(),
 328                                gfx::PointF(), gfx::Size(500, 500), true, false,
 329                                false);
 330
 331   scoped_ptr<LayerImpl> scroll_layer_scoped_ptr(
 332       LayerImpl::Create(host_impl.active_tree(), 2));
 333   LayerImpl* scroll_layer = scroll_layer_scoped_ptr.get();
 334   SetLayerPropertiesForTesting(scroll_layer, identity_matrix, gfx::Point3F(),
 335                                gfx::PointF(), gfx::Size(10, 20), true, false,
 336                                false);
 337   scoped_ptr<LayerImpl> clip_layer_scoped_ptr(
 338       LayerImpl::Create(host_impl.active_tree(), 4));
 339   LayerImpl* clip_layer = clip_layer_scoped_ptr.get();
 340
 341   scroll_layer->SetScrollClipLayer(clip_layer->id());
 342   clip_layer->SetBounds(
 343       gfx::Size(scroll_layer->bounds().width() + kMaxScrollOffset.x(),
 344                 scroll_layer->bounds().height() + kMaxScrollOffset.y()));
 345   scroll_layer->SetScrollClipLayer(clip_layer->id());
 346   scroll_layer->SetScrollDelta(kScrollDelta);
 347   gfx::Transform impl_transform;
 348   scroll_layer->AddChild(sublayer_scoped_ptr.Pass());
 349   LayerImpl* scroll_layer_raw_ptr = scroll_layer_scoped_ptr.get();
 350   clip_layer->AddChild(scroll_layer_scoped_ptr.Pass());
 351   scroll_layer_raw_ptr->PushScrollOffsetFromMainThread(kScrollOffset);
 352
 353   scoped_ptr<LayerImpl> root(LayerImpl::Create(host_impl.active_tree(), 3));
 354   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
 355                                gfx::PointF(), gfx::Size(3, 4), true, false,
 356                                false);
 357   root->AddChild(clip_layer_scoped_ptr.Pass());
 358   root->SetHasRenderSurface(true);
 359
 360   ExecuteCalculateDrawProperties(
 361       root.get(), kDeviceScale, kPageScale, scroll_layer->parent());
 362   gfx::Transform expected_transform = identity_matrix;
 363   gfx::PointF sub_layer_screen_position = kScrollLayerPosition - kScrollDelta;
 364   sub_layer_screen_position.Scale(kPageScale * kDeviceScale);
 365   expected_transform.Translate(MathUtil::Round(sub_layer_screen_position.x()),
 366                                MathUtil::Round(sub_layer_screen_position.y()));
 367   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform,
 368                                   sublayer->draw_transform());
 369   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform,
 370                                   sublayer->screen_space_transform());
 371
 372   gfx::Transform arbitrary_translate;
 373   const float kTranslateX = 10.6f;
 374   const float kTranslateY = 20.6f;
 375   arbitrary_translate.Translate(kTranslateX, kTranslateY);
 376   SetLayerPropertiesForTesting(scroll_layer, arbitrary_translate,
 377                                gfx::Point3F(), gfx::PointF(), gfx::Size(10, 20),
 378                                true, false, false);
 379   ExecuteCalculateDrawProperties(
 380       root.get(), kDeviceScale, kPageScale, scroll_layer->parent());
 381   expected_transform.MakeIdentity();
 382   expected_transform.Translate(
 383       MathUtil::Round(kTranslateX * kPageScale * kDeviceScale +
 384                       sub_layer_screen_position.x()),
 385       MathUtil::Round(kTranslateY * kPageScale * kDeviceScale +
 386                       sub_layer_screen_position.y()));
 387   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform,
 388                                   sublayer->draw_transform());
 389 }
 390
 391 TEST_F(LayerTreeHostCommonTest, TransformsForSimpleHierarchy) {
 392   gfx::Transform identity_matrix;
 393   scoped_refptr<Layer> root = Layer::Create();
 394   scoped_refptr<Layer> parent = Layer::Create();
 395   scoped_refptr<Layer> child = Layer::Create();
 396   scoped_refptr<Layer> grand_child = Layer::Create();
 397   root->AddChild(parent);
 398   parent->AddChild(child);
 399   child->AddChild(grand_child);
 400
 401   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
 402   host->SetRootLayer(root);
 403
 404   // One-time setup of root layer
 405   SetLayerPropertiesForTesting(root.get(),
 406                                identity_matrix,
 407                                gfx::Point3F(),
 408                                gfx::PointF(),
 409                                gfx::Size(1, 2),
 410                                true,
 411                                false);
 412
 413   // Case 1: parent's anchor point should not affect child or grand_child.
 414   SetLayerPropertiesForTesting(parent.get(),
 415                                identity_matrix,
 416                                gfx::Point3F(2.5f, 3.0f, 0.f),
 417                                gfx::PointF(),
 418                                gfx::Size(10, 12),
 419                                true,
 420                                false);
 421   SetLayerPropertiesForTesting(child.get(),
 422                                identity_matrix,
 423                                gfx::Point3F(),
 424                                gfx::PointF(),
 425                                gfx::Size(16, 18),
 426                                true,
 427                                false);
 428   SetLayerPropertiesForTesting(grand_child.get(),
 429                                identity_matrix,
 430                                gfx::Point3F(),
 431                                gfx::PointF(),
 432                                gfx::Size(76, 78),
 433                                true,
 434                                false);
 435   ExecuteCalculateDrawProperties(root.get());
 436   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->draw_transform());
 437   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
 438                                   child->screen_space_transform());
 439   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
 440                                   grand_child->draw_transform());
 441   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
 442                                   grand_child->screen_space_transform());
 443
 444   // Case 2: parent's position affects child and grand_child.
 445   gfx::Transform parent_position_transform;
 446   parent_position_transform.Translate(0.f, 1.2f);
 447   SetLayerPropertiesForTesting(parent.get(),
 448                                identity_matrix,
 449                                gfx::Point3F(2.5f, 3.0f, 0.f),
 450                                gfx::PointF(0.f, 1.2f),
 451                                gfx::Size(10, 12),
 452                                true,
 453                                false);
 454   SetLayerPropertiesForTesting(child.get(),
 455                                identity_matrix,
 456                                gfx::Point3F(),
 457                                gfx::PointF(),
 458                                gfx::Size(16, 18),
 459                                true,
 460                                false);
 461   SetLayerPropertiesForTesting(grand_child.get(),
 462                                identity_matrix,
 463                                gfx::Point3F(),
 464                                gfx::PointF(),
 465                                gfx::Size(76, 78),
 466                                true,
 467                                false);
 468   ExecuteCalculateDrawProperties(root.get());
 469   EXPECT_TRANSFORMATION_MATRIX_EQ(parent_position_transform,
 470                                   child->draw_transform());
 471   EXPECT_TRANSFORMATION_MATRIX_EQ(parent_position_transform,
 472                                   child->screen_space_transform());
 473   EXPECT_TRANSFORMATION_MATRIX_EQ(parent_position_transform,
 474                                   grand_child->draw_transform());
 475   EXPECT_TRANSFORMATION_MATRIX_EQ(parent_position_transform,
 476                                   grand_child->screen_space_transform());
 477
 478   // Case 3: parent's local transform affects child and grandchild
 479   gfx::Transform parent_layer_transform;
 480   parent_layer_transform.Scale3d(2.0, 2.0, 1.0);
 481   gfx::Transform parent_translation_to_anchor;
 482   parent_translation_to_anchor.Translate(2.5, 3.0);
 483   gfx::Transform parent_composite_transform =
 484       parent_translation_to_anchor * parent_layer_transform *
 485       Inverse(parent_translation_to_anchor);
 486   SetLayerPropertiesForTesting(parent.get(),
 487                                parent_layer_transform,
 488                                gfx::Point3F(2.5f, 3.0f, 0.f),
 489                                gfx::PointF(),
 490                                gfx::Size(10, 12),
 491                                true,
 492                                false);
 493   SetLayerPropertiesForTesting(child.get(),
 494                                identity_matrix,
 495                                gfx::Point3F(),
 496                                gfx::PointF(),
 497                                gfx::Size(16, 18),
 498                                true,
 499                                false);
 500   SetLayerPropertiesForTesting(grand_child.get(),
 501                                identity_matrix,
 502                                gfx::Point3F(),
 503                                gfx::PointF(),
 504                                gfx::Size(76, 78),
 505                                true,
 506                                false);
 507   ExecuteCalculateDrawProperties(root.get());
 508   EXPECT_TRANSFORMATION_MATRIX_EQ(parent_composite_transform,
 509                                   child->draw_transform());
 510   EXPECT_TRANSFORMATION_MATRIX_EQ(parent_composite_transform,
 511                                   child->screen_space_transform());
 512   EXPECT_TRANSFORMATION_MATRIX_EQ(parent_composite_transform,
 513                                   grand_child->draw_transform());
 514   EXPECT_TRANSFORMATION_MATRIX_EQ(parent_composite_transform,
 515                                   grand_child->screen_space_transform());
 516 }
 517
 518 TEST_F(LayerTreeHostCommonTest, TransformsForSingleRenderSurface) {
 519   scoped_refptr<Layer> root = Layer::Create();
 520   scoped_refptr<Layer> parent = Layer::Create();
 521   scoped_refptr<Layer> child = Layer::Create();
 522   scoped_refptr<LayerWithForcedDrawsContent> grand_child =
 523       make_scoped_refptr(new LayerWithForcedDrawsContent());
 524   root->AddChild(parent);
 525   parent->AddChild(child);
 526   child->AddChild(grand_child);
 527
 528   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
 529   host->SetRootLayer(root);
 530
 531   // One-time setup of root layer
 532   gfx::Transform identity_matrix;
 533   SetLayerPropertiesForTesting(root.get(),
 534                                identity_matrix,
 535                                gfx::Point3F(),
 536                                gfx::PointF(),
 537                                gfx::Size(1, 2),
 538                                true,
 539                                false);
 540
 541   // Child is set up so that a new render surface should be created.
 542   child->SetOpacity(0.5f);
 543   child->SetForceRenderSurface(true);
 544
 545   gfx::Transform parent_layer_transform;
 546   parent_layer_transform.Scale3d(1.f, 0.9f, 1.f);
 547   gfx::Transform parent_translation_to_anchor;
 548   parent_translation_to_anchor.Translate(25.0, 30.0);
 549
 550   gfx::Transform parent_composite_transform =
 551       parent_translation_to_anchor * parent_layer_transform *
 552       Inverse(parent_translation_to_anchor);
 553   gfx::Vector2dF parent_composite_scale =
 554       MathUtil::ComputeTransform2dScaleComponents(parent_composite_transform,
 555                                                   1.f);
 556   gfx::Transform surface_sublayer_transform;
 557   surface_sublayer_transform.Scale(parent_composite_scale.x(),
 558                                    parent_composite_scale.y());
 559   gfx::Transform surface_sublayer_composite_transform =
 560       parent_composite_transform * Inverse(surface_sublayer_transform);
 561
 562   // Child's render surface should not exist yet.
 563   ASSERT_FALSE(child->render_surface());
 564
 565   SetLayerPropertiesForTesting(parent.get(),
 566                                parent_layer_transform,
 567                                gfx::Point3F(25.0f, 30.0f, 0.f),
 568                                gfx::PointF(),
 569                                gfx::Size(100, 120),
 570                                true,
 571                                false);
 572   SetLayerPropertiesForTesting(child.get(),
 573                                identity_matrix,
 574                                gfx::Point3F(),
 575                                gfx::PointF(),
 576                                gfx::Size(16, 18),
 577                                true,
 578                                false);
 579   SetLayerPropertiesForTesting(grand_child.get(),
 580                                identity_matrix,
 581                                gfx::Point3F(),
 582                                gfx::PointF(),
 583                                gfx::Size(8, 10),
 584                                true,
 585                                false);
 586   ExecuteCalculateDrawProperties(root.get());
 587
 588   // Render surface should have been created now.
 589   ASSERT_TRUE(child->render_surface());
 590   ASSERT_EQ(child.get(), child->render_target());
 591
 592   // The child layer's draw transform should refer to its new render surface.
 593   // The screen-space transform, however, should still refer to the root.
 594   EXPECT_TRANSFORMATION_MATRIX_EQ(surface_sublayer_transform,
 595                                   child->draw_transform());
 596   EXPECT_TRANSFORMATION_MATRIX_EQ(parent_composite_transform,
 597                                   child->screen_space_transform());
 598
 599   // Because the grand_child is the only drawable content, the child's render
 600   // surface will tighten its bounds to the grand_child.  The scale at which the
 601   // surface's subtree is drawn must be removed from the composite transform.
 602   EXPECT_TRANSFORMATION_MATRIX_EQ(
 603       surface_sublayer_composite_transform,
 604       child->render_target()->render_surface()->draw_transform());
 605
 606   // The screen space is the same as the target since the child surface draws
 607   // into the root.
 608   EXPECT_TRANSFORMATION_MATRIX_EQ(
 609       surface_sublayer_composite_transform,
 610       child->render_target()->render_surface()->screen_space_transform());
 611 }
 612
 613 TEST_F(LayerTreeHostCommonTest, TransformsForReplica) {
 614   scoped_refptr<Layer> root = Layer::Create();
 615   scoped_refptr<Layer> parent = Layer::Create();
 616   scoped_refptr<Layer> child = Layer::Create();
 617   scoped_refptr<Layer> child_replica = Layer::Create();
 618   scoped_refptr<LayerWithForcedDrawsContent> grand_child =
 619       make_scoped_refptr(new LayerWithForcedDrawsContent());
 620   root->AddChild(parent);
 621   parent->AddChild(child);
 622   child->AddChild(grand_child);
 623   child->SetReplicaLayer(child_replica.get());
 624
 625   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
 626   host->SetRootLayer(root);
 627
 628   // One-time setup of root layer
 629   gfx::Transform identity_matrix;
 630   SetLayerPropertiesForTesting(root.get(),
 631                                identity_matrix,
 632                                gfx::Point3F(),
 633                                gfx::PointF(),
 634                                gfx::Size(1, 2),
 635                                true,
 636                                false);
 637
 638   // Child is set up so that a new render surface should be created.
 639   child->SetOpacity(0.5f);
 640
 641   gfx::Transform parent_layer_transform;
 642   parent_layer_transform.Scale3d(2.0, 2.0, 1.0);
 643   gfx::Transform parent_translation_to_anchor;
 644   parent_translation_to_anchor.Translate(2.5, 3.0);
 645   gfx::Transform parent_composite_transform =
 646       parent_translation_to_anchor * parent_layer_transform *
 647       Inverse(parent_translation_to_anchor);
 648   gfx::Transform replica_layer_transform;
 649   replica_layer_transform.Scale3d(3.0, 3.0, 1.0);
 650   gfx::Vector2dF parent_composite_scale =
 651       MathUtil::ComputeTransform2dScaleComponents(parent_composite_transform,
 652                                                   1.f);
 653   gfx::Transform surface_sublayer_transform;
 654   surface_sublayer_transform.Scale(parent_composite_scale.x(),
 655                                    parent_composite_scale.y());
 656   gfx::Transform replica_composite_transform =
 657       parent_composite_transform * replica_layer_transform *
 658       Inverse(surface_sublayer_transform);
 659   child_replica->SetIsDrawable(true);
 660   // Child's render surface should not exist yet.
 661   ASSERT_FALSE(child->render_surface());
 662
 663   SetLayerPropertiesForTesting(parent.get(),
 664                                parent_layer_transform,
 665                                gfx::Point3F(2.5f, 3.0f, 0.f),
 666                                gfx::PointF(),
 667                                gfx::Size(10, 12),
 668                                true,
 669                                false);
 670   SetLayerPropertiesForTesting(child.get(),
 671                                identity_matrix,
 672                                gfx::Point3F(),
 673                                gfx::PointF(),
 674                                gfx::Size(16, 18),
 675                                true,
 676                                false);
 677   SetLayerPropertiesForTesting(grand_child.get(),
 678                                identity_matrix,
 679                                gfx::Point3F(),
 680                                gfx::PointF(-0.5f, -0.5f),
 681                                gfx::Size(1, 1),
 682                                true,
 683                                false);
 684   SetLayerPropertiesForTesting(child_replica.get(),
 685                                replica_layer_transform,
 686                                gfx::Point3F(),
 687                                gfx::PointF(),
 688                                gfx::Size(),
 689                                true,
 690                                false);
 691   ExecuteCalculateDrawProperties(root.get());
 692
 693   // Render surface should have been created now.
 694   ASSERT_TRUE(child->render_surface());
 695   ASSERT_EQ(child.get(), child->render_target());
 696
 697   EXPECT_TRANSFORMATION_MATRIX_EQ(
 698       replica_composite_transform,
 699       child->render_target()->render_surface()->replica_draw_transform());
 700   EXPECT_TRANSFORMATION_MATRIX_EQ(replica_composite_transform,
 701                                   child->render_target()
 702                                       ->render_surface()
 703                                       ->replica_screen_space_transform());
 704 }
 705
 706 TEST_F(LayerTreeHostCommonTest, TransformsForRenderSurfaceHierarchy) {
 707   // This test creates a more complex tree and verifies it all at once. This
 708   // covers the following cases:
 709   //   - layers that are described w.r.t. a render surface: should have draw
 710   //   transforms described w.r.t. that surface
 711   //   - A render surface described w.r.t. an ancestor render surface: should
 712   //   have a draw transform described w.r.t. that ancestor surface
 713   //   - Replicas of a render surface are described w.r.t. the replica's
 714   //   transform around its anchor, along with the surface itself.
 715   //   - Sanity check on recursion: verify transforms of layers described w.r.t.
 716   //   a render surface that is described w.r.t. an ancestor render surface.
 717   //   - verifying that each layer has a reference to the correct render surface
 718   //   and render target values.
 719
 720   scoped_refptr<Layer> root = Layer::Create();
 721   scoped_refptr<Layer> parent = Layer::Create();
 722   scoped_refptr<Layer> render_surface1 = Layer::Create();
 723   scoped_refptr<Layer> render_surface2 = Layer::Create();
 724   scoped_refptr<Layer> child_of_root = Layer::Create();
 725   scoped_refptr<Layer> child_of_rs1 = Layer::Create();
 726   scoped_refptr<Layer> child_of_rs2 = Layer::Create();
 727   scoped_refptr<Layer> replica_of_rs1 = Layer::Create();
 728   scoped_refptr<Layer> replica_of_rs2 = Layer::Create();
 729   scoped_refptr<Layer> grand_child_of_root = Layer::Create();
 730   scoped_refptr<LayerWithForcedDrawsContent> grand_child_of_rs1 =
 731       make_scoped_refptr(new LayerWithForcedDrawsContent());
 732   scoped_refptr<LayerWithForcedDrawsContent> grand_child_of_rs2 =
 733       make_scoped_refptr(new LayerWithForcedDrawsContent());
 734   root->AddChild(parent);
 735   parent->AddChild(render_surface1);
 736   parent->AddChild(child_of_root);
 737   render_surface1->AddChild(child_of_rs1);
 738   render_surface1->AddChild(render_surface2);
 739   render_surface2->AddChild(child_of_rs2);
 740   child_of_root->AddChild(grand_child_of_root);
 741   child_of_rs1->AddChild(grand_child_of_rs1);
 742   child_of_rs2->AddChild(grand_child_of_rs2);
 743   render_surface1->SetReplicaLayer(replica_of_rs1.get());
 744   render_surface2->SetReplicaLayer(replica_of_rs2.get());
 745
 746   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
 747   host->SetRootLayer(root);
 748
 749   // In combination with descendant draws content, opacity != 1 forces the layer
 750   // to have a new render surface.
 751   render_surface1->SetOpacity(0.5f);
 752   render_surface2->SetOpacity(0.33f);
 753
 754   // One-time setup of root layer
 755   gfx::Transform identity_matrix;
 756   SetLayerPropertiesForTesting(root.get(),
 757                                identity_matrix,
 758                                gfx::Point3F(),
 759                                gfx::PointF(),
 760                                gfx::Size(1, 2),
 761                                true,
 762                                false);
 763
 764   // All layers in the tree are initialized with an anchor at .25 and a size of
 765   // (10,10).  matrix "A" is the composite layer transform used in all layers,
 766   // Matrix "R" is the composite replica transform used in all replica layers.
 767   gfx::Transform translation_to_anchor;
 768   translation_to_anchor.Translate(2.5, 0.0);
 769   gfx::Transform layer_transform;
 770   layer_transform.Translate(1.0, 1.0);
 771   gfx::Transform replica_layer_transform;
 772   replica_layer_transform.Scale3d(-2.0, 5.0, 1.0);
 773
 774   gfx::Transform A =
 775       translation_to_anchor * layer_transform * Inverse(translation_to_anchor);
 776   gfx::Transform R = A * translation_to_anchor * replica_layer_transform *
 777                      Inverse(translation_to_anchor);
 778
 779   gfx::Vector2dF surface1_parent_transform_scale =
 780       MathUtil::ComputeTransform2dScaleComponents(A, 1.f);
 781   gfx::Transform surface1_sublayer_transform;
 782   surface1_sublayer_transform.Scale(surface1_parent_transform_scale.x(),
 783                                     surface1_parent_transform_scale.y());
 784
 785   // SS1 = transform given to the subtree of render_surface1
 786   gfx::Transform SS1 = surface1_sublayer_transform;
 787   // S1 = transform to move from render_surface1 pixels to the layer space of
 788   // the owning layer
 789   gfx::Transform S1 = Inverse(surface1_sublayer_transform);
 790
 791   gfx::Vector2dF surface2_parent_transform_scale =
 792       MathUtil::ComputeTransform2dScaleComponents(SS1 * A, 1.f);
 793   gfx::Transform surface2_sublayer_transform;
 794   surface2_sublayer_transform.Scale(surface2_parent_transform_scale.x(),
 795                                     surface2_parent_transform_scale.y());
 796
 797   // SS2 = transform given to the subtree of render_surface2
 798   gfx::Transform SS2 = surface2_sublayer_transform;
 799   // S2 = transform to move from render_surface2 pixels to the layer space of
 800   // the owning layer
 801   gfx::Transform S2 = Inverse(surface2_sublayer_transform);
 802
 803   SetLayerPropertiesForTesting(parent.get(),
 804                                layer_transform,
 805                                gfx::Point3F(2.5f, 0.f, 0.f),
 806                                gfx::PointF(),
 807                                gfx::Size(10, 10),
 808                                true,
 809                                false);
 810   SetLayerPropertiesForTesting(render_surface1.get(),
 811                                layer_transform,
 812                                gfx::Point3F(2.5f, 0.f, 0.f),
 813                                gfx::PointF(),
 814                                gfx::Size(10, 10),
 815                                true,
 816                                false);
 817   SetLayerPropertiesForTesting(render_surface2.get(),
 818                                layer_transform,
 819                                gfx::Point3F(2.5f, 0.f, 0.f),
 820                                gfx::PointF(),
 821                                gfx::Size(10, 10),
 822                                true,
 823                                false);
 824   SetLayerPropertiesForTesting(child_of_root.get(),
 825                                layer_transform,
 826                                gfx::Point3F(2.5f, 0.f, 0.f),
 827                                gfx::PointF(),
 828                                gfx::Size(10, 10),
 829                                true,
 830                                false);
 831   SetLayerPropertiesForTesting(child_of_rs1.get(),
 832                                layer_transform,
 833                                gfx::Point3F(2.5f, 0.f, 0.f),
 834                                gfx::PointF(),
 835                                gfx::Size(10, 10),
 836                                true,
 837                                false);
 838   SetLayerPropertiesForTesting(child_of_rs2.get(),
 839                                layer_transform,
 840                                gfx::Point3F(2.5f, 0.f, 0.f),
 841                                gfx::PointF(),
 842                                gfx::Size(10, 10),
 843                                true,
 844                                false);
 845   SetLayerPropertiesForTesting(grand_child_of_root.get(),
 846                                layer_transform,
 847                                gfx::Point3F(2.5f, 0.f, 0.f),
 848                                gfx::PointF(),
 849                                gfx::Size(10, 10),
 850                                true,
 851                                false);
 852   SetLayerPropertiesForTesting(grand_child_of_rs1.get(),
 853                                layer_transform,
 854                                gfx::Point3F(2.5f, 0.f, 0.f),
 855                                gfx::PointF(),
 856                                gfx::Size(10, 10),
 857                                true,
 858                                false);
 859   SetLayerPropertiesForTesting(grand_child_of_rs2.get(),
 860                                layer_transform,
 861                                gfx::Point3F(2.5f, 0.f, 0.f),
 862                                gfx::PointF(),
 863                                gfx::Size(10, 10),
 864                                true,
 865                                false);
 866   SetLayerPropertiesForTesting(replica_of_rs1.get(),
 867                                replica_layer_transform,
 868                                gfx::Point3F(2.5f, 0.f, 0.f),
 869                                gfx::PointF(),
 870                                gfx::Size(),
 871                                true,
 872                                false);
 873   SetLayerPropertiesForTesting(replica_of_rs2.get(),
 874                                replica_layer_transform,
 875                                gfx::Point3F(2.5f, 0.f, 0.f),
 876                                gfx::PointF(),
 877                                gfx::Size(),
 878                                true,
 879                                false);
 880
 881   ExecuteCalculateDrawProperties(root.get());
 882
 883   // Only layers that are associated with render surfaces should have an actual
 884   // RenderSurface() value.
 885   ASSERT_TRUE(root->render_surface());
 886   ASSERT_FALSE(child_of_root->render_surface());
 887   ASSERT_FALSE(grand_child_of_root->render_surface());
 888
 889   ASSERT_TRUE(render_surface1->render_surface());
 890   ASSERT_FALSE(child_of_rs1->render_surface());
 891   ASSERT_FALSE(grand_child_of_rs1->render_surface());
 892
 893   ASSERT_TRUE(render_surface2->render_surface());
 894   ASSERT_FALSE(child_of_rs2->render_surface());
 895   ASSERT_FALSE(grand_child_of_rs2->render_surface());
 896
 897   // Verify all render target accessors
 898   EXPECT_EQ(root.get(), parent->render_target());
 899   EXPECT_EQ(root.get(), child_of_root->render_target());
 900   EXPECT_EQ(root.get(), grand_child_of_root->render_target());
 901
 902   EXPECT_EQ(render_surface1.get(), render_surface1->render_target());
 903   EXPECT_EQ(render_surface1.get(), child_of_rs1->render_target());
 904   EXPECT_EQ(render_surface1.get(), grand_child_of_rs1->render_target());
 905
 906   EXPECT_EQ(render_surface2.get(), render_surface2->render_target());
 907   EXPECT_EQ(render_surface2.get(), child_of_rs2->render_target());
 908   EXPECT_EQ(render_surface2.get(), grand_child_of_rs2->render_target());
 909
 910   // Verify layer draw transforms note that draw transforms are described with
 911   // respect to the nearest ancestor render surface but screen space transforms
 912   // are described with respect to the root.
 913   EXPECT_TRANSFORMATION_MATRIX_EQ(A, parent->draw_transform());
 914   EXPECT_TRANSFORMATION_MATRIX_EQ(A * A, child_of_root->draw_transform());
 915   EXPECT_TRANSFORMATION_MATRIX_EQ(A * A * A,
 916                                   grand_child_of_root->draw_transform());
 917
 918   EXPECT_TRANSFORMATION_MATRIX_EQ(SS1, render_surface1->draw_transform());
 919   EXPECT_TRANSFORMATION_MATRIX_EQ(SS1 * A, child_of_rs1->draw_transform());
 920   EXPECT_TRANSFORMATION_MATRIX_EQ(SS1 * A * A,
 921                                   grand_child_of_rs1->draw_transform());
 922
 923   EXPECT_TRANSFORMATION_MATRIX_EQ(SS2, render_surface2->draw_transform());
 924   EXPECT_TRANSFORMATION_MATRIX_EQ(SS2 * A, child_of_rs2->draw_transform());
 925   EXPECT_TRANSFORMATION_MATRIX_EQ(SS2 * A * A,
 926                                   grand_child_of_rs2->draw_transform());
 927
 928   // Verify layer screen-space transforms
 929   //
 930   EXPECT_TRANSFORMATION_MATRIX_EQ(A, parent->screen_space_transform());
 931   EXPECT_TRANSFORMATION_MATRIX_EQ(A * A,
 932                                   child_of_root->screen_space_transform());
 933   EXPECT_TRANSFORMATION_MATRIX_EQ(
 934       A * A * A, grand_child_of_root->screen_space_transform());
 935
 936   EXPECT_TRANSFORMATION_MATRIX_EQ(A * A,
 937                                   render_surface1->screen_space_transform());
 938   EXPECT_TRANSFORMATION_MATRIX_EQ(A * A * A,
 939                                   child_of_rs1->screen_space_transform());
 940   EXPECT_TRANSFORMATION_MATRIX_EQ(A * A * A * A,
 941                                   grand_child_of_rs1->screen_space_transform());
 942
 943   EXPECT_TRANSFORMATION_MATRIX_EQ(A * A * A,
 944                                   render_surface2->screen_space_transform());
 945   EXPECT_TRANSFORMATION_MATRIX_EQ(A * A * A * A,
 946                                   child_of_rs2->screen_space_transform());
 947   EXPECT_TRANSFORMATION_MATRIX_EQ(A * A * A * A * A,
 948                                   grand_child_of_rs2->screen_space_transform());
 949
 950   // Verify render surface transforms.
 951   //
 952   // Draw transform of render surface 1 is described with respect to root.
 953   EXPECT_TRANSFORMATION_MATRIX_EQ(
 954       A * A * S1, render_surface1->render_surface()->draw_transform());
 955   EXPECT_TRANSFORMATION_MATRIX_EQ(
 956       A * R * S1, render_surface1->render_surface()->replica_draw_transform());
 957   EXPECT_TRANSFORMATION_MATRIX_EQ(
 958       A * A * S1, render_surface1->render_surface()->screen_space_transform());
 959   EXPECT_TRANSFORMATION_MATRIX_EQ(
 960       A * R * S1,
 961       render_surface1->render_surface()->replica_screen_space_transform());
 962   // Draw transform of render surface 2 is described with respect to render
 963   // surface 1.
 964   EXPECT_TRANSFORMATION_MATRIX_EQ(
 965       SS1 * A * S2, render_surface2->render_surface()->draw_transform());
 966   EXPECT_TRANSFORMATION_MATRIX_EQ(
 967       SS1 * R * S2,
 968       render_surface2->render_surface()->replica_draw_transform());
 969   EXPECT_TRANSFORMATION_MATRIX_EQ(
 970       A * A * A * S2,
 971       render_surface2->render_surface()->screen_space_transform());
 972   EXPECT_TRANSFORMATION_MATRIX_EQ(
 973       A * A * R * S2,
 974       render_surface2->render_surface()->replica_screen_space_transform());
 975
 976   // Sanity check. If these fail there is probably a bug in the test itself.  It
 977   // is expected that we correctly set up transforms so that the y-component of
 978   // the screen-space transform encodes the "depth" of the layer in the tree.
 979   EXPECT_FLOAT_EQ(1.0, parent->screen_space_transform().matrix().get(1, 3));
 980   EXPECT_FLOAT_EQ(2.0,
 981                   child_of_root->screen_space_transform().matrix().get(1, 3));
 982   EXPECT_FLOAT_EQ(
 983       3.0, grand_child_of_root->screen_space_transform().matrix().get(1, 3));
 984
 985   EXPECT_FLOAT_EQ(2.0,
 986                   render_surface1->screen_space_transform().matrix().get(1, 3));
 987   EXPECT_FLOAT_EQ(3.0,
 988                   child_of_rs1->screen_space_transform().matrix().get(1, 3));
 989   EXPECT_FLOAT_EQ(
 990       4.0, grand_child_of_rs1->screen_space_transform().matrix().get(1, 3));
 991
 992   EXPECT_FLOAT_EQ(3.0,
 993                   render_surface2->screen_space_transform().matrix().get(1, 3));
 994   EXPECT_FLOAT_EQ(4.0,
 995                   child_of_rs2->screen_space_transform().matrix().get(1, 3));
 996   EXPECT_FLOAT_EQ(
 997       5.0, grand_child_of_rs2->screen_space_transform().matrix().get(1, 3));
 998 }
 999
1000 TEST_F(LayerTreeHostCommonTest, TransformsForFlatteningLayer) {
1001   // For layers that flatten their subtree, there should be an orthographic
1002   // projection (for x and y values) in the middle of the transform sequence.
1003   // Note that the way the code is currently implemented, it is not expected to
1004   // use a canonical orthographic projection.
1005
1006   scoped_refptr<Layer> root = Layer::Create();
1007   scoped_refptr<Layer> child = Layer::Create();
1008   scoped_refptr<LayerWithForcedDrawsContent> grand_child =
1009       make_scoped_refptr(new LayerWithForcedDrawsContent());
1010   scoped_refptr<LayerWithForcedDrawsContent> great_grand_child =
1011       make_scoped_refptr(new LayerWithForcedDrawsContent());
1012
1013   gfx::Transform rotation_about_y_axis;
1014   rotation_about_y_axis.RotateAboutYAxis(30.0);
1015
1016   const gfx::Transform identity_matrix;
1017   SetLayerPropertiesForTesting(root.get(),
1018                                identity_matrix,
1019                                gfx::Point3F(),
1020                                gfx::PointF(),
1021                                gfx::Size(100, 100),
1022                                true,
1023                                false);
1024   SetLayerPropertiesForTesting(child.get(),
1025                                rotation_about_y_axis,
1026                                gfx::Point3F(),
1027                                gfx::PointF(),
1028                                gfx::Size(10, 10),
1029                                true,
1030                                false);
1031   SetLayerPropertiesForTesting(grand_child.get(),
1032                                rotation_about_y_axis,
1033                                gfx::Point3F(),
1034                                gfx::PointF(),
1035                                gfx::Size(10, 10),
1036                                true,
1037                                false);
1038   SetLayerPropertiesForTesting(great_grand_child.get(), identity_matrix,
1039                                gfx::Point3F(), gfx::PointF(), gfx::Size(10, 10),
1040                                true, false);
1041
1042   root->AddChild(child);
1043   child->AddChild(grand_child);
1044   grand_child->AddChild(great_grand_child);
1045   child->SetForceRenderSurface(true);
1046
1047   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
1048   host->SetRootLayer(root);
1049
1050   // No layers in this test should preserve 3d.
1051   ASSERT_TRUE(root->should_flatten_transform());
1052   ASSERT_TRUE(child->should_flatten_transform());
1053   ASSERT_TRUE(grand_child->should_flatten_transform());
1054   ASSERT_TRUE(great_grand_child->should_flatten_transform());
1055
1056   gfx::Transform expected_child_draw_transform = rotation_about_y_axis;
1057   gfx::Transform expected_child_screen_space_transform = rotation_about_y_axis;
1058   gfx::Transform expected_grand_child_draw_transform =
1059       rotation_about_y_axis;  // draws onto child's render surface
1060   gfx::Transform flattened_rotation_about_y = rotation_about_y_axis;
1061   flattened_rotation_about_y.FlattenTo2d();
1062   gfx::Transform expected_grand_child_screen_space_transform =
1063       flattened_rotation_about_y * rotation_about_y_axis;
1064   gfx::Transform expected_great_grand_child_draw_transform =
1065       flattened_rotation_about_y;
1066   gfx::Transform expected_great_grand_child_screen_space_transform =
1067       flattened_rotation_about_y * flattened_rotation_about_y;
1068
1069   ExecuteCalculateDrawProperties(root.get());
1070
1071   // The child's draw transform should have been taken by its surface.
1072   ASSERT_TRUE(child->render_surface());
1073   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_draw_transform,
1074                                   child->render_surface()->draw_transform());
1075   EXPECT_TRANSFORMATION_MATRIX_EQ(
1076       expected_child_screen_space_transform,
1077       child->render_surface()->screen_space_transform());
1078   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->draw_transform());
1079   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_screen_space_transform,
1080                                   child->screen_space_transform());
1081   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_draw_transform,
1082                                   grand_child->draw_transform());
1083   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_screen_space_transform,
1084                                   grand_child->screen_space_transform());
1085   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_draw_transform,
1086                                   great_grand_child->draw_transform());
1087   EXPECT_TRANSFORMATION_MATRIX_EQ(
1088       expected_great_grand_child_screen_space_transform,
1089       great_grand_child->screen_space_transform());
1090 }
1091
1092 TEST_F(LayerTreeHostCommonTest, TransformsForDegenerateIntermediateLayer) {
1093   // A layer that is empty in one axis, but not the other, was accidentally
1094   // skipping a necessary translation.  Without that translation, the coordinate
1095   // space of the layer's draw transform is incorrect.
1096   //
1097   // Normally this isn't a problem, because the layer wouldn't be drawn anyway,
1098   // but if that layer becomes a render surface, then its draw transform is
1099   // implicitly inherited by the rest of the subtree, which then is positioned
1100   // incorrectly as a result.
1101
1102   scoped_refptr<Layer> root = Layer::Create();
1103   scoped_refptr<Layer> child = Layer::Create();
1104   scoped_refptr<LayerWithForcedDrawsContent> grand_child =
1105       make_scoped_refptr(new LayerWithForcedDrawsContent());
1106
1107   // The child height is zero, but has non-zero width that should be accounted
1108   // for while computing draw transforms.
1109   const gfx::Transform identity_matrix;
1110   SetLayerPropertiesForTesting(root.get(),
1111                                identity_matrix,
1112                                gfx::Point3F(),
1113                                gfx::PointF(),
1114                                gfx::Size(100, 100),
1115                                true,
1116                                false);
1117   SetLayerPropertiesForTesting(child.get(),
1118                                identity_matrix,
1119                                gfx::Point3F(),
1120                                gfx::PointF(),
1121                                gfx::Size(10, 0),
1122                                true,
1123                                false);
1124   SetLayerPropertiesForTesting(grand_child.get(),
1125                                identity_matrix,
1126                                gfx::Point3F(),
1127                                gfx::PointF(),
1128                                gfx::Size(10, 10),
1129                                true,
1130                                false);
1131
1132   root->AddChild(child);
1133   child->AddChild(grand_child);
1134   child->SetForceRenderSurface(true);
1135
1136   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
1137   host->SetRootLayer(root);
1138
1139   ExecuteCalculateDrawProperties(root.get());
1140
1141   ASSERT_TRUE(child->render_surface());
1142   // This is the real test, the rest are sanity checks.
1143   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
1144                                   child->render_surface()->draw_transform());
1145   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->draw_transform());
1146   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
1147                                   grand_child->draw_transform());
1148 }
1149
1150 TEST_F(LayerTreeHostCommonTest, TransformAboveRootLayer) {
1151   // Transformations applied at the root of the tree should be forwarded
1152   // to child layers instead of applied to the root RenderSurface.
1153   const gfx::Transform identity_matrix;
1154   scoped_refptr<LayerWithForcedDrawsContent> root =
1155       new LayerWithForcedDrawsContent;
1156   scoped_refptr<LayerWithForcedDrawsContent> child =
1157       new LayerWithForcedDrawsContent;
1158   child->SetScrollClipLayerId(root->id());
1159   root->AddChild(child);
1160
1161   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
1162   host->SetRootLayer(root);
1163
1164   SetLayerPropertiesForTesting(root.get(),
1165                                identity_matrix,
1166                                gfx::Point3F(),
1167                                gfx::PointF(),
1168                                gfx::Size(20, 20),
1169                                true,
1170                                false);
1171   SetLayerPropertiesForTesting(child.get(),
1172                                identity_matrix,
1173                                gfx::Point3F(),
1174                                gfx::PointF(),
1175                                gfx::Size(20, 20),
1176                                true,
1177                                false);
1178
1179   gfx::Transform translate;
1180   translate.Translate(50, 50);
1181   {
1182     RenderSurfaceLayerList render_surface_layer_list;
1183     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
1184         root.get(), root->bounds(), translate, &render_surface_layer_list);
1185     inputs.can_adjust_raster_scales = true;
1186     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
1187     EXPECT_EQ(translate, root->draw_properties().target_space_transform);
1188     EXPECT_EQ(translate, child->draw_properties().target_space_transform);
1189     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
1190     EXPECT_EQ(1.f, root->draw_properties().device_scale_factor);
1191     EXPECT_EQ(1.f, child->draw_properties().device_scale_factor);
1192   }
1193
1194   gfx::Transform scale;
1195   scale.Scale(2, 2);
1196   {
1197     RenderSurfaceLayerList render_surface_layer_list;
1198     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
1199         root.get(), root->bounds(), scale, &render_surface_layer_list);
1200     inputs.can_adjust_raster_scales = true;
1201     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
1202     EXPECT_EQ(scale, root->draw_properties().target_space_transform);
1203     EXPECT_EQ(scale, child->draw_properties().target_space_transform);
1204     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
1205     EXPECT_EQ(2.f, root->draw_properties().device_scale_factor);
1206     EXPECT_EQ(2.f, child->draw_properties().device_scale_factor);
1207   }
1208
1209   gfx::Transform rotate;
1210   rotate.Rotate(2);
1211   {
1212     RenderSurfaceLayerList render_surface_layer_list;
1213     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
1214         root.get(), root->bounds(), rotate, &render_surface_layer_list);
1215     inputs.can_adjust_raster_scales = true;
1216     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
1217     EXPECT_EQ(rotate, root->draw_properties().target_space_transform);
1218     EXPECT_EQ(rotate, child->draw_properties().target_space_transform);
1219     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
1220     EXPECT_EQ(1.f, root->draw_properties().device_scale_factor);
1221     EXPECT_EQ(1.f, child->draw_properties().device_scale_factor);
1222   }
1223
1224   gfx::Transform composite;
1225   composite.ConcatTransform(translate);
1226   composite.ConcatTransform(scale);
1227   composite.ConcatTransform(rotate);
1228   {
1229     RenderSurfaceLayerList render_surface_layer_list;
1230     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
1231         root.get(), root->bounds(), composite, &render_surface_layer_list);
1232     inputs.can_adjust_raster_scales = true;
1233     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
1234     EXPECT_EQ(composite, root->draw_properties().target_space_transform);
1235     EXPECT_EQ(composite, child->draw_properties().target_space_transform);
1236     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
1237   }
1238
1239   // Verify it composes correctly with device scale.
1240   float device_scale_factor = 1.5f;
1241
1242   {
1243     RenderSurfaceLayerList render_surface_layer_list;
1244     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
1245         root.get(), root->bounds(), translate, &render_surface_layer_list);
1246     inputs.device_scale_factor = device_scale_factor;
1247     inputs.can_adjust_raster_scales = true;
1248     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
1249     gfx::Transform device_scaled_translate = translate;
1250     device_scaled_translate.Scale(device_scale_factor, device_scale_factor);
1251     EXPECT_EQ(device_scaled_translate,
1252               root->draw_properties().target_space_transform);
1253     EXPECT_EQ(device_scaled_translate,
1254               child->draw_properties().target_space_transform);
1255     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
1256     EXPECT_EQ(device_scale_factor, root->draw_properties().device_scale_factor);
1257     EXPECT_EQ(device_scale_factor,
1258               child->draw_properties().device_scale_factor);
1259   }
1260
1261   // Verify it composes correctly with page scale.
1262   float page_scale_factor = 2.f;
1263
1264   {
1265     RenderSurfaceLayerList render_surface_layer_list;
1266     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
1267         root.get(), root->bounds(), translate, &render_surface_layer_list);
1268     inputs.page_scale_factor = page_scale_factor;
1269     inputs.page_scale_application_layer = root.get();
1270     inputs.can_adjust_raster_scales = true;
1271     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
1272     gfx::Transform page_scaled_translate = translate;
1273     page_scaled_translate.Scale(page_scale_factor, page_scale_factor);
1274     EXPECT_EQ(translate, root->draw_properties().target_space_transform);
1275     EXPECT_EQ(page_scaled_translate,
1276               child->draw_properties().target_space_transform);
1277     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
1278     EXPECT_EQ(1.f, root->draw_properties().device_scale_factor);
1279     EXPECT_EQ(1.f, child->draw_properties().device_scale_factor);
1280   }
1281
1282   // Verify that it composes correctly with transforms directly on root layer.
1283   root->SetTransform(composite);
1284
1285   {
1286     RenderSurfaceLayerList render_surface_layer_list;
1287     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
1288         root.get(), root->bounds(), composite, &render_surface_layer_list);
1289     inputs.can_adjust_raster_scales = true;
1290     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
1291     gfx::Transform compositeSquared = composite;
1292     compositeSquared.ConcatTransform(composite);
1293     EXPECT_TRANSFORMATION_MATRIX_EQ(
1294         compositeSquared, root->draw_properties().target_space_transform);
1295     EXPECT_TRANSFORMATION_MATRIX_EQ(
1296         compositeSquared, child->draw_properties().target_space_transform);
1297     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
1298   }
1299 }
1300
1301 TEST_F(LayerTreeHostCommonTest,
1302        RenderSurfaceListForRenderSurfaceWithClippedLayer) {
1303   scoped_refptr<Layer> parent = Layer::Create();
1304   scoped_refptr<Layer> render_surface1 = Layer::Create();
1305   scoped_refptr<LayerWithForcedDrawsContent> child =
1306       make_scoped_refptr(new LayerWithForcedDrawsContent());
1307
1308   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
1309   host->SetRootLayer(parent);
1310
1311   const gfx::Transform identity_matrix;
1312   SetLayerPropertiesForTesting(parent.get(),
1313                                identity_matrix,
1314                                gfx::Point3F(),
1315                                gfx::PointF(),
1316                                gfx::Size(10, 10),
1317                                true,
1318                                false);
1319   SetLayerPropertiesForTesting(render_surface1.get(),
1320                                identity_matrix,
1321                                gfx::Point3F(),
1322                                gfx::PointF(),
1323                                gfx::Size(10, 10),
1324                                true,
1325                                false);
1326   SetLayerPropertiesForTesting(child.get(),
1327                                identity_matrix,
1328                                gfx::Point3F(),
1329                                gfx::PointF(30.f, 30.f),
1330                                gfx::Size(10, 10),
1331                                true,
1332                                false);
1333
1334   parent->AddChild(render_surface1);
1335   parent->SetMasksToBounds(true);
1336   render_surface1->AddChild(child);
1337   render_surface1->SetForceRenderSurface(true);
1338
1339   RenderSurfaceLayerList render_surface_layer_list;
1340   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
1341       parent.get(),
1342       parent->bounds(),
1343       gfx::Transform(),
1344       &render_surface_layer_list);
1345   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
1346
1347   // The child layer's content is entirely outside the parent's clip rect, so
1348   // the intermediate render surface should not be listed here, even if it was
1349   // forced to be created. Render surfaces without children or visible content
1350   // are unexpected at draw time (e.g. we might try to create a content texture
1351   // of size 0).
1352   ASSERT_TRUE(parent->render_surface());
1353   EXPECT_EQ(1U, render_surface_layer_list.size());
1354 }
1355
1356 TEST_F(LayerTreeHostCommonTest, RenderSurfaceListForTransparentChild) {
1357   scoped_refptr<Layer> parent = Layer::Create();
1358   scoped_refptr<Layer> render_surface1 = Layer::Create();
1359   scoped_refptr<LayerWithForcedDrawsContent> child =
1360       make_scoped_refptr(new LayerWithForcedDrawsContent());
1361
1362   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
1363   host->SetRootLayer(parent);
1364
1365   const gfx::Transform identity_matrix;
1366   SetLayerPropertiesForTesting(render_surface1.get(),
1367                                identity_matrix,
1368                                gfx::Point3F(),
1369                                gfx::PointF(),
1370                                gfx::Size(10, 10),
1371                                true,
1372                                false);
1373   SetLayerPropertiesForTesting(child.get(),
1374                                identity_matrix,
1375                                gfx::Point3F(),
1376                                gfx::PointF(),
1377                                gfx::Size(10, 10),
1378                                true,
1379                                false);
1380
1381   parent->AddChild(render_surface1);
1382   render_surface1->AddChild(child);
1383   render_surface1->SetForceRenderSurface(true);
1384   render_surface1->SetOpacity(0.f);
1385
1386   RenderSurfaceLayerList render_surface_layer_list;
1387   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
1388       parent.get(), parent->bounds(), &render_surface_layer_list);
1389   inputs.can_adjust_raster_scales = true;
1390   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
1391
1392   // Since the layer is transparent, render_surface1->render_surface() should
1393   // not have gotten added anywhere.  Also, the drawable content rect should not
1394   // have been extended by the children.
1395   ASSERT_TRUE(parent->render_surface());
1396   EXPECT_EQ(0U, parent->render_surface()->layer_list().size());
1397   EXPECT_EQ(1U, render_surface_layer_list.size());
1398   EXPECT_EQ(parent->id(), render_surface_layer_list.at(0)->id());
1399   EXPECT_EQ(gfx::Rect(), parent->drawable_content_rect());
1400 }
1401
1402 TEST_F(LayerTreeHostCommonTest, RenderSurfaceForBlendMode) {
1403   scoped_refptr<Layer> parent = Layer::Create();
1404   scoped_refptr<LayerWithForcedDrawsContent> child =
1405       make_scoped_refptr(new LayerWithForcedDrawsContent());
1406
1407   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
1408   host->SetRootLayer(parent);
1409
1410   const gfx::Transform identity_matrix;
1411   const SkXfermode::Mode blend_mode = SkXfermode::kMultiply_Mode;
1412   SetLayerPropertiesForTesting(child.get(), identity_matrix, gfx::Point3F(),
1413                                gfx::PointF(), gfx::Size(10, 10), true, false);
1414
1415   parent->AddChild(child);
1416   child->SetBlendMode(blend_mode);
1417
1418   RenderSurfaceLayerList render_surface_layer_list;
1419   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
1420       parent.get(), parent->bounds(), &render_surface_layer_list);
1421   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
1422
1423   // Since the child layer has a blend mode other than normal, it should get
1424   // its own render surface. Also, layer's draw_properties should contain the
1425   // default blend mode, since the render surface becomes responsible for
1426   // applying the blend mode.
1427   ASSERT_TRUE(child->render_surface());
1428   EXPECT_EQ(1U, child->render_surface()->layer_list().size());
1429   EXPECT_EQ(SkXfermode::kSrcOver_Mode, child->draw_properties().blend_mode);
1430 }
1431
1432 TEST_F(LayerTreeHostCommonTest, ForceRenderSurface) {
1433   scoped_refptr<Layer> parent = Layer::Create();
1434   scoped_refptr<Layer> render_surface1 = Layer::Create();
1435   scoped_refptr<LayerWithForcedDrawsContent> child =
1436       make_scoped_refptr(new LayerWithForcedDrawsContent());
1437   render_surface1->SetForceRenderSurface(true);
1438
1439   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
1440   host->SetRootLayer(parent);
1441
1442   const gfx::Transform identity_matrix;
1443   SetLayerPropertiesForTesting(parent.get(),
1444                                identity_matrix,
1445                                gfx::Point3F(),
1446                                gfx::PointF(),
1447                                gfx::Size(10, 10),
1448                                true,
1449                                false);
1450   SetLayerPropertiesForTesting(render_surface1.get(),
1451                                identity_matrix,
1452                                gfx::Point3F(),
1453                                gfx::PointF(),
1454                                gfx::Size(10, 10),
1455                                true,
1456                                false);
1457   SetLayerPropertiesForTesting(child.get(),
1458                                identity_matrix,
1459                                gfx::Point3F(),
1460                                gfx::PointF(),
1461                                gfx::Size(10, 10),
1462                                true,
1463                                false);
1464
1465   parent->AddChild(render_surface1);
1466   render_surface1->AddChild(child);
1467
1468   // Sanity check before the actual test
1469   EXPECT_FALSE(parent->render_surface());
1470   EXPECT_FALSE(render_surface1->render_surface());
1471
1472   {
1473     RenderSurfaceLayerList render_surface_layer_list;
1474     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
1475         parent.get(), parent->bounds(), &render_surface_layer_list);
1476     inputs.can_adjust_raster_scales = true;
1477     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
1478
1479     // The root layer always creates a render surface
1480     EXPECT_TRUE(parent->render_surface());
1481     EXPECT_TRUE(render_surface1->render_surface());
1482     EXPECT_EQ(2U, render_surface_layer_list.size());
1483   }
1484
1485   {
1486     RenderSurfaceLayerList render_surface_layer_list;
1487     render_surface1->SetForceRenderSurface(false);
1488     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
1489         parent.get(), parent->bounds(), &render_surface_layer_list);
1490     inputs.can_adjust_raster_scales = true;
1491     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
1492     EXPECT_TRUE(parent->render_surface());
1493     EXPECT_FALSE(render_surface1->render_surface());
1494     EXPECT_EQ(1U, render_surface_layer_list.size());
1495   }
1496 }
1497
1498 TEST_F(LayerTreeHostCommonTest, RenderSurfacesFlattenScreenSpaceTransform) {
1499   // Render surfaces act as a flattening point for their subtree, so should
1500   // always flatten the target-to-screen space transform seen by descendants.
1501
1502   scoped_refptr<Layer> root = Layer::Create();
1503   scoped_refptr<Layer> parent = Layer::Create();
1504   scoped_refptr<LayerWithForcedDrawsContent> child =
1505       make_scoped_refptr(new LayerWithForcedDrawsContent());
1506   scoped_refptr<LayerWithForcedDrawsContent> grand_child =
1507       make_scoped_refptr(new LayerWithForcedDrawsContent());
1508
1509   gfx::Transform rotation_about_y_axis;
1510   rotation_about_y_axis.RotateAboutYAxis(30.0);
1511   // Make |parent| have a render surface.
1512   parent->SetOpacity(0.9f);
1513
1514   const gfx::Transform identity_matrix;
1515   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
1516                                gfx::PointF(), gfx::Size(100, 100), true, false);
1517   SetLayerPropertiesForTesting(parent.get(), rotation_about_y_axis,
1518                                gfx::Point3F(), gfx::PointF(), gfx::Size(10, 10),
1519                                true, false);
1520   SetLayerPropertiesForTesting(child.get(), identity_matrix, gfx::Point3F(),
1521                                gfx::PointF(), gfx::Size(10, 10), true, false);
1522   SetLayerPropertiesForTesting(grand_child.get(), identity_matrix,
1523                                gfx::Point3F(), gfx::PointF(), gfx::Size(10, 10),
1524                                true, false);
1525
1526   root->AddChild(parent);
1527   parent->AddChild(child);
1528   child->AddChild(grand_child);
1529
1530   grand_child->SetShouldFlattenTransform(false);
1531
1532   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
1533   host->SetRootLayer(root);
1534
1535   // Only grand_child should preserve 3d.
1536   EXPECT_TRUE(root->should_flatten_transform());
1537   EXPECT_TRUE(parent->should_flatten_transform());
1538   EXPECT_TRUE(child->should_flatten_transform());
1539   EXPECT_FALSE(grand_child->should_flatten_transform());
1540
1541   gfx::Transform expected_child_draw_transform = identity_matrix;
1542   gfx::Transform expected_grand_child_draw_transform = identity_matrix;
1543
1544   gfx::Transform flattened_rotation_about_y = rotation_about_y_axis;
1545   flattened_rotation_about_y.FlattenTo2d();
1546
1547   ExecuteCalculateDrawProperties(root.get());
1548
1549   EXPECT_TRUE(parent->render_surface());
1550   EXPECT_FALSE(child->render_surface());
1551   EXPECT_FALSE(grand_child->render_surface());
1552
1553   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix, child->draw_transform());
1554   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
1555                                   grand_child->draw_transform());
1556
1557   // The screen-space transform inherited by |child| and |grand_child| should
1558   // have been flattened at their render target. In particular, the fact that
1559   // |grand_child| happens to preserve 3d shouldn't affect this flattening.
1560   EXPECT_TRANSFORMATION_MATRIX_EQ(flattened_rotation_about_y,
1561                                   child->screen_space_transform());
1562   EXPECT_TRANSFORMATION_MATRIX_EQ(flattened_rotation_about_y,
1563                                   grand_child->screen_space_transform());
1564 }
1565
1566 TEST_F(LayerTreeHostCommonTest, ClipRectCullsRenderSurfaces) {
1567   // The entire subtree of layers that are outside the clip rect should be
1568   // culled away, and should not affect the render_surface_layer_list.
1569   //
1570   // The test tree is set up as follows:
1571   //  - all layers except the leaf_nodes are forced to be a new render surface
1572   //  that have something to draw.
1573   //  - parent is a large container layer.
1574   //  - child has masksToBounds=true to cause clipping.
1575   //  - grand_child is positioned outside of the child's bounds
1576   //  - great_grand_child is also kept outside child's bounds.
1577   //
1578   // In this configuration, grand_child and great_grand_child are completely
1579   // outside the clip rect, and they should never get scheduled on the list of
1580   // render surfaces.
1581   //
1582
1583   const gfx::Transform identity_matrix;
1584   scoped_refptr<Layer> parent = Layer::Create();
1585   scoped_refptr<Layer> child = Layer::Create();
1586   scoped_refptr<Layer> grand_child = Layer::Create();
1587   scoped_refptr<Layer> great_grand_child = Layer::Create();
1588   scoped_refptr<LayerWithForcedDrawsContent> leaf_node1 =
1589       make_scoped_refptr(new LayerWithForcedDrawsContent());
1590   scoped_refptr<LayerWithForcedDrawsContent> leaf_node2 =
1591       make_scoped_refptr(new LayerWithForcedDrawsContent());
1592   parent->AddChild(child);
1593   child->AddChild(grand_child);
1594   grand_child->AddChild(great_grand_child);
1595
1596   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
1597   host->SetRootLayer(parent);
1598
1599   // leaf_node1 ensures that parent and child are kept on the
1600   // render_surface_layer_list, even though grand_child and great_grand_child
1601   // should be clipped.
1602   child->AddChild(leaf_node1);
1603   great_grand_child->AddChild(leaf_node2);
1604
1605   SetLayerPropertiesForTesting(parent.get(),
1606                                identity_matrix,
1607                                gfx::Point3F(),
1608                                gfx::PointF(),
1609                                gfx::Size(500, 500),
1610                                true,
1611                                false);
1612   SetLayerPropertiesForTesting(child.get(),
1613                                identity_matrix,
1614                                gfx::Point3F(),
1615                                gfx::PointF(),
1616                                gfx::Size(20, 20),
1617                                true,
1618                                false);
1619   SetLayerPropertiesForTesting(grand_child.get(),
1620                                identity_matrix,
1621                                gfx::Point3F(),
1622                                gfx::PointF(45.f, 45.f),
1623                                gfx::Size(10, 10),
1624                                true,
1625                                false);
1626   SetLayerPropertiesForTesting(great_grand_child.get(),
1627                                identity_matrix,
1628                                gfx::Point3F(),
1629                                gfx::PointF(),
1630                                gfx::Size(10, 10),
1631                                true,
1632                                false);
1633   SetLayerPropertiesForTesting(leaf_node1.get(),
1634                                identity_matrix,
1635                                gfx::Point3F(),
1636                                gfx::PointF(),
1637                                gfx::Size(500, 500),
1638                                true,
1639                                false);
1640   SetLayerPropertiesForTesting(leaf_node2.get(),
1641                                identity_matrix,
1642                                gfx::Point3F(),
1643                                gfx::PointF(),
1644                                gfx::Size(20, 20),
1645                                true,
1646                                false);
1647
1648   child->SetMasksToBounds(true);
1649   child->SetOpacity(0.4f);
1650   child->SetForceRenderSurface(true);
1651   grand_child->SetOpacity(0.5f);
1652   great_grand_child->SetOpacity(0.4f);
1653
1654   RenderSurfaceLayerList render_surface_layer_list;
1655   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
1656       parent.get(), parent->bounds(), &render_surface_layer_list);
1657   inputs.can_adjust_raster_scales = true;
1658   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
1659
1660   ASSERT_EQ(2U, render_surface_layer_list.size());
1661   EXPECT_EQ(parent->id(), render_surface_layer_list.at(0)->id());
1662   EXPECT_EQ(child->id(), render_surface_layer_list.at(1)->id());
1663 }
1664
1665 TEST_F(LayerTreeHostCommonTest, ClipRectCullsSurfaceWithoutVisibleContent) {
1666   // When a render surface has a clip rect, it is used to clip the content rect
1667   // of the surface. When the render surface is animating its transforms, then
1668   // the content rect's position in the clip rect is not defined on the main
1669   // thread, and its content rect should not be clipped.
1670
1671   // The test tree is set up as follows:
1672   //  - parent is a container layer that masksToBounds=true to cause clipping.
1673   //  - child is a render surface, which has a clip rect set to the bounds of
1674   //  the parent.
1675   //  - grand_child is a render surface, and the only visible content in child.
1676   //  It is positioned outside of the clip rect from parent.
1677
1678   // In this configuration, grand_child should be outside the clipped
1679   // content rect of the child, making grand_child not appear in the
1680   // render_surface_layer_list. However, when we place an animation on the
1681   // child, this clipping should be avoided and we should keep the grand_child
1682   // in the render_surface_layer_list.
1683
1684   const gfx::Transform identity_matrix;
1685   scoped_refptr<Layer> parent = Layer::Create();
1686   scoped_refptr<Layer> child = Layer::Create();
1687   scoped_refptr<Layer> grand_child = Layer::Create();
1688   scoped_refptr<LayerWithForcedDrawsContent> leaf_node =
1689       make_scoped_refptr(new LayerWithForcedDrawsContent());
1690   parent->AddChild(child);
1691   child->AddChild(grand_child);
1692   grand_child->AddChild(leaf_node);
1693
1694   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
1695   host->SetRootLayer(parent);
1696
1697   SetLayerPropertiesForTesting(parent.get(),
1698                                identity_matrix,
1699                                gfx::Point3F(),
1700                                gfx::PointF(),
1701                                gfx::Size(100, 100),
1702                                true,
1703                                false);
1704   SetLayerPropertiesForTesting(child.get(),
1705                                identity_matrix,
1706                                gfx::Point3F(),
1707                                gfx::PointF(),
1708                                gfx::Size(20, 20),
1709                                true,
1710                                false);
1711   SetLayerPropertiesForTesting(grand_child.get(),
1712                                identity_matrix,
1713                                gfx::Point3F(),
1714                                gfx::PointF(200.f, 200.f),
1715                                gfx::Size(10, 10),
1716                                true,
1717                                false);
1718   SetLayerPropertiesForTesting(leaf_node.get(),
1719                                identity_matrix,
1720                                gfx::Point3F(),
1721                                gfx::PointF(),
1722                                gfx::Size(10, 10),
1723                                true,
1724                                false);
1725
1726   parent->SetMasksToBounds(true);
1727   child->SetOpacity(0.4f);
1728   child->SetForceRenderSurface(true);
1729   grand_child->SetOpacity(0.4f);
1730   grand_child->SetForceRenderSurface(true);
1731
1732   {
1733     RenderSurfaceLayerList render_surface_layer_list;
1734     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
1735         parent.get(), parent->bounds(), &render_surface_layer_list);
1736     inputs.can_adjust_raster_scales = true;
1737     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
1738
1739     // Without an animation, we should cull child and grand_child from the
1740     // render_surface_layer_list.
1741     ASSERT_EQ(1U, render_surface_layer_list.size());
1742     EXPECT_EQ(parent->id(), render_surface_layer_list.at(0)->id());
1743   }
1744
1745   // Now put an animating transform on child.
1746   AddAnimatedTransformToController(
1747       child->layer_animation_controller(), 10.0, 30, 0);
1748
1749   {
1750     RenderSurfaceLayerList render_surface_layer_list;
1751     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
1752         parent.get(), parent->bounds(), &render_surface_layer_list);
1753     inputs.can_adjust_raster_scales = true;
1754     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
1755
1756     // With an animating transform, we should keep child and grand_child in the
1757     // render_surface_layer_list.
1758     ASSERT_EQ(3U, render_surface_layer_list.size());
1759     EXPECT_EQ(parent->id(), render_surface_layer_list.at(0)->id());
1760     EXPECT_EQ(child->id(), render_surface_layer_list.at(1)->id());
1761     EXPECT_EQ(grand_child->id(), render_surface_layer_list.at(2)->id());
1762   }
1763 }
1764
1765 TEST_F(LayerTreeHostCommonTest, IsClippedIsSetCorrectly) {
1766   // Layer's IsClipped() property is set to true when:
1767   //  - the layer clips its subtree, e.g. masks to bounds,
1768   //  - the layer is clipped by an ancestor that contributes to the same
1769   //    render target,
1770   //  - a surface is clipped by an ancestor that contributes to the same
1771   //    render target.
1772   //
1773   // In particular, for a layer that owns a render surface:
1774   //  - the render surface inherits any clip from ancestors, and does NOT
1775   //    pass that clipped status to the layer itself.
1776   //  - but if the layer itself masks to bounds, it is considered clipped
1777   //    and propagates the clip to the subtree.
1778
1779   const gfx::Transform identity_matrix;
1780   scoped_refptr<Layer> root = Layer::Create();
1781   scoped_refptr<Layer> parent = Layer::Create();
1782   scoped_refptr<Layer> child1 = Layer::Create();
1783   scoped_refptr<Layer> child2 = Layer::Create();
1784   scoped_refptr<Layer> grand_child = Layer::Create();
1785   scoped_refptr<LayerWithForcedDrawsContent> leaf_node1 =
1786       make_scoped_refptr(new LayerWithForcedDrawsContent());
1787   scoped_refptr<LayerWithForcedDrawsContent> leaf_node2 =
1788       make_scoped_refptr(new LayerWithForcedDrawsContent());
1789   root->AddChild(parent);
1790   parent->AddChild(child1);
1791   parent->AddChild(child2);
1792   child1->AddChild(grand_child);
1793   child2->AddChild(leaf_node2);
1794   grand_child->AddChild(leaf_node1);
1795
1796   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
1797   host->SetRootLayer(root);
1798
1799   child2->SetForceRenderSurface(true);
1800
1801   SetLayerPropertiesForTesting(root.get(),
1802                                identity_matrix,
1803                                gfx::Point3F(),
1804                                gfx::PointF(),
1805                                gfx::Size(100, 100),
1806                                true,
1807                                false);
1808   SetLayerPropertiesForTesting(parent.get(),
1809                                identity_matrix,
1810                                gfx::Point3F(),
1811                                gfx::PointF(),
1812                                gfx::Size(100, 100),
1813                                true,
1814                                false);
1815   SetLayerPropertiesForTesting(child1.get(),
1816                                identity_matrix,
1817                                gfx::Point3F(),
1818                                gfx::PointF(),
1819                                gfx::Size(100, 100),
1820                                true,
1821                                false);
1822   SetLayerPropertiesForTesting(child2.get(),
1823                                identity_matrix,
1824                                gfx::Point3F(),
1825                                gfx::PointF(),
1826                                gfx::Size(100, 100),
1827                                true,
1828                                false);
1829   SetLayerPropertiesForTesting(grand_child.get(),
1830                                identity_matrix,
1831                                gfx::Point3F(),
1832                                gfx::PointF(),
1833                                gfx::Size(100, 100),
1834                                true,
1835                                false);
1836   SetLayerPropertiesForTesting(leaf_node1.get(),
1837                                identity_matrix,
1838                                gfx::Point3F(),
1839                                gfx::PointF(),
1840                                gfx::Size(100, 100),
1841                                true,
1842                                false);
1843   SetLayerPropertiesForTesting(leaf_node2.get(),
1844                                identity_matrix,
1845                                gfx::Point3F(),
1846                                gfx::PointF(),
1847                                gfx::Size(100, 100),
1848                                true,
1849                                false);
1850
1851   // Case 1: nothing is clipped except the root render surface.
1852   {
1853     RenderSurfaceLayerList render_surface_layer_list;
1854     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
1855         root.get(), parent->bounds(), &render_surface_layer_list);
1856     inputs.can_adjust_raster_scales = true;
1857     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
1858
1859     ASSERT_TRUE(root->render_surface());
1860     ASSERT_TRUE(child2->render_surface());
1861
1862     EXPECT_FALSE(root->is_clipped());
1863     EXPECT_TRUE(root->render_surface()->is_clipped());
1864     EXPECT_FALSE(parent->is_clipped());
1865     EXPECT_FALSE(child1->is_clipped());
1866     EXPECT_FALSE(child2->is_clipped());
1867     EXPECT_FALSE(child2->render_surface()->is_clipped());
1868     EXPECT_FALSE(grand_child->is_clipped());
1869     EXPECT_FALSE(leaf_node1->is_clipped());
1870     EXPECT_FALSE(leaf_node2->is_clipped());
1871   }
1872
1873   // Case 2: parent masksToBounds, so the parent, child1, and child2's
1874   // surface are clipped. But layers that contribute to child2's surface are
1875   // not clipped explicitly because child2's surface already accounts for
1876   // that clip.
1877   {
1878     RenderSurfaceLayerList render_surface_layer_list;
1879     parent->SetMasksToBounds(true);
1880     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
1881         root.get(), parent->bounds(), &render_surface_layer_list);
1882     inputs.can_adjust_raster_scales = true;
1883     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
1884
1885     ASSERT_TRUE(root->render_surface());
1886     ASSERT_TRUE(child2->render_surface());
1887
1888     EXPECT_FALSE(root->is_clipped());
1889     EXPECT_TRUE(root->render_surface()->is_clipped());
1890     EXPECT_TRUE(parent->is_clipped());
1891     EXPECT_TRUE(child1->is_clipped());
1892     EXPECT_FALSE(child2->is_clipped());
1893     EXPECT_TRUE(child2->render_surface()->is_clipped());
1894     EXPECT_TRUE(grand_child->is_clipped());
1895     EXPECT_TRUE(leaf_node1->is_clipped());
1896     EXPECT_FALSE(leaf_node2->is_clipped());
1897   }
1898
1899   // Case 3: child2 masksToBounds. The layer and subtree are clipped, and
1900   // child2's render surface is not clipped.
1901   {
1902     RenderSurfaceLayerList render_surface_layer_list;
1903     parent->SetMasksToBounds(false);
1904     child2->SetMasksToBounds(true);
1905     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
1906         root.get(), parent->bounds(), &render_surface_layer_list);
1907     inputs.can_adjust_raster_scales = true;
1908     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
1909
1910     ASSERT_TRUE(root->render_surface());
1911     ASSERT_TRUE(child2->render_surface());
1912
1913     EXPECT_FALSE(root->is_clipped());
1914     EXPECT_TRUE(root->render_surface()->is_clipped());
1915     EXPECT_FALSE(parent->is_clipped());
1916     EXPECT_FALSE(child1->is_clipped());
1917     EXPECT_TRUE(child2->is_clipped());
1918     EXPECT_FALSE(child2->render_surface()->is_clipped());
1919     EXPECT_FALSE(grand_child->is_clipped());
1920     EXPECT_FALSE(leaf_node1->is_clipped());
1921     EXPECT_TRUE(leaf_node2->is_clipped());
1922   }
1923 }
1924
1925 TEST_F(LayerTreeHostCommonTest, DrawableContentRectForLayers) {
1926   // Verify that layers get the appropriate DrawableContentRect when their
1927   // parent masksToBounds is true.
1928   //
1929   //   grand_child1 - completely inside the region; DrawableContentRect should
1930   //   be the layer rect expressed in target space.
1931   //   grand_child2 - partially clipped but NOT masksToBounds; the clip rect
1932   //   will be the intersection of layer bounds and the mask region.
1933   //   grand_child3 - partially clipped and masksToBounds; the
1934   //   DrawableContentRect will still be the intersection of layer bounds and
1935   //   the mask region.
1936   //   grand_child4 - outside parent's clip rect; the DrawableContentRect should
1937   //   be empty.
1938   //
1939
1940   const gfx::Transform identity_matrix;
1941   scoped_refptr<Layer> parent = Layer::Create();
1942   scoped_refptr<Layer> child = Layer::Create();
1943   scoped_refptr<Layer> grand_child1 = Layer::Create();
1944   scoped_refptr<Layer> grand_child2 = Layer::Create();
1945   scoped_refptr<Layer> grand_child3 = Layer::Create();
1946   scoped_refptr<Layer> grand_child4 = Layer::Create();
1947
1948   parent->AddChild(child);
1949   child->AddChild(grand_child1);
1950   child->AddChild(grand_child2);
1951   child->AddChild(grand_child3);
1952   child->AddChild(grand_child4);
1953
1954   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
1955   host->SetRootLayer(parent);
1956
1957   SetLayerPropertiesForTesting(parent.get(),
1958                                identity_matrix,
1959                                gfx::Point3F(),
1960                                gfx::PointF(),
1961                                gfx::Size(500, 500),
1962                                true,
1963                                false);
1964   SetLayerPropertiesForTesting(child.get(),
1965                                identity_matrix,
1966                                gfx::Point3F(),
1967                                gfx::PointF(),
1968                                gfx::Size(20, 20),
1969                                true,
1970                                false);
1971   SetLayerPropertiesForTesting(grand_child1.get(),
1972                                identity_matrix,
1973                                gfx::Point3F(),
1974                                gfx::PointF(5.f, 5.f),
1975                                gfx::Size(10, 10),
1976                                true,
1977                                false);
1978   SetLayerPropertiesForTesting(grand_child2.get(),
1979                                identity_matrix,
1980                                gfx::Point3F(),
1981                                gfx::PointF(15.f, 15.f),
1982                                gfx::Size(10, 10),
1983                                true,
1984                                false);
1985   SetLayerPropertiesForTesting(grand_child3.get(),
1986                                identity_matrix,
1987                                gfx::Point3F(),
1988                                gfx::PointF(15.f, 15.f),
1989                                gfx::Size(10, 10),
1990                                true,
1991                                false);
1992   SetLayerPropertiesForTesting(grand_child4.get(),
1993                                identity_matrix,
1994                                gfx::Point3F(),
1995                                gfx::PointF(45.f, 45.f),
1996                                gfx::Size(10, 10),
1997                                true,
1998                                false);
1999
2000   child->SetMasksToBounds(true);
2001   grand_child3->SetMasksToBounds(true);
2002
2003   // Force everyone to be a render surface.
2004   child->SetOpacity(0.4f);
2005   grand_child1->SetOpacity(0.5f);
2006   grand_child2->SetOpacity(0.5f);
2007   grand_child3->SetOpacity(0.5f);
2008   grand_child4->SetOpacity(0.5f);
2009
2010   RenderSurfaceLayerList render_surface_layer_list;
2011   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
2012       parent.get(), parent->bounds(), &render_surface_layer_list);
2013   inputs.can_adjust_raster_scales = true;
2014   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
2015
2016   EXPECT_EQ(gfx::Rect(5, 5, 10, 10), grand_child1->drawable_content_rect());
2017   EXPECT_EQ(gfx::Rect(15, 15, 5, 5), grand_child3->drawable_content_rect());
2018   EXPECT_EQ(gfx::Rect(15, 15, 5, 5), grand_child3->drawable_content_rect());
2019   EXPECT_TRUE(grand_child4->drawable_content_rect().IsEmpty());
2020 }
2021
2022 TEST_F(LayerTreeHostCommonTest, ClipRectIsPropagatedCorrectlyToSurfaces) {
2023   // Verify that render surfaces (and their layers) get the appropriate
2024   // clip rects when their parent masksToBounds is true.
2025   //
2026   // Layers that own render surfaces (at least for now) do not inherit any
2027   // clipping; instead the surface will enforce the clip for the entire subtree.
2028   // They may still have a clip rect of their own layer bounds, however, if
2029   // masksToBounds was true.
2030   const gfx::Transform identity_matrix;
2031   scoped_refptr<Layer> parent = Layer::Create();
2032   scoped_refptr<Layer> child = Layer::Create();
2033   scoped_refptr<Layer> grand_child1 = Layer::Create();
2034   scoped_refptr<Layer> grand_child2 = Layer::Create();
2035   scoped_refptr<Layer> grand_child3 = Layer::Create();
2036   scoped_refptr<Layer> grand_child4 = Layer::Create();
2037   scoped_refptr<LayerWithForcedDrawsContent> leaf_node1 =
2038       make_scoped_refptr(new LayerWithForcedDrawsContent());
2039   scoped_refptr<LayerWithForcedDrawsContent> leaf_node2 =
2040       make_scoped_refptr(new LayerWithForcedDrawsContent());
2041   scoped_refptr<LayerWithForcedDrawsContent> leaf_node3 =
2042       make_scoped_refptr(new LayerWithForcedDrawsContent());
2043   scoped_refptr<LayerWithForcedDrawsContent> leaf_node4 =
2044       make_scoped_refptr(new LayerWithForcedDrawsContent());
2045
2046   parent->AddChild(child);
2047   child->AddChild(grand_child1);
2048   child->AddChild(grand_child2);
2049   child->AddChild(grand_child3);
2050   child->AddChild(grand_child4);
2051
2052   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
2053   host->SetRootLayer(parent);
2054
2055   // the leaf nodes ensure that these grand_children become render surfaces for
2056   // this test.
2057   grand_child1->AddChild(leaf_node1);
2058   grand_child2->AddChild(leaf_node2);
2059   grand_child3->AddChild(leaf_node3);
2060   grand_child4->AddChild(leaf_node4);
2061
2062   SetLayerPropertiesForTesting(parent.get(),
2063                                identity_matrix,
2064                                gfx::Point3F(),
2065                                gfx::PointF(),
2066                                gfx::Size(500, 500),
2067                                true,
2068                                false);
2069   SetLayerPropertiesForTesting(child.get(),
2070                                identity_matrix,
2071                                gfx::Point3F(),
2072                                gfx::PointF(),
2073                                gfx::Size(20, 20),
2074                                true,
2075                                false);
2076   SetLayerPropertiesForTesting(grand_child1.get(),
2077                                identity_matrix,
2078                                gfx::Point3F(),
2079                                gfx::PointF(5.f, 5.f),
2080                                gfx::Size(10, 10),
2081                                true,
2082                                false);
2083   SetLayerPropertiesForTesting(grand_child2.get(),
2084                                identity_matrix,
2085                                gfx::Point3F(),
2086                                gfx::PointF(15.f, 15.f),
2087                                gfx::Size(10, 10),
2088                                true,
2089                                false);
2090   SetLayerPropertiesForTesting(grand_child3.get(),
2091                                identity_matrix,
2092                                gfx::Point3F(),
2093                                gfx::PointF(15.f, 15.f),
2094                                gfx::Size(10, 10),
2095                                true,
2096                                false);
2097   SetLayerPropertiesForTesting(grand_child4.get(),
2098                                identity_matrix,
2099                                gfx::Point3F(),
2100                                gfx::PointF(45.f, 45.f),
2101                                gfx::Size(10, 10),
2102                                true,
2103                                false);
2104   SetLayerPropertiesForTesting(leaf_node1.get(),
2105                                identity_matrix,
2106                                gfx::Point3F(),
2107                                gfx::PointF(),
2108                                gfx::Size(10, 10),
2109                                true,
2110                                false);
2111   SetLayerPropertiesForTesting(leaf_node2.get(),
2112                                identity_matrix,
2113                                gfx::Point3F(),
2114                                gfx::PointF(),
2115                                gfx::Size(10, 10),
2116                                true,
2117                                false);
2118   SetLayerPropertiesForTesting(leaf_node3.get(),
2119                                identity_matrix,
2120                                gfx::Point3F(),
2121                                gfx::PointF(),
2122                                gfx::Size(10, 10),
2123                                true,
2124                                false);
2125   SetLayerPropertiesForTesting(leaf_node4.get(),
2126                                identity_matrix,
2127                                gfx::Point3F(),
2128                                gfx::PointF(),
2129                                gfx::Size(10, 10),
2130                                true,
2131                                false);
2132
2133   child->SetMasksToBounds(true);
2134   grand_child3->SetMasksToBounds(true);
2135   grand_child4->SetMasksToBounds(true);
2136
2137   // Force everyone to be a render surface.
2138   child->SetOpacity(0.4f);
2139   child->SetForceRenderSurface(true);
2140   grand_child1->SetOpacity(0.5f);
2141   grand_child1->SetForceRenderSurface(true);
2142   grand_child2->SetOpacity(0.5f);
2143   grand_child2->SetForceRenderSurface(true);
2144   grand_child3->SetOpacity(0.5f);
2145   grand_child3->SetForceRenderSurface(true);
2146   grand_child4->SetOpacity(0.5f);
2147   grand_child4->SetForceRenderSurface(true);
2148
2149   RenderSurfaceLayerList render_surface_layer_list;
2150   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
2151       parent.get(), parent->bounds(), &render_surface_layer_list);
2152   inputs.can_adjust_raster_scales = true;
2153   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
2154   ASSERT_TRUE(grand_child1->render_surface());
2155   ASSERT_TRUE(grand_child2->render_surface());
2156   ASSERT_TRUE(grand_child3->render_surface());
2157
2158   // Surfaces are clipped by their parent, but un-affected by the owning layer's
2159   // masksToBounds.
2160   EXPECT_EQ(gfx::Rect(0, 0, 20, 20),
2161             grand_child1->render_surface()->clip_rect());
2162   EXPECT_EQ(gfx::Rect(0, 0, 20, 20),
2163             grand_child2->render_surface()->clip_rect());
2164   EXPECT_EQ(gfx::Rect(0, 0, 20, 20),
2165             grand_child3->render_surface()->clip_rect());
2166 }
2167
2168 TEST_F(LayerTreeHostCommonTest, AnimationsForRenderSurfaceHierarchy) {
2169   scoped_refptr<Layer> parent = Layer::Create();
2170   scoped_refptr<Layer> render_surface1 = Layer::Create();
2171   scoped_refptr<Layer> render_surface2 = Layer::Create();
2172   scoped_refptr<Layer> child_of_root = Layer::Create();
2173   scoped_refptr<Layer> child_of_rs1 = Layer::Create();
2174   scoped_refptr<Layer> child_of_rs2 = Layer::Create();
2175   scoped_refptr<Layer> grand_child_of_root = Layer::Create();
2176   scoped_refptr<LayerWithForcedDrawsContent> grand_child_of_rs1 =
2177       make_scoped_refptr(new LayerWithForcedDrawsContent());
2178   scoped_refptr<LayerWithForcedDrawsContent> grand_child_of_rs2 =
2179       make_scoped_refptr(new LayerWithForcedDrawsContent());
2180   parent->AddChild(render_surface1);
2181   parent->AddChild(child_of_root);
2182   render_surface1->AddChild(child_of_rs1);
2183   render_surface1->AddChild(render_surface2);
2184   render_surface2->AddChild(child_of_rs2);
2185   child_of_root->AddChild(grand_child_of_root);
2186   child_of_rs1->AddChild(grand_child_of_rs1);
2187   child_of_rs2->AddChild(grand_child_of_rs2);
2188
2189   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
2190   host->SetRootLayer(parent);
2191
2192   // Make our render surfaces.
2193   render_surface1->SetForceRenderSurface(true);
2194   render_surface2->SetForceRenderSurface(true);
2195
2196   gfx::Transform layer_transform;
2197   layer_transform.Translate(1.0, 1.0);
2198
2199   SetLayerPropertiesForTesting(parent.get(),
2200                                layer_transform,
2201                                gfx::Point3F(0.25f, 0.f, 0.f),
2202                                gfx::PointF(2.5f, 0.f),
2203                                gfx::Size(10, 10),
2204                                true,
2205                                false);
2206   SetLayerPropertiesForTesting(render_surface1.get(),
2207                                layer_transform,
2208                                gfx::Point3F(0.25f, 0.f, 0.f),
2209                                gfx::PointF(2.5f, 0.f),
2210                                gfx::Size(10, 10),
2211                                true,
2212                                false);
2213   SetLayerPropertiesForTesting(render_surface2.get(),
2214                                layer_transform,
2215                                gfx::Point3F(0.25f, 0.f, 0.f),
2216                                gfx::PointF(2.5f, 0.f),
2217                                gfx::Size(10, 10),
2218                                true,
2219                                false);
2220   SetLayerPropertiesForTesting(child_of_root.get(),
2221                                layer_transform,
2222                                gfx::Point3F(0.25f, 0.f, 0.f),
2223                                gfx::PointF(2.5f, 0.f),
2224                                gfx::Size(10, 10),
2225                                true,
2226                                false);
2227   SetLayerPropertiesForTesting(child_of_rs1.get(),
2228                                layer_transform,
2229                                gfx::Point3F(0.25f, 0.f, 0.f),
2230                                gfx::PointF(2.5f, 0.f),
2231                                gfx::Size(10, 10),
2232                                true,
2233                                false);
2234   SetLayerPropertiesForTesting(child_of_rs2.get(),
2235                                layer_transform,
2236                                gfx::Point3F(0.25f, 0.f, 0.f),
2237                                gfx::PointF(2.5f, 0.f),
2238                                gfx::Size(10, 10),
2239                                true,
2240                                false);
2241   SetLayerPropertiesForTesting(grand_child_of_root.get(),
2242                                layer_transform,
2243                                gfx::Point3F(0.25f, 0.f, 0.f),
2244                                gfx::PointF(2.5f, 0.f),
2245                                gfx::Size(10, 10),
2246                                true,
2247                                false);
2248   SetLayerPropertiesForTesting(grand_child_of_rs1.get(),
2249                                layer_transform,
2250                                gfx::Point3F(0.25f, 0.f, 0.f),
2251                                gfx::PointF(2.5f, 0.f),
2252                                gfx::Size(10, 10),
2253                                true,
2254                                false);
2255   SetLayerPropertiesForTesting(grand_child_of_rs2.get(),
2256                                layer_transform,
2257                                gfx::Point3F(0.25f, 0.f, 0.f),
2258                                gfx::PointF(2.5f, 0.f),
2259                                gfx::Size(10, 10),
2260                                true,
2261                                false);
2262
2263   // Put an animated opacity on the render surface.
2264   AddOpacityTransitionToController(
2265       render_surface1->layer_animation_controller(), 10.0, 1.f, 0.f, false);
2266
2267   // Also put an animated opacity on a layer without descendants.
2268   AddOpacityTransitionToController(
2269       grand_child_of_root->layer_animation_controller(), 10.0, 1.f, 0.f, false);
2270
2271   // Put a transform animation on the render surface.
2272   AddAnimatedTransformToController(
2273       render_surface2->layer_animation_controller(), 10.0, 30, 0);
2274
2275   // Also put transform animations on grand_child_of_root, and
2276   // grand_child_of_rs2
2277   AddAnimatedTransformToController(
2278       grand_child_of_root->layer_animation_controller(), 10.0, 30, 0);
2279   AddAnimatedTransformToController(
2280       grand_child_of_rs2->layer_animation_controller(), 10.0, 30, 0);
2281
2282   ExecuteCalculateDrawProperties(parent.get());
2283
2284   // Only layers that are associated with render surfaces should have an actual
2285   // RenderSurface() value.
2286   ASSERT_TRUE(parent->render_surface());
2287   ASSERT_FALSE(child_of_root->render_surface());
2288   ASSERT_FALSE(grand_child_of_root->render_surface());
2289
2290   ASSERT_TRUE(render_surface1->render_surface());
2291   ASSERT_FALSE(child_of_rs1->render_surface());
2292   ASSERT_FALSE(grand_child_of_rs1->render_surface());
2293
2294   ASSERT_TRUE(render_surface2->render_surface());
2295   ASSERT_FALSE(child_of_rs2->render_surface());
2296   ASSERT_FALSE(grand_child_of_rs2->render_surface());
2297
2298   // Verify all render target accessors
2299   EXPECT_EQ(parent.get(), parent->render_target());
2300   EXPECT_EQ(parent.get(), child_of_root->render_target());
2301   EXPECT_EQ(parent.get(), grand_child_of_root->render_target());
2302
2303   EXPECT_EQ(render_surface1.get(), render_surface1->render_target());
2304   EXPECT_EQ(render_surface1.get(), child_of_rs1->render_target());
2305   EXPECT_EQ(render_surface1.get(), grand_child_of_rs1->render_target());
2306
2307   EXPECT_EQ(render_surface2.get(), render_surface2->render_target());
2308   EXPECT_EQ(render_surface2.get(), child_of_rs2->render_target());
2309   EXPECT_EQ(render_surface2.get(), grand_child_of_rs2->render_target());
2310
2311   // Verify draw_opacity_is_animating values
2312   EXPECT_FALSE(parent->draw_opacity_is_animating());
2313   EXPECT_FALSE(child_of_root->draw_opacity_is_animating());
2314   EXPECT_TRUE(grand_child_of_root->draw_opacity_is_animating());
2315   EXPECT_FALSE(render_surface1->draw_opacity_is_animating());
2316   EXPECT_TRUE(render_surface1->render_surface()->draw_opacity_is_animating());
2317   EXPECT_FALSE(child_of_rs1->draw_opacity_is_animating());
2318   EXPECT_FALSE(grand_child_of_rs1->draw_opacity_is_animating());
2319   EXPECT_FALSE(render_surface2->draw_opacity_is_animating());
2320   EXPECT_FALSE(render_surface2->render_surface()->draw_opacity_is_animating());
2321   EXPECT_FALSE(child_of_rs2->draw_opacity_is_animating());
2322   EXPECT_FALSE(grand_child_of_rs2->draw_opacity_is_animating());
2323
2324   // Verify draw_transform_is_animating values
2325   EXPECT_FALSE(parent->draw_transform_is_animating());
2326   EXPECT_FALSE(child_of_root->draw_transform_is_animating());
2327   EXPECT_TRUE(grand_child_of_root->draw_transform_is_animating());
2328   EXPECT_FALSE(render_surface1->draw_transform_is_animating());
2329   EXPECT_FALSE(render_surface1->render_surface()
2330                    ->target_surface_transforms_are_animating());
2331   EXPECT_FALSE(child_of_rs1->draw_transform_is_animating());
2332   EXPECT_FALSE(grand_child_of_rs1->draw_transform_is_animating());
2333   EXPECT_FALSE(render_surface2->draw_transform_is_animating());
2334   EXPECT_TRUE(render_surface2->render_surface()
2335                   ->target_surface_transforms_are_animating());
2336   EXPECT_FALSE(child_of_rs2->draw_transform_is_animating());
2337   EXPECT_TRUE(grand_child_of_rs2->draw_transform_is_animating());
2338
2339   // Verify screen_space_transform_is_animating values
2340   EXPECT_FALSE(parent->screen_space_transform_is_animating());
2341   EXPECT_FALSE(child_of_root->screen_space_transform_is_animating());
2342   EXPECT_TRUE(grand_child_of_root->screen_space_transform_is_animating());
2343   EXPECT_FALSE(render_surface1->screen_space_transform_is_animating());
2344   EXPECT_FALSE(render_surface1->render_surface()
2345                    ->screen_space_transforms_are_animating());
2346   EXPECT_FALSE(child_of_rs1->screen_space_transform_is_animating());
2347   EXPECT_FALSE(grand_child_of_rs1->screen_space_transform_is_animating());
2348   EXPECT_TRUE(render_surface2->screen_space_transform_is_animating());
2349   EXPECT_TRUE(render_surface2->render_surface()
2350                   ->screen_space_transforms_are_animating());
2351   EXPECT_TRUE(child_of_rs2->screen_space_transform_is_animating());
2352   EXPECT_TRUE(grand_child_of_rs2->screen_space_transform_is_animating());
2353
2354   // Sanity check. If these fail there is probably a bug in the test itself.
2355   // It is expected that we correctly set up transforms so that the y-component
2356   // of the screen-space transform encodes the "depth" of the layer in the tree.
2357   EXPECT_FLOAT_EQ(1.0, parent->screen_space_transform().matrix().get(1, 3));
2358   EXPECT_FLOAT_EQ(2.0,
2359                   child_of_root->screen_space_transform().matrix().get(1, 3));
2360   EXPECT_FLOAT_EQ(
2361       3.0, grand_child_of_root->screen_space_transform().matrix().get(1, 3));
2362
2363   EXPECT_FLOAT_EQ(2.0,
2364                   render_surface1->screen_space_transform().matrix().get(1, 3));
2365   EXPECT_FLOAT_EQ(3.0,
2366                   child_of_rs1->screen_space_transform().matrix().get(1, 3));
2367   EXPECT_FLOAT_EQ(
2368       4.0, grand_child_of_rs1->screen_space_transform().matrix().get(1, 3));
2369
2370   EXPECT_FLOAT_EQ(3.0,
2371                   render_surface2->screen_space_transform().matrix().get(1, 3));
2372   EXPECT_FLOAT_EQ(4.0,
2373                   child_of_rs2->screen_space_transform().matrix().get(1, 3));
2374   EXPECT_FLOAT_EQ(
2375       5.0, grand_child_of_rs2->screen_space_transform().matrix().get(1, 3));
2376 }
2377
2378 TEST_F(LayerTreeHostCommonTest, VisibleRectForIdentityTransform) {
2379   // Test the calculateVisibleRect() function works correctly for identity
2380   // transforms.
2381
2382   gfx::Rect target_surface_rect = gfx::Rect(0, 0, 100, 100);
2383   gfx::Transform layer_to_surface_transform;
2384
2385   // Case 1: Layer is contained within the surface.
2386   gfx::Rect layer_content_rect = gfx::Rect(10, 10, 30, 30);
2387   gfx::Rect expected = gfx::Rect(10, 10, 30, 30);
2388   gfx::Rect actual = LayerTreeHostCommon::CalculateVisibleRect(
2389       target_surface_rect, layer_content_rect, layer_to_surface_transform);
2390   EXPECT_EQ(expected, actual);
2391
2392   // Case 2: Layer is outside the surface rect.
2393   layer_content_rect = gfx::Rect(120, 120, 30, 30);
2394   actual = LayerTreeHostCommon::CalculateVisibleRect(
2395       target_surface_rect, layer_content_rect, layer_to_surface_transform);
2396   EXPECT_TRUE(actual.IsEmpty());
2397
2398   // Case 3: Layer is partially overlapping the surface rect.
2399   layer_content_rect = gfx::Rect(80, 80, 30, 30);
2400   expected = gfx::Rect(80, 80, 20, 20);
2401   actual = LayerTreeHostCommon::CalculateVisibleRect(
2402       target_surface_rect, layer_content_rect, layer_to_surface_transform);
2403   EXPECT_EQ(expected, actual);
2404 }
2405
2406 TEST_F(LayerTreeHostCommonTest, VisibleRectForTranslations) {
2407   // Test the calculateVisibleRect() function works correctly for scaling
2408   // transforms.
2409
2410   gfx::Rect target_surface_rect = gfx::Rect(0, 0, 100, 100);
2411   gfx::Rect layer_content_rect = gfx::Rect(0, 0, 30, 30);
2412   gfx::Transform layer_to_surface_transform;
2413
2414   // Case 1: Layer is contained within the surface.
2415   layer_to_surface_transform.MakeIdentity();
2416   layer_to_surface_transform.Translate(10.0, 10.0);
2417   gfx::Rect expected = gfx::Rect(0, 0, 30, 30);
2418   gfx::Rect actual = LayerTreeHostCommon::CalculateVisibleRect(
2419       target_surface_rect, layer_content_rect, layer_to_surface_transform);
2420   EXPECT_EQ(expected, actual);
2421
2422   // Case 2: Layer is outside the surface rect.
2423   layer_to_surface_transform.MakeIdentity();
2424   layer_to_surface_transform.Translate(120.0, 120.0);
2425   actual = LayerTreeHostCommon::CalculateVisibleRect(
2426       target_surface_rect, layer_content_rect, layer_to_surface_transform);
2427   EXPECT_TRUE(actual.IsEmpty());
2428
2429   // Case 3: Layer is partially overlapping the surface rect.
2430   layer_to_surface_transform.MakeIdentity();
2431   layer_to_surface_transform.Translate(80.0, 80.0);
2432   expected = gfx::Rect(0, 0, 20, 20);
2433   actual = LayerTreeHostCommon::CalculateVisibleRect(
2434       target_surface_rect, layer_content_rect, layer_to_surface_transform);
2435   EXPECT_EQ(expected, actual);
2436 }
2437
2438 TEST_F(LayerTreeHostCommonTest, VisibleRectFor2DRotations) {
2439   // Test the calculateVisibleRect() function works correctly for rotations
2440   // about z-axis (i.e. 2D rotations).  Remember that calculateVisibleRect()
2441   // should return the g in the layer's space.
2442
2443   gfx::Rect target_surface_rect = gfx::Rect(0, 0, 100, 100);
2444   gfx::Rect layer_content_rect = gfx::Rect(0, 0, 30, 30);
2445   gfx::Transform layer_to_surface_transform;
2446
2447   // Case 1: Layer is contained within the surface.
2448   layer_to_surface_transform.MakeIdentity();
2449   layer_to_surface_transform.Translate(50.0, 50.0);
2450   layer_to_surface_transform.Rotate(45.0);
2451   gfx::Rect expected = gfx::Rect(0, 0, 30, 30);
2452   gfx::Rect actual = LayerTreeHostCommon::CalculateVisibleRect(
2453       target_surface_rect, layer_content_rect, layer_to_surface_transform);
2454   EXPECT_EQ(expected, actual);
2455
2456   // Case 2: Layer is outside the surface rect.
2457   layer_to_surface_transform.MakeIdentity();
2458   layer_to_surface_transform.Translate(-50.0, 0.0);
2459   layer_to_surface_transform.Rotate(45.0);
2460   actual = LayerTreeHostCommon::CalculateVisibleRect(
2461       target_surface_rect, layer_content_rect, layer_to_surface_transform);
2462   EXPECT_TRUE(actual.IsEmpty());
2463
2464   // Case 3: The layer is rotated about its top-left corner. In surface space,
2465   // the layer is oriented diagonally, with the left half outside of the render
2466   // surface. In this case, the g should still be the entire layer
2467   // (remember the g is computed in layer space); both the top-left
2468   // and bottom-right corners of the layer are still visible.
2469   layer_to_surface_transform.MakeIdentity();
2470   layer_to_surface_transform.Rotate(45.0);
2471   expected = gfx::Rect(0, 0, 30, 30);
2472   actual = LayerTreeHostCommon::CalculateVisibleRect(
2473       target_surface_rect, layer_content_rect, layer_to_surface_transform);
2474   EXPECT_EQ(expected, actual);
2475
2476   // Case 4: The layer is rotated about its top-left corner, and translated
2477   // upwards. In surface space, the layer is oriented diagonally, with only the
2478   // top corner of the surface overlapping the layer. In layer space, the render
2479   // surface overlaps the right side of the layer. The g should be
2480   // the layer's right half.
2481   layer_to_surface_transform.MakeIdentity();
2482   layer_to_surface_transform.Translate(0.0, -sqrt(2.0) * 15.0);
2483   layer_to_surface_transform.Rotate(45.0);
2484   expected = gfx::Rect(15, 0, 15, 30);  // Right half of layer bounds.
2485   actual = LayerTreeHostCommon::CalculateVisibleRect(
2486       target_surface_rect, layer_content_rect, layer_to_surface_transform);
2487   EXPECT_EQ(expected, actual);
2488 }
2489
2490 TEST_F(LayerTreeHostCommonTest, VisibleRectFor3dOrthographicTransform) {
2491   // Test that the calculateVisibleRect() function works correctly for 3d
2492   // transforms.
2493
2494   gfx::Rect target_surface_rect = gfx::Rect(0, 0, 100, 100);
2495   gfx::Rect layer_content_rect = gfx::Rect(0, 0, 100, 100);
2496   gfx::Transform layer_to_surface_transform;
2497
2498   // Case 1: Orthographic projection of a layer rotated about y-axis by 45
2499   // degrees, should be fully contained in the render surface.
2500   layer_to_surface_transform.MakeIdentity();
2501   layer_to_surface_transform.RotateAboutYAxis(45.0);
2502   gfx::Rect expected = gfx::Rect(0, 0, 100, 100);
2503   gfx::Rect actual = LayerTreeHostCommon::CalculateVisibleRect(
2504       target_surface_rect, layer_content_rect, layer_to_surface_transform);
2505   EXPECT_EQ(expected, actual);
2506
2507   // Case 2: Orthographic projection of a layer rotated about y-axis by 45
2508   // degrees, but shifted to the side so only the right-half the layer would be
2509   // visible on the surface.
2510   // 100 is the un-rotated layer width; divided by sqrt(2) is the rotated width.
2511   SkMScalar half_width_of_rotated_layer =
2512       SkDoubleToMScalar((100.0 / sqrt(2.0)) * 0.5);
2513   layer_to_surface_transform.MakeIdentity();
2514   layer_to_surface_transform.Translate(-half_width_of_rotated_layer, 0.0);
2515   layer_to_surface_transform.RotateAboutYAxis(45.0);  // Rotates about the left
2516                                                       // edge of the layer.
2517   expected = gfx::Rect(50, 0, 50, 100);  // Tight half of the layer.
2518   actual = LayerTreeHostCommon::CalculateVisibleRect(
2519       target_surface_rect, layer_content_rect, layer_to_surface_transform);
2520   EXPECT_EQ(expected, actual);
2521 }
2522
2523 TEST_F(LayerTreeHostCommonTest, VisibleRectFor3dPerspectiveTransform) {
2524   // Test the calculateVisibleRect() function works correctly when the layer has
2525   // a perspective projection onto the target surface.
2526
2527   gfx::Rect target_surface_rect = gfx::Rect(0, 0, 100, 100);
2528   gfx::Rect layer_content_rect = gfx::Rect(-50, -50, 200, 200);
2529   gfx::Transform layer_to_surface_transform;
2530
2531   // Case 1: Even though the layer is twice as large as the surface, due to
2532   // perspective foreshortening, the layer will fit fully in the surface when
2533   // its translated more than the perspective amount.
2534   layer_to_surface_transform.MakeIdentity();
2535
2536   // The following sequence of transforms applies the perspective about the
2537   // center of the surface.
2538   layer_to_surface_transform.Translate(50.0, 50.0);
2539   layer_to_surface_transform.ApplyPerspectiveDepth(9.0);
2540   layer_to_surface_transform.Translate(-50.0, -50.0);
2541
2542   // This translate places the layer in front of the surface's projection plane.
2543   layer_to_surface_transform.Translate3d(0.0, 0.0, -27.0);
2544
2545   gfx::Rect expected = gfx::Rect(-50, -50, 200, 200);
2546   gfx::Rect actual = LayerTreeHostCommon::CalculateVisibleRect(
2547       target_surface_rect, layer_content_rect, layer_to_surface_transform);
2548   EXPECT_EQ(expected, actual);
2549
2550   // Case 2: same projection as before, except that the layer is also translated
2551   // to the side, so that only the right half of the layer should be visible.
2552   //
2553   // Explanation of expected result: The perspective ratio is (z distance
2554   // between layer and camera origin) / (z distance between projection plane and
2555   // camera origin) == ((-27 - 9) / 9) Then, by similar triangles, if we want to
2556   // move a layer by translating -50 units in projected surface units (so that
2557   // only half of it is visible), then we would need to translate by (-36 / 9) *
2558   // -50 == -200 in the layer's units.
2559   layer_to_surface_transform.Translate3d(-200.0, 0.0, 0.0);
2560   expected = gfx::Rect(gfx::Point(50, -50),
2561                        gfx::Size(100, 200));  // The right half of the layer's
2562                                               // bounding rect.
2563   actual = LayerTreeHostCommon::CalculateVisibleRect(
2564       target_surface_rect, layer_content_rect, layer_to_surface_transform);
2565   EXPECT_EQ(expected, actual);
2566 }
2567
2568 TEST_F(LayerTreeHostCommonTest,
2569        VisibleRectFor3dOrthographicIsNotClippedBehindSurface) {
2570   // There is currently no explicit concept of an orthographic projection plane
2571   // in our code (nor in the CSS spec to my knowledge). Therefore, layers that
2572   // are technically behind the surface in an orthographic world should not be
2573   // clipped when they are flattened to the surface.
2574
2575   gfx::Rect target_surface_rect = gfx::Rect(0, 0, 100, 100);
2576   gfx::Rect layer_content_rect = gfx::Rect(0, 0, 100, 100);
2577   gfx::Transform layer_to_surface_transform;
2578
2579   // This sequence of transforms effectively rotates the layer about the y-axis
2580   // at the center of the layer.
2581   layer_to_surface_transform.MakeIdentity();
2582   layer_to_surface_transform.Translate(50.0, 0.0);
2583   layer_to_surface_transform.RotateAboutYAxis(45.0);
2584   layer_to_surface_transform.Translate(-50.0, 0.0);
2585
2586   gfx::Rect expected = gfx::Rect(0, 0, 100, 100);
2587   gfx::Rect actual = LayerTreeHostCommon::CalculateVisibleRect(
2588       target_surface_rect, layer_content_rect, layer_to_surface_transform);
2589   EXPECT_EQ(expected, actual);
2590 }
2591
2592 TEST_F(LayerTreeHostCommonTest, VisibleRectFor3dPerspectiveWhenClippedByW) {
2593   // Test the calculateVisibleRect() function works correctly when projecting a
2594   // surface onto a layer, but the layer is partially behind the camera (not
2595   // just behind the projection plane). In this case, the cartesian coordinates
2596   // may seem to be valid, but actually they are not. The visible rect needs to
2597   // be properly clipped by the w = 0 plane in homogeneous coordinates before
2598   // converting to cartesian coordinates.
2599
2600   gfx::Rect target_surface_rect = gfx::Rect(-50, -50, 100, 100);
2601   gfx::Rect layer_content_rect = gfx::Rect(-10, -1, 20, 2);
2602   gfx::Transform layer_to_surface_transform;
2603
2604   // The layer is positioned so that the right half of the layer should be in
2605   // front of the camera, while the other half is behind the surface's
2606   // projection plane. The following sequence of transforms applies the
2607   // perspective and rotation about the center of the layer.
2608   layer_to_surface_transform.MakeIdentity();
2609   layer_to_surface_transform.ApplyPerspectiveDepth(1.0);
2610   layer_to_surface_transform.Translate3d(-2.0, 0.0, 1.0);
2611   layer_to_surface_transform.RotateAboutYAxis(45.0);
2612
2613   // Sanity check that this transform does indeed cause w < 0 when applying the
2614   // transform, otherwise this code is not testing the intended scenario.
2615   bool clipped;
2616   MathUtil::MapQuad(layer_to_surface_transform,
2617                     gfx::QuadF(gfx::RectF(layer_content_rect)),
2618                     &clipped);
2619   ASSERT_TRUE(clipped);
2620
2621   int expected_x_position = 0;
2622   int expected_width = 10;
2623   gfx::Rect actual = LayerTreeHostCommon::CalculateVisibleRect(
2624       target_surface_rect, layer_content_rect, layer_to_surface_transform);
2625   EXPECT_EQ(expected_x_position, actual.x());
2626   EXPECT_EQ(expected_width, actual.width());
2627 }
2628
2629 TEST_F(LayerTreeHostCommonTest, VisibleRectForPerspectiveUnprojection) {
2630   // To determine visible rect in layer space, there needs to be an
2631   // un-projection from surface space to layer space. When the original
2632   // transform was a perspective projection that was clipped, it returns a rect
2633   // that encloses the clipped bounds.  Un-projecting this new rect may require
2634   // clipping again.
2635
2636   // This sequence of transforms causes one corner of the layer to protrude
2637   // across the w = 0 plane, and should be clipped.
2638   gfx::Rect target_surface_rect = gfx::Rect(-50, -50, 100, 100);
2639   gfx::Rect layer_content_rect = gfx::Rect(-10, -10, 20, 20);
2640   gfx::Transform layer_to_surface_transform;
2641   layer_to_surface_transform.MakeIdentity();
2642   layer_to_surface_transform.ApplyPerspectiveDepth(1.0);
2643   layer_to_surface_transform.Translate3d(0.0, 0.0, -5.0);
2644   layer_to_surface_transform.RotateAboutYAxis(45.0);
2645   layer_to_surface_transform.RotateAboutXAxis(80.0);
2646
2647   // Sanity check that un-projection does indeed cause w < 0, otherwise this
2648   // code is not testing the intended scenario.
2649   bool clipped;
2650   gfx::RectF clipped_rect =
2651       MathUtil::MapClippedRect(layer_to_surface_transform, layer_content_rect);
2652   MathUtil::ProjectQuad(
2653       Inverse(layer_to_surface_transform), gfx::QuadF(clipped_rect), &clipped);
2654   ASSERT_TRUE(clipped);
2655
2656   // Only the corner of the layer is not visible on the surface because of being
2657   // clipped. But, the net result of rounding visible region to an axis-aligned
2658   // rect is that the entire layer should still be considered visible.
2659   gfx::Rect expected = gfx::Rect(-10, -10, 20, 20);
2660   gfx::Rect actual = LayerTreeHostCommon::CalculateVisibleRect(
2661       target_surface_rect, layer_content_rect, layer_to_surface_transform);
2662   EXPECT_EQ(expected, actual);
2663 }
2664
2665 TEST_F(LayerTreeHostCommonTest, DrawableAndVisibleContentRectsForSimpleLayers) {
2666   scoped_refptr<Layer> root = Layer::Create();
2667   scoped_refptr<LayerWithForcedDrawsContent> child1 =
2668       make_scoped_refptr(new LayerWithForcedDrawsContent());
2669   scoped_refptr<LayerWithForcedDrawsContent> child2 =
2670       make_scoped_refptr(new LayerWithForcedDrawsContent());
2671   scoped_refptr<LayerWithForcedDrawsContent> child3 =
2672       make_scoped_refptr(new LayerWithForcedDrawsContent());
2673   root->AddChild(child1);
2674   root->AddChild(child2);
2675   root->AddChild(child3);
2676
2677   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
2678   host->SetRootLayer(root);
2679
2680   gfx::Transform identity_matrix;
2681   SetLayerPropertiesForTesting(root.get(),
2682                                identity_matrix,
2683                                gfx::Point3F(),
2684                                gfx::PointF(),
2685                                gfx::Size(100, 100),
2686                                true,
2687                                false);
2688   SetLayerPropertiesForTesting(child1.get(),
2689                                identity_matrix,
2690                                gfx::Point3F(),
2691                                gfx::PointF(),
2692                                gfx::Size(50, 50),
2693                                true,
2694                                false);
2695   SetLayerPropertiesForTesting(child2.get(),
2696                                identity_matrix,
2697                                gfx::Point3F(),
2698                                gfx::PointF(75.f, 75.f),
2699                                gfx::Size(50, 50),
2700                                true,
2701                                false);
2702   SetLayerPropertiesForTesting(child3.get(),
2703                                identity_matrix,
2704                                gfx::Point3F(),
2705                                gfx::PointF(125.f, 125.f),
2706                                gfx::Size(50, 50),
2707                                true,
2708                                false);
2709
2710   ExecuteCalculateDrawProperties(root.get());
2711
2712   EXPECT_EQ(gfx::Rect(0, 0, 100, 100),
2713             root->render_surface()->DrawableContentRect());
2714   EXPECT_EQ(gfx::Rect(0, 0, 100, 100), root->drawable_content_rect());
2715
2716   // Layers that do not draw content should have empty visible_content_rects.
2717   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_content_rect());
2718
2719   // layer visible_content_rects are clipped by their target surface.
2720   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_content_rect());
2721   EXPECT_EQ(gfx::Rect(0, 0, 25, 25), child2->visible_content_rect());
2722   EXPECT_TRUE(child3->visible_content_rect().IsEmpty());
2723
2724   // layer drawable_content_rects are not clipped.
2725   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->drawable_content_rect());
2726   EXPECT_EQ(gfx::Rect(75, 75, 50, 50), child2->drawable_content_rect());
2727   EXPECT_EQ(gfx::Rect(125, 125, 50, 50), child3->drawable_content_rect());
2728 }
2729
2730 TEST_F(LayerTreeHostCommonTest,
2731        DrawableAndVisibleContentRectsForLayersClippedByLayer) {
2732   scoped_refptr<Layer> root = Layer::Create();
2733   scoped_refptr<Layer> child = Layer::Create();
2734   scoped_refptr<LayerWithForcedDrawsContent> grand_child1 =
2735       make_scoped_refptr(new LayerWithForcedDrawsContent());
2736   scoped_refptr<LayerWithForcedDrawsContent> grand_child2 =
2737       make_scoped_refptr(new LayerWithForcedDrawsContent());
2738   scoped_refptr<LayerWithForcedDrawsContent> grand_child3 =
2739       make_scoped_refptr(new LayerWithForcedDrawsContent());
2740   root->AddChild(child);
2741   child->AddChild(grand_child1);
2742   child->AddChild(grand_child2);
2743   child->AddChild(grand_child3);
2744
2745   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
2746   host->SetRootLayer(root);
2747
2748   gfx::Transform identity_matrix;
2749   SetLayerPropertiesForTesting(root.get(),
2750                                identity_matrix,
2751                                gfx::Point3F(),
2752                                gfx::PointF(),
2753                                gfx::Size(100, 100),
2754                                true,
2755                                false);
2756   SetLayerPropertiesForTesting(child.get(),
2757                                identity_matrix,
2758                                gfx::Point3F(),
2759                                gfx::PointF(),
2760                                gfx::Size(100, 100),
2761                                true,
2762                                false);
2763   SetLayerPropertiesForTesting(grand_child1.get(),
2764                                identity_matrix,
2765                                gfx::Point3F(),
2766                                gfx::PointF(5.f, 5.f),
2767                                gfx::Size(50, 50),
2768                                true,
2769                                false);
2770   SetLayerPropertiesForTesting(grand_child2.get(),
2771                                identity_matrix,
2772                                gfx::Point3F(),
2773                                gfx::PointF(75.f, 75.f),
2774                                gfx::Size(50, 50),
2775                                true,
2776                                false);
2777   SetLayerPropertiesForTesting(grand_child3.get(),
2778                                identity_matrix,
2779                                gfx::Point3F(),
2780                                gfx::PointF(125.f, 125.f),
2781                                gfx::Size(50, 50),
2782                                true,
2783                                false);
2784
2785   child->SetMasksToBounds(true);
2786   ExecuteCalculateDrawProperties(root.get());
2787
2788   ASSERT_FALSE(child->render_surface());
2789
2790   EXPECT_EQ(gfx::Rect(0, 0, 100, 100),
2791             root->render_surface()->DrawableContentRect());
2792   EXPECT_EQ(gfx::Rect(0, 0, 100, 100), root->drawable_content_rect());
2793
2794   // Layers that do not draw content should have empty visible content rects.
2795   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_content_rect());
2796   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), child->visible_content_rect());
2797
2798   // All grandchild visible content rects should be clipped by child.
2799   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), grand_child1->visible_content_rect());
2800   EXPECT_EQ(gfx::Rect(0, 0, 25, 25), grand_child2->visible_content_rect());
2801   EXPECT_TRUE(grand_child3->visible_content_rect().IsEmpty());
2802
2803   // All grandchild DrawableContentRects should also be clipped by child.
2804   EXPECT_EQ(gfx::Rect(5, 5, 50, 50), grand_child1->drawable_content_rect());
2805   EXPECT_EQ(gfx::Rect(75, 75, 25, 25), grand_child2->drawable_content_rect());
2806   EXPECT_TRUE(grand_child3->drawable_content_rect().IsEmpty());
2807 }
2808
2809 TEST_F(LayerTreeHostCommonTest, VisibleContentRectWithClippingAndScaling) {
2810   scoped_refptr<Layer> root = Layer::Create();
2811   scoped_refptr<Layer> child = Layer::Create();
2812   scoped_refptr<LayerWithForcedDrawsContent> grand_child =
2813       make_scoped_refptr(new LayerWithForcedDrawsContent());
2814   root->AddChild(child);
2815   child->AddChild(grand_child);
2816
2817   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
2818   host->SetRootLayer(root);
2819
2820   gfx::Transform identity_matrix;
2821   gfx::Transform child_scale_matrix;
2822   child_scale_matrix.Scale(0.25f, 0.25f);
2823   gfx::Transform grand_child_scale_matrix;
2824   grand_child_scale_matrix.Scale(0.246f, 0.246f);
2825   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
2826                                gfx::PointF(), gfx::Size(100, 100), true, false);
2827   SetLayerPropertiesForTesting(child.get(), child_scale_matrix, gfx::Point3F(),
2828                                gfx::PointF(), gfx::Size(10, 10), true, false);
2829   SetLayerPropertiesForTesting(grand_child.get(), grand_child_scale_matrix,
2830                                gfx::Point3F(), gfx::PointF(),
2831                                gfx::Size(100, 100), true, false);
2832
2833   child->SetMasksToBounds(true);
2834   ExecuteCalculateDrawProperties(root.get());
2835
2836   // The visible rect is expanded to integer coordinates in target space before
2837   // being projected back to layer space, where it is once again expanded to
2838   // integer coordinates.
2839   EXPECT_EQ(gfx::Rect(49, 49), grand_child->visible_rect_from_property_trees());
2840 }
2841
2842 TEST_F(LayerTreeHostCommonTest,
2843        DrawableAndVisibleContentRectsForLayersInUnclippedRenderSurface) {
2844   scoped_refptr<Layer> root = Layer::Create();
2845   scoped_refptr<Layer> render_surface1 = Layer::Create();
2846   scoped_refptr<LayerWithForcedDrawsContent> child1 =
2847       make_scoped_refptr(new LayerWithForcedDrawsContent());
2848   scoped_refptr<LayerWithForcedDrawsContent> child2 =
2849       make_scoped_refptr(new LayerWithForcedDrawsContent());
2850   scoped_refptr<LayerWithForcedDrawsContent> child3 =
2851       make_scoped_refptr(new LayerWithForcedDrawsContent());
2852   root->AddChild(render_surface1);
2853   render_surface1->AddChild(child1);
2854   render_surface1->AddChild(child2);
2855   render_surface1->AddChild(child3);
2856
2857   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
2858   host->SetRootLayer(root);
2859
2860   gfx::Transform identity_matrix;
2861   SetLayerPropertiesForTesting(root.get(),
2862                                identity_matrix,
2863                                gfx::Point3F(),
2864                                gfx::PointF(),
2865                                gfx::Size(100, 100),
2866                                true,
2867                                false);
2868   SetLayerPropertiesForTesting(render_surface1.get(),
2869                                identity_matrix,
2870                                gfx::Point3F(),
2871                                gfx::PointF(),
2872                                gfx::Size(3, 4),
2873                                true,
2874                                false);
2875   SetLayerPropertiesForTesting(child1.get(),
2876                                identity_matrix,
2877                                gfx::Point3F(),
2878                                gfx::PointF(5.f, 5.f),
2879                                gfx::Size(50, 50),
2880                                true,
2881                                false);
2882   SetLayerPropertiesForTesting(child2.get(),
2883                                identity_matrix,
2884                                gfx::Point3F(),
2885                                gfx::PointF(75.f, 75.f),
2886                                gfx::Size(50, 50),
2887                                true,
2888                                false);
2889   SetLayerPropertiesForTesting(child3.get(),
2890                                identity_matrix,
2891                                gfx::Point3F(),
2892                                gfx::PointF(125.f, 125.f),
2893                                gfx::Size(50, 50),
2894                                true,
2895                                false);
2896
2897   render_surface1->SetForceRenderSurface(true);
2898   ExecuteCalculateDrawProperties(root.get());
2899
2900   ASSERT_TRUE(render_surface1->render_surface());
2901
2902   EXPECT_EQ(gfx::Rect(0, 0, 100, 100),
2903             root->render_surface()->DrawableContentRect());
2904   EXPECT_EQ(gfx::Rect(0, 0, 100, 100), root->drawable_content_rect());
2905
2906   // Layers that do not draw content should have empty visible content rects.
2907   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_content_rect());
2908   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface1->visible_content_rect());
2909
2910   // An unclipped surface grows its DrawableContentRect to include all drawable
2911   // regions of the subtree.
2912   EXPECT_EQ(gfx::Rect(5, 5, 170, 170),
2913             render_surface1->render_surface()->DrawableContentRect());
2914
2915   // All layers that draw content into the unclipped surface are also unclipped.
2916   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_content_rect());
2917   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child2->visible_content_rect());
2918   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child3->visible_content_rect());
2919
2920   EXPECT_EQ(gfx::Rect(5, 5, 50, 50), child1->drawable_content_rect());
2921   EXPECT_EQ(gfx::Rect(75, 75, 50, 50), child2->drawable_content_rect());
2922   EXPECT_EQ(gfx::Rect(125, 125, 50, 50), child3->drawable_content_rect());
2923 }
2924
2925 TEST_F(LayerTreeHostCommonTest,
2926        VisibleContentRectsForClippedSurfaceWithEmptyClip) {
2927   scoped_refptr<Layer> root = Layer::Create();
2928   scoped_refptr<LayerWithForcedDrawsContent> child1 =
2929       make_scoped_refptr(new LayerWithForcedDrawsContent());
2930   scoped_refptr<LayerWithForcedDrawsContent> child2 =
2931       make_scoped_refptr(new LayerWithForcedDrawsContent());
2932   scoped_refptr<LayerWithForcedDrawsContent> child3 =
2933       make_scoped_refptr(new LayerWithForcedDrawsContent());
2934   root->AddChild(child1);
2935   root->AddChild(child2);
2936   root->AddChild(child3);
2937
2938   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
2939   host->SetRootLayer(root);
2940
2941   gfx::Transform identity_matrix;
2942   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
2943                                gfx::PointF(), gfx::Size(100, 100), true, false);
2944   SetLayerPropertiesForTesting(child1.get(), identity_matrix, gfx::Point3F(),
2945                                gfx::PointF(5.f, 5.f), gfx::Size(50, 50), true,
2946                                false);
2947   SetLayerPropertiesForTesting(child2.get(), identity_matrix, gfx::Point3F(),
2948                                gfx::PointF(75.f, 75.f), gfx::Size(50, 50), true,
2949                                false);
2950   SetLayerPropertiesForTesting(child3.get(), identity_matrix, gfx::Point3F(),
2951                                gfx::PointF(125.f, 125.f), gfx::Size(50, 50),
2952                                true, false);
2953
2954   RenderSurfaceLayerList render_surface_layer_list;
2955   // Now set the root render surface an empty clip.
2956   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
2957       root.get(), gfx::Size(), &render_surface_layer_list);
2958
2959   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
2960   ASSERT_TRUE(root->render_surface());
2961   EXPECT_FALSE(root->is_clipped());
2962
2963   gfx::Rect empty;
2964   EXPECT_EQ(empty, root->render_surface()->clip_rect());
2965   EXPECT_TRUE(root->render_surface()->is_clipped());
2966
2967   // Visible content rect calculation will check if the target surface is
2968   // clipped or not. An empty clip rect does not indicate the render surface
2969   // is unclipped.
2970   EXPECT_EQ(empty, child1->visible_content_rect());
2971   EXPECT_EQ(empty, child2->visible_content_rect());
2972   EXPECT_EQ(empty, child3->visible_content_rect());
2973 }
2974
2975 TEST_F(LayerTreeHostCommonTest,
2976        DrawableAndVisibleContentRectsForLayersWithUninvertibleTransform) {
2977   scoped_refptr<Layer> root = Layer::Create();
2978   scoped_refptr<LayerWithForcedDrawsContent> child =
2979       make_scoped_refptr(new LayerWithForcedDrawsContent());
2980   root->AddChild(child);
2981
2982   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
2983   host->SetRootLayer(root);
2984
2985   // Case 1: a truly degenerate matrix
2986   gfx::Transform identity_matrix;
2987   gfx::Transform uninvertible_matrix(0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
2988   ASSERT_FALSE(uninvertible_matrix.IsInvertible());
2989
2990   SetLayerPropertiesForTesting(root.get(),
2991                                identity_matrix,
2992                                gfx::Point3F(),
2993                                gfx::PointF(),
2994                                gfx::Size(100, 100),
2995                                true,
2996                                false);
2997   SetLayerPropertiesForTesting(child.get(),
2998                                uninvertible_matrix,
2999                                gfx::Point3F(),
3000                                gfx::PointF(5.f, 5.f),
3001                                gfx::Size(50, 50),
3002                                true,
3003                                false);
3004
3005   ExecuteCalculateDrawProperties(root.get());
3006
3007   EXPECT_TRUE(child->visible_content_rect().IsEmpty());
3008   EXPECT_TRUE(child->drawable_content_rect().IsEmpty());
3009
3010   // Case 2: a matrix with flattened z, uninvertible and not visible according
3011   // to the CSS spec.
3012   uninvertible_matrix.MakeIdentity();
3013   uninvertible_matrix.matrix().set(2, 2, 0.0);
3014   ASSERT_FALSE(uninvertible_matrix.IsInvertible());
3015
3016   SetLayerPropertiesForTesting(child.get(),
3017                                uninvertible_matrix,
3018                                gfx::Point3F(),
3019                                gfx::PointF(5.f, 5.f),
3020                                gfx::Size(50, 50),
3021                                true,
3022                                false);
3023
3024   ExecuteCalculateDrawProperties(root.get());
3025
3026   EXPECT_TRUE(child->visible_content_rect().IsEmpty());
3027   EXPECT_TRUE(child->drawable_content_rect().IsEmpty());
3028
3029   // Case 3: a matrix with flattened z, also uninvertible and not visible.
3030   uninvertible_matrix.MakeIdentity();
3031   uninvertible_matrix.Translate(500.0, 0.0);
3032   uninvertible_matrix.matrix().set(2, 2, 0.0);
3033   ASSERT_FALSE(uninvertible_matrix.IsInvertible());
3034
3035   SetLayerPropertiesForTesting(child.get(),
3036                                uninvertible_matrix,
3037                                gfx::Point3F(),
3038                                gfx::PointF(5.f, 5.f),
3039                                gfx::Size(50, 50),
3040                                true,
3041                                false);
3042
3043   ExecuteCalculateDrawProperties(root.get());
3044
3045   EXPECT_TRUE(child->visible_content_rect().IsEmpty());
3046   EXPECT_TRUE(child->drawable_content_rect().IsEmpty());
3047 }
3048
3049 TEST_F(LayerTreeHostCommonTest,
3050        SingularTransformDoesNotPreventClearingDrawProperties) {
3051   scoped_refptr<Layer> root = Layer::Create();
3052   scoped_refptr<LayerWithForcedDrawsContent> child =
3053       make_scoped_refptr(new LayerWithForcedDrawsContent());
3054   root->AddChild(child);
3055
3056   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
3057   host->SetRootLayer(root);
3058
3059   gfx::Transform identity_matrix;
3060   gfx::Transform uninvertible_matrix(0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
3061   ASSERT_FALSE(uninvertible_matrix.IsInvertible());
3062
3063   SetLayerPropertiesForTesting(root.get(),
3064                                uninvertible_matrix,
3065                                gfx::Point3F(),
3066                                gfx::PointF(),
3067                                gfx::Size(100, 100),
3068                                true,
3069                                false);
3070   SetLayerPropertiesForTesting(child.get(),
3071                                identity_matrix,
3072                                gfx::Point3F(),
3073                                gfx::PointF(5.f, 5.f),
3074                                gfx::Size(50, 50),
3075                                true,
3076                                false);
3077
3078   child->draw_properties().sorted_for_recursion = true;
3079
3080   TransformOperations start_transform_operations;
3081   start_transform_operations.AppendScale(1.f, 0.f, 0.f);
3082
3083   TransformOperations end_transform_operations;
3084   end_transform_operations.AppendScale(1.f, 1.f, 0.f);
3085
3086   AddAnimatedTransformToLayer(
3087       root.get(), 10.0, start_transform_operations, end_transform_operations);
3088
3089   EXPECT_TRUE(root->TransformIsAnimating());
3090
3091   ExecuteCalculateDrawProperties(root.get());
3092
3093   EXPECT_FALSE(child->draw_properties().sorted_for_recursion);
3094 }
3095
3096 TEST_F(LayerTreeHostCommonTest,
3097        SingularNonAnimatingTransformDoesNotPreventClearingDrawProperties) {
3098   scoped_refptr<Layer> root = Layer::Create();
3099
3100   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
3101   host->SetRootLayer(root);
3102
3103   gfx::Transform identity_matrix;
3104   gfx::Transform uninvertible_matrix(0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
3105   ASSERT_FALSE(uninvertible_matrix.IsInvertible());
3106
3107   SetLayerPropertiesForTesting(root.get(),
3108                                uninvertible_matrix,
3109                                gfx::Point3F(),
3110                                gfx::PointF(),
3111                                gfx::Size(100, 100),
3112                                true,
3113                                false);
3114
3115   root->draw_properties().sorted_for_recursion = true;
3116
3117   EXPECT_FALSE(root->TransformIsAnimating());
3118
3119   ExecuteCalculateDrawProperties(root.get());
3120
3121   EXPECT_FALSE(root->draw_properties().sorted_for_recursion);
3122 }
3123
3124 TEST_F(LayerTreeHostCommonTest,
3125        DrawableAndVisibleContentRectsForLayersInClippedRenderSurface) {
3126   scoped_refptr<Layer> root = Layer::Create();
3127   scoped_refptr<Layer> render_surface1 = Layer::Create();
3128   scoped_refptr<LayerWithForcedDrawsContent> child1 =
3129       make_scoped_refptr(new LayerWithForcedDrawsContent());
3130   scoped_refptr<LayerWithForcedDrawsContent> child2 =
3131       make_scoped_refptr(new LayerWithForcedDrawsContent());
3132   scoped_refptr<LayerWithForcedDrawsContent> child3 =
3133       make_scoped_refptr(new LayerWithForcedDrawsContent());
3134   root->AddChild(render_surface1);
3135   render_surface1->AddChild(child1);
3136   render_surface1->AddChild(child2);
3137   render_surface1->AddChild(child3);
3138
3139   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
3140   host->SetRootLayer(root);
3141
3142   gfx::Transform identity_matrix;
3143   SetLayerPropertiesForTesting(root.get(),
3144                                identity_matrix,
3145                                gfx::Point3F(),
3146                                gfx::PointF(),
3147                                gfx::Size(100, 100),
3148                                true,
3149                                false);
3150   SetLayerPropertiesForTesting(render_surface1.get(),
3151                                identity_matrix,
3152                                gfx::Point3F(),
3153                                gfx::PointF(),
3154                                gfx::Size(3, 4),
3155                                true,
3156                                false);
3157   SetLayerPropertiesForTesting(child1.get(),
3158                                identity_matrix,
3159                                gfx::Point3F(),
3160                                gfx::PointF(5.f, 5.f),
3161                                gfx::Size(50, 50),
3162                                true,
3163                                false);
3164   SetLayerPropertiesForTesting(child2.get(),
3165                                identity_matrix,
3166                                gfx::Point3F(),
3167                                gfx::PointF(75.f, 75.f),
3168                                gfx::Size(50, 50),
3169                                true,
3170                                false);
3171   SetLayerPropertiesForTesting(child3.get(),
3172                                identity_matrix,
3173                                gfx::Point3F(),
3174                                gfx::PointF(125.f, 125.f),
3175                                gfx::Size(50, 50),
3176                                true,
3177                                false);
3178
3179   root->SetMasksToBounds(true);
3180   render_surface1->SetForceRenderSurface(true);
3181   ExecuteCalculateDrawProperties(root.get());
3182
3183   ASSERT_TRUE(render_surface1->render_surface());
3184
3185   EXPECT_EQ(gfx::Rect(0, 0, 100, 100),
3186             root->render_surface()->DrawableContentRect());
3187   EXPECT_EQ(gfx::Rect(0, 0, 100, 100), root->drawable_content_rect());
3188
3189   // Layers that do not draw content should have empty visible content rects.
3190   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_content_rect());
3191   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface1->visible_content_rect());
3192
3193   // A clipped surface grows its DrawableContentRect to include all drawable
3194   // regions of the subtree, but also gets clamped by the ancestor's clip.
3195   EXPECT_EQ(gfx::Rect(5, 5, 95, 95),
3196             render_surface1->render_surface()->DrawableContentRect());
3197
3198   // All layers that draw content into the surface have their visible content
3199   // rect clipped by the surface clip rect.
3200   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_content_rect());
3201   EXPECT_EQ(gfx::Rect(0, 0, 25, 25), child2->visible_content_rect());
3202   EXPECT_TRUE(child3->visible_content_rect().IsEmpty());
3203
3204   // But the DrawableContentRects are unclipped.
3205   EXPECT_EQ(gfx::Rect(5, 5, 50, 50), child1->drawable_content_rect());
3206   EXPECT_EQ(gfx::Rect(75, 75, 50, 50), child2->drawable_content_rect());
3207   EXPECT_EQ(gfx::Rect(125, 125, 50, 50), child3->drawable_content_rect());
3208 }
3209
3210 TEST_F(LayerTreeHostCommonTest,
3211        DrawableAndVisibleContentRectsForSurfaceHierarchy) {
3212   // Check that clipping does not propagate down surfaces.
3213   scoped_refptr<Layer> root = Layer::Create();
3214   scoped_refptr<Layer> render_surface1 = Layer::Create();
3215   scoped_refptr<Layer> render_surface2 = Layer::Create();
3216   scoped_refptr<LayerWithForcedDrawsContent> child1 =
3217       make_scoped_refptr(new LayerWithForcedDrawsContent());
3218   scoped_refptr<LayerWithForcedDrawsContent> child2 =
3219       make_scoped_refptr(new LayerWithForcedDrawsContent());
3220   scoped_refptr<LayerWithForcedDrawsContent> child3 =
3221       make_scoped_refptr(new LayerWithForcedDrawsContent());
3222   root->AddChild(render_surface1);
3223   render_surface1->AddChild(render_surface2);
3224   render_surface2->AddChild(child1);
3225   render_surface2->AddChild(child2);
3226   render_surface2->AddChild(child3);
3227
3228   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
3229   host->SetRootLayer(root);
3230
3231   gfx::Transform identity_matrix;
3232   SetLayerPropertiesForTesting(root.get(),
3233                                identity_matrix,
3234                                gfx::Point3F(),
3235                                gfx::PointF(),
3236                                gfx::Size(100, 100),
3237                                true,
3238                                false);
3239   SetLayerPropertiesForTesting(render_surface1.get(),
3240                                identity_matrix,
3241                                gfx::Point3F(),
3242                                gfx::PointF(),
3243                                gfx::Size(3, 4),
3244                                true,
3245                                false);
3246   SetLayerPropertiesForTesting(render_surface2.get(),
3247                                identity_matrix,
3248                                gfx::Point3F(),
3249                                gfx::PointF(),
3250                                gfx::Size(7, 13),
3251                                true,
3252                                false);
3253   SetLayerPropertiesForTesting(child1.get(),
3254                                identity_matrix,
3255                                gfx::Point3F(),
3256                                gfx::PointF(5.f, 5.f),
3257                                gfx::Size(50, 50),
3258                                true,
3259                                false);
3260   SetLayerPropertiesForTesting(child2.get(),
3261                                identity_matrix,
3262                                gfx::Point3F(),
3263                                gfx::PointF(75.f, 75.f),
3264                                gfx::Size(50, 50),
3265                                true,
3266                                false);
3267   SetLayerPropertiesForTesting(child3.get(),
3268                                identity_matrix,
3269                                gfx::Point3F(),
3270                                gfx::PointF(125.f, 125.f),
3271                                gfx::Size(50, 50),
3272                                true,
3273                                false);
3274
3275   root->SetMasksToBounds(true);
3276   render_surface1->SetForceRenderSurface(true);
3277   render_surface2->SetForceRenderSurface(true);
3278   ExecuteCalculateDrawProperties(root.get());
3279
3280   ASSERT_TRUE(render_surface1->render_surface());
3281   ASSERT_TRUE(render_surface2->render_surface());
3282
3283   EXPECT_EQ(gfx::Rect(0, 0, 100, 100),
3284             root->render_surface()->DrawableContentRect());
3285   EXPECT_EQ(gfx::Rect(0, 0, 100, 100), root->drawable_content_rect());
3286
3287   // Layers that do not draw content should have empty visible content rects.
3288   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_content_rect());
3289   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface1->visible_content_rect());
3290   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface2->visible_content_rect());
3291
3292   // A clipped surface grows its DrawableContentRect to include all drawable
3293   // regions of the subtree, but also gets clamped by the ancestor's clip.
3294   EXPECT_EQ(gfx::Rect(5, 5, 95, 95),
3295             render_surface1->render_surface()->DrawableContentRect());
3296
3297   // render_surface1 lives in the "unclipped universe" of render_surface1, and
3298   // is only implicitly clipped by render_surface1's content rect. So,
3299   // render_surface2 grows to enclose all drawable content of its subtree.
3300   EXPECT_EQ(gfx::Rect(5, 5, 170, 170),
3301             render_surface2->render_surface()->DrawableContentRect());
3302
3303   // All layers that draw content into render_surface2 think they are unclipped.
3304   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_content_rect());
3305   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child2->visible_content_rect());
3306   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child3->visible_content_rect());
3307
3308   // DrawableContentRects are also unclipped.
3309   EXPECT_EQ(gfx::Rect(5, 5, 50, 50), child1->drawable_content_rect());
3310   EXPECT_EQ(gfx::Rect(75, 75, 50, 50), child2->drawable_content_rect());
3311   EXPECT_EQ(gfx::Rect(125, 125, 50, 50), child3->drawable_content_rect());
3312 }
3313
3314 TEST_F(LayerTreeHostCommonTest,
3315        DrawableAndVisibleContentRectsWithTransformOnUnclippedSurface) {
3316   // Layers that have non-axis aligned bounds (due to transforms) have an
3317   // expanded, axis-aligned DrawableContentRect and visible content rect.
3318
3319   scoped_refptr<Layer> root = Layer::Create();
3320   scoped_refptr<Layer> render_surface1 = Layer::Create();
3321   scoped_refptr<LayerWithForcedDrawsContent> child1 =
3322       make_scoped_refptr(new LayerWithForcedDrawsContent());
3323   root->AddChild(render_surface1);
3324   render_surface1->AddChild(child1);
3325
3326   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
3327   host->SetRootLayer(root);
3328
3329   gfx::Transform identity_matrix;
3330   gfx::Transform child_rotation;
3331   child_rotation.Rotate(45.0);
3332   SetLayerPropertiesForTesting(root.get(),
3333                                identity_matrix,
3334                                gfx::Point3F(),
3335                                gfx::PointF(),
3336                                gfx::Size(100, 100),
3337                                true,
3338                                false);
3339   SetLayerPropertiesForTesting(render_surface1.get(),
3340                                identity_matrix,
3341                                gfx::Point3F(),
3342                                gfx::PointF(),
3343                                gfx::Size(3, 4),
3344                                true,
3345                                false);
3346   SetLayerPropertiesForTesting(child1.get(),
3347                                child_rotation,
3348                                gfx::Point3F(25, 25, 0.f),
3349                                gfx::PointF(25.f, 25.f),
3350                                gfx::Size(50, 50),
3351                                true,
3352                                false);
3353
3354   render_surface1->SetForceRenderSurface(true);
3355   ExecuteCalculateDrawProperties(root.get());
3356
3357   ASSERT_TRUE(render_surface1->render_surface());
3358
3359   EXPECT_EQ(gfx::Rect(0, 0, 100, 100),
3360             root->render_surface()->DrawableContentRect());
3361   EXPECT_EQ(gfx::Rect(0, 0, 100, 100), root->drawable_content_rect());
3362
3363   // Layers that do not draw content should have empty visible content rects.
3364   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_content_rect());
3365   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface1->visible_content_rect());
3366
3367   // The unclipped surface grows its DrawableContentRect to include all drawable
3368   // regions of the subtree.
3369   int diagonal_radius = ceil(sqrt(2.0) * 25.0);
3370   gfx::Rect expected_surface_drawable_content =
3371       gfx::Rect(50 - diagonal_radius,
3372                 50 - diagonal_radius,
3373                 diagonal_radius * 2,
3374                 diagonal_radius * 2);
3375   EXPECT_EQ(expected_surface_drawable_content,
3376             render_surface1->render_surface()->DrawableContentRect());
3377
3378   // All layers that draw content into the unclipped surface are also unclipped.
3379   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_content_rect());
3380   EXPECT_EQ(expected_surface_drawable_content, child1->drawable_content_rect());
3381 }
3382
3383 TEST_F(LayerTreeHostCommonTest,
3384        DrawableAndVisibleContentRectsWithTransformOnClippedSurface) {
3385   // Layers that have non-axis aligned bounds (due to transforms) have an
3386   // expanded, axis-aligned DrawableContentRect and visible content rect.
3387
3388   scoped_refptr<Layer> root = Layer::Create();
3389   scoped_refptr<Layer> render_surface1 = Layer::Create();
3390   scoped_refptr<LayerWithForcedDrawsContent> child1 =
3391       make_scoped_refptr(new LayerWithForcedDrawsContent());
3392   root->AddChild(render_surface1);
3393   render_surface1->AddChild(child1);
3394
3395   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
3396   host->SetRootLayer(root);
3397
3398   gfx::Transform identity_matrix;
3399   gfx::Transform child_rotation;
3400   child_rotation.Rotate(45.0);
3401   SetLayerPropertiesForTesting(root.get(),
3402                                identity_matrix,
3403                                gfx::Point3F(),
3404                                gfx::PointF(),
3405                                gfx::Size(50, 50),
3406                                true,
3407                                false);
3408   SetLayerPropertiesForTesting(render_surface1.get(),
3409                                identity_matrix,
3410                                gfx::Point3F(),
3411                                gfx::PointF(),
3412                                gfx::Size(3, 4),
3413                                true,
3414                                false);
3415
3416   SetLayerPropertiesForTesting(child1.get(),
3417                                child_rotation,
3418                                gfx::Point3F(25, 25, 0.f),
3419                                gfx::PointF(25.f, 25.f),
3420                                gfx::Size(50, 50),
3421                                true,
3422                                false);
3423
3424   root->SetMasksToBounds(true);
3425   render_surface1->SetForceRenderSurface(true);
3426   ExecuteCalculateDrawProperties(root.get());
3427
3428   ASSERT_TRUE(render_surface1->render_surface());
3429
3430   // The clipped surface clamps the DrawableContentRect that encloses the
3431   // rotated layer.
3432   int diagonal_radius = ceil(sqrt(2.0) * 25.0);
3433   gfx::Rect unclipped_surface_content = gfx::Rect(50 - diagonal_radius,
3434                                                   50 - diagonal_radius,
3435                                                   diagonal_radius * 2,
3436                                                   diagonal_radius * 2);
3437   gfx::Rect expected_surface_drawable_content =
3438       gfx::IntersectRects(unclipped_surface_content, gfx::Rect(0, 0, 50, 50));
3439   EXPECT_EQ(expected_surface_drawable_content,
3440             render_surface1->render_surface()->DrawableContentRect());
3441
3442   // On the clipped surface, only a quarter  of the child1 is visible, but when
3443   // rotating it back to  child1's content space, the actual enclosing rect ends
3444   // up covering the full left half of child1.
3445   //
3446   // Given the floating point math, this number is a little bit fuzzy.
3447   EXPECT_EQ(gfx::Rect(0, 0, 26, 50), child1->visible_content_rect());
3448
3449   // The child's DrawableContentRect is unclipped.
3450   EXPECT_EQ(unclipped_surface_content, child1->drawable_content_rect());
3451 }
3452
3453 TEST_F(LayerTreeHostCommonTest, DrawableAndVisibleContentRectsInHighDPI) {
3454   MockContentLayerClient client;
3455
3456   scoped_refptr<Layer> root = Layer::Create();
3457   scoped_refptr<FakePictureLayer> render_surface1 =
3458       CreateDrawablePictureLayer(&client);
3459   scoped_refptr<FakePictureLayer> render_surface2 =
3460       CreateDrawablePictureLayer(&client);
3461   scoped_refptr<FakePictureLayer> child1 = CreateDrawablePictureLayer(&client);
3462   scoped_refptr<FakePictureLayer> child2 = CreateDrawablePictureLayer(&client);
3463   scoped_refptr<FakePictureLayer> child3 = CreateDrawablePictureLayer(&client);
3464   root->AddChild(render_surface1);
3465   render_surface1->AddChild(render_surface2);
3466   render_surface2->AddChild(child1);
3467   render_surface2->AddChild(child2);
3468   render_surface2->AddChild(child3);
3469
3470   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
3471   host->SetRootLayer(root);
3472
3473   gfx::Transform identity_matrix;
3474   SetLayerPropertiesForTesting(root.get(),
3475                                identity_matrix,
3476                                gfx::Point3F(),
3477                                gfx::PointF(),
3478                                gfx::Size(100, 100),
3479                                true,
3480                                false);
3481   SetLayerPropertiesForTesting(render_surface1.get(),
3482                                identity_matrix,
3483                                gfx::Point3F(),
3484                                gfx::PointF(5.f, 5.f),
3485                                gfx::Size(3, 4),
3486                                true,
3487                                false);
3488   SetLayerPropertiesForTesting(render_surface2.get(),
3489                                identity_matrix,
3490                                gfx::Point3F(),
3491                                gfx::PointF(5.f, 5.f),
3492                                gfx::Size(7, 13),
3493                                true,
3494                                false);
3495   SetLayerPropertiesForTesting(child1.get(),
3496                                identity_matrix,
3497                                gfx::Point3F(),
3498                                gfx::PointF(5.f, 5.f),
3499                                gfx::Size(50, 50),
3500                                true,
3501                                false);
3502   SetLayerPropertiesForTesting(child2.get(),
3503                                identity_matrix,
3504                                gfx::Point3F(),
3505                                gfx::PointF(75.f, 75.f),
3506                                gfx::Size(50, 50),
3507                                true,
3508                                false);
3509   SetLayerPropertiesForTesting(child3.get(),
3510                                identity_matrix,
3511                                gfx::Point3F(),
3512                                gfx::PointF(125.f, 125.f),
3513                                gfx::Size(50, 50),
3514                                true,
3515                                false);
3516
3517   float device_scale_factor = 2.f;
3518
3519   root->SetMasksToBounds(true);
3520   render_surface1->SetForceRenderSurface(true);
3521   render_surface2->SetForceRenderSurface(true);
3522   ExecuteCalculateDrawProperties(root.get(), device_scale_factor);
3523
3524   ASSERT_TRUE(render_surface1->render_surface());
3525   ASSERT_TRUE(render_surface2->render_surface());
3526
3527   // drawable_content_rects for all layers and surfaces are scaled by
3528   // device_scale_factor.
3529   EXPECT_EQ(gfx::Rect(0, 0, 200, 200),
3530             root->render_surface()->DrawableContentRect());
3531   EXPECT_EQ(gfx::Rect(0, 0, 200, 200), root->drawable_content_rect());
3532   EXPECT_EQ(gfx::Rect(10, 10, 190, 190),
3533             render_surface1->render_surface()->DrawableContentRect());
3534
3535   // render_surface2 lives in the "unclipped universe" of render_surface1, and
3536   // is only implicitly clipped by render_surface1.
3537   EXPECT_EQ(gfx::Rect(10, 10, 350, 350),
3538             render_surface2->render_surface()->DrawableContentRect());
3539
3540   EXPECT_EQ(gfx::Rect(10, 10, 100, 100), child1->drawable_content_rect());
3541   EXPECT_EQ(gfx::Rect(150, 150, 100, 100), child2->drawable_content_rect());
3542   EXPECT_EQ(gfx::Rect(250, 250, 100, 100), child3->drawable_content_rect());
3543
3544   // The root layer does not actually draw content of its own.
3545   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_content_rect());
3546
3547   // All layer visible content rects are not expressed in content space of each
3548   // layer, so they are not scaled by the device_scale_factor.
3549   EXPECT_EQ(gfx::Rect(0, 0, 3, 4), render_surface1->visible_content_rect());
3550   EXPECT_EQ(gfx::Rect(0, 0, 7, 13), render_surface2->visible_content_rect());
3551   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_content_rect());
3552   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child2->visible_content_rect());
3553   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child3->visible_content_rect());
3554 }
3555
3556 TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithoutPreserves3d) {
3557   // Verify the behavior of back-face culling when there are no preserve-3d
3558   // layers. Note that 3d transforms still apply in this case, but they are
3559   // "flattened" to each parent layer according to current W3C spec.
3560
3561   const gfx::Transform identity_matrix;
3562   scoped_refptr<Layer> parent = Layer::Create();
3563   scoped_refptr<LayerWithForcedDrawsContent> front_facing_child =
3564       make_scoped_refptr(new LayerWithForcedDrawsContent());
3565   scoped_refptr<LayerWithForcedDrawsContent> back_facing_child =
3566       make_scoped_refptr(new LayerWithForcedDrawsContent());
3567   scoped_refptr<LayerWithForcedDrawsContent> front_facing_surface =
3568       make_scoped_refptr(new LayerWithForcedDrawsContent());
3569   scoped_refptr<LayerWithForcedDrawsContent> back_facing_surface =
3570       make_scoped_refptr(new LayerWithForcedDrawsContent());
3571   scoped_refptr<LayerWithForcedDrawsContent>
3572       front_facing_child_of_front_facing_surface =
3573           make_scoped_refptr(new LayerWithForcedDrawsContent());
3574   scoped_refptr<LayerWithForcedDrawsContent>
3575       back_facing_child_of_front_facing_surface =
3576           make_scoped_refptr(new LayerWithForcedDrawsContent());
3577   scoped_refptr<LayerWithForcedDrawsContent>
3578       front_facing_child_of_back_facing_surface =
3579           make_scoped_refptr(new LayerWithForcedDrawsContent());
3580   scoped_refptr<LayerWithForcedDrawsContent>
3581       back_facing_child_of_back_facing_surface =
3582           make_scoped_refptr(new LayerWithForcedDrawsContent());
3583
3584   parent->AddChild(front_facing_child);
3585   parent->AddChild(back_facing_child);
3586   parent->AddChild(front_facing_surface);
3587   parent->AddChild(back_facing_surface);
3588   front_facing_surface->AddChild(front_facing_child_of_front_facing_surface);
3589   front_facing_surface->AddChild(back_facing_child_of_front_facing_surface);
3590   back_facing_surface->AddChild(front_facing_child_of_back_facing_surface);
3591   back_facing_surface->AddChild(back_facing_child_of_back_facing_surface);
3592
3593   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
3594   host->SetRootLayer(parent);
3595
3596   // Nothing is double-sided
3597   front_facing_child->SetDoubleSided(false);
3598   back_facing_child->SetDoubleSided(false);
3599   front_facing_surface->SetDoubleSided(false);
3600   back_facing_surface->SetDoubleSided(false);
3601   front_facing_child_of_front_facing_surface->SetDoubleSided(false);
3602   back_facing_child_of_front_facing_surface->SetDoubleSided(false);
3603   front_facing_child_of_back_facing_surface->SetDoubleSided(false);
3604   back_facing_child_of_back_facing_surface->SetDoubleSided(false);
3605
3606   gfx::Transform backface_matrix;
3607   backface_matrix.Translate(50.0, 50.0);
3608   backface_matrix.RotateAboutYAxis(180.0);
3609   backface_matrix.Translate(-50.0, -50.0);
3610
3611   // Having a descendant and opacity will force these to have render surfaces.
3612   front_facing_surface->SetOpacity(0.5f);
3613   back_facing_surface->SetOpacity(0.5f);
3614
3615   // Nothing preserves 3d. According to current W3C CSS gfx::Transforms spec,
3616   // these layers should blindly use their own local transforms to determine
3617   // back-face culling.
3618   SetLayerPropertiesForTesting(parent.get(),
3619                                identity_matrix,
3620                                gfx::Point3F(),
3621                                gfx::PointF(),
3622                                gfx::Size(100, 100),
3623                                true,
3624                                false);
3625   SetLayerPropertiesForTesting(front_facing_child.get(),
3626                                identity_matrix,
3627                                gfx::Point3F(),
3628                                gfx::PointF(),
3629                                gfx::Size(100, 100),
3630                                true,
3631                                false);
3632   SetLayerPropertiesForTesting(back_facing_child.get(),
3633                                backface_matrix,
3634                                gfx::Point3F(),
3635                                gfx::PointF(),
3636                                gfx::Size(100, 100),
3637                                true,
3638                                false);
3639   SetLayerPropertiesForTesting(front_facing_surface.get(),
3640                                identity_matrix,
3641                                gfx::Point3F(),
3642                                gfx::PointF(),
3643                                gfx::Size(100, 100),
3644                                true,
3645                                false);
3646   SetLayerPropertiesForTesting(back_facing_surface.get(),
3647                                backface_matrix,
3648                                gfx::Point3F(),
3649                                gfx::PointF(),
3650                                gfx::Size(100, 100),
3651                                true,
3652                                false);
3653   SetLayerPropertiesForTesting(front_facing_child_of_front_facing_surface.get(),
3654                                identity_matrix,
3655                                gfx::Point3F(),
3656                                gfx::PointF(),
3657                                gfx::Size(100, 100),
3658                                true,
3659                                false);
3660   SetLayerPropertiesForTesting(back_facing_child_of_front_facing_surface.get(),
3661                                backface_matrix,
3662                                gfx::Point3F(),
3663                                gfx::PointF(),
3664                                gfx::Size(100, 100),
3665                                true,
3666                                false);
3667   SetLayerPropertiesForTesting(front_facing_child_of_back_facing_surface.get(),
3668                                identity_matrix,
3669                                gfx::Point3F(),
3670                                gfx::PointF(),
3671                                gfx::Size(100, 100),
3672                                true,
3673                                false);
3674   SetLayerPropertiesForTesting(back_facing_child_of_back_facing_surface.get(),
3675                                backface_matrix,
3676                                gfx::Point3F(),
3677                                gfx::PointF(),
3678                                gfx::Size(100, 100),
3679                                true,
3680                                false);
3681
3682   RenderSurfaceLayerList render_surface_layer_list;
3683   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
3684       parent.get(), parent->bounds(), &render_surface_layer_list);
3685   inputs.can_adjust_raster_scales = true;
3686   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
3687
3688   // Verify which render surfaces were created.
3689   EXPECT_FALSE(front_facing_child->render_surface());
3690   EXPECT_FALSE(back_facing_child->render_surface());
3691   EXPECT_TRUE(front_facing_surface->render_surface());
3692   EXPECT_TRUE(back_facing_surface->render_surface());
3693   EXPECT_FALSE(front_facing_child_of_front_facing_surface->render_surface());
3694   EXPECT_FALSE(back_facing_child_of_front_facing_surface->render_surface());
3695   EXPECT_FALSE(front_facing_child_of_back_facing_surface->render_surface());
3696   EXPECT_FALSE(back_facing_child_of_back_facing_surface->render_surface());
3697
3698   // Verify the render_surface_layer_list.
3699   ASSERT_EQ(3u, render_surface_layer_list.size());
3700   EXPECT_EQ(parent->id(), render_surface_layer_list.at(0)->id());
3701   EXPECT_EQ(front_facing_surface->id(), render_surface_layer_list.at(1)->id());
3702   // Even though the back facing surface LAYER gets culled, the other
3703   // descendants should still be added, so the SURFACE should not be culled.
3704   EXPECT_EQ(back_facing_surface->id(), render_surface_layer_list.at(2)->id());
3705
3706   // Verify root surface's layer list.
3707   ASSERT_EQ(
3708       3u,
3709       render_surface_layer_list.at(0)->render_surface()->layer_list().size());
3710   EXPECT_EQ(front_facing_child->id(),
3711             render_surface_layer_list.at(0)
3712                 ->render_surface()
3713                 ->layer_list()
3714                 .at(0)
3715                 ->id());
3716   EXPECT_EQ(front_facing_surface->id(),
3717             render_surface_layer_list.at(0)
3718                 ->render_surface()
3719                 ->layer_list()
3720                 .at(1)
3721                 ->id());
3722   EXPECT_EQ(back_facing_surface->id(),
3723             render_surface_layer_list.at(0)
3724                 ->render_surface()
3725                 ->layer_list()
3726                 .at(2)
3727                 ->id());
3728
3729   // Verify front_facing_surface's layer list.
3730   ASSERT_EQ(
3731       2u,
3732       render_surface_layer_list.at(1)->render_surface()->layer_list().size());
3733   EXPECT_EQ(front_facing_surface->id(),
3734             render_surface_layer_list.at(1)
3735                 ->render_surface()
3736                 ->layer_list()
3737                 .at(0)
3738                 ->id());
3739   EXPECT_EQ(front_facing_child_of_front_facing_surface->id(),
3740             render_surface_layer_list.at(1)
3741                 ->render_surface()
3742                 ->layer_list()
3743                 .at(1)
3744                 ->id());
3745
3746   // Verify back_facing_surface's layer list; its own layer should be culled
3747   // from the surface list.
3748   ASSERT_EQ(
3749       1u,
3750       render_surface_layer_list.at(2)->render_surface()->layer_list().size());
3751   EXPECT_EQ(front_facing_child_of_back_facing_surface->id(),
3752             render_surface_layer_list.at(2)
3753                 ->render_surface()
3754                 ->layer_list()
3755                 .at(0)
3756                 ->id());
3757 }
3758
3759 TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithPreserves3d) {
3760   // Verify the behavior of back-face culling when preserves-3d transform style
3761   // is used.
3762
3763   const gfx::Transform identity_matrix;
3764   scoped_refptr<Layer> parent = Layer::Create();
3765   scoped_refptr<LayerWithForcedDrawsContent> front_facing_child =
3766       make_scoped_refptr(new LayerWithForcedDrawsContent());
3767   scoped_refptr<LayerWithForcedDrawsContent> back_facing_child =
3768       make_scoped_refptr(new LayerWithForcedDrawsContent());
3769   scoped_refptr<LayerWithForcedDrawsContent> front_facing_surface =
3770       make_scoped_refptr(new LayerWithForcedDrawsContent());
3771   scoped_refptr<LayerWithForcedDrawsContent> back_facing_surface =
3772       make_scoped_refptr(new LayerWithForcedDrawsContent());
3773   scoped_refptr<LayerWithForcedDrawsContent>
3774   front_facing_child_of_front_facing_surface =
3775       make_scoped_refptr(new LayerWithForcedDrawsContent());
3776   scoped_refptr<LayerWithForcedDrawsContent>
3777   back_facing_child_of_front_facing_surface =
3778       make_scoped_refptr(new LayerWithForcedDrawsContent());
3779   scoped_refptr<LayerWithForcedDrawsContent>
3780   front_facing_child_of_back_facing_surface =
3781       make_scoped_refptr(new LayerWithForcedDrawsContent());
3782   scoped_refptr<LayerWithForcedDrawsContent>
3783   back_facing_child_of_back_facing_surface =
3784       make_scoped_refptr(new LayerWithForcedDrawsContent());
3785   scoped_refptr<LayerWithForcedDrawsContent> dummy_replica_layer1 =
3786       make_scoped_refptr(new LayerWithForcedDrawsContent());
3787   scoped_refptr<LayerWithForcedDrawsContent> dummy_replica_layer2 =
3788       make_scoped_refptr(new LayerWithForcedDrawsContent());
3789
3790   parent->AddChild(front_facing_child);
3791   parent->AddChild(back_facing_child);
3792   parent->AddChild(front_facing_surface);
3793   parent->AddChild(back_facing_surface);
3794   front_facing_surface->AddChild(front_facing_child_of_front_facing_surface);
3795   front_facing_surface->AddChild(back_facing_child_of_front_facing_surface);
3796   back_facing_surface->AddChild(front_facing_child_of_back_facing_surface);
3797   back_facing_surface->AddChild(back_facing_child_of_back_facing_surface);
3798
3799   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
3800   host->SetRootLayer(parent);
3801
3802   // Nothing is double-sided
3803   front_facing_child->SetDoubleSided(false);
3804   back_facing_child->SetDoubleSided(false);
3805   front_facing_surface->SetDoubleSided(false);
3806   back_facing_surface->SetDoubleSided(false);
3807   front_facing_child_of_front_facing_surface->SetDoubleSided(false);
3808   back_facing_child_of_front_facing_surface->SetDoubleSided(false);
3809   front_facing_child_of_back_facing_surface->SetDoubleSided(false);
3810   back_facing_child_of_back_facing_surface->SetDoubleSided(false);
3811
3812   gfx::Transform backface_matrix;
3813   backface_matrix.Translate(50.0, 50.0);
3814   backface_matrix.RotateAboutYAxis(180.0);
3815   backface_matrix.Translate(-50.0, -50.0);
3816
3817   // Opacity will not force creation of render surfaces in this case because of
3818   // the preserve-3d transform style. Instead, an example of when a surface
3819   // would be created with preserve-3d is when there is a replica layer.
3820   front_facing_surface->SetReplicaLayer(dummy_replica_layer1.get());
3821   back_facing_surface->SetReplicaLayer(dummy_replica_layer2.get());
3822
3823   // Each surface creates its own new 3d rendering context (as defined by W3C
3824   // spec).  According to current W3C CSS gfx::Transforms spec, layers in a 3d
3825   // rendering context should use the transform with respect to that context.
3826   // This 3d rendering context occurs when (a) parent's transform style is flat
3827   // and (b) the layer's transform style is preserve-3d.
3828   SetLayerPropertiesForTesting(parent.get(),
3829                                identity_matrix,
3830                                gfx::Point3F(),
3831                                gfx::PointF(),
3832                                gfx::Size(100, 100),
3833                                true,
3834                                false);  // parent transform style is flat.
3835   SetLayerPropertiesForTesting(front_facing_child.get(),
3836                                identity_matrix,
3837                                gfx::Point3F(),
3838                                gfx::PointF(),
3839                                gfx::Size(100, 100),
3840                                true,
3841                                false);
3842   SetLayerPropertiesForTesting(back_facing_child.get(),
3843                                backface_matrix,
3844                                gfx::Point3F(),
3845                                gfx::PointF(),
3846                                gfx::Size(100, 100),
3847                                true,
3848                                false);
3849   // surface transform style is preserve-3d.
3850   SetLayerPropertiesForTesting(front_facing_surface.get(),
3851                                identity_matrix,
3852                                gfx::Point3F(),
3853                                gfx::PointF(),
3854                                gfx::Size(100, 100),
3855                                false,
3856                                true);
3857   // surface transform style is preserve-3d.
3858   SetLayerPropertiesForTesting(back_facing_surface.get(),
3859                                backface_matrix,
3860                                gfx::Point3F(),
3861                                gfx::PointF(),
3862                                gfx::Size(100, 100),
3863                                false,
3864                                true);
3865   SetLayerPropertiesForTesting(front_facing_child_of_front_facing_surface.get(),
3866                                identity_matrix,
3867                                gfx::Point3F(),
3868                                gfx::PointF(),
3869                                gfx::Size(100, 100),
3870                                true,
3871                                true);
3872   SetLayerPropertiesForTesting(back_facing_child_of_front_facing_surface.get(),
3873                                backface_matrix,
3874                                gfx::Point3F(),
3875                                gfx::PointF(),
3876                                gfx::Size(100, 100),
3877                                true,
3878                                true);
3879   SetLayerPropertiesForTesting(front_facing_child_of_back_facing_surface.get(),
3880                                identity_matrix,
3881                                gfx::Point3F(),
3882                                gfx::PointF(),
3883                                gfx::Size(100, 100),
3884                                true,
3885                                true);
3886   SetLayerPropertiesForTesting(back_facing_child_of_back_facing_surface.get(),
3887                                backface_matrix,
3888                                gfx::Point3F(),
3889                                gfx::PointF(),
3890                                gfx::Size(100, 100),
3891                                true,
3892                                true);
3893
3894   RenderSurfaceLayerList render_surface_layer_list;
3895   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
3896       parent.get(), parent->bounds(), &render_surface_layer_list);
3897   inputs.can_adjust_raster_scales = true;
3898   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
3899
3900   // Verify which render surfaces were created and used.
3901   EXPECT_FALSE(front_facing_child->render_surface());
3902   EXPECT_FALSE(back_facing_child->render_surface());
3903   EXPECT_TRUE(front_facing_surface->render_surface());
3904   EXPECT_NE(back_facing_surface->render_target(), back_facing_surface);
3905   // We expect that a render_surface was created but not used.
3906   EXPECT_TRUE(back_facing_surface->render_surface());
3907   EXPECT_FALSE(front_facing_child_of_front_facing_surface->render_surface());
3908   EXPECT_FALSE(back_facing_child_of_front_facing_surface->render_surface());
3909   EXPECT_FALSE(front_facing_child_of_back_facing_surface->render_surface());
3910   EXPECT_FALSE(back_facing_child_of_back_facing_surface->render_surface());
3911
3912   // Verify the render_surface_layer_list. The back-facing surface should be
3913   // culled.
3914   ASSERT_EQ(2u, render_surface_layer_list.size());
3915   EXPECT_EQ(parent->id(), render_surface_layer_list.at(0)->id());
3916   EXPECT_EQ(front_facing_surface->id(), render_surface_layer_list.at(1)->id());
3917
3918   // Verify root surface's layer list.
3919   ASSERT_EQ(
3920       2u,
3921       render_surface_layer_list.at(0)->render_surface()->layer_list().size());
3922   EXPECT_EQ(front_facing_child->id(),
3923             render_surface_layer_list.at(0)
3924                 ->render_surface()->layer_list().at(0)->id());
3925   EXPECT_EQ(front_facing_surface->id(),
3926             render_surface_layer_list.at(0)
3927                 ->render_surface()->layer_list().at(1)->id());
3928
3929   // Verify front_facing_surface's layer list.
3930   ASSERT_EQ(
3931       2u,
3932       render_surface_layer_list.at(1)->render_surface()->layer_list().size());
3933   EXPECT_EQ(front_facing_surface->id(),
3934             render_surface_layer_list.at(1)
3935                 ->render_surface()->layer_list().at(0)->id());
3936   EXPECT_EQ(front_facing_child_of_front_facing_surface->id(),
3937             render_surface_layer_list.at(1)
3938                 ->render_surface()->layer_list().at(1)->id());
3939 }
3940
3941 TEST_F(LayerTreeHostCommonTest, BackFaceCullingWithAnimatingTransforms) {
3942   // Verify that layers are appropriately culled when their back face is showing
3943   // and they are not double sided, while animations are going on.
3944   //
3945   // Layers that are animating do not get culled on the main thread, as their
3946   // transforms should be treated as "unknown" so we can not be sure that their
3947   // back face is really showing.
3948   const gfx::Transform identity_matrix;
3949   scoped_refptr<Layer> parent = Layer::Create();
3950   scoped_refptr<LayerWithForcedDrawsContent> child =
3951       make_scoped_refptr(new LayerWithForcedDrawsContent());
3952   scoped_refptr<LayerWithForcedDrawsContent> animating_surface =
3953       make_scoped_refptr(new LayerWithForcedDrawsContent());
3954   scoped_refptr<LayerWithForcedDrawsContent> child_of_animating_surface =
3955       make_scoped_refptr(new LayerWithForcedDrawsContent());
3956   scoped_refptr<LayerWithForcedDrawsContent> animating_child =
3957       make_scoped_refptr(new LayerWithForcedDrawsContent());
3958   scoped_refptr<LayerWithForcedDrawsContent> child2 =
3959       make_scoped_refptr(new LayerWithForcedDrawsContent());
3960
3961   parent->AddChild(child);
3962   parent->AddChild(animating_surface);
3963   animating_surface->AddChild(child_of_animating_surface);
3964   parent->AddChild(animating_child);
3965   parent->AddChild(child2);
3966
3967   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
3968   host->SetRootLayer(parent);
3969
3970   // Nothing is double-sided
3971   child->SetDoubleSided(false);
3972   child2->SetDoubleSided(false);
3973   animating_surface->SetDoubleSided(false);
3974   child_of_animating_surface->SetDoubleSided(false);
3975   animating_child->SetDoubleSided(false);
3976
3977   gfx::Transform backface_matrix;
3978   backface_matrix.Translate(50.0, 50.0);
3979   backface_matrix.RotateAboutYAxis(180.0);
3980   backface_matrix.Translate(-50.0, -50.0);
3981
3982   // Make our render surface.
3983   animating_surface->SetForceRenderSurface(true);
3984
3985   // Animate the transform on the render surface.
3986   AddAnimatedTransformToController(
3987       animating_surface->layer_animation_controller(), 10.0, 30, 0);
3988   // This is just an animating layer, not a surface.
3989   AddAnimatedTransformToController(
3990       animating_child->layer_animation_controller(), 10.0, 30, 0);
3991
3992   SetLayerPropertiesForTesting(parent.get(),
3993                                identity_matrix,
3994                                gfx::Point3F(),
3995                                gfx::PointF(),
3996                                gfx::Size(100, 100),
3997                                true,
3998                                false);
3999   SetLayerPropertiesForTesting(child.get(),
4000                                backface_matrix,
4001                                gfx::Point3F(),
4002                                gfx::PointF(),
4003                                gfx::Size(100, 100),
4004                                true,
4005                                false);
4006   SetLayerPropertiesForTesting(animating_surface.get(),
4007                                backface_matrix,
4008                                gfx::Point3F(),
4009                                gfx::PointF(),
4010                                gfx::Size(100, 100),
4011                                true,
4012                                false);
4013   SetLayerPropertiesForTesting(child_of_animating_surface.get(),
4014                                backface_matrix,
4015                                gfx::Point3F(),
4016                                gfx::PointF(),
4017                                gfx::Size(100, 100),
4018                                true,
4019                                false);
4020   SetLayerPropertiesForTesting(animating_child.get(),
4021                                backface_matrix,
4022                                gfx::Point3F(),
4023                                gfx::PointF(),
4024                                gfx::Size(100, 100),
4025                                true,
4026                                false);
4027   SetLayerPropertiesForTesting(child2.get(),
4028                                identity_matrix,
4029                                gfx::Point3F(),
4030                                gfx::PointF(),
4031                                gfx::Size(100, 100),
4032                                true,
4033                                false);
4034
4035   RenderSurfaceLayerList render_surface_layer_list;
4036   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
4037       parent.get(), parent->bounds(), &render_surface_layer_list);
4038   inputs.can_adjust_raster_scales = true;
4039   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
4040
4041   EXPECT_FALSE(child->render_surface());
4042   EXPECT_TRUE(animating_surface->render_surface());
4043   EXPECT_FALSE(child_of_animating_surface->render_surface());
4044   EXPECT_FALSE(animating_child->render_surface());
4045   EXPECT_FALSE(child2->render_surface());
4046
4047   // Verify that the animating_child and child_of_animating_surface were not
4048   // culled, but that child was.
4049   ASSERT_EQ(2u, render_surface_layer_list.size());
4050   EXPECT_EQ(parent->id(), render_surface_layer_list.at(0)->id());
4051   EXPECT_EQ(animating_surface->id(), render_surface_layer_list.at(1)->id());
4052
4053   // The non-animating child be culled from the layer list for the parent render
4054   // surface.
4055   ASSERT_EQ(
4056       3u,
4057       render_surface_layer_list.at(0)->render_surface()->layer_list().size());
4058   EXPECT_EQ(animating_surface->id(),
4059             render_surface_layer_list.at(0)
4060                 ->render_surface()->layer_list().at(0)->id());
4061   EXPECT_EQ(animating_child->id(),
4062             render_surface_layer_list.at(0)
4063                 ->render_surface()->layer_list().at(1)->id());
4064   EXPECT_EQ(child2->id(),
4065             render_surface_layer_list.at(0)
4066                 ->render_surface()->layer_list().at(2)->id());
4067
4068   ASSERT_EQ(
4069       2u,
4070       render_surface_layer_list.at(1)->render_surface()->layer_list().size());
4071   EXPECT_EQ(animating_surface->id(),
4072             render_surface_layer_list.at(1)
4073                 ->render_surface()->layer_list().at(0)->id());
4074   EXPECT_EQ(child_of_animating_surface->id(),
4075             render_surface_layer_list.at(1)
4076                 ->render_surface()->layer_list().at(1)->id());
4077
4078   EXPECT_FALSE(child2->visible_content_rect().IsEmpty());
4079
4080   // The animating layers should have a visible content rect that represents the
4081   // area of the front face that is within the viewport.
4082   EXPECT_EQ(animating_child->visible_content_rect(),
4083             gfx::Rect(animating_child->content_bounds()));
4084   EXPECT_EQ(animating_surface->visible_content_rect(),
4085             gfx::Rect(animating_surface->content_bounds()));
4086   // And layers in the subtree of the animating layer should have valid visible
4087   // content rects also.
4088   EXPECT_EQ(child_of_animating_surface->visible_content_rect(),
4089             gfx::Rect(child_of_animating_surface->content_bounds()));
4090 }
4091
4092 TEST_F(LayerTreeHostCommonTest,
4093      BackFaceCullingWithPreserves3dForFlatteningSurface) {
4094   // Verify the behavior of back-face culling for a render surface that is
4095   // created when it flattens its subtree, and its parent has preserves-3d.
4096
4097   const gfx::Transform identity_matrix;
4098   scoped_refptr<Layer> parent = Layer::Create();
4099   scoped_refptr<LayerWithForcedDrawsContent> front_facing_surface =
4100       make_scoped_refptr(new LayerWithForcedDrawsContent());
4101   scoped_refptr<LayerWithForcedDrawsContent> back_facing_surface =
4102       make_scoped_refptr(new LayerWithForcedDrawsContent());
4103   scoped_refptr<LayerWithForcedDrawsContent> child1 =
4104       make_scoped_refptr(new LayerWithForcedDrawsContent());
4105   scoped_refptr<LayerWithForcedDrawsContent> child2 =
4106       make_scoped_refptr(new LayerWithForcedDrawsContent());
4107
4108   parent->AddChild(front_facing_surface);
4109   parent->AddChild(back_facing_surface);
4110   front_facing_surface->AddChild(child1);
4111   back_facing_surface->AddChild(child2);
4112
4113   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
4114   host->SetRootLayer(parent);
4115
4116   // RenderSurfaces are not double-sided
4117   front_facing_surface->SetDoubleSided(false);
4118   back_facing_surface->SetDoubleSided(false);
4119
4120   gfx::Transform backface_matrix;
4121   backface_matrix.Translate(50.0, 50.0);
4122   backface_matrix.RotateAboutYAxis(180.0);
4123   backface_matrix.Translate(-50.0, -50.0);
4124
4125   SetLayerPropertiesForTesting(parent.get(),
4126                                identity_matrix,
4127                                gfx::Point3F(),
4128                                gfx::PointF(),
4129                                gfx::Size(100, 100),
4130                                false,
4131                                true);  // parent transform style is preserve3d.
4132   SetLayerPropertiesForTesting(front_facing_surface.get(),
4133                                identity_matrix,
4134                                gfx::Point3F(),
4135                                gfx::PointF(),
4136                                gfx::Size(100, 100),
4137                                true,
4138                                true);  // surface transform style is flat.
4139   SetLayerPropertiesForTesting(back_facing_surface.get(),
4140                                backface_matrix,
4141                                gfx::Point3F(),
4142                                gfx::PointF(),
4143                                gfx::Size(100, 100),
4144                                true,
4145                                true);  // surface transform style is flat.
4146   SetLayerPropertiesForTesting(child1.get(),
4147                                identity_matrix,
4148                                gfx::Point3F(),
4149                                gfx::PointF(),
4150                                gfx::Size(100, 100),
4151                                true,
4152                                false);
4153   SetLayerPropertiesForTesting(child2.get(),
4154                                identity_matrix,
4155                                gfx::Point3F(),
4156                                gfx::PointF(),
4157                                gfx::Size(100, 100),
4158                                true,
4159                                false);
4160
4161   front_facing_surface->Set3dSortingContextId(1);
4162   back_facing_surface->Set3dSortingContextId(1);
4163
4164   RenderSurfaceLayerList render_surface_layer_list;
4165   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
4166       parent.get(), parent->bounds(), &render_surface_layer_list);
4167   inputs.can_adjust_raster_scales = true;
4168   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
4169
4170   // Verify which render surfaces were created and used.
4171   EXPECT_TRUE(front_facing_surface->render_surface());
4172
4173   // We expect the render surface to have been created, but remain unused.
4174   EXPECT_TRUE(back_facing_surface->render_surface());
4175   EXPECT_NE(back_facing_surface->render_target(),
4176             back_facing_surface);  // because it should be culled
4177   EXPECT_FALSE(child1->render_surface());
4178   EXPECT_FALSE(child2->render_surface());
4179
4180   // Verify the render_surface_layer_list. The back-facing surface should be
4181   // culled.
4182   ASSERT_EQ(2u, render_surface_layer_list.size());
4183   EXPECT_EQ(parent->id(), render_surface_layer_list.at(0)->id());
4184   EXPECT_EQ(front_facing_surface->id(), render_surface_layer_list.at(1)->id());
4185
4186   // Verify root surface's layer list.
4187   ASSERT_EQ(
4188       1u,
4189       render_surface_layer_list.at(0)->render_surface()->layer_list().size());
4190   EXPECT_EQ(front_facing_surface->id(),
4191             render_surface_layer_list.at(0)
4192                 ->render_surface()->layer_list().at(0)->id());
4193
4194   // Verify front_facing_surface's layer list.
4195   ASSERT_EQ(
4196       2u,
4197       render_surface_layer_list.at(1)->render_surface()->layer_list().size());
4198   EXPECT_EQ(front_facing_surface->id(),
4199             render_surface_layer_list.at(1)
4200                 ->render_surface()->layer_list().at(0)->id());
4201   EXPECT_EQ(child1->id(),
4202             render_surface_layer_list.at(1)
4203                 ->render_surface()->layer_list().at(1)->id());
4204 }
4205
4206 class NoScaleContentLayer : public ContentLayer {
4207  public:
4208   static scoped_refptr<NoScaleContentLayer> Create(ContentLayerClient* client) {
4209     return make_scoped_refptr(new NoScaleContentLayer(client));
4210   }
4211
4212   void CalculateContentsScale(float ideal_contents_scale,
4213                               float* contents_scale_x,
4214                               float* contents_scale_y,
4215                               gfx::Size* content_bounds) override {
4216     // Skip over the ContentLayer to the base Layer class.
4217     Layer::CalculateContentsScale(ideal_contents_scale,
4218                                   contents_scale_x,
4219                                   contents_scale_y,
4220                                   content_bounds);
4221   }
4222
4223  protected:
4224   explicit NoScaleContentLayer(ContentLayerClient* client)
4225       : ContentLayer(client) {}
4226   ~NoScaleContentLayer() override {}
4227 };
4228
4229 scoped_refptr<NoScaleContentLayer> CreateNoScaleDrawableContentLayer(
4230     ContentLayerClient* delegate) {
4231   scoped_refptr<NoScaleContentLayer> to_return =
4232       NoScaleContentLayer::Create(delegate);
4233   to_return->SetIsDrawable(true);
4234   return to_return;
4235 }
4236
4237 TEST_F(LayerTreeHostCommonTest, LayerTransformsInHighDPI) {
4238   // Verify draw and screen space transforms of layers not in a surface.
4239   MockContentLayerClient delegate;
4240   gfx::Transform identity_matrix;
4241
4242   scoped_refptr<FakePictureLayer> parent =
4243       CreateDrawablePictureLayer(&delegate);
4244   SetLayerPropertiesForTesting(parent.get(),
4245                                identity_matrix,
4246                                gfx::Point3F(),
4247                                gfx::PointF(),
4248                                gfx::Size(100, 100),
4249                                false,
4250                                true);
4251
4252   scoped_refptr<FakePictureLayer> child = CreateDrawablePictureLayer(&delegate);
4253   SetLayerPropertiesForTesting(child.get(),
4254                                identity_matrix,
4255                                gfx::Point3F(),
4256                                gfx::PointF(2.f, 2.f),
4257                                gfx::Size(10, 10),
4258                                false,
4259                                true);
4260
4261   scoped_refptr<FakePictureLayer> child_empty =
4262       CreateDrawablePictureLayer(&delegate);
4263   SetLayerPropertiesForTesting(child_empty.get(),
4264                                identity_matrix,
4265                                gfx::Point3F(),
4266                                gfx::PointF(2.f, 2.f),
4267                                gfx::Size(),
4268                                false,
4269                                true);
4270
4271   parent->AddChild(child);
4272   parent->AddChild(child_empty);
4273
4274   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
4275   host->SetRootLayer(parent);
4276
4277   float device_scale_factor = 2.5f;
4278   float page_scale_factor = 1.f;
4279
4280   RenderSurfaceLayerList render_surface_layer_list;
4281   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
4282       parent.get(), parent->bounds(), &render_surface_layer_list);
4283   inputs.device_scale_factor = device_scale_factor;
4284   inputs.page_scale_factor = page_scale_factor;
4285   inputs.can_adjust_raster_scales = true;
4286   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
4287
4288   EXPECT_IDEAL_SCALE_EQ(device_scale_factor * page_scale_factor, parent);
4289   EXPECT_IDEAL_SCALE_EQ(device_scale_factor * page_scale_factor, child);
4290   EXPECT_IDEAL_SCALE_EQ(device_scale_factor * page_scale_factor, child_empty);
4291
4292   EXPECT_EQ(1u, render_surface_layer_list.size());
4293
4294   // Verify parent transforms
4295   gfx::Transform expected_parent_transform;
4296   expected_parent_transform.Scale(device_scale_factor * page_scale_factor,
4297                                   device_scale_factor * page_scale_factor);
4298   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform,
4299                                   parent->screen_space_transform());
4300   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform,
4301                                   parent->draw_transform());
4302
4303   // Verify results of transformed parent rects
4304   gfx::RectF parent_content_bounds(parent->content_bounds());
4305
4306   gfx::RectF parent_draw_rect =
4307       MathUtil::MapClippedRect(parent->draw_transform(), parent_content_bounds);
4308   gfx::RectF parent_screen_space_rect = MathUtil::MapClippedRect(
4309       parent->screen_space_transform(), parent_content_bounds);
4310
4311   gfx::RectF expected_parent_draw_rect(parent->bounds());
4312   expected_parent_draw_rect.Scale(device_scale_factor);
4313   EXPECT_FLOAT_RECT_EQ(expected_parent_draw_rect, parent_draw_rect);
4314   EXPECT_FLOAT_RECT_EQ(expected_parent_draw_rect, parent_screen_space_rect);
4315
4316   // Verify child and child_empty transforms. They should match.
4317   gfx::Transform expected_child_transform;
4318   expected_child_transform.Scale(device_scale_factor, device_scale_factor);
4319   expected_child_transform.Translate(child->position().x(),
4320                                      child->position().y());
4321   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
4322                                   child->draw_transform());
4323   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
4324                                   child->screen_space_transform());
4325   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
4326                                   child_empty->draw_transform());
4327   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
4328                                   child_empty->screen_space_transform());
4329
4330   // Verify results of transformed child and child_empty rects. They should
4331   // match.
4332   gfx::RectF child_content_bounds(child->content_bounds());
4333
4334   gfx::RectF child_draw_rect =
4335       MathUtil::MapClippedRect(child->draw_transform(), child_content_bounds);
4336   gfx::RectF child_screen_space_rect = MathUtil::MapClippedRect(
4337       child->screen_space_transform(), child_content_bounds);
4338
4339   gfx::RectF child_empty_draw_rect = MathUtil::MapClippedRect(
4340       child_empty->draw_transform(), child_content_bounds);
4341   gfx::RectF child_empty_screen_space_rect = MathUtil::MapClippedRect(
4342       child_empty->screen_space_transform(), child_content_bounds);
4343
4344   gfx::RectF expected_child_draw_rect(child->position(), child->bounds());
4345   expected_child_draw_rect.Scale(device_scale_factor);
4346   EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child_draw_rect);
4347   EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child_screen_space_rect);
4348   EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child_empty_draw_rect);
4349   EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child_empty_screen_space_rect);
4350 }
4351
4352 TEST_F(LayerTreeHostCommonTest, SurfaceLayerTransformsInHighDPI) {
4353   // Verify draw and screen space transforms of layers in a surface.
4354   MockContentLayerClient delegate;
4355   gfx::Transform identity_matrix;
4356
4357   gfx::Transform perspective_matrix;
4358   perspective_matrix.ApplyPerspectiveDepth(2.0);
4359
4360   gfx::Transform scale_small_matrix;
4361   scale_small_matrix.Scale(SK_MScalar1 / 10.f, SK_MScalar1 / 12.f);
4362
4363   scoped_refptr<Layer> root = Layer::Create();
4364
4365   scoped_refptr<FakePictureLayer> parent =
4366       CreateDrawablePictureLayer(&delegate);
4367   SetLayerPropertiesForTesting(parent.get(),
4368                                identity_matrix,
4369                                gfx::Point3F(),
4370                                gfx::PointF(),
4371                                gfx::Size(100, 100),
4372                                false,
4373                                true);
4374
4375   scoped_refptr<FakePictureLayer> perspective_surface =
4376       CreateDrawablePictureLayer(&delegate);
4377   SetLayerPropertiesForTesting(perspective_surface.get(),
4378                                perspective_matrix * scale_small_matrix,
4379                                gfx::Point3F(),
4380                                gfx::PointF(2.f, 2.f),
4381                                gfx::Size(10, 10),
4382                                false,
4383                                true);
4384
4385   scoped_refptr<FakePictureLayer> scale_surface =
4386       CreateDrawablePictureLayer(&delegate);
4387   SetLayerPropertiesForTesting(scale_surface.get(),
4388                                scale_small_matrix,
4389                                gfx::Point3F(),
4390                                gfx::PointF(2.f, 2.f),
4391                                gfx::Size(10, 10),
4392                                false,
4393                                true);
4394
4395   perspective_surface->SetForceRenderSurface(true);
4396   scale_surface->SetForceRenderSurface(true);
4397
4398   parent->AddChild(perspective_surface);
4399   parent->AddChild(scale_surface);
4400   root->AddChild(parent);
4401
4402   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
4403   host->SetRootLayer(root);
4404
4405   float device_scale_factor = 2.5f;
4406   float page_scale_factor = 3.f;
4407
4408   RenderSurfaceLayerList render_surface_layer_list;
4409   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
4410       root.get(), parent->bounds(), &render_surface_layer_list);
4411   inputs.device_scale_factor = device_scale_factor;
4412   inputs.page_scale_factor = page_scale_factor;
4413   inputs.page_scale_application_layer = root.get();
4414   inputs.can_adjust_raster_scales = true;
4415   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
4416
4417   EXPECT_IDEAL_SCALE_EQ(device_scale_factor * page_scale_factor, parent);
4418   EXPECT_IDEAL_SCALE_EQ(device_scale_factor * page_scale_factor,
4419                         perspective_surface);
4420   // Ideal scale is the max 2d scale component of the combined transform up to
4421   // the nearest render target. Here this includes the layer transform as well
4422   // as the device and page scale factors.
4423   gfx::Transform transform = scale_small_matrix;
4424   transform.Scale(device_scale_factor * page_scale_factor,
4425                   device_scale_factor * page_scale_factor);
4426   gfx::Vector2dF scales =
4427       MathUtil::ComputeTransform2dScaleComponents(transform, 0.f);
4428   float max_2d_scale = std::max(scales.x(), scales.y());
4429   EXPECT_IDEAL_SCALE_EQ(max_2d_scale, scale_surface);
4430
4431   // The ideal scale will draw 1:1 with its render target space along
4432   // the larger-scale axis.
4433   gfx::Vector2dF target_space_transform_scales =
4434       MathUtil::ComputeTransform2dScaleComponents(
4435           scale_surface->draw_properties().target_space_transform, 0.f);
4436   EXPECT_FLOAT_EQ(max_2d_scale,
4437                   std::max(target_space_transform_scales.x(),
4438                            target_space_transform_scales.y()));
4439
4440   EXPECT_EQ(3u, render_surface_layer_list.size());
4441
4442   gfx::Transform expected_parent_draw_transform;
4443   expected_parent_draw_transform.Scale(device_scale_factor * page_scale_factor,
4444                                        device_scale_factor * page_scale_factor);
4445   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_draw_transform,
4446                                   parent->draw_transform());
4447
4448   // The scale for the perspective surface is not known, so it is rendered 1:1
4449   // with the screen, and then scaled during drawing.
4450   gfx::Transform expected_perspective_surface_draw_transform;
4451   expected_perspective_surface_draw_transform.Translate(
4452       device_scale_factor * page_scale_factor *
4453       perspective_surface->position().x(),
4454       device_scale_factor * page_scale_factor *
4455       perspective_surface->position().y());
4456   expected_perspective_surface_draw_transform.PreconcatTransform(
4457       perspective_matrix);
4458   expected_perspective_surface_draw_transform.PreconcatTransform(
4459       scale_small_matrix);
4460   gfx::Transform expected_perspective_surface_layer_draw_transform;
4461   expected_perspective_surface_layer_draw_transform.Scale(
4462       device_scale_factor * page_scale_factor,
4463       device_scale_factor * page_scale_factor);
4464   EXPECT_TRANSFORMATION_MATRIX_EQ(
4465       expected_perspective_surface_draw_transform,
4466       perspective_surface->render_surface()->draw_transform());
4467   EXPECT_TRANSFORMATION_MATRIX_EQ(
4468       expected_perspective_surface_layer_draw_transform,
4469       perspective_surface->draw_transform());
4470 }
4471
4472 // TODO(sohanjg): Remove this test when ContentLayer is removed.
4473 TEST_F(LayerTreeHostCommonTest,
4474      LayerTransformsInHighDPIAccurateScaleZeroChildPosition) {
4475   // Verify draw and screen space transforms of layers not in a surface.
4476   MockContentLayerClient delegate;
4477   gfx::Transform identity_matrix;
4478
4479   scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate);
4480   SetLayerPropertiesForTesting(parent.get(),
4481                                identity_matrix,
4482                                gfx::Point3F(),
4483                                gfx::PointF(),
4484                                gfx::Size(133, 133),
4485                                false,
4486                                true);
4487
4488   scoped_refptr<ContentLayer> child = CreateDrawableContentLayer(&delegate);
4489   SetLayerPropertiesForTesting(child.get(),
4490                                identity_matrix,
4491                                gfx::Point3F(),
4492                                gfx::PointF(),
4493                                gfx::Size(13, 13),
4494                                false,
4495                                true);
4496
4497   scoped_refptr<NoScaleContentLayer> child_no_scale =
4498       CreateNoScaleDrawableContentLayer(&delegate);
4499   SetLayerPropertiesForTesting(child_no_scale.get(),
4500                                identity_matrix,
4501                                gfx::Point3F(),
4502                                gfx::PointF(),
4503                                gfx::Size(13, 13),
4504                                false,
4505                                true);
4506
4507   parent->AddChild(child);
4508   parent->AddChild(child_no_scale);
4509
4510   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
4511   host->SetRootLayer(parent);
4512
4513   float device_scale_factor = 1.7f;
4514   float page_scale_factor = 1.f;
4515
4516   RenderSurfaceLayerList render_surface_layer_list;
4517   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
4518       parent.get(), parent->bounds(), &render_surface_layer_list);
4519   inputs.device_scale_factor = device_scale_factor;
4520   inputs.page_scale_factor = page_scale_factor;
4521   inputs.page_scale_application_layer = parent.get();
4522   inputs.can_adjust_raster_scales = true;
4523   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
4524
4525   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor, parent);
4526   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor, child);
4527   EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
4528
4529   EXPECT_EQ(1u, render_surface_layer_list.size());
4530
4531   // Verify parent transforms
4532   gfx::Transform expected_parent_transform;
4533   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform,
4534                                   parent->screen_space_transform());
4535   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform,
4536                                   parent->draw_transform());
4537
4538   // Verify results of transformed parent rects
4539   gfx::RectF parent_content_bounds(parent->content_bounds());
4540
4541   gfx::RectF parent_draw_rect =
4542       MathUtil::MapClippedRect(parent->draw_transform(), parent_content_bounds);
4543   gfx::RectF parent_screen_space_rect = MathUtil::MapClippedRect(
4544       parent->screen_space_transform(), parent_content_bounds);
4545
4546   gfx::RectF expected_parent_draw_rect(parent->bounds());
4547   expected_parent_draw_rect.Scale(device_scale_factor);
4548   expected_parent_draw_rect.set_width(ceil(expected_parent_draw_rect.width()));
4549   expected_parent_draw_rect.set_height(
4550       ceil(expected_parent_draw_rect.height()));
4551   EXPECT_FLOAT_RECT_EQ(expected_parent_draw_rect, parent_draw_rect);
4552   EXPECT_FLOAT_RECT_EQ(expected_parent_draw_rect, parent_screen_space_rect);
4553
4554   // Verify child transforms
4555   gfx::Transform expected_child_transform;
4556   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
4557                                   child->draw_transform());
4558   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
4559                                   child->screen_space_transform());
4560
4561   // Verify results of transformed child rects
4562   gfx::RectF child_content_bounds(child->content_bounds());
4563
4564   gfx::RectF child_draw_rect =
4565       MathUtil::MapClippedRect(child->draw_transform(), child_content_bounds);
4566   gfx::RectF child_screen_space_rect = MathUtil::MapClippedRect(
4567       child->screen_space_transform(), child_content_bounds);
4568
4569   gfx::RectF expected_child_draw_rect(child->bounds());
4570   expected_child_draw_rect.Scale(device_scale_factor);
4571   expected_child_draw_rect.set_width(ceil(expected_child_draw_rect.width()));
4572   expected_child_draw_rect.set_height(ceil(expected_child_draw_rect.height()));
4573   EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child_draw_rect);
4574   EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child_screen_space_rect);
4575
4576   // Verify child_no_scale transforms
4577   gfx::Transform expected_child_no_scale_transform = child->draw_transform();
4578   // All transforms operate on content rects. The child's content rect
4579   // incorporates device scale, but the child_no_scale does not; add it here.
4580   expected_child_no_scale_transform.Scale(device_scale_factor,
4581                                           device_scale_factor);
4582   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_no_scale_transform,
4583                                   child_no_scale->draw_transform());
4584   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_no_scale_transform,
4585                                   child_no_scale->screen_space_transform());
4586 }
4587
4588 // TODO(sohanjg): Remove this test when ContentLayer is removed.
4589 TEST_F(LayerTreeHostCommonTest, ContentsScale) {
4590   MockContentLayerClient delegate;
4591   gfx::Transform identity_matrix;
4592
4593   gfx::Transform parent_scale_matrix;
4594   SkMScalar initial_parent_scale = 1.75;
4595   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
4596
4597   gfx::Transform child_scale_matrix;
4598   SkMScalar initial_child_scale = 1.25;
4599   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
4600
4601   scoped_refptr<Layer> root = Layer::Create();
4602   root->SetBounds(gfx::Size(100, 100));
4603
4604   scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate);
4605   SetLayerPropertiesForTesting(parent.get(),
4606                                parent_scale_matrix,
4607                                gfx::Point3F(),
4608                                gfx::PointF(),
4609                                gfx::Size(100, 100),
4610                                false,
4611                                true);
4612
4613   scoped_refptr<ContentLayer> child_scale =
4614       CreateDrawableContentLayer(&delegate);
4615   SetLayerPropertiesForTesting(child_scale.get(),
4616                                child_scale_matrix,
4617                                gfx::Point3F(),
4618                                gfx::PointF(2.f, 2.f),
4619                                gfx::Size(10, 10),
4620                                false,
4621                                true);
4622
4623   scoped_refptr<ContentLayer> child_empty =
4624       CreateDrawableContentLayer(&delegate);
4625   SetLayerPropertiesForTesting(child_empty.get(),
4626                                child_scale_matrix,
4627                                gfx::Point3F(),
4628                                gfx::PointF(2.f, 2.f),
4629                                gfx::Size(),
4630                                false,
4631                                true);
4632
4633   scoped_refptr<NoScaleContentLayer> child_no_scale =
4634       CreateNoScaleDrawableContentLayer(&delegate);
4635   SetLayerPropertiesForTesting(child_no_scale.get(),
4636                                child_scale_matrix,
4637                                gfx::Point3F(),
4638                                gfx::PointF(12.f, 12.f),
4639                                gfx::Size(10, 10),
4640                                false,
4641                                true);
4642
4643   root->AddChild(parent);
4644
4645   parent->AddChild(child_scale);
4646   parent->AddChild(child_empty);
4647   parent->AddChild(child_no_scale);
4648
4649   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
4650   host->SetRootLayer(root);
4651
4652   float device_scale_factor = 2.5f;
4653   float page_scale_factor = 1.f;
4654
4655   {
4656     RenderSurfaceLayerList render_surface_layer_list;
4657     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
4658         root.get(), root->bounds(), &render_surface_layer_list);
4659     inputs.device_scale_factor = device_scale_factor;
4660     inputs.page_scale_factor = page_scale_factor;
4661     inputs.page_scale_application_layer = root.get();
4662     inputs.can_adjust_raster_scales = true;
4663     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
4664
4665     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
4666                              initial_parent_scale, parent);
4667     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
4668                              initial_parent_scale * initial_child_scale,
4669                              child_scale);
4670     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
4671                              initial_parent_scale * initial_child_scale,
4672                              child_empty);
4673     EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
4674
4675     // The parent is scaled up and shouldn't need to scale during draw. The
4676     // child that can scale its contents should also not need to scale during
4677     // draw. This shouldn't change if the child has empty bounds. The other
4678     // children should.
4679     EXPECT_FLOAT_EQ(1.0, parent->draw_transform().matrix().get(0, 0));
4680     EXPECT_FLOAT_EQ(1.0, parent->draw_transform().matrix().get(1, 1));
4681     EXPECT_FLOAT_EQ(1.0, child_scale->draw_transform().matrix().get(0, 0));
4682     EXPECT_FLOAT_EQ(1.0, child_scale->draw_transform().matrix().get(1, 1));
4683     EXPECT_FLOAT_EQ(1.0, child_empty->draw_transform().matrix().get(0, 0));
4684     EXPECT_FLOAT_EQ(1.0, child_empty->draw_transform().matrix().get(1, 1));
4685     EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
4686                         initial_parent_scale * initial_child_scale,
4687                     child_no_scale->draw_transform().matrix().get(0, 0));
4688     EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
4689                         initial_parent_scale * initial_child_scale,
4690                     child_no_scale->draw_transform().matrix().get(1, 1));
4691   }
4692
4693   // If the device_scale_factor or page_scale_factor changes, then it should be
4694   // updated using the initial transform as the raster scale.
4695   device_scale_factor = 2.25f;
4696   page_scale_factor = 1.25f;
4697
4698   {
4699     RenderSurfaceLayerList render_surface_layer_list;
4700     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
4701         root.get(), root->bounds(), &render_surface_layer_list);
4702     inputs.device_scale_factor = device_scale_factor;
4703     inputs.page_scale_factor = page_scale_factor;
4704     inputs.page_scale_application_layer = root.get();
4705     inputs.can_adjust_raster_scales = true;
4706     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
4707
4708     EXPECT_CONTENTS_SCALE_EQ(
4709         device_scale_factor * page_scale_factor * initial_parent_scale, parent);
4710     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
4711                                  initial_parent_scale * initial_child_scale,
4712                              child_scale);
4713     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
4714                              initial_parent_scale * initial_child_scale,
4715                              child_empty);
4716     EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
4717   }
4718
4719   // If the transform changes, we expect the raster scale to be reset to 1.0.
4720   SkMScalar second_child_scale = 1.75;
4721   child_scale_matrix.Scale(second_child_scale / initial_child_scale,
4722                            second_child_scale / initial_child_scale);
4723   child_scale->SetTransform(child_scale_matrix);
4724   child_empty->SetTransform(child_scale_matrix);
4725
4726   {
4727     RenderSurfaceLayerList render_surface_layer_list;
4728     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
4729         root.get(), root->bounds(), &render_surface_layer_list);
4730     inputs.device_scale_factor = device_scale_factor;
4731     inputs.page_scale_factor = page_scale_factor;
4732     inputs.page_scale_application_layer = root.get();
4733     inputs.can_adjust_raster_scales = true;
4734     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
4735
4736     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
4737                              initial_parent_scale,
4738                              parent);
4739     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
4740                              child_scale);
4741     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
4742                              child_empty);
4743     EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
4744   }
4745
4746   // If the device_scale_factor or page_scale_factor changes, then it should be
4747   // updated, but still using 1.0 as the raster scale.
4748   device_scale_factor = 2.75f;
4749   page_scale_factor = 1.75f;
4750
4751   {
4752     RenderSurfaceLayerList render_surface_layer_list;
4753     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
4754         root.get(), root->bounds(), &render_surface_layer_list);
4755     inputs.device_scale_factor = device_scale_factor;
4756     inputs.page_scale_factor = page_scale_factor;
4757     inputs.page_scale_application_layer = root.get();
4758     inputs.can_adjust_raster_scales = true;
4759     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
4760
4761     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
4762                              initial_parent_scale,
4763                              parent);
4764     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
4765                              child_scale);
4766     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
4767                              child_empty);
4768     EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
4769   }
4770 }
4771
4772 // TODO(sohanjg): Remove this test when ContentLayer is removed.
4773 TEST_F(LayerTreeHostCommonTest,
4774        ContentsScale_LayerTransformsDontAffectContentsScale) {
4775   MockContentLayerClient delegate;
4776   gfx::Transform identity_matrix;
4777
4778   gfx::Transform parent_scale_matrix;
4779   SkMScalar initial_parent_scale = 1.75;
4780   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
4781
4782   gfx::Transform child_scale_matrix;
4783   SkMScalar initial_child_scale = 1.25;
4784   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
4785
4786   scoped_refptr<Layer> root = Layer::Create();
4787   root->SetBounds(gfx::Size(100, 100));
4788
4789   scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate);
4790   SetLayerPropertiesForTesting(parent.get(),
4791                                parent_scale_matrix,
4792                                gfx::Point3F(),
4793                                gfx::PointF(),
4794                                gfx::Size(100, 100),
4795                                false,
4796                                true);
4797
4798   scoped_refptr<ContentLayer> child_scale =
4799       CreateDrawableContentLayer(&delegate);
4800   SetLayerPropertiesForTesting(child_scale.get(),
4801                                child_scale_matrix,
4802                                gfx::Point3F(),
4803                                gfx::PointF(2.f, 2.f),
4804                                gfx::Size(10, 10),
4805                                false,
4806                                true);
4807
4808   scoped_refptr<ContentLayer> child_empty =
4809       CreateDrawableContentLayer(&delegate);
4810   SetLayerPropertiesForTesting(child_empty.get(),
4811                                child_scale_matrix,
4812                                gfx::Point3F(),
4813                                gfx::PointF(2.f, 2.f),
4814                                gfx::Size(),
4815                                false,
4816                                true);
4817
4818   scoped_refptr<NoScaleContentLayer> child_no_scale =
4819       CreateNoScaleDrawableContentLayer(&delegate);
4820   SetLayerPropertiesForTesting(child_no_scale.get(),
4821                                child_scale_matrix,
4822                                gfx::Point3F(),
4823                                gfx::PointF(12.f, 12.f),
4824                                gfx::Size(10, 10),
4825                                false,
4826                                true);
4827
4828   root->AddChild(parent);
4829
4830   parent->AddChild(child_scale);
4831   parent->AddChild(child_empty);
4832   parent->AddChild(child_no_scale);
4833
4834   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
4835   host->SetRootLayer(root);
4836
4837   RenderSurfaceLayerList render_surface_layer_list;
4838
4839   float device_scale_factor = 2.5f;
4840   float page_scale_factor = 1.f;
4841
4842   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
4843       root.get(), root->bounds(), &render_surface_layer_list);
4844   inputs.device_scale_factor = device_scale_factor;
4845   inputs.page_scale_factor = page_scale_factor;
4846   inputs.page_scale_application_layer = root.get(),
4847   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
4848
4849   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor, parent);
4850   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
4851                            child_scale);
4852   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
4853                            child_empty);
4854   EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
4855
4856   // Since the transform scale does not affect contents scale, it should affect
4857   // the draw transform instead.
4858   EXPECT_FLOAT_EQ(initial_parent_scale,
4859                   parent->draw_transform().matrix().get(0, 0));
4860   EXPECT_FLOAT_EQ(initial_parent_scale,
4861                   parent->draw_transform().matrix().get(1, 1));
4862   EXPECT_FLOAT_EQ(initial_parent_scale * initial_child_scale,
4863                   child_scale->draw_transform().matrix().get(0, 0));
4864   EXPECT_FLOAT_EQ(initial_parent_scale * initial_child_scale,
4865                   child_scale->draw_transform().matrix().get(1, 1));
4866   EXPECT_FLOAT_EQ(initial_parent_scale * initial_child_scale,
4867                   child_empty->draw_transform().matrix().get(0, 0));
4868   EXPECT_FLOAT_EQ(initial_parent_scale * initial_child_scale,
4869                   child_empty->draw_transform().matrix().get(1, 1));
4870   EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
4871                       initial_parent_scale * initial_child_scale,
4872                   child_no_scale->draw_transform().matrix().get(0, 0));
4873   EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
4874                       initial_parent_scale * initial_child_scale,
4875                   child_no_scale->draw_transform().matrix().get(1, 1));
4876 }
4877
4878 TEST_F(LayerTreeHostCommonTest, SmallIdealScale) {
4879   MockContentLayerClient delegate;
4880   gfx::Transform identity_matrix;
4881
4882   gfx::Transform parent_scale_matrix;
4883   SkMScalar initial_parent_scale = 1.75;
4884   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
4885
4886   gfx::Transform child_scale_matrix;
4887   SkMScalar initial_child_scale = 0.25;
4888   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
4889
4890   scoped_refptr<Layer> root = Layer::Create();
4891   root->SetBounds(gfx::Size(100, 100));
4892
4893   scoped_refptr<FakePictureLayer> parent =
4894       CreateDrawablePictureLayer(&delegate);
4895   SetLayerPropertiesForTesting(parent.get(),
4896                                parent_scale_matrix,
4897                                gfx::Point3F(),
4898                                gfx::PointF(),
4899                                gfx::Size(100, 100),
4900                                false,
4901                                true);
4902
4903   scoped_refptr<FakePictureLayer> child_scale =
4904       CreateDrawablePictureLayer(&delegate);
4905   SetLayerPropertiesForTesting(child_scale.get(),
4906                                child_scale_matrix,
4907                                gfx::Point3F(),
4908                                gfx::PointF(2.f, 2.f),
4909                                gfx::Size(10, 10),
4910                                false,
4911                                true);
4912
4913   root->AddChild(parent);
4914
4915   parent->AddChild(child_scale);
4916
4917   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
4918   host->SetRootLayer(root);
4919
4920   float device_scale_factor = 2.5f;
4921   float page_scale_factor = 0.01f;
4922
4923   {
4924     RenderSurfaceLayerList render_surface_layer_list;
4925     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
4926         root.get(), root->bounds(), &render_surface_layer_list);
4927     inputs.device_scale_factor = device_scale_factor;
4928     inputs.page_scale_factor = page_scale_factor;
4929     inputs.page_scale_application_layer = root.get();
4930     inputs.can_adjust_raster_scales = true;
4931     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
4932
4933     // The ideal scale is able to go below 1.
4934     float expected_ideal_scale =
4935         device_scale_factor * page_scale_factor * initial_parent_scale;
4936     EXPECT_LT(expected_ideal_scale, 1.f);
4937     EXPECT_IDEAL_SCALE_EQ(expected_ideal_scale, parent);
4938
4939     expected_ideal_scale = device_scale_factor * page_scale_factor *
4940                            initial_parent_scale * initial_child_scale;
4941     EXPECT_LT(expected_ideal_scale, 1.f);
4942     EXPECT_IDEAL_SCALE_EQ(expected_ideal_scale, child_scale);
4943   }
4944 }
4945
4946 TEST_F(LayerTreeHostCommonTest, ContentsScaleForSurfaces) {
4947   MockContentLayerClient delegate;
4948   gfx::Transform identity_matrix;
4949
4950   gfx::Transform parent_scale_matrix;
4951   SkMScalar initial_parent_scale = 2.0;
4952   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
4953
4954   gfx::Transform child_scale_matrix;
4955   SkMScalar initial_child_scale = 3.0;
4956   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
4957
4958   scoped_refptr<Layer> root = Layer::Create();
4959   root->SetBounds(gfx::Size(100, 100));
4960
4961   scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate);
4962   SetLayerPropertiesForTesting(parent.get(),
4963                                parent_scale_matrix,
4964                                gfx::Point3F(),
4965                                gfx::PointF(),
4966                                gfx::Size(100, 100),
4967                                false,
4968                                true);
4969
4970   scoped_refptr<ContentLayer> surface_scale =
4971       CreateDrawableContentLayer(&delegate);
4972   SetLayerPropertiesForTesting(surface_scale.get(),
4973                                child_scale_matrix,
4974                                gfx::Point3F(),
4975                                gfx::PointF(2.f, 2.f),
4976                                gfx::Size(10, 10),
4977                                false,
4978                                true);
4979
4980   scoped_refptr<ContentLayer> surface_scale_child_scale =
4981       CreateDrawableContentLayer(&delegate);
4982   SetLayerPropertiesForTesting(surface_scale_child_scale.get(),
4983                                child_scale_matrix,
4984                                gfx::Point3F(),
4985                                gfx::PointF(),
4986                                gfx::Size(10, 10),
4987                                false,
4988                                true);
4989
4990   scoped_refptr<NoScaleContentLayer> surface_scale_child_no_scale =
4991       CreateNoScaleDrawableContentLayer(&delegate);
4992   SetLayerPropertiesForTesting(surface_scale_child_no_scale.get(),
4993                                child_scale_matrix,
4994                                gfx::Point3F(),
4995                                gfx::PointF(),
4996                                gfx::Size(10, 10),
4997                                false,
4998                                true);
4999
5000   scoped_refptr<NoScaleContentLayer> surface_no_scale =
5001       CreateNoScaleDrawableContentLayer(&delegate);
5002   SetLayerPropertiesForTesting(surface_no_scale.get(),
5003                                child_scale_matrix,
5004                                gfx::Point3F(),
5005                                gfx::PointF(12.f, 12.f),
5006                                gfx::Size(10, 10),
5007                                false,
5008                                true);
5009
5010   scoped_refptr<ContentLayer> surface_no_scale_child_scale =
5011       CreateDrawableContentLayer(&delegate);
5012   SetLayerPropertiesForTesting(surface_no_scale_child_scale.get(),
5013                                child_scale_matrix,
5014                                gfx::Point3F(),
5015                                gfx::PointF(),
5016                                gfx::Size(10, 10),
5017                                false,
5018                                true);
5019
5020   scoped_refptr<NoScaleContentLayer> surface_no_scale_child_no_scale =
5021       CreateNoScaleDrawableContentLayer(&delegate);
5022   SetLayerPropertiesForTesting(surface_no_scale_child_no_scale.get(),
5023                                child_scale_matrix,
5024                                gfx::Point3F(),
5025                                gfx::PointF(),
5026                                gfx::Size(10, 10),
5027                                false,
5028                                true);
5029
5030   root->AddChild(parent);
5031
5032   parent->AddChild(surface_scale);
5033   parent->AddChild(surface_no_scale);
5034
5035   surface_scale->SetForceRenderSurface(true);
5036   surface_scale->AddChild(surface_scale_child_scale);
5037   surface_scale->AddChild(surface_scale_child_no_scale);
5038
5039   surface_no_scale->SetForceRenderSurface(true);
5040   surface_no_scale->AddChild(surface_no_scale_child_scale);
5041   surface_no_scale->AddChild(surface_no_scale_child_no_scale);
5042
5043   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
5044   host->SetRootLayer(root);
5045
5046   SkMScalar device_scale_factor = 5;
5047   SkMScalar page_scale_factor = 7;
5048
5049   RenderSurfaceLayerList render_surface_layer_list;
5050   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
5051       root.get(), root->bounds(), &render_surface_layer_list);
5052   inputs.device_scale_factor = device_scale_factor;
5053   inputs.page_scale_factor = page_scale_factor;
5054   inputs.page_scale_application_layer = root.get();
5055   inputs.can_adjust_raster_scales = true;
5056   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
5057
5058   EXPECT_CONTENTS_SCALE_EQ(
5059       device_scale_factor * page_scale_factor * initial_parent_scale, parent);
5060   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
5061                                initial_parent_scale * initial_child_scale,
5062                            surface_scale);
5063   EXPECT_CONTENTS_SCALE_EQ(1, surface_no_scale);
5064   EXPECT_CONTENTS_SCALE_EQ(
5065       device_scale_factor * page_scale_factor * initial_parent_scale *
5066       initial_child_scale * initial_child_scale,
5067       surface_scale_child_scale);
5068   EXPECT_CONTENTS_SCALE_EQ(1, surface_scale_child_no_scale);
5069   EXPECT_CONTENTS_SCALE_EQ(
5070       device_scale_factor * page_scale_factor * initial_parent_scale *
5071       initial_child_scale * initial_child_scale,
5072       surface_no_scale_child_scale);
5073   EXPECT_CONTENTS_SCALE_EQ(1, surface_no_scale_child_no_scale);
5074
5075   // The parent is scaled up and shouldn't need to scale during draw.
5076   EXPECT_FLOAT_EQ(1.0, parent->draw_transform().matrix().get(0, 0));
5077   EXPECT_FLOAT_EQ(1.0, parent->draw_transform().matrix().get(1, 1));
5078
5079   // RenderSurfaces should always be 1:1 with their target.
5080   EXPECT_FLOAT_EQ(
5081       1.0,
5082       surface_scale->render_surface()->draw_transform().matrix().get(0, 0));
5083   EXPECT_FLOAT_EQ(
5084       1.0,
5085       surface_scale->render_surface()->draw_transform().matrix().get(1, 1));
5086
5087   // The surface_scale can apply contents scale so the layer shouldn't need to
5088   // scale during draw.
5089   EXPECT_FLOAT_EQ(1.0, surface_scale->draw_transform().matrix().get(0, 0));
5090   EXPECT_FLOAT_EQ(1.0, surface_scale->draw_transform().matrix().get(1, 1));
5091
5092   // The surface_scale_child_scale can apply contents scale so it shouldn't need
5093   // to scale during draw.
5094   EXPECT_FLOAT_EQ(
5095       1.0, surface_scale_child_scale->draw_transform().matrix().get(0, 0));
5096   EXPECT_FLOAT_EQ(
5097       1.0, surface_scale_child_scale->draw_transform().matrix().get(1, 1));
5098
5099   // The surface_scale_child_no_scale can not apply contents scale, so it needs
5100   // to be scaled during draw.
5101   EXPECT_FLOAT_EQ(
5102       device_scale_factor * page_scale_factor * initial_parent_scale *
5103           initial_child_scale * initial_child_scale,
5104       surface_scale_child_no_scale->draw_transform().matrix().get(0, 0));
5105   EXPECT_FLOAT_EQ(
5106       device_scale_factor * page_scale_factor * initial_parent_scale *
5107           initial_child_scale * initial_child_scale,
5108       surface_scale_child_no_scale->draw_transform().matrix().get(1, 1));
5109
5110   // RenderSurfaces should always be 1:1 with their target.
5111   EXPECT_FLOAT_EQ(
5112       1.0,
5113       surface_no_scale->render_surface()->draw_transform().matrix().get(0, 0));
5114   EXPECT_FLOAT_EQ(
5115       1.0,
5116       surface_no_scale->render_surface()->draw_transform().matrix().get(1, 1));
5117
5118   // The surface_no_scale layer can not apply contents scale, so it needs to be
5119   // scaled during draw.
5120   EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
5121                       initial_parent_scale * initial_child_scale,
5122                   surface_no_scale->draw_transform().matrix().get(0, 0));
5123   EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
5124                       initial_parent_scale * initial_child_scale,
5125                   surface_no_scale->draw_transform().matrix().get(1, 1));
5126
5127   // The surface_scale_child_scale can apply contents scale so it shouldn't need
5128   // to scale during draw.
5129   EXPECT_FLOAT_EQ(
5130       1.0, surface_no_scale_child_scale->draw_transform().matrix().get(0, 0));
5131   EXPECT_FLOAT_EQ(
5132       1.0, surface_no_scale_child_scale->draw_transform().matrix().get(1, 1));
5133
5134   // The surface_scale_child_no_scale can not apply contents scale, so it needs
5135   // to be scaled during draw.
5136   EXPECT_FLOAT_EQ(
5137       device_scale_factor * page_scale_factor * initial_parent_scale *
5138           initial_child_scale * initial_child_scale,
5139       surface_no_scale_child_no_scale->draw_transform().matrix().get(0, 0));
5140   EXPECT_FLOAT_EQ(
5141       device_scale_factor * page_scale_factor * initial_parent_scale *
5142           initial_child_scale * initial_child_scale,
5143       surface_no_scale_child_no_scale->draw_transform().matrix().get(1, 1));
5144 }
5145
5146 // TODO(sohanjg): Remove this test when ContentLayer is removed.
5147 TEST_F(LayerTreeHostCommonTest,
5148        ContentsScaleForSurfaces_LayerTransformsDontAffectContentsScale) {
5149   MockContentLayerClient delegate;
5150   gfx::Transform identity_matrix;
5151
5152   gfx::Transform parent_scale_matrix;
5153   SkMScalar initial_parent_scale = 2.0;
5154   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
5155
5156   gfx::Transform child_scale_matrix;
5157   SkMScalar initial_child_scale = 3.0;
5158   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
5159
5160   scoped_refptr<Layer> root = Layer::Create();
5161   root->SetBounds(gfx::Size(100, 100));
5162
5163   scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate);
5164   SetLayerPropertiesForTesting(parent.get(),
5165                                parent_scale_matrix,
5166                                gfx::Point3F(),
5167                                gfx::PointF(),
5168                                gfx::Size(100, 100),
5169                                false,
5170                                true);
5171
5172   scoped_refptr<ContentLayer> surface_scale =
5173       CreateDrawableContentLayer(&delegate);
5174   SetLayerPropertiesForTesting(surface_scale.get(),
5175                                child_scale_matrix,
5176                                gfx::Point3F(),
5177                                gfx::PointF(2.f, 2.f),
5178                                gfx::Size(10, 10),
5179                                false,
5180                                true);
5181
5182   scoped_refptr<ContentLayer> surface_scale_child_scale =
5183       CreateDrawableContentLayer(&delegate);
5184   SetLayerPropertiesForTesting(surface_scale_child_scale.get(),
5185                                child_scale_matrix,
5186                                gfx::Point3F(),
5187                                gfx::PointF(),
5188                                gfx::Size(10, 10),
5189                                false,
5190                                true);
5191
5192   scoped_refptr<NoScaleContentLayer> surface_scale_child_no_scale =
5193       CreateNoScaleDrawableContentLayer(&delegate);
5194   SetLayerPropertiesForTesting(surface_scale_child_no_scale.get(),
5195                                child_scale_matrix,
5196                                gfx::Point3F(),
5197                                gfx::PointF(),
5198                                gfx::Size(10, 10),
5199                                false,
5200                                true);
5201
5202   scoped_refptr<NoScaleContentLayer> surface_no_scale =
5203       CreateNoScaleDrawableContentLayer(&delegate);
5204   SetLayerPropertiesForTesting(surface_no_scale.get(),
5205                                child_scale_matrix,
5206                                gfx::Point3F(),
5207                                gfx::PointF(12.f, 12.f),
5208                                gfx::Size(10, 10),
5209                                false,
5210                                true);
5211
5212   scoped_refptr<ContentLayer> surface_no_scale_child_scale =
5213       CreateDrawableContentLayer(&delegate);
5214   SetLayerPropertiesForTesting(surface_no_scale_child_scale.get(),
5215                                child_scale_matrix,
5216                                gfx::Point3F(),
5217                                gfx::PointF(),
5218                                gfx::Size(10, 10),
5219                                false,
5220                                true);
5221
5222   scoped_refptr<NoScaleContentLayer> surface_no_scale_child_no_scale =
5223       CreateNoScaleDrawableContentLayer(&delegate);
5224   SetLayerPropertiesForTesting(surface_no_scale_child_no_scale.get(),
5225                                child_scale_matrix,
5226                                gfx::Point3F(),
5227                                gfx::PointF(),
5228                                gfx::Size(10, 10),
5229                                false,
5230                                true);
5231
5232   root->AddChild(parent);
5233
5234   parent->AddChild(surface_scale);
5235   parent->AddChild(surface_no_scale);
5236
5237   surface_scale->SetForceRenderSurface(true);
5238   surface_scale->AddChild(surface_scale_child_scale);
5239   surface_scale->AddChild(surface_scale_child_no_scale);
5240
5241   surface_no_scale->SetForceRenderSurface(true);
5242   surface_no_scale->AddChild(surface_no_scale_child_scale);
5243   surface_no_scale->AddChild(surface_no_scale_child_no_scale);
5244
5245   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
5246   host->SetRootLayer(root);
5247
5248   RenderSurfaceLayerList render_surface_layer_list;
5249
5250   SkMScalar device_scale_factor = 5.0;
5251   SkMScalar page_scale_factor = 7.0;
5252   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
5253       root.get(), root->bounds(), &render_surface_layer_list);
5254   inputs.device_scale_factor = device_scale_factor;
5255   inputs.page_scale_factor = page_scale_factor;
5256   inputs.page_scale_application_layer = root.get();
5257   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
5258
5259   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
5260                            parent);
5261   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
5262                            surface_scale);
5263   EXPECT_CONTENTS_SCALE_EQ(1.f, surface_no_scale);
5264   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
5265                            surface_scale_child_scale);
5266   EXPECT_CONTENTS_SCALE_EQ(1.f, surface_scale_child_no_scale);
5267   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
5268                            surface_no_scale_child_scale);
5269   EXPECT_CONTENTS_SCALE_EQ(1.f, surface_no_scale_child_no_scale);
5270
5271   // The parent is scaled up during draw, since its contents are not scaled by
5272   // the transform hierarchy.
5273   EXPECT_FLOAT_EQ(initial_parent_scale,
5274                   parent->draw_transform().matrix().get(0, 0));
5275   EXPECT_FLOAT_EQ(initial_parent_scale,
5276                   parent->draw_transform().matrix().get(1, 1));
5277
5278   // The child surface is not scaled up during draw since its subtree is scaled
5279   // by the transform hierarchy.
5280   EXPECT_FLOAT_EQ(
5281       1.f,
5282       surface_scale->render_surface()->draw_transform().matrix().get(0, 0));
5283   EXPECT_FLOAT_EQ(
5284       1.f,
5285       surface_scale->render_surface()->draw_transform().matrix().get(1, 1));
5286
5287   // The surface_scale's RenderSurface is not scaled during draw, so the layer
5288   // needs to be scaled when drawing into its surface.
5289   EXPECT_FLOAT_EQ(initial_parent_scale * initial_child_scale,
5290                   surface_scale->draw_transform().matrix().get(0, 0));
5291   EXPECT_FLOAT_EQ(initial_parent_scale * initial_child_scale,
5292                   surface_scale->draw_transform().matrix().get(1, 1));
5293
5294   // The surface_scale_child_scale is not scaled when drawing into its surface,
5295   // since its content bounds are scaled by the transform hierarchy.
5296   EXPECT_FLOAT_EQ(
5297       initial_child_scale * initial_child_scale * initial_parent_scale,
5298       surface_scale_child_scale->draw_transform().matrix().get(0, 0));
5299   EXPECT_FLOAT_EQ(
5300       initial_child_scale * initial_child_scale * initial_parent_scale,
5301       surface_scale_child_scale->draw_transform().matrix().get(1, 1));
5302
5303   // The surface_scale_child_no_scale is scaled by the device scale, page scale
5304   // and transform hierarchy.
5305   EXPECT_FLOAT_EQ(
5306       device_scale_factor * page_scale_factor * initial_parent_scale *
5307           initial_child_scale * initial_child_scale,
5308       surface_scale_child_no_scale->draw_transform().matrix().get(0, 0));
5309   EXPECT_FLOAT_EQ(
5310       device_scale_factor * page_scale_factor * initial_parent_scale *
5311           initial_child_scale * initial_child_scale,
5312       surface_scale_child_no_scale->draw_transform().matrix().get(1, 1));
5313
5314   // The child surface is not scaled up during draw since its subtree is scaled
5315   // by the transform hierarchy.
5316   EXPECT_FLOAT_EQ(
5317       1.f,
5318       surface_no_scale->render_surface()->draw_transform().matrix().get(0, 0));
5319   EXPECT_FLOAT_EQ(
5320       1.f,
5321       surface_no_scale->render_surface()->draw_transform().matrix().get(1, 1));
5322
5323   // The surface_no_scale layer has a fixed contents scale of 1, so it needs to
5324   // be scaled by the device and page scale factors. Its surface is already
5325   // scaled by the transform hierarchy so those don't need to scale the layer's
5326   // drawing.
5327   EXPECT_FLOAT_EQ(initial_parent_scale * initial_child_scale *
5328                       device_scale_factor * page_scale_factor,
5329                   surface_no_scale->draw_transform().matrix().get(0, 0));
5330   EXPECT_FLOAT_EQ(initial_parent_scale * initial_child_scale *
5331                       device_scale_factor * page_scale_factor,
5332                   surface_no_scale->draw_transform().matrix().get(1, 1));
5333
5334   // The surface_no_scale_child_scale has its contents scaled by the page and
5335   // device scale factors, but needs to be scaled by the transform hierarchy
5336   // when drawing.
5337   EXPECT_FLOAT_EQ(
5338       initial_parent_scale * initial_child_scale * initial_child_scale,
5339       surface_no_scale_child_scale->draw_transform().matrix().get(0, 0));
5340   EXPECT_FLOAT_EQ(
5341       initial_parent_scale * initial_child_scale * initial_child_scale,
5342       surface_no_scale_child_scale->draw_transform().matrix().get(1, 1));
5343
5344   // The surface_no_scale_child_no_scale needs to be scaled by the device and
5345   // page scale factors and by any transform heirarchy below its target surface.
5346   EXPECT_FLOAT_EQ(
5347       device_scale_factor * page_scale_factor * initial_parent_scale *
5348           initial_child_scale * initial_child_scale,
5349       surface_no_scale_child_no_scale->draw_transform().matrix().get(0, 0));
5350   EXPECT_FLOAT_EQ(
5351       device_scale_factor * page_scale_factor * initial_parent_scale *
5352           initial_child_scale * initial_child_scale,
5353       surface_no_scale_child_no_scale->draw_transform().matrix().get(1, 1));
5354 }
5355
5356 TEST_F(LayerTreeHostCommonTest, IdealScaleForAnimatingLayer) {
5357   MockContentLayerClient delegate;
5358   gfx::Transform identity_matrix;
5359
5360   gfx::Transform parent_scale_matrix;
5361   SkMScalar initial_parent_scale = 1.75;
5362   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
5363
5364   gfx::Transform child_scale_matrix;
5365   SkMScalar initial_child_scale = 1.25;
5366   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
5367
5368   scoped_refptr<Layer> root = Layer::Create();
5369   root->SetBounds(gfx::Size(100, 100));
5370
5371   scoped_refptr<FakePictureLayer> parent =
5372       CreateDrawablePictureLayer(&delegate);
5373   SetLayerPropertiesForTesting(parent.get(),
5374                                parent_scale_matrix,
5375                                gfx::Point3F(),
5376                                gfx::PointF(),
5377                                gfx::Size(100, 100),
5378                                false,
5379                                true);
5380
5381   scoped_refptr<FakePictureLayer> child_scale =
5382       CreateDrawablePictureLayer(&delegate);
5383   SetLayerPropertiesForTesting(child_scale.get(),
5384                                child_scale_matrix,
5385                                gfx::Point3F(),
5386                                gfx::PointF(2.f, 2.f),
5387                                gfx::Size(10, 10),
5388                                false,
5389                                true);
5390
5391   root->AddChild(parent);
5392
5393   parent->AddChild(child_scale);
5394
5395   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
5396   host->SetRootLayer(root);
5397
5398   {
5399     RenderSurfaceLayerList render_surface_layer_list;
5400     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
5401         root.get(), root->bounds(), &render_surface_layer_list);
5402     inputs.can_adjust_raster_scales = true;
5403     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
5404
5405     EXPECT_IDEAL_SCALE_EQ(initial_parent_scale, parent);
5406     // Animating layers compute ideal scale in the same way as when
5407     // they are static.
5408     EXPECT_IDEAL_SCALE_EQ(initial_child_scale * initial_parent_scale,
5409                           child_scale);
5410   }
5411 }
5412
5413 // TODO(sohanjg): Remove this test when ContentLayer is removed.
5414 TEST_F(LayerTreeHostCommonTest,
5415        ChangeInContentBoundsOrScaleTriggersPushProperties) {
5416   MockContentLayerClient delegate;
5417   scoped_refptr<Layer> root = Layer::Create();
5418   scoped_refptr<Layer> child = CreateDrawableContentLayer(&delegate);
5419   root->AddChild(child);
5420
5421   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
5422   host->SetRootLayer(root);
5423
5424   gfx::Transform identity_matrix;
5425   SetLayerPropertiesForTesting(root.get(),
5426                                identity_matrix,
5427                                gfx::Point3F(),
5428                                gfx::PointF(),
5429                                gfx::Size(100, 100),
5430                                true,
5431                                false);
5432   SetLayerPropertiesForTesting(child.get(),
5433                                identity_matrix,
5434                                gfx::Point3F(),
5435                                gfx::PointF(),
5436                                gfx::Size(100, 100),
5437                                true,
5438                                false);
5439
5440   root->reset_needs_push_properties_for_testing();
5441   child->reset_needs_push_properties_for_testing();
5442
5443   // This will change both layers' content bounds.
5444   ExecuteCalculateDrawProperties(root.get());
5445   EXPECT_TRUE(root->needs_push_properties());
5446   EXPECT_TRUE(child->needs_push_properties());
5447
5448   root->reset_needs_push_properties_for_testing();
5449   child->reset_needs_push_properties_for_testing();
5450
5451   // This will change only the child layer's contents scale and content bounds,
5452   // since the root layer is not a ContentsScalingLayer.
5453   ExecuteCalculateDrawProperties(root.get(), 2.f);
5454   EXPECT_FALSE(root->needs_push_properties());
5455   EXPECT_TRUE(child->needs_push_properties());
5456
5457   root->reset_needs_push_properties_for_testing();
5458   child->reset_needs_push_properties_for_testing();
5459
5460   // This will not change either layer's contents scale or content bounds.
5461   ExecuteCalculateDrawProperties(root.get(), 2.f);
5462   EXPECT_FALSE(root->needs_push_properties());
5463   EXPECT_FALSE(child->needs_push_properties());
5464 }
5465
5466 TEST_F(LayerTreeHostCommonTest, RenderSurfaceTransformsInHighDPI) {
5467   MockContentLayerClient delegate;
5468   gfx::Transform identity_matrix;
5469
5470   scoped_refptr<FakePictureLayer> parent =
5471       CreateDrawablePictureLayer(&delegate);
5472   SetLayerPropertiesForTesting(parent.get(),
5473                                identity_matrix,
5474                                gfx::Point3F(),
5475                                gfx::PointF(),
5476                                gfx::Size(30, 30),
5477                                false,
5478                                true);
5479
5480   scoped_refptr<FakePictureLayer> child = CreateDrawablePictureLayer(&delegate);
5481   SetLayerPropertiesForTesting(child.get(),
5482                                identity_matrix,
5483                                gfx::Point3F(),
5484                                gfx::PointF(2.f, 2.f),
5485                                gfx::Size(10, 10),
5486                                false,
5487                                true);
5488
5489   gfx::Transform replica_transform;
5490   replica_transform.Scale(1.0, -1.0);
5491   scoped_refptr<FakePictureLayer> replica =
5492       CreateDrawablePictureLayer(&delegate);
5493   SetLayerPropertiesForTesting(replica.get(),
5494                                replica_transform,
5495                                gfx::Point3F(),
5496                                gfx::PointF(2.f, 2.f),
5497                                gfx::Size(10, 10),
5498                                false,
5499                                true);
5500
5501   // This layer should end up in the same surface as child, with the same draw
5502   // and screen space transforms.
5503   scoped_refptr<FakePictureLayer> duplicate_child_non_owner =
5504       CreateDrawablePictureLayer(&delegate);
5505   SetLayerPropertiesForTesting(duplicate_child_non_owner.get(),
5506                                identity_matrix,
5507                                gfx::Point3F(),
5508                                gfx::PointF(),
5509                                gfx::Size(10, 10),
5510                                false,
5511                                true);
5512
5513   parent->AddChild(child);
5514   child->AddChild(duplicate_child_non_owner);
5515   child->SetReplicaLayer(replica.get());
5516
5517   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
5518   host->SetRootLayer(parent);
5519
5520   RenderSurfaceLayerList render_surface_layer_list;
5521
5522   float device_scale_factor = 1.5f;
5523   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
5524       parent.get(), parent->bounds(), &render_surface_layer_list);
5525   inputs.device_scale_factor = device_scale_factor;
5526   inputs.can_adjust_raster_scales = true;
5527   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
5528
5529   // We should have two render surfaces. The root's render surface and child's
5530   // render surface (it needs one because it has a replica layer).
5531   EXPECT_EQ(2u, render_surface_layer_list.size());
5532
5533   gfx::Transform expected_parent_transform;
5534   expected_parent_transform.Scale(device_scale_factor, device_scale_factor);
5535   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform,
5536                                   parent->screen_space_transform());
5537   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform,
5538                                   parent->draw_transform());
5539
5540   gfx::Transform expected_draw_transform;
5541   expected_draw_transform.Scale(device_scale_factor, device_scale_factor);
5542   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_draw_transform,
5543                                   child->draw_transform());
5544
5545   gfx::Transform expected_screen_space_transform;
5546   expected_screen_space_transform.Scale(device_scale_factor,
5547                                         device_scale_factor);
5548   expected_screen_space_transform.Translate(child->position().x(),
5549                                             child->position().y());
5550   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_screen_space_transform,
5551                                   child->screen_space_transform());
5552
5553   gfx::Transform expected_duplicate_child_draw_transform =
5554       child->draw_transform();
5555   EXPECT_TRANSFORMATION_MATRIX_EQ(child->draw_transform(),
5556                                   duplicate_child_non_owner->draw_transform());
5557   EXPECT_TRANSFORMATION_MATRIX_EQ(
5558       child->screen_space_transform(),
5559       duplicate_child_non_owner->screen_space_transform());
5560   EXPECT_EQ(child->drawable_content_rect(),
5561             duplicate_child_non_owner->drawable_content_rect());
5562   EXPECT_EQ(child->content_bounds(),
5563             duplicate_child_non_owner->content_bounds());
5564
5565   gfx::Transform expected_render_surface_draw_transform;
5566   expected_render_surface_draw_transform.Translate(
5567       device_scale_factor * child->position().x(),
5568       device_scale_factor * child->position().y());
5569   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_render_surface_draw_transform,
5570                                   child->render_surface()->draw_transform());
5571
5572   gfx::Transform expected_surface_draw_transform;
5573   expected_surface_draw_transform.Translate(device_scale_factor * 2.f,
5574                                             device_scale_factor * 2.f);
5575   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_surface_draw_transform,
5576                                   child->render_surface()->draw_transform());
5577
5578   gfx::Transform expected_surface_screen_space_transform;
5579   expected_surface_screen_space_transform.Translate(device_scale_factor * 2.f,
5580                                                     device_scale_factor * 2.f);
5581   EXPECT_TRANSFORMATION_MATRIX_EQ(
5582       expected_surface_screen_space_transform,
5583       child->render_surface()->screen_space_transform());
5584
5585   gfx::Transform expected_replica_draw_transform;
5586   expected_replica_draw_transform.matrix().set(1, 1, -1.0);
5587   expected_replica_draw_transform.matrix().set(0, 3, 6.0);
5588   expected_replica_draw_transform.matrix().set(1, 3, 6.0);
5589   EXPECT_TRANSFORMATION_MATRIX_EQ(
5590       expected_replica_draw_transform,
5591       child->render_surface()->replica_draw_transform());
5592
5593   gfx::Transform expected_replica_screen_space_transform;
5594   expected_replica_screen_space_transform.matrix().set(1, 1, -1.0);
5595   expected_replica_screen_space_transform.matrix().set(0, 3, 6.0);
5596   expected_replica_screen_space_transform.matrix().set(1, 3, 6.0);
5597   EXPECT_TRANSFORMATION_MATRIX_EQ(
5598       expected_replica_screen_space_transform,
5599       child->render_surface()->replica_screen_space_transform());
5600   EXPECT_TRANSFORMATION_MATRIX_EQ(
5601       expected_replica_screen_space_transform,
5602       child->render_surface()->replica_screen_space_transform());
5603 }
5604
5605 TEST_F(LayerTreeHostCommonTest,
5606      RenderSurfaceTransformsInHighDPIAccurateScaleZeroPosition) {
5607   MockContentLayerClient delegate;
5608   gfx::Transform identity_matrix;
5609
5610   scoped_refptr<FakePictureLayer> parent =
5611       CreateDrawablePictureLayer(&delegate);
5612   SetLayerPropertiesForTesting(parent.get(),
5613                                identity_matrix,
5614                                gfx::Point3F(),
5615                                gfx::PointF(),
5616                                gfx::Size(33, 31),
5617                                false,
5618                                true);
5619
5620   scoped_refptr<FakePictureLayer> child = CreateDrawablePictureLayer(&delegate);
5621   SetLayerPropertiesForTesting(child.get(),
5622                                identity_matrix,
5623                                gfx::Point3F(),
5624                                gfx::PointF(),
5625                                gfx::Size(13, 11),
5626                                false,
5627                                true);
5628
5629   gfx::Transform replica_transform;
5630   replica_transform.Scale(1.0, -1.0);
5631   scoped_refptr<FakePictureLayer> replica =
5632       CreateDrawablePictureLayer(&delegate);
5633   SetLayerPropertiesForTesting(replica.get(),
5634                                replica_transform,
5635                                gfx::Point3F(),
5636                                gfx::PointF(),
5637                                gfx::Size(13, 11),
5638                                false,
5639                                true);
5640
5641   parent->AddChild(child);
5642   child->SetReplicaLayer(replica.get());
5643
5644   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
5645   host->SetRootLayer(parent);
5646
5647   float device_scale_factor = 1.7f;
5648
5649   RenderSurfaceLayerList render_surface_layer_list;
5650   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
5651       parent.get(), parent->bounds(), &render_surface_layer_list);
5652   inputs.device_scale_factor = device_scale_factor;
5653   inputs.can_adjust_raster_scales = true;
5654   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
5655
5656   // We should have two render surfaces. The root's render surface and child's
5657   // render surface (it needs one because it has a replica layer).
5658   EXPECT_EQ(2u, render_surface_layer_list.size());
5659
5660   gfx::Transform identity_transform;
5661   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_transform,
5662                                   child->render_surface()->draw_transform());
5663   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_transform,
5664                                   child->render_surface()->draw_transform());
5665   EXPECT_TRANSFORMATION_MATRIX_EQ(
5666       identity_transform, child->render_surface()->screen_space_transform());
5667
5668   gfx::Transform expected_replica_draw_transform;
5669   expected_replica_draw_transform.matrix().set(1, 1, -1.0);
5670   EXPECT_TRANSFORMATION_MATRIX_EQ(
5671       expected_replica_draw_transform,
5672       child->render_surface()->replica_draw_transform());
5673
5674   gfx::Transform expected_replica_screen_space_transform;
5675   expected_replica_screen_space_transform.matrix().set(1, 1, -1.0);
5676   EXPECT_TRANSFORMATION_MATRIX_EQ(
5677       expected_replica_screen_space_transform,
5678       child->render_surface()->replica_screen_space_transform());
5679 }
5680
5681 TEST_F(LayerTreeHostCommonTest, SubtreeSearch) {
5682   scoped_refptr<Layer> root = Layer::Create();
5683   scoped_refptr<Layer> child = Layer::Create();
5684   scoped_refptr<Layer> grand_child = Layer::Create();
5685   scoped_refptr<Layer> mask_layer = Layer::Create();
5686   scoped_refptr<Layer> replica_layer = Layer::Create();
5687
5688   grand_child->SetReplicaLayer(replica_layer.get());
5689   child->AddChild(grand_child.get());
5690   child->SetMaskLayer(mask_layer.get());
5691   root->AddChild(child.get());
5692
5693   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
5694   host->SetRootLayer(root);
5695
5696   int nonexistent_id = -1;
5697   EXPECT_EQ(root.get(),
5698             LayerTreeHostCommon::FindLayerInSubtree(root.get(), root->id()));
5699   EXPECT_EQ(child.get(),
5700             LayerTreeHostCommon::FindLayerInSubtree(root.get(), child->id()));
5701   EXPECT_EQ(
5702       grand_child.get(),
5703       LayerTreeHostCommon::FindLayerInSubtree(root.get(), grand_child->id()));
5704   EXPECT_EQ(
5705       mask_layer.get(),
5706       LayerTreeHostCommon::FindLayerInSubtree(root.get(), mask_layer->id()));
5707   EXPECT_EQ(
5708       replica_layer.get(),
5709       LayerTreeHostCommon::FindLayerInSubtree(root.get(), replica_layer->id()));
5710   EXPECT_EQ(
5711       0, LayerTreeHostCommon::FindLayerInSubtree(root.get(), nonexistent_id));
5712 }
5713
5714 TEST_F(LayerTreeHostCommonTest, TransparentChildRenderSurfaceCreation) {
5715   scoped_refptr<Layer> root = Layer::Create();
5716   scoped_refptr<Layer> child = Layer::Create();
5717   scoped_refptr<LayerWithForcedDrawsContent> grand_child =
5718       make_scoped_refptr(new LayerWithForcedDrawsContent());
5719
5720   const gfx::Transform identity_matrix;
5721   SetLayerPropertiesForTesting(root.get(),
5722                                identity_matrix,
5723                                gfx::Point3F(),
5724                                gfx::PointF(),
5725                                gfx::Size(100, 100),
5726                                true,
5727                                false);
5728   SetLayerPropertiesForTesting(child.get(),
5729                                identity_matrix,
5730                                gfx::Point3F(),
5731                                gfx::PointF(),
5732                                gfx::Size(10, 10),
5733                                true,
5734                                false);
5735   SetLayerPropertiesForTesting(grand_child.get(),
5736                                identity_matrix,
5737                                gfx::Point3F(),
5738                                gfx::PointF(),
5739                                gfx::Size(10, 10),
5740                                true,
5741                                false);
5742
5743   root->AddChild(child);
5744   child->AddChild(grand_child);
5745   child->SetOpacity(0.5f);
5746
5747   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
5748   host->SetRootLayer(root);
5749
5750   ExecuteCalculateDrawProperties(root.get());
5751
5752   EXPECT_FALSE(child->render_surface());
5753 }
5754
5755 TEST_F(LayerTreeHostCommonTest, OpacityAnimatingOnPendingTree) {
5756   FakeImplProxy proxy;
5757   TestSharedBitmapManager shared_bitmap_manager;
5758   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager, nullptr);
5759   host_impl.CreatePendingTree();
5760   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.pending_tree(), 1);
5761
5762   const gfx::Transform identity_matrix;
5763   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
5764                                gfx::PointF(), gfx::Size(100, 100), true, false,
5765                                false);
5766   root->SetDrawsContent(true);
5767
5768   scoped_ptr<LayerImpl> child = LayerImpl::Create(host_impl.pending_tree(), 2);
5769   SetLayerPropertiesForTesting(child.get(), identity_matrix, gfx::Point3F(),
5770                                gfx::PointF(), gfx::Size(50, 50), true, false,
5771                                false);
5772   child->SetDrawsContent(true);
5773   child->SetOpacity(0.0f);
5774
5775   // Add opacity animation.
5776   AddOpacityTransitionToController(
5777       child->layer_animation_controller(), 10.0, 0.0f, 1.0f, false);
5778
5779   root->AddChild(child.Pass());
5780   root->SetHasRenderSurface(true);
5781
5782   LayerImplList render_surface_layer_list;
5783   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
5784       root.get(), root->bounds(), &render_surface_layer_list);
5785   inputs.can_adjust_raster_scales = true;
5786   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
5787
5788   // We should have one render surface and two layers. The child
5789   // layer should be included even though it is transparent.
5790   ASSERT_EQ(1u, render_surface_layer_list.size());
5791   ASSERT_EQ(2u, root->render_surface()->layer_list().size());
5792 }
5793
5794 using LCDTextTestParam = std::tr1::tuple<bool, bool, bool>;
5795 class LCDTextTest
5796     : public LayerTreeHostCommonTestBase,
5797       public testing::TestWithParam<LCDTextTestParam> {
5798  public:
5799   LCDTextTest()
5800       : host_impl_(&proxy_, &shared_bitmap_manager_, &task_graph_runner_),
5801         root_(nullptr),
5802         child_(nullptr),
5803         grand_child_(nullptr) {}
5804
5805  protected:
5806   void SetUp() override {
5807     can_use_lcd_text_ = std::tr1::get<0>(GetParam());
5808     layers_always_allowed_lcd_text_ = std::tr1::get<1>(GetParam());
5809
5810     scoped_ptr<LayerImpl> root_ptr =
5811         LayerImpl::Create(host_impl_.active_tree(), 1);
5812     scoped_ptr<LayerImpl> child_ptr =
5813         LayerImpl::Create(host_impl_.active_tree(), 2);
5814     scoped_ptr<LayerImpl> grand_child_ptr =
5815         LayerImpl::Create(host_impl_.active_tree(), 3);
5816
5817     // Stash raw pointers to look at later.
5818     root_ = root_ptr.get();
5819     child_ = child_ptr.get();
5820     grand_child_ = grand_child_ptr.get();
5821
5822     child_->AddChild(grand_child_ptr.Pass());
5823     root_->AddChild(child_ptr.Pass());
5824     host_impl_.active_tree()->SetRootLayer(root_ptr.Pass());
5825
5826     root_->SetContentsOpaque(true);
5827     child_->SetContentsOpaque(true);
5828     grand_child_->SetContentsOpaque(true);
5829
5830     gfx::Transform identity_matrix;
5831     SetLayerPropertiesForTesting(root_, identity_matrix, gfx::Point3F(),
5832                                  gfx::PointF(), gfx::Size(1, 1), true, false,
5833                                  true);
5834     SetLayerPropertiesForTesting(child_, identity_matrix, gfx::Point3F(),
5835                                  gfx::PointF(), gfx::Size(1, 1), true, false,
5836                                  std::tr1::get<2>(GetParam()));
5837     SetLayerPropertiesForTesting(grand_child_, identity_matrix, gfx::Point3F(),
5838                                  gfx::PointF(), gfx::Size(1, 1), true, false,
5839                                  false);
5840   }
5841
5842   bool can_use_lcd_text_;
5843   bool layers_always_allowed_lcd_text_;
5844
5845   FakeImplProxy proxy_;
5846   TestSharedBitmapManager shared_bitmap_manager_;
5847   TestTaskGraphRunner task_graph_runner_;
5848   FakeLayerTreeHostImpl host_impl_;
5849
5850   LayerImpl* root_;
5851   LayerImpl* child_;
5852   LayerImpl* grand_child_;
5853 };
5854
5855 TEST_P(LCDTextTest, CanUseLCDText) {
5856   bool expect_lcd_text = can_use_lcd_text_ || layers_always_allowed_lcd_text_;
5857   bool expect_not_lcd_text = layers_always_allowed_lcd_text_;
5858
5859   // Case 1: Identity transform.
5860   gfx::Transform identity_matrix;
5861   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, NULL, can_use_lcd_text_,
5862                                  layers_always_allowed_lcd_text_);
5863   EXPECT_EQ(expect_lcd_text, root_->can_use_lcd_text());
5864   EXPECT_EQ(expect_lcd_text, child_->can_use_lcd_text());
5865   EXPECT_EQ(expect_lcd_text, grand_child_->can_use_lcd_text());
5866
5867   // Case 2: Integral translation.
5868   gfx::Transform integral_translation;
5869   integral_translation.Translate(1.0, 2.0);
5870   child_->SetTransform(integral_translation);
5871   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, NULL, can_use_lcd_text_,
5872                                  layers_always_allowed_lcd_text_);
5873   EXPECT_EQ(expect_lcd_text, root_->can_use_lcd_text());
5874   EXPECT_EQ(expect_lcd_text, child_->can_use_lcd_text());
5875   EXPECT_EQ(expect_lcd_text, grand_child_->can_use_lcd_text());
5876
5877   // Case 3: Non-integral translation.
5878   gfx::Transform non_integral_translation;
5879   non_integral_translation.Translate(1.5, 2.5);
5880   child_->SetTransform(non_integral_translation);
5881   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, NULL, can_use_lcd_text_,
5882                                  layers_always_allowed_lcd_text_);
5883   EXPECT_EQ(expect_lcd_text, root_->can_use_lcd_text());
5884   EXPECT_EQ(expect_not_lcd_text, child_->can_use_lcd_text());
5885   EXPECT_EQ(expect_not_lcd_text, grand_child_->can_use_lcd_text());
5886
5887   // Case 4: Rotation.
5888   gfx::Transform rotation;
5889   rotation.Rotate(10.0);
5890   child_->SetTransform(rotation);
5891   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, NULL, can_use_lcd_text_,
5892                                  layers_always_allowed_lcd_text_);
5893   EXPECT_EQ(expect_lcd_text, root_->can_use_lcd_text());
5894   EXPECT_EQ(expect_not_lcd_text, child_->can_use_lcd_text());
5895   EXPECT_EQ(expect_not_lcd_text, grand_child_->can_use_lcd_text());
5896
5897   // Case 5: Scale.
5898   gfx::Transform scale;
5899   scale.Scale(2.0, 2.0);
5900   child_->SetTransform(scale);
5901   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, NULL, can_use_lcd_text_,
5902                                  layers_always_allowed_lcd_text_);
5903   EXPECT_EQ(expect_lcd_text, root_->can_use_lcd_text());
5904   EXPECT_EQ(expect_not_lcd_text, child_->can_use_lcd_text());
5905   EXPECT_EQ(expect_not_lcd_text, grand_child_->can_use_lcd_text());
5906
5907   // Case 6: Skew.
5908   gfx::Transform skew;
5909   skew.SkewX(10.0);
5910   child_->SetTransform(skew);
5911   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, NULL, can_use_lcd_text_,
5912                                  layers_always_allowed_lcd_text_);
5913   EXPECT_EQ(expect_lcd_text, root_->can_use_lcd_text());
5914   EXPECT_EQ(expect_not_lcd_text, child_->can_use_lcd_text());
5915   EXPECT_EQ(expect_not_lcd_text, grand_child_->can_use_lcd_text());
5916
5917   // Case 7: Translucent.
5918   child_->SetTransform(identity_matrix);
5919   child_->SetOpacity(0.5f);
5920   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, NULL, can_use_lcd_text_,
5921                                  layers_always_allowed_lcd_text_);
5922   EXPECT_EQ(expect_lcd_text, root_->can_use_lcd_text());
5923   EXPECT_EQ(expect_not_lcd_text, child_->can_use_lcd_text());
5924   EXPECT_EQ(expect_not_lcd_text, grand_child_->can_use_lcd_text());
5925
5926   // Case 8: Sanity check: restore transform and opacity.
5927   child_->SetTransform(identity_matrix);
5928   child_->SetOpacity(1.f);
5929   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, NULL, can_use_lcd_text_,
5930                                  layers_always_allowed_lcd_text_);
5931   EXPECT_EQ(expect_lcd_text, root_->can_use_lcd_text());
5932   EXPECT_EQ(expect_lcd_text, child_->can_use_lcd_text());
5933   EXPECT_EQ(expect_lcd_text, grand_child_->can_use_lcd_text());
5934
5935   // Case 9: Non-opaque content.
5936   child_->SetContentsOpaque(false);
5937   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, NULL, can_use_lcd_text_,
5938                                  layers_always_allowed_lcd_text_);
5939   EXPECT_EQ(expect_lcd_text, root_->can_use_lcd_text());
5940   EXPECT_EQ(expect_not_lcd_text, child_->can_use_lcd_text());
5941   EXPECT_EQ(expect_lcd_text, grand_child_->can_use_lcd_text());
5942
5943   // Case 10: Sanity check: restore content opaqueness.
5944   child_->SetContentsOpaque(true);
5945   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, NULL, can_use_lcd_text_,
5946                                  layers_always_allowed_lcd_text_);
5947   EXPECT_EQ(expect_lcd_text, root_->can_use_lcd_text());
5948   EXPECT_EQ(expect_lcd_text, child_->can_use_lcd_text());
5949   EXPECT_EQ(expect_lcd_text, grand_child_->can_use_lcd_text());
5950 }
5951
5952 TEST_P(LCDTextTest, CanUseLCDTextWithAnimation) {
5953   bool expect_lcd_text = can_use_lcd_text_ || layers_always_allowed_lcd_text_;
5954
5955   // Sanity check: Make sure can_use_lcd_text_ is set on each node.
5956   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, NULL, can_use_lcd_text_,
5957                                  layers_always_allowed_lcd_text_);
5958   EXPECT_EQ(expect_lcd_text, root_->can_use_lcd_text());
5959   EXPECT_EQ(expect_lcd_text, child_->can_use_lcd_text());
5960   EXPECT_EQ(expect_lcd_text, grand_child_->can_use_lcd_text());
5961
5962   // Add opacity animation.
5963   child_->SetOpacity(0.9f);
5964   AddOpacityTransitionToController(
5965       child_->layer_animation_controller(), 10.0, 0.9f, 0.1f, false);
5966
5967   ExecuteCalculateDrawProperties(root_, 1.f, 1.f, NULL, can_use_lcd_text_,
5968                                  layers_always_allowed_lcd_text_);
5969   // Text AA should not be adjusted while animation is active.
5970   // Make sure LCD text AA setting remains unchanged.
5971   EXPECT_EQ(expect_lcd_text, root_->can_use_lcd_text());
5972   EXPECT_EQ(expect_lcd_text, child_->can_use_lcd_text());
5973   EXPECT_EQ(expect_lcd_text, grand_child_->can_use_lcd_text());
5974 }
5975
5976 INSTANTIATE_TEST_CASE_P(LayerTreeHostCommonTest,
5977                         LCDTextTest,
5978                         testing::Combine(testing::Bool(),
5979                                          testing::Bool(),
5980                                          testing::Bool()));
5981
5982 TEST_F(LayerTreeHostCommonTest, SubtreeHidden_SingleLayer) {
5983   FakeImplProxy proxy;
5984   TestSharedBitmapManager shared_bitmap_manager;
5985   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager, nullptr);
5986   host_impl.CreatePendingTree();
5987   const gfx::Transform identity_matrix;
5988
5989   scoped_refptr<Layer> root = Layer::Create();
5990   SetLayerPropertiesForTesting(root.get(),
5991                                identity_matrix,
5992                                gfx::Point3F(),
5993                                gfx::PointF(),
5994                                gfx::Size(50, 50),
5995                                true,
5996                                false);
5997   root->SetIsDrawable(true);
5998
5999   scoped_refptr<Layer> child = Layer::Create();
6000   SetLayerPropertiesForTesting(child.get(),
6001                                identity_matrix,
6002                                gfx::Point3F(),
6003                                gfx::PointF(),
6004                                gfx::Size(40, 40),
6005                                true,
6006                                false);
6007   child->SetIsDrawable(true);
6008
6009   scoped_refptr<Layer> grand_child = Layer::Create();
6010   SetLayerPropertiesForTesting(grand_child.get(),
6011                                identity_matrix,
6012                                gfx::Point3F(),
6013                                gfx::PointF(),
6014                                gfx::Size(30, 30),
6015                                true,
6016                                false);
6017   grand_child->SetIsDrawable(true);
6018   grand_child->SetHideLayerAndSubtree(true);
6019
6020   child->AddChild(grand_child);
6021   root->AddChild(child);
6022
6023   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
6024   host->SetRootLayer(root);
6025
6026   RenderSurfaceLayerList render_surface_layer_list;
6027   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
6028       root.get(), root->bounds(), &render_surface_layer_list);
6029   inputs.can_adjust_raster_scales = true;
6030   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
6031
6032   // We should have one render surface and two layers. The grand child has
6033   // hidden itself.
6034   ASSERT_EQ(1u, render_surface_layer_list.size());
6035   ASSERT_EQ(2u, root->render_surface()->layer_list().size());
6036   EXPECT_EQ(root->id(), root->render_surface()->layer_list().at(0)->id());
6037   EXPECT_EQ(child->id(), root->render_surface()->layer_list().at(1)->id());
6038 }
6039
6040 TEST_F(LayerTreeHostCommonTest, SubtreeHidden_SingleLayerImpl) {
6041   FakeImplProxy proxy;
6042   TestSharedBitmapManager shared_bitmap_manager;
6043   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager, nullptr);
6044   host_impl.CreatePendingTree();
6045   const gfx::Transform identity_matrix;
6046
6047   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.pending_tree(), 1);
6048   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
6049                                gfx::PointF(), gfx::Size(50, 50), true, false,
6050                                false);
6051   root->SetDrawsContent(true);
6052
6053   scoped_ptr<LayerImpl> child = LayerImpl::Create(host_impl.pending_tree(), 2);
6054   SetLayerPropertiesForTesting(child.get(), identity_matrix, gfx::Point3F(),
6055                                gfx::PointF(), gfx::Size(40, 40), true, false,
6056                                false);
6057   child->SetDrawsContent(true);
6058
6059   scoped_ptr<LayerImpl> grand_child =
6060       LayerImpl::Create(host_impl.pending_tree(), 3);
6061   SetLayerPropertiesForTesting(grand_child.get(), identity_matrix,
6062                                gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
6063                                true, false, false);
6064   grand_child->SetDrawsContent(true);
6065   grand_child->SetHideLayerAndSubtree(true);
6066
6067   child->AddChild(grand_child.Pass());
6068   root->AddChild(child.Pass());
6069   root->SetHasRenderSurface(true);
6070
6071   LayerImplList render_surface_layer_list;
6072   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
6073       root.get(), root->bounds(), &render_surface_layer_list);
6074   inputs.can_adjust_raster_scales = true;
6075   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
6076
6077   // We should have one render surface and two layers. The grand child has
6078   // hidden itself.
6079   ASSERT_EQ(1u, render_surface_layer_list.size());
6080   ASSERT_EQ(2u, root->render_surface()->layer_list().size());
6081   EXPECT_EQ(1, root->render_surface()->layer_list().at(0)->id());
6082   EXPECT_EQ(2, root->render_surface()->layer_list().at(1)->id());
6083 }
6084
6085 TEST_F(LayerTreeHostCommonTest, SubtreeHidden_TwoLayers) {
6086   FakeImplProxy proxy;
6087   TestSharedBitmapManager shared_bitmap_manager;
6088   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager, nullptr);
6089   host_impl.CreatePendingTree();
6090   const gfx::Transform identity_matrix;
6091
6092   scoped_refptr<Layer> root = Layer::Create();
6093   SetLayerPropertiesForTesting(root.get(),
6094                                identity_matrix,
6095                                gfx::Point3F(),
6096                                gfx::PointF(),
6097                                gfx::Size(50, 50),
6098                                true,
6099                                false);
6100   root->SetIsDrawable(true);
6101
6102   scoped_refptr<Layer> child = Layer::Create();
6103   SetLayerPropertiesForTesting(child.get(),
6104                                identity_matrix,
6105                                gfx::Point3F(),
6106                                gfx::PointF(),
6107                                gfx::Size(40, 40),
6108                                true,
6109                                false);
6110   child->SetIsDrawable(true);
6111   child->SetHideLayerAndSubtree(true);
6112
6113   scoped_refptr<Layer> grand_child = Layer::Create();
6114   SetLayerPropertiesForTesting(grand_child.get(),
6115                                identity_matrix,
6116                                gfx::Point3F(),
6117                                gfx::PointF(),
6118                                gfx::Size(30, 30),
6119                                true,
6120                                false);
6121   grand_child->SetIsDrawable(true);
6122
6123   child->AddChild(grand_child);
6124   root->AddChild(child);
6125
6126   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
6127   host->SetRootLayer(root);
6128
6129   RenderSurfaceLayerList render_surface_layer_list;
6130   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
6131       root.get(), root->bounds(), &render_surface_layer_list);
6132   inputs.can_adjust_raster_scales = true;
6133   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
6134
6135   // We should have one render surface and one layers. The child has
6136   // hidden itself and the grand child.
6137   ASSERT_EQ(1u, render_surface_layer_list.size());
6138   ASSERT_EQ(1u, root->render_surface()->layer_list().size());
6139   EXPECT_EQ(root->id(), root->render_surface()->layer_list().at(0)->id());
6140 }
6141
6142 TEST_F(LayerTreeHostCommonTest, SubtreeHidden_TwoLayersImpl) {
6143   FakeImplProxy proxy;
6144   TestSharedBitmapManager shared_bitmap_manager;
6145   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager, nullptr);
6146   host_impl.CreatePendingTree();
6147   const gfx::Transform identity_matrix;
6148
6149   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.pending_tree(), 1);
6150   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
6151                                gfx::PointF(), gfx::Size(50, 50), true, false,
6152                                true);
6153   root->SetDrawsContent(true);
6154
6155   scoped_ptr<LayerImpl> child = LayerImpl::Create(host_impl.pending_tree(), 2);
6156   SetLayerPropertiesForTesting(child.get(), identity_matrix, gfx::Point3F(),
6157                                gfx::PointF(), gfx::Size(40, 40), true, false,
6158                                false);
6159   child->SetDrawsContent(true);
6160   child->SetHideLayerAndSubtree(true);
6161
6162   scoped_ptr<LayerImpl> grand_child =
6163       LayerImpl::Create(host_impl.pending_tree(), 3);
6164   SetLayerPropertiesForTesting(grand_child.get(), identity_matrix,
6165                                gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
6166                                true, false, false);
6167   grand_child->SetDrawsContent(true);
6168
6169   child->AddChild(grand_child.Pass());
6170   root->AddChild(child.Pass());
6171
6172   LayerImplList render_surface_layer_list;
6173   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
6174       root.get(), root->bounds(), &render_surface_layer_list);
6175   inputs.can_adjust_raster_scales = true;
6176   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
6177
6178   // We should have one render surface and one layers. The child has
6179   // hidden itself and the grand child.
6180   ASSERT_EQ(1u, render_surface_layer_list.size());
6181   ASSERT_EQ(1u, root->render_surface()->layer_list().size());
6182   EXPECT_EQ(1, root->render_surface()->layer_list().at(0)->id());
6183 }
6184
6185 void EmptyCopyOutputCallback(scoped_ptr<CopyOutputResult> result) {}
6186
6187 TEST_F(LayerTreeHostCommonTest, SubtreeHiddenWithCopyRequest) {
6188   FakeImplProxy proxy;
6189   TestSharedBitmapManager shared_bitmap_manager;
6190   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager, nullptr);
6191   host_impl.CreatePendingTree();
6192   const gfx::Transform identity_matrix;
6193
6194   scoped_refptr<Layer> root = Layer::Create();
6195   SetLayerPropertiesForTesting(root.get(),
6196                                identity_matrix,
6197                                gfx::Point3F(),
6198                                gfx::PointF(),
6199                                gfx::Size(50, 50),
6200                                true,
6201                                false);
6202   root->SetIsDrawable(true);
6203
6204   scoped_refptr<Layer> copy_grand_parent = Layer::Create();
6205   SetLayerPropertiesForTesting(copy_grand_parent.get(),
6206                                identity_matrix,
6207                                gfx::Point3F(),
6208                                gfx::PointF(),
6209                                gfx::Size(40, 40),
6210                                true,
6211                                false);
6212   copy_grand_parent->SetIsDrawable(true);
6213
6214   scoped_refptr<Layer> copy_parent = Layer::Create();
6215   SetLayerPropertiesForTesting(copy_parent.get(),
6216                                identity_matrix,
6217                                gfx::Point3F(),
6218                                gfx::PointF(),
6219                                gfx::Size(30, 30),
6220                                true,
6221                                false);
6222   copy_parent->SetIsDrawable(true);
6223   copy_parent->SetForceRenderSurface(true);
6224
6225   scoped_refptr<Layer> copy_layer = Layer::Create();
6226   SetLayerPropertiesForTesting(copy_layer.get(),
6227                                identity_matrix,
6228                                gfx::Point3F(),
6229                                gfx::PointF(),
6230                                gfx::Size(20, 20),
6231                                true,
6232                                false);
6233   copy_layer->SetIsDrawable(true);
6234
6235   scoped_refptr<Layer> copy_child = Layer::Create();
6236   SetLayerPropertiesForTesting(copy_child.get(),
6237                                identity_matrix,
6238                                gfx::Point3F(),
6239                                gfx::PointF(),
6240                                gfx::Size(20, 20),
6241                                true,
6242                                false);
6243   copy_child->SetIsDrawable(true);
6244
6245   scoped_refptr<Layer> copy_grand_parent_sibling_before = Layer::Create();
6246   SetLayerPropertiesForTesting(copy_grand_parent_sibling_before.get(),
6247                                identity_matrix,
6248                                gfx::Point3F(),
6249                                gfx::PointF(),
6250                                gfx::Size(40, 40),
6251                                true,
6252                                false);
6253   copy_grand_parent_sibling_before->SetIsDrawable(true);
6254
6255   scoped_refptr<Layer> copy_grand_parent_sibling_after = Layer::Create();
6256   SetLayerPropertiesForTesting(copy_grand_parent_sibling_after.get(),
6257                                identity_matrix,
6258                                gfx::Point3F(),
6259                                gfx::PointF(),
6260                                gfx::Size(40, 40),
6261                                true,
6262                                false);
6263   copy_grand_parent_sibling_after->SetIsDrawable(true);
6264
6265   copy_layer->AddChild(copy_child);
6266   copy_parent->AddChild(copy_layer);
6267   copy_grand_parent->AddChild(copy_parent);
6268   root->AddChild(copy_grand_parent_sibling_before);
6269   root->AddChild(copy_grand_parent);
6270   root->AddChild(copy_grand_parent_sibling_after);
6271
6272   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
6273   host->SetRootLayer(root);
6274
6275   // Hide the copy_grand_parent and its subtree. But make a copy request in that
6276   // hidden subtree on copy_layer.
6277   copy_grand_parent->SetHideLayerAndSubtree(true);
6278   copy_grand_parent_sibling_before->SetHideLayerAndSubtree(true);
6279   copy_grand_parent_sibling_after->SetHideLayerAndSubtree(true);
6280   copy_layer->RequestCopyOfOutput(CopyOutputRequest::CreateRequest(
6281       base::Bind(&EmptyCopyOutputCallback)));
6282   EXPECT_TRUE(copy_layer->HasCopyRequest());
6283
6284   RenderSurfaceLayerList render_surface_layer_list;
6285   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
6286       root.get(), root->bounds(), &render_surface_layer_list);
6287   inputs.can_adjust_raster_scales = true;
6288   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
6289
6290   EXPECT_TRUE(root->draw_properties().layer_or_descendant_has_copy_request);
6291   EXPECT_TRUE(copy_grand_parent->draw_properties().
6292               layer_or_descendant_has_copy_request);
6293   EXPECT_TRUE(copy_parent->draw_properties().
6294               layer_or_descendant_has_copy_request);
6295   EXPECT_TRUE(copy_layer->draw_properties().
6296               layer_or_descendant_has_copy_request);
6297   EXPECT_FALSE(copy_child->draw_properties().
6298                layer_or_descendant_has_copy_request);
6299   EXPECT_FALSE(copy_grand_parent_sibling_before->draw_properties().
6300                layer_or_descendant_has_copy_request);
6301   EXPECT_FALSE(copy_grand_parent_sibling_after->draw_properties().
6302                layer_or_descendant_has_copy_request);
6303
6304   // We should have three render surfaces, one for the root, one for the parent
6305   // since it owns a surface, and one for the copy_layer.
6306   ASSERT_EQ(3u, render_surface_layer_list.size());
6307   EXPECT_EQ(root->id(), render_surface_layer_list.at(0)->id());
6308   EXPECT_EQ(copy_parent->id(), render_surface_layer_list.at(1)->id());
6309   EXPECT_EQ(copy_layer->id(), render_surface_layer_list.at(2)->id());
6310
6311   // The root render surface should have 2 contributing layers. The
6312   // copy_grand_parent is hidden along with its siblings, but the copy_parent
6313   // will appear since something in its subtree needs to be drawn for a copy
6314   // request.
6315   ASSERT_EQ(2u, root->render_surface()->layer_list().size());
6316   EXPECT_EQ(root->id(), root->render_surface()->layer_list().at(0)->id());
6317   EXPECT_EQ(copy_parent->id(),
6318             root->render_surface()->layer_list().at(1)->id());
6319
6320   // Nothing actually draws into the copy parent, so only the copy_layer will
6321   // appear in its list, since it needs to be drawn for the copy request.
6322   ASSERT_EQ(1u, copy_parent->render_surface()->layer_list().size());
6323   EXPECT_EQ(copy_layer->id(),
6324             copy_parent->render_surface()->layer_list().at(0)->id());
6325
6326   // The copy_layer's render surface should have two contributing layers.
6327   ASSERT_EQ(2u, copy_layer->render_surface()->layer_list().size());
6328   EXPECT_EQ(copy_layer->id(),
6329             copy_layer->render_surface()->layer_list().at(0)->id());
6330   EXPECT_EQ(copy_child->id(),
6331             copy_layer->render_surface()->layer_list().at(1)->id());
6332 }
6333
6334 TEST_F(LayerTreeHostCommonTest, ClippedOutCopyRequest) {
6335   FakeImplProxy proxy;
6336   TestSharedBitmapManager shared_bitmap_manager;
6337   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager, nullptr);
6338   host_impl.CreatePendingTree();
6339   const gfx::Transform identity_matrix;
6340
6341   scoped_refptr<Layer> root = Layer::Create();
6342   SetLayerPropertiesForTesting(root.get(),
6343                                identity_matrix,
6344                                gfx::Point3F(),
6345                                gfx::PointF(),
6346                                gfx::Size(50, 50),
6347                                true,
6348                                false);
6349   root->SetIsDrawable(true);
6350
6351   scoped_refptr<Layer> copy_parent = Layer::Create();
6352   SetLayerPropertiesForTesting(copy_parent.get(),
6353                                identity_matrix,
6354                                gfx::Point3F(),
6355                                gfx::PointF(),
6356                                gfx::Size(),
6357                                true,
6358                                false);
6359   copy_parent->SetIsDrawable(true);
6360   copy_parent->SetMasksToBounds(true);
6361
6362   scoped_refptr<Layer> copy_layer = Layer::Create();
6363   SetLayerPropertiesForTesting(copy_layer.get(),
6364                                identity_matrix,
6365                                gfx::Point3F(),
6366                                gfx::PointF(),
6367                                gfx::Size(30, 30),
6368                                true,
6369                                false);
6370   copy_layer->SetIsDrawable(true);
6371
6372   scoped_refptr<Layer> copy_child = Layer::Create();
6373   SetLayerPropertiesForTesting(copy_child.get(),
6374                                identity_matrix,
6375                                gfx::Point3F(),
6376                                gfx::PointF(),
6377                                gfx::Size(20, 20),
6378                                true,
6379                                false);
6380   copy_child->SetIsDrawable(true);
6381
6382   copy_layer->AddChild(copy_child);
6383   copy_parent->AddChild(copy_layer);
6384   root->AddChild(copy_parent);
6385
6386   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
6387   host->SetRootLayer(root);
6388
6389   copy_layer->RequestCopyOfOutput(CopyOutputRequest::CreateRequest(
6390       base::Bind(&EmptyCopyOutputCallback)));
6391   EXPECT_TRUE(copy_layer->HasCopyRequest());
6392
6393   RenderSurfaceLayerList render_surface_layer_list;
6394   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
6395       root.get(), root->bounds(), &render_surface_layer_list);
6396   inputs.can_adjust_raster_scales = true;
6397   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
6398
6399   // We should have one render surface, as the others are clipped out.
6400   ASSERT_EQ(1u, render_surface_layer_list.size());
6401   EXPECT_EQ(root->id(), render_surface_layer_list.at(0)->id());
6402
6403   // The root render surface should only have 1 contributing layer, since the
6404   // other layers are empty/clipped away.
6405   ASSERT_EQ(1u, root->render_surface()->layer_list().size());
6406   EXPECT_EQ(root->id(), root->render_surface()->layer_list().at(0)->id());
6407 }
6408
6409 TEST_F(LayerTreeHostCommonTest, VisibleContentRectInsideSurface) {
6410   FakeImplProxy proxy;
6411   TestSharedBitmapManager shared_bitmap_manager;
6412   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager, nullptr);
6413   host_impl.CreatePendingTree();
6414   const gfx::Transform identity_matrix;
6415
6416   scoped_refptr<Layer> root = Layer::Create();
6417   SetLayerPropertiesForTesting(root.get(),
6418                                identity_matrix,
6419                                gfx::Point3F(),
6420                                gfx::PointF(),
6421                                gfx::Size(50, 50),
6422                                true,
6423                                false);
6424   root->SetIsDrawable(true);
6425
6426   // The surface is moved slightly outside of the viewport.
6427   scoped_refptr<Layer> surface = Layer::Create();
6428   SetLayerPropertiesForTesting(surface.get(),
6429                                identity_matrix,
6430                                gfx::Point3F(),
6431                                gfx::PointF(-10, -20),
6432                                gfx::Size(),
6433                                true,
6434                                false);
6435   surface->SetForceRenderSurface(true);
6436
6437   scoped_refptr<Layer> surface_child = Layer::Create();
6438   SetLayerPropertiesForTesting(surface_child.get(),
6439                                identity_matrix,
6440                                gfx::Point3F(),
6441                                gfx::PointF(),
6442                                gfx::Size(50, 50),
6443                                true,
6444                                false);
6445   surface_child->SetIsDrawable(true);
6446
6447   surface->AddChild(surface_child);
6448   root->AddChild(surface);
6449
6450   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
6451   host->SetRootLayer(root);
6452
6453   RenderSurfaceLayerList render_surface_layer_list;
6454   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
6455       root.get(), root->bounds(), &render_surface_layer_list);
6456   inputs.can_adjust_raster_scales = true;
6457   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
6458
6459   // The visible_content_rect for the |surface_child| should not be clipped by
6460   // the viewport.
6461   EXPECT_EQ(gfx::Rect(50, 50).ToString(),
6462             surface_child->visible_content_rect().ToString());
6463 }
6464
6465 TEST_F(LayerTreeHostCommonTest, TransformedClipParent) {
6466   // Ensure that a transform between the layer and its render surface is not a
6467   // problem. Constructs the following layer tree.
6468   //
6469   //   root (a render surface)
6470   //     + render_surface
6471   //       + clip_parent (scaled)
6472   //         + intervening_clipping_layer
6473   //           + clip_child
6474   //
6475   // The render surface should be resized correctly and the clip child should
6476   // inherit the right clip rect.
6477   scoped_refptr<Layer> root = Layer::Create();
6478   scoped_refptr<Layer> render_surface = Layer::Create();
6479   scoped_refptr<Layer> clip_parent = Layer::Create();
6480   scoped_refptr<Layer> intervening = Layer::Create();
6481   scoped_refptr<LayerWithForcedDrawsContent> clip_child =
6482       make_scoped_refptr(new LayerWithForcedDrawsContent);
6483
6484   root->AddChild(render_surface);
6485   render_surface->AddChild(clip_parent);
6486   clip_parent->AddChild(intervening);
6487   intervening->AddChild(clip_child);
6488
6489   clip_child->SetClipParent(clip_parent.get());
6490
6491   intervening->SetMasksToBounds(true);
6492   clip_parent->SetMasksToBounds(true);
6493
6494   render_surface->SetForceRenderSurface(true);
6495
6496   gfx::Transform scale_transform;
6497   scale_transform.Scale(2, 2);
6498
6499   gfx::Transform identity_transform;
6500
6501   SetLayerPropertiesForTesting(root.get(),
6502                                identity_transform,
6503                                gfx::Point3F(),
6504                                gfx::PointF(),
6505                                gfx::Size(50, 50),
6506                                true,
6507                                false);
6508   SetLayerPropertiesForTesting(render_surface.get(),
6509                                identity_transform,
6510                                gfx::Point3F(),
6511                                gfx::PointF(),
6512                                gfx::Size(10, 10),
6513                                true,
6514                                false);
6515   SetLayerPropertiesForTesting(clip_parent.get(),
6516                                scale_transform,
6517                                gfx::Point3F(),
6518                                gfx::PointF(1.f, 1.f),
6519                                gfx::Size(10, 10),
6520                                true,
6521                                false);
6522   SetLayerPropertiesForTesting(intervening.get(),
6523                                identity_transform,
6524                                gfx::Point3F(),
6525                                gfx::PointF(1.f, 1.f),
6526                                gfx::Size(5, 5),
6527                                true,
6528                                false);
6529   SetLayerPropertiesForTesting(clip_child.get(),
6530                                identity_transform,
6531                                gfx::Point3F(),
6532                                gfx::PointF(1.f, 1.f),
6533                                gfx::Size(10, 10),
6534                                true,
6535                                false);
6536
6537   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
6538   host->SetRootLayer(root);
6539
6540   ExecuteCalculateDrawProperties(root.get());
6541
6542   ASSERT_TRUE(root->render_surface());
6543   ASSERT_TRUE(render_surface->render_surface());
6544
6545   // Ensure that we've inherited our clip parent's clip and weren't affected
6546   // by the intervening clip layer.
6547   ASSERT_EQ(gfx::Rect(1, 1, 20, 20).ToString(),
6548             clip_parent->clip_rect().ToString());
6549   ASSERT_EQ(clip_parent->clip_rect().ToString(),
6550             clip_child->clip_rect().ToString());
6551   ASSERT_EQ(gfx::Rect(3, 3, 10, 10).ToString(),
6552             intervening->clip_rect().ToString());
6553
6554   // Ensure that the render surface reports a content rect that has been grown
6555   // to accomodate for the clip child.
6556   ASSERT_EQ(gfx::Rect(5, 5, 16, 16).ToString(),
6557             render_surface->render_surface()->content_rect().ToString());
6558
6559   // The above check implies the two below, but they nicely demonstrate that
6560   // we've grown, despite the intervening layer's clip.
6561   ASSERT_TRUE(clip_parent->clip_rect().Contains(
6562       render_surface->render_surface()->content_rect()));
6563   ASSERT_FALSE(intervening->clip_rect().Contains(
6564       render_surface->render_surface()->content_rect()));
6565 }
6566
6567 TEST_F(LayerTreeHostCommonTest, ClipParentWithInterveningRenderSurface) {
6568   // Ensure that intervening render surfaces are not a problem in the basic
6569   // case. In the following tree, both render surfaces should be resized to
6570   // accomodate for the clip child, despite an intervening clip.
6571   //
6572   //   root (a render surface)
6573   //    + clip_parent (masks to bounds)
6574   //      + render_surface1 (sets opacity)
6575   //        + intervening (masks to bounds)
6576   //          + render_surface2 (also sets opacity)
6577   //            + clip_child
6578   //
6579   scoped_refptr<Layer> root = Layer::Create();
6580   scoped_refptr<Layer> clip_parent = Layer::Create();
6581   scoped_refptr<Layer> render_surface1 = Layer::Create();
6582   scoped_refptr<Layer> intervening = Layer::Create();
6583   scoped_refptr<Layer> render_surface2 = Layer::Create();
6584   scoped_refptr<LayerWithForcedDrawsContent> clip_child =
6585       make_scoped_refptr(new LayerWithForcedDrawsContent);
6586
6587   root->AddChild(clip_parent);
6588   clip_parent->AddChild(render_surface1);
6589   render_surface1->AddChild(intervening);
6590   intervening->AddChild(render_surface2);
6591   render_surface2->AddChild(clip_child);
6592
6593   clip_child->SetClipParent(clip_parent.get());
6594
6595   intervening->SetMasksToBounds(true);
6596   clip_parent->SetMasksToBounds(true);
6597
6598   render_surface1->SetForceRenderSurface(true);
6599   render_surface2->SetForceRenderSurface(true);
6600
6601   gfx::Transform translation_transform;
6602   translation_transform.Translate(2, 2);
6603
6604   gfx::Transform identity_transform;
6605   SetLayerPropertiesForTesting(root.get(),
6606                                identity_transform,
6607                                gfx::Point3F(),
6608                                gfx::PointF(),
6609                                gfx::Size(50, 50),
6610                                true,
6611                                false);
6612   SetLayerPropertiesForTesting(clip_parent.get(),
6613                                translation_transform,
6614                                gfx::Point3F(),
6615                                gfx::PointF(1.f, 1.f),
6616                                gfx::Size(40, 40),
6617                                true,
6618                                false);
6619   SetLayerPropertiesForTesting(render_surface1.get(),
6620                                identity_transform,
6621                                gfx::Point3F(),
6622                                gfx::PointF(),
6623                                gfx::Size(10, 10),
6624                                true,
6625                                false);
6626   SetLayerPropertiesForTesting(intervening.get(),
6627                                identity_transform,
6628                                gfx::Point3F(),
6629                                gfx::PointF(1.f, 1.f),
6630                                gfx::Size(5, 5),
6631                                true,
6632                                false);
6633   SetLayerPropertiesForTesting(render_surface2.get(),
6634                                identity_transform,
6635                                gfx::Point3F(),
6636                                gfx::PointF(),
6637                                gfx::Size(10, 10),
6638                                true,
6639                                false);
6640   SetLayerPropertiesForTesting(clip_child.get(),
6641                                identity_transform,
6642                                gfx::Point3F(),
6643                                gfx::PointF(-10.f, -10.f),
6644                                gfx::Size(60, 60),
6645                                true,
6646                                false);
6647
6648   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
6649   host->SetRootLayer(root);
6650
6651   ExecuteCalculateDrawProperties(root.get());
6652
6653   EXPECT_TRUE(root->render_surface());
6654   EXPECT_TRUE(render_surface1->render_surface());
6655   EXPECT_TRUE(render_surface2->render_surface());
6656
6657   // Since the render surfaces could have expanded, they should not clip (their
6658   // bounds would no longer be reliable). We should resort to layer clipping
6659   // in this case.
6660   EXPECT_EQ(gfx::Rect(0, 0, 0, 0).ToString(),
6661             render_surface1->render_surface()->clip_rect().ToString());
6662   EXPECT_FALSE(render_surface1->render_surface()->is_clipped());
6663   EXPECT_EQ(gfx::Rect(0, 0, 0, 0).ToString(),
6664             render_surface2->render_surface()->clip_rect().ToString());
6665   EXPECT_FALSE(render_surface2->render_surface()->is_clipped());
6666
6667   // NB: clip rects are in target space.
6668   EXPECT_EQ(gfx::Rect(0, 0, 40, 40).ToString(),
6669             render_surface1->clip_rect().ToString());
6670   EXPECT_TRUE(render_surface1->is_clipped());
6671
6672   // This value is inherited from the clipping ancestor layer, 'intervening'.
6673   EXPECT_EQ(gfx::Rect(0, 0, 5, 5).ToString(),
6674             render_surface2->clip_rect().ToString());
6675   EXPECT_TRUE(render_surface2->is_clipped());
6676
6677   // The content rects of both render surfaces should both have expanded to
6678   // contain the clip child.
6679   EXPECT_EQ(gfx::Rect(0, 0, 40, 40).ToString(),
6680             render_surface1->render_surface()->content_rect().ToString());
6681   EXPECT_EQ(gfx::Rect(-1, -1, 40, 40).ToString(),
6682             render_surface2->render_surface()->content_rect().ToString());
6683
6684   // The clip child should have inherited the clip parent's clip (projected to
6685   // the right space, of course), and should have the correctly sized visible
6686   // content rect.
6687   EXPECT_EQ(gfx::Rect(-1, -1, 40, 40).ToString(),
6688             clip_child->clip_rect().ToString());
6689   EXPECT_EQ(gfx::Rect(9, 9, 40, 40).ToString(),
6690             clip_child->visible_content_rect().ToString());
6691   EXPECT_TRUE(clip_child->is_clipped());
6692 }
6693
6694 TEST_F(LayerTreeHostCommonTest, ClipParentScrolledInterveningLayer) {
6695   // Ensure that intervening render surfaces are not a problem, even if there
6696   // is a scroll involved. Note, we do _not_ have to consider any other sort
6697   // of transform.
6698   //
6699   //   root (a render surface)
6700   //    + clip_parent (masks to bounds)
6701   //      + render_surface1 (sets opacity)
6702   //        + intervening (masks to bounds AND scrolls)
6703   //          + render_surface2 (also sets opacity)
6704   //            + clip_child
6705   //
6706   scoped_refptr<Layer> root = Layer::Create();
6707   scoped_refptr<Layer> clip_parent = Layer::Create();
6708   scoped_refptr<Layer> render_surface1 = Layer::Create();
6709   scoped_refptr<Layer> intervening = Layer::Create();
6710   scoped_refptr<Layer> render_surface2 = Layer::Create();
6711   scoped_refptr<LayerWithForcedDrawsContent> clip_child =
6712       make_scoped_refptr(new LayerWithForcedDrawsContent);
6713
6714   root->AddChild(clip_parent);
6715   clip_parent->AddChild(render_surface1);
6716   render_surface1->AddChild(intervening);
6717   intervening->AddChild(render_surface2);
6718   render_surface2->AddChild(clip_child);
6719
6720   clip_child->SetClipParent(clip_parent.get());
6721
6722   intervening->SetMasksToBounds(true);
6723   clip_parent->SetMasksToBounds(true);
6724   intervening->SetScrollClipLayerId(clip_parent->id());
6725   intervening->SetScrollOffset(gfx::ScrollOffset(3, 3));
6726
6727   render_surface1->SetForceRenderSurface(true);
6728   render_surface2->SetForceRenderSurface(true);
6729
6730   gfx::Transform translation_transform;
6731   translation_transform.Translate(2, 2);
6732
6733   gfx::Transform identity_transform;
6734   SetLayerPropertiesForTesting(root.get(),
6735                                identity_transform,
6736                                gfx::Point3F(),
6737                                gfx::PointF(),
6738                                gfx::Size(50, 50),
6739                                true,
6740                                false);
6741   SetLayerPropertiesForTesting(clip_parent.get(),
6742                                translation_transform,
6743                                gfx::Point3F(),
6744                                gfx::PointF(1.f, 1.f),
6745                                gfx::Size(40, 40),
6746                                true,
6747                                false);
6748   SetLayerPropertiesForTesting(render_surface1.get(),
6749                                identity_transform,
6750                                gfx::Point3F(),
6751                                gfx::PointF(),
6752                                gfx::Size(10, 10),
6753                                true,
6754                                false);
6755   SetLayerPropertiesForTesting(intervening.get(),
6756                                identity_transform,
6757                                gfx::Point3F(),
6758                                gfx::PointF(1.f, 1.f),
6759                                gfx::Size(5, 5),
6760                                true,
6761                                false);
6762   SetLayerPropertiesForTesting(render_surface2.get(),
6763                                identity_transform,
6764                                gfx::Point3F(),
6765                                gfx::PointF(),
6766                                gfx::Size(10, 10),
6767                                true,
6768                                false);
6769   SetLayerPropertiesForTesting(clip_child.get(),
6770                                identity_transform,
6771                                gfx::Point3F(),
6772                                gfx::PointF(-10.f, -10.f),
6773                                gfx::Size(60, 60),
6774                                true,
6775                                false);
6776
6777   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
6778   host->SetRootLayer(root);
6779
6780   ExecuteCalculateDrawProperties(root.get());
6781
6782   EXPECT_TRUE(root->render_surface());
6783   EXPECT_TRUE(render_surface1->render_surface());
6784   EXPECT_TRUE(render_surface2->render_surface());
6785
6786   // Since the render surfaces could have expanded, they should not clip (their
6787   // bounds would no longer be reliable). We should resort to layer clipping
6788   // in this case.
6789   EXPECT_EQ(gfx::Rect(0, 0, 0, 0).ToString(),
6790             render_surface1->render_surface()->clip_rect().ToString());
6791   EXPECT_FALSE(render_surface1->render_surface()->is_clipped());
6792   EXPECT_EQ(gfx::Rect(0, 0, 0, 0).ToString(),
6793             render_surface2->render_surface()->clip_rect().ToString());
6794   EXPECT_FALSE(render_surface2->render_surface()->is_clipped());
6795
6796   // NB: clip rects are in target space.
6797   EXPECT_EQ(gfx::Rect(0, 0, 40, 40).ToString(),
6798             render_surface1->clip_rect().ToString());
6799   EXPECT_TRUE(render_surface1->is_clipped());
6800
6801   // This value is inherited from the clipping ancestor layer, 'intervening'.
6802   EXPECT_EQ(gfx::Rect(2, 2, 3, 3).ToString(),
6803             render_surface2->clip_rect().ToString());
6804   EXPECT_TRUE(render_surface2->is_clipped());
6805
6806   // The content rects of both render surfaces should both have expanded to
6807   // contain the clip child.
6808   EXPECT_EQ(gfx::Rect(0, 0, 40, 40).ToString(),
6809             render_surface1->render_surface()->content_rect().ToString());
6810   EXPECT_EQ(gfx::Rect(2, 2, 40, 40).ToString(),
6811             render_surface2->render_surface()->content_rect().ToString());
6812
6813   // The clip child should have inherited the clip parent's clip (projected to
6814   // the right space, of course), and should have the correctly sized visible
6815   // content rect.
6816   EXPECT_EQ(gfx::Rect(2, 2, 40, 40).ToString(),
6817             clip_child->clip_rect().ToString());
6818   EXPECT_EQ(gfx::Rect(12, 12, 40, 40).ToString(),
6819             clip_child->visible_content_rect().ToString());
6820   EXPECT_TRUE(clip_child->is_clipped());
6821 }
6822
6823 TEST_F(LayerTreeHostCommonTest, DescendantsOfClipChildren) {
6824   // Ensures that descendants of the clip child inherit the correct clip.
6825   //
6826   //   root (a render surface)
6827   //    + clip_parent (masks to bounds)
6828   //      + intervening (masks to bounds)
6829   //        + clip_child
6830   //          + child
6831   //
6832   scoped_refptr<Layer> root = Layer::Create();
6833   scoped_refptr<Layer> clip_parent = Layer::Create();
6834   scoped_refptr<Layer> intervening = Layer::Create();
6835   scoped_refptr<Layer> clip_child = Layer::Create();
6836   scoped_refptr<LayerWithForcedDrawsContent> child =
6837       make_scoped_refptr(new LayerWithForcedDrawsContent);
6838
6839   root->AddChild(clip_parent);
6840   clip_parent->AddChild(intervening);
6841   intervening->AddChild(clip_child);
6842   clip_child->AddChild(child);
6843
6844   clip_child->SetClipParent(clip_parent.get());
6845
6846   intervening->SetMasksToBounds(true);
6847   clip_parent->SetMasksToBounds(true);
6848
6849   gfx::Transform identity_transform;
6850   SetLayerPropertiesForTesting(root.get(),
6851                                identity_transform,
6852                                gfx::Point3F(),
6853                                gfx::PointF(),
6854                                gfx::Size(50, 50),
6855                                true,
6856                                false);
6857   SetLayerPropertiesForTesting(clip_parent.get(),
6858                                identity_transform,
6859                                gfx::Point3F(),
6860                                gfx::PointF(),
6861                                gfx::Size(40, 40),
6862                                true,
6863                                false);
6864   SetLayerPropertiesForTesting(intervening.get(),
6865                                identity_transform,
6866                                gfx::Point3F(),
6867                                gfx::PointF(),
6868                                gfx::Size(5, 5),
6869                                true,
6870                                false);
6871   SetLayerPropertiesForTesting(clip_child.get(),
6872                                identity_transform,
6873                                gfx::Point3F(),
6874                                gfx::PointF(),
6875                                gfx::Size(60, 60),
6876                                true,
6877                                false);
6878   SetLayerPropertiesForTesting(child.get(),
6879                                identity_transform,
6880                                gfx::Point3F(),
6881                                gfx::PointF(),
6882                                gfx::Size(60, 60),
6883                                true,
6884                                false);
6885
6886   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
6887   host->SetRootLayer(root);
6888
6889   ExecuteCalculateDrawProperties(root.get());
6890
6891   EXPECT_TRUE(root->render_surface());
6892
6893   // Neither the clip child nor its descendant should have inherited the clip
6894   // from |intervening|.
6895   EXPECT_EQ(gfx::Rect(0, 0, 40, 40).ToString(),
6896             clip_child->clip_rect().ToString());
6897   EXPECT_TRUE(clip_child->is_clipped());
6898   EXPECT_EQ(gfx::Rect(0, 0, 40, 40).ToString(),
6899             child->visible_content_rect().ToString());
6900   EXPECT_TRUE(child->is_clipped());
6901 }
6902
6903 TEST_F(LayerTreeHostCommonTest,
6904        SurfacesShouldBeUnaffectedByNonDescendantClipChildren) {
6905   // Ensures that non-descendant clip children in the tree do not affect
6906   // render surfaces.
6907   //
6908   //   root (a render surface)
6909   //    + clip_parent (masks to bounds)
6910   //      + render_surface1
6911   //        + clip_child
6912   //      + render_surface2
6913   //        + non_clip_child
6914   //
6915   // In this example render_surface2 should be unaffected by clip_child.
6916   scoped_refptr<Layer> root = Layer::Create();
6917   scoped_refptr<Layer> clip_parent = Layer::Create();
6918   scoped_refptr<Layer> render_surface1 = Layer::Create();
6919   scoped_refptr<LayerWithForcedDrawsContent> clip_child =
6920       make_scoped_refptr(new LayerWithForcedDrawsContent);
6921   scoped_refptr<Layer> render_surface2 = Layer::Create();
6922   scoped_refptr<LayerWithForcedDrawsContent> non_clip_child =
6923       make_scoped_refptr(new LayerWithForcedDrawsContent);
6924
6925   root->AddChild(clip_parent);
6926   clip_parent->AddChild(render_surface1);
6927   render_surface1->AddChild(clip_child);
6928   clip_parent->AddChild(render_surface2);
6929   render_surface2->AddChild(non_clip_child);
6930
6931   clip_child->SetClipParent(clip_parent.get());
6932
6933   clip_parent->SetMasksToBounds(true);
6934   render_surface1->SetMasksToBounds(true);
6935
6936   gfx::Transform identity_transform;
6937   SetLayerPropertiesForTesting(root.get(),
6938                                identity_transform,
6939                                gfx::Point3F(),
6940                                gfx::PointF(),
6941                                gfx::Size(15, 15),
6942                                true,
6943                                false);
6944   SetLayerPropertiesForTesting(clip_parent.get(),
6945                                identity_transform,
6946                                gfx::Point3F(),
6947                                gfx::PointF(),
6948                                gfx::Size(10, 10),
6949                                true,
6950                                false);
6951   SetLayerPropertiesForTesting(render_surface1.get(),
6952                                identity_transform,
6953                                gfx::Point3F(),
6954                                gfx::PointF(5, 5),
6955                                gfx::Size(5, 5),
6956                                true,
6957                                false);
6958   SetLayerPropertiesForTesting(render_surface2.get(),
6959                                identity_transform,
6960                                gfx::Point3F(),
6961                                gfx::PointF(),
6962                                gfx::Size(5, 5),
6963                                true,
6964                                false);
6965   SetLayerPropertiesForTesting(clip_child.get(),
6966                                identity_transform,
6967                                gfx::Point3F(),
6968                                gfx::PointF(-1, 1),
6969                                gfx::Size(10, 10),
6970                                true,
6971                                false);
6972   SetLayerPropertiesForTesting(non_clip_child.get(),
6973                                identity_transform,
6974                                gfx::Point3F(),
6975                                gfx::PointF(),
6976                                gfx::Size(5, 5),
6977                                true,
6978                                false);
6979
6980   render_surface1->SetForceRenderSurface(true);
6981   render_surface2->SetForceRenderSurface(true);
6982
6983   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
6984   host->SetRootLayer(root);
6985
6986   ExecuteCalculateDrawProperties(root.get());
6987
6988   EXPECT_TRUE(root->render_surface());
6989   EXPECT_TRUE(render_surface1->render_surface());
6990   EXPECT_TRUE(render_surface2->render_surface());
6991
6992   EXPECT_EQ(gfx::Rect(0, 0, 5, 5).ToString(),
6993             render_surface1->clip_rect().ToString());
6994   EXPECT_TRUE(render_surface1->is_clipped());
6995
6996   // The render surface should not clip (it has unclipped descendants), instead
6997   // it should rely on layer clipping.
6998   EXPECT_EQ(gfx::Rect(0, 0, 0, 0).ToString(),
6999             render_surface1->render_surface()->clip_rect().ToString());
7000   EXPECT_FALSE(render_surface1->render_surface()->is_clipped());
7001
7002   // That said, it should have grown to accomodate the unclipped descendant.
7003   EXPECT_EQ(gfx::Rect(-1, 1, 6, 4).ToString(),
7004             render_surface1->render_surface()->content_rect().ToString());
7005
7006   // This render surface should clip. It has no unclipped descendants.
7007   EXPECT_EQ(gfx::Rect(0, 0, 5, 5).ToString(),
7008             render_surface2->clip_rect().ToString());
7009   EXPECT_TRUE(render_surface2->render_surface()->is_clipped());
7010
7011   // It also shouldn't have grown to accomodate the clip child.
7012   EXPECT_EQ(gfx::Rect(0, 0, 5, 5).ToString(),
7013             render_surface2->render_surface()->content_rect().ToString());
7014
7015   // Sanity check our num_unclipped_descendants values.
7016   EXPECT_EQ(1, render_surface1->num_unclipped_descendants());
7017   EXPECT_EQ(0, render_surface2->num_unclipped_descendants());
7018 }
7019
7020 TEST_F(LayerTreeHostCommonTest, CanRenderToSeparateSurface) {
7021   FakeImplProxy proxy;
7022   TestSharedBitmapManager shared_bitmap_manager;
7023   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager, nullptr);
7024   scoped_ptr<LayerImpl> root =
7025       LayerImpl::Create(host_impl.active_tree(), 12345);
7026   scoped_ptr<LayerImpl> child1 =
7027       LayerImpl::Create(host_impl.active_tree(), 123456);
7028   scoped_ptr<LayerImpl> child2 =
7029       LayerImpl::Create(host_impl.active_tree(), 1234567);
7030   scoped_ptr<LayerImpl> child3 =
7031       LayerImpl::Create(host_impl.active_tree(), 12345678);
7032
7033   gfx::Transform identity_matrix;
7034   gfx::Point3F transform_origin;
7035   gfx::PointF position;
7036   gfx::Size bounds(100, 100);
7037   SetLayerPropertiesForTesting(root.get(), identity_matrix, transform_origin,
7038                                position, bounds, true, false, true);
7039   root->SetDrawsContent(true);
7040
7041   // This layer structure normally forces render surface due to preserves3d
7042   // behavior.
7043   SetLayerPropertiesForTesting(child1.get(), identity_matrix, transform_origin,
7044                                position, bounds, false, true, true);
7045   child1->SetDrawsContent(true);
7046   SetLayerPropertiesForTesting(child2.get(), identity_matrix, transform_origin,
7047                                position, bounds, true, false, false);
7048   child2->SetDrawsContent(true);
7049   SetLayerPropertiesForTesting(child3.get(), identity_matrix, transform_origin,
7050                                position, bounds, true, false, false);
7051   child3->SetDrawsContent(true);
7052
7053   child2->Set3dSortingContextId(1);
7054   child3->Set3dSortingContextId(1);
7055
7056   child2->AddChild(child3.Pass());
7057   child1->AddChild(child2.Pass());
7058   root->AddChild(child1.Pass());
7059
7060   {
7061     LayerImplList render_surface_layer_list;
7062     FakeLayerTreeHostImpl::RecursiveUpdateNumChildren(root.get());
7063     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
7064         root.get(), root->bounds(), &render_surface_layer_list);
7065     inputs.can_render_to_separate_surface = true;
7066     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
7067
7068     EXPECT_EQ(2u, render_surface_layer_list.size());
7069
7070     int count_represents_target_render_surface = 0;
7071     int count_represents_contributing_render_surface = 0;
7072     int count_represents_itself = 0;
7073     auto end = LayerIterator<LayerImpl>::End(&render_surface_layer_list);
7074     for (auto it = LayerIterator<LayerImpl>::Begin(&render_surface_layer_list);
7075          it != end; ++it) {
7076       if (it.represents_target_render_surface())
7077         count_represents_target_render_surface++;
7078       if (it.represents_contributing_render_surface())
7079         count_represents_contributing_render_surface++;
7080       if (it.represents_itself())
7081         count_represents_itself++;
7082     }
7083
7084     // Two render surfaces.
7085     EXPECT_EQ(2, count_represents_target_render_surface);
7086     // Second render surface contributes to root render surface.
7087     EXPECT_EQ(1, count_represents_contributing_render_surface);
7088     // All 4 layers represent itself.
7089     EXPECT_EQ(4, count_represents_itself);
7090   }
7091
7092   {
7093     LayerImplList render_surface_layer_list;
7094     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
7095         root.get(), root->bounds(), &render_surface_layer_list);
7096     inputs.can_render_to_separate_surface = false;
7097     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
7098
7099     EXPECT_EQ(1u, render_surface_layer_list.size());
7100
7101     int count_represents_target_render_surface = 0;
7102     int count_represents_contributing_render_surface = 0;
7103     int count_represents_itself = 0;
7104     auto end = LayerIterator<LayerImpl>::End(&render_surface_layer_list);
7105     for (auto it = LayerIterator<LayerImpl>::Begin(&render_surface_layer_list);
7106          it != end; ++it) {
7107       if (it.represents_target_render_surface())
7108         count_represents_target_render_surface++;
7109       if (it.represents_contributing_render_surface())
7110         count_represents_contributing_render_surface++;
7111       if (it.represents_itself())
7112         count_represents_itself++;
7113     }
7114
7115     // Only root layer has a render surface.
7116     EXPECT_EQ(1, count_represents_target_render_surface);
7117     // No layer contributes a render surface to root render surface.
7118     EXPECT_EQ(0, count_represents_contributing_render_surface);
7119     // All 4 layers represent itself.
7120     EXPECT_EQ(4, count_represents_itself);
7121   }
7122 }
7123
7124 TEST_F(LayerTreeHostCommonTest, DoNotIncludeBackfaceInvisibleSurfaces) {
7125   scoped_refptr<Layer> root = Layer::Create();
7126   scoped_refptr<Layer> render_surface = Layer::Create();
7127   scoped_refptr<LayerWithForcedDrawsContent> child =
7128       make_scoped_refptr(new LayerWithForcedDrawsContent);
7129
7130   root->AddChild(render_surface);
7131   render_surface->AddChild(child);
7132
7133   gfx::Transform identity_transform;
7134   SetLayerPropertiesForTesting(root.get(),
7135                                identity_transform,
7136                                gfx::Point3F(),
7137                                gfx::PointF(),
7138                                gfx::Size(50, 50),
7139                                true,
7140                                false);
7141   SetLayerPropertiesForTesting(render_surface.get(),
7142                                identity_transform,
7143                                gfx::Point3F(),
7144                                gfx::PointF(),
7145                                gfx::Size(30, 30),
7146                                false,
7147                                true);
7148   SetLayerPropertiesForTesting(child.get(),
7149                                identity_transform,
7150                                gfx::Point3F(),
7151                                gfx::PointF(),
7152                                gfx::Size(20, 20),
7153                                true,
7154                                false);
7155
7156   root->SetShouldFlattenTransform(false);
7157   root->Set3dSortingContextId(1);
7158   render_surface->SetDoubleSided(false);
7159   render_surface->SetForceRenderSurface(true);
7160
7161   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
7162   host->SetRootLayer(root);
7163
7164   ExecuteCalculateDrawProperties(root.get());
7165
7166   EXPECT_EQ(2u, render_surface_layer_list()->size());
7167   EXPECT_EQ(1u,
7168             render_surface_layer_list()->at(0)
7169                 ->render_surface()->layer_list().size());
7170   EXPECT_EQ(1u,
7171             render_surface_layer_list()->at(1)
7172                 ->render_surface()->layer_list().size());
7173
7174   gfx::Transform rotation_transform = identity_transform;
7175   rotation_transform.RotateAboutXAxis(180.0);
7176
7177   render_surface->SetTransform(rotation_transform);
7178
7179   ExecuteCalculateDrawProperties(root.get());
7180
7181   EXPECT_EQ(1u, render_surface_layer_list()->size());
7182   EXPECT_EQ(0u,
7183             render_surface_layer_list()->at(0)
7184                 ->render_surface()->layer_list().size());
7185 }
7186
7187 TEST_F(LayerTreeHostCommonTest, ClippedByScrollParent) {
7188   // Checks that the simple case (being clipped by a scroll parent that would
7189   // have been processed before you anyhow) results in the right clips.
7190   //
7191   // + root
7192   //   + scroll_parent_border
7193   //   | + scroll_parent_clip
7194   //   |   + scroll_parent
7195   //   + scroll_child
7196   //
7197   scoped_refptr<Layer> root = Layer::Create();
7198   scoped_refptr<Layer> scroll_parent_border = Layer::Create();
7199   scoped_refptr<Layer> scroll_parent_clip = Layer::Create();
7200   scoped_refptr<LayerWithForcedDrawsContent> scroll_parent =
7201       make_scoped_refptr(new LayerWithForcedDrawsContent);
7202   scoped_refptr<LayerWithForcedDrawsContent> scroll_child =
7203       make_scoped_refptr(new LayerWithForcedDrawsContent);
7204
7205   root->AddChild(scroll_child);
7206
7207   root->AddChild(scroll_parent_border);
7208   scroll_parent_border->AddChild(scroll_parent_clip);
7209   scroll_parent_clip->AddChild(scroll_parent);
7210
7211   scroll_parent_clip->SetMasksToBounds(true);
7212
7213   scroll_child->SetScrollParent(scroll_parent.get());
7214
7215   gfx::Transform identity_transform;
7216   SetLayerPropertiesForTesting(root.get(),
7217                                identity_transform,
7218                                gfx::Point3F(),
7219                                gfx::PointF(),
7220                                gfx::Size(50, 50),
7221                                true,
7222                                false);
7223   SetLayerPropertiesForTesting(scroll_parent_border.get(),
7224                                identity_transform,
7225                                gfx::Point3F(),
7226                                gfx::PointF(),
7227                                gfx::Size(40, 40),
7228                                true,
7229                                false);
7230   SetLayerPropertiesForTesting(scroll_parent_clip.get(),
7231                                identity_transform,
7232                                gfx::Point3F(),
7233                                gfx::PointF(),
7234                                gfx::Size(30, 30),
7235                                true,
7236                                false);
7237   SetLayerPropertiesForTesting(scroll_parent.get(),
7238                                identity_transform,
7239                                gfx::Point3F(),
7240                                gfx::PointF(),
7241                                gfx::Size(50, 50),
7242                                true,
7243                                false);
7244   SetLayerPropertiesForTesting(scroll_child.get(),
7245                                identity_transform,
7246                                gfx::Point3F(),
7247                                gfx::PointF(),
7248                                gfx::Size(50, 50),
7249                                true,
7250                                false);
7251
7252   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
7253   host->SetRootLayer(root);
7254
7255   ExecuteCalculateDrawProperties(root.get());
7256
7257   EXPECT_TRUE(root->render_surface());
7258
7259   EXPECT_EQ(gfx::Rect(0, 0, 30, 30).ToString(),
7260             scroll_child->clip_rect().ToString());
7261   EXPECT_TRUE(scroll_child->is_clipped());
7262 }
7263
7264 TEST_F(LayerTreeHostCommonTest, SingularTransformSubtreesDoNotDraw) {
7265   scoped_refptr<LayerWithForcedDrawsContent> root =
7266       make_scoped_refptr(new LayerWithForcedDrawsContent);
7267   scoped_refptr<LayerWithForcedDrawsContent> parent =
7268       make_scoped_refptr(new LayerWithForcedDrawsContent);
7269   scoped_refptr<LayerWithForcedDrawsContent> child =
7270       make_scoped_refptr(new LayerWithForcedDrawsContent);
7271
7272   root->AddChild(parent);
7273   parent->AddChild(child);
7274
7275   gfx::Transform identity_transform;
7276   SetLayerPropertiesForTesting(root.get(),
7277                                identity_transform,
7278                                gfx::Point3F(),
7279                                gfx::PointF(),
7280                                gfx::Size(50, 50),
7281                                true,
7282                                true);
7283   root->SetForceRenderSurface(true);
7284   SetLayerPropertiesForTesting(parent.get(),
7285                                identity_transform,
7286                                gfx::Point3F(),
7287                                gfx::PointF(),
7288                                gfx::Size(30, 30),
7289                                true,
7290                                true);
7291   parent->SetForceRenderSurface(true);
7292   SetLayerPropertiesForTesting(child.get(),
7293                                identity_transform,
7294                                gfx::Point3F(),
7295                                gfx::PointF(),
7296                                gfx::Size(20, 20),
7297                                true,
7298                                true);
7299   child->SetForceRenderSurface(true);
7300
7301   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
7302   host->SetRootLayer(root);
7303
7304   ExecuteCalculateDrawProperties(root.get());
7305
7306   EXPECT_EQ(3u, render_surface_layer_list()->size());
7307
7308   gfx::Transform singular_transform;
7309   singular_transform.Scale3d(
7310       SkDoubleToMScalar(1.0), SkDoubleToMScalar(1.0), SkDoubleToMScalar(0.0));
7311
7312   child->SetTransform(singular_transform);
7313
7314   ExecuteCalculateDrawProperties(root.get());
7315
7316   EXPECT_EQ(2u, render_surface_layer_list()->size());
7317
7318   // Ensure that the entire subtree under a layer with singular transform does
7319   // not get rendered.
7320   parent->SetTransform(singular_transform);
7321   child->SetTransform(identity_transform);
7322
7323   ExecuteCalculateDrawProperties(root.get());
7324
7325   EXPECT_EQ(1u, render_surface_layer_list()->size());
7326 }
7327
7328 TEST_F(LayerTreeHostCommonTest, ClippedByOutOfOrderScrollParent) {
7329   // Checks that clipping by a scroll parent that follows you in paint order
7330   // still results in correct clipping.
7331   //
7332   // + root
7333   //   + scroll_child
7334   //   + scroll_parent_border
7335   //     + scroll_parent_clip
7336   //       + scroll_parent
7337   //
7338   scoped_refptr<Layer> root = Layer::Create();
7339   scoped_refptr<Layer> scroll_parent_border = Layer::Create();
7340   scoped_refptr<Layer> scroll_parent_clip = Layer::Create();
7341   scoped_refptr<LayerWithForcedDrawsContent> scroll_parent =
7342       make_scoped_refptr(new LayerWithForcedDrawsContent);
7343   scoped_refptr<LayerWithForcedDrawsContent> scroll_child =
7344       make_scoped_refptr(new LayerWithForcedDrawsContent);
7345
7346   root->AddChild(scroll_parent_border);
7347   scroll_parent_border->AddChild(scroll_parent_clip);
7348   scroll_parent_clip->AddChild(scroll_parent);
7349
7350   root->AddChild(scroll_child);
7351
7352   scroll_parent_clip->SetMasksToBounds(true);
7353
7354   scroll_child->SetScrollParent(scroll_parent.get());
7355
7356   gfx::Transform identity_transform;
7357   SetLayerPropertiesForTesting(root.get(),
7358                                identity_transform,
7359                                gfx::Point3F(),
7360                                gfx::PointF(),
7361                                gfx::Size(50, 50),
7362                                true,
7363                                false);
7364   SetLayerPropertiesForTesting(scroll_parent_border.get(),
7365                                identity_transform,
7366                                gfx::Point3F(),
7367                                gfx::PointF(),
7368                                gfx::Size(40, 40),
7369                                true,
7370                                false);
7371   SetLayerPropertiesForTesting(scroll_parent_clip.get(),
7372                                identity_transform,
7373                                gfx::Point3F(),
7374                                gfx::PointF(),
7375                                gfx::Size(30, 30),
7376                                true,
7377                                false);
7378   SetLayerPropertiesForTesting(scroll_parent.get(),
7379                                identity_transform,
7380                                gfx::Point3F(),
7381                                gfx::PointF(),
7382                                gfx::Size(50, 50),
7383                                true,
7384                                false);
7385   SetLayerPropertiesForTesting(scroll_child.get(),
7386                                identity_transform,
7387                                gfx::Point3F(),
7388                                gfx::PointF(),
7389                                gfx::Size(50, 50),
7390                                true,
7391                                false);
7392
7393   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
7394   host->SetRootLayer(root);
7395
7396   ExecuteCalculateDrawProperties(root.get());
7397
7398   EXPECT_TRUE(root->render_surface());
7399
7400   EXPECT_EQ(gfx::Rect(0, 0, 30, 30).ToString(),
7401             scroll_child->clip_rect().ToString());
7402   EXPECT_TRUE(scroll_child->is_clipped());
7403 }
7404
7405 TEST_F(LayerTreeHostCommonTest, ClippedByOutOfOrderScrollGrandparent) {
7406   // Checks that clipping by a scroll parent and scroll grandparent that follow
7407   // you in paint order still results in correct clipping.
7408   //
7409   // + root
7410   //   + scroll_child
7411   //   + scroll_parent_border
7412   //   | + scroll_parent_clip
7413   //   |   + scroll_parent
7414   //   + scroll_grandparent_border
7415   //     + scroll_grandparent_clip
7416   //       + scroll_grandparent
7417   //
7418   scoped_refptr<Layer> root = Layer::Create();
7419   scoped_refptr<Layer> scroll_parent_border = Layer::Create();
7420   scoped_refptr<Layer> scroll_parent_clip = Layer::Create();
7421   scoped_refptr<LayerWithForcedDrawsContent> scroll_parent =
7422       make_scoped_refptr(new LayerWithForcedDrawsContent);
7423
7424   scoped_refptr<Layer> scroll_grandparent_border = Layer::Create();
7425   scoped_refptr<Layer> scroll_grandparent_clip = Layer::Create();
7426   scoped_refptr<LayerWithForcedDrawsContent> scroll_grandparent =
7427       make_scoped_refptr(new LayerWithForcedDrawsContent);
7428
7429   scoped_refptr<LayerWithForcedDrawsContent> scroll_child =
7430       make_scoped_refptr(new LayerWithForcedDrawsContent);
7431
7432   root->AddChild(scroll_child);
7433
7434   root->AddChild(scroll_parent_border);
7435   scroll_parent_border->AddChild(scroll_parent_clip);
7436   scroll_parent_clip->AddChild(scroll_parent);
7437
7438   root->AddChild(scroll_grandparent_border);
7439   scroll_grandparent_border->AddChild(scroll_grandparent_clip);
7440   scroll_grandparent_clip->AddChild(scroll_grandparent);
7441
7442   scroll_parent_clip->SetMasksToBounds(true);
7443   scroll_grandparent_clip->SetMasksToBounds(true);
7444
7445   scroll_child->SetScrollParent(scroll_parent.get());
7446   scroll_parent_border->SetScrollParent(scroll_grandparent.get());
7447
7448   gfx::Transform identity_transform;
7449   SetLayerPropertiesForTesting(root.get(),
7450                                identity_transform,
7451                                gfx::Point3F(),
7452                                gfx::PointF(),
7453                                gfx::Size(50, 50),
7454                                true,
7455                                false);
7456   SetLayerPropertiesForTesting(scroll_grandparent_border.get(),
7457                                identity_transform,
7458                                gfx::Point3F(),
7459                                gfx::PointF(),
7460                                gfx::Size(40, 40),
7461                                true,
7462                                false);
7463   SetLayerPropertiesForTesting(scroll_grandparent_clip.get(),
7464                                identity_transform,
7465                                gfx::Point3F(),
7466                                gfx::PointF(),
7467                                gfx::Size(20, 20),
7468                                true,
7469                                false);
7470   SetLayerPropertiesForTesting(scroll_grandparent.get(),
7471                                identity_transform,
7472                                gfx::Point3F(),
7473                                gfx::PointF(),
7474                                gfx::Size(50, 50),
7475                                true,
7476                                false);
7477   SetLayerPropertiesForTesting(scroll_parent_border.get(),
7478                                identity_transform,
7479                                gfx::Point3F(),
7480                                gfx::PointF(),
7481                                gfx::Size(40, 40),
7482                                true,
7483                                false);
7484   SetLayerPropertiesForTesting(scroll_parent_clip.get(),
7485                                identity_transform,
7486                                gfx::Point3F(),
7487                                gfx::PointF(),
7488                                gfx::Size(30, 30),
7489                                true,
7490                                false);
7491   SetLayerPropertiesForTesting(scroll_parent.get(),
7492                                identity_transform,
7493                                gfx::Point3F(),
7494                                gfx::PointF(),
7495                                gfx::Size(50, 50),
7496                                true,
7497                                false);
7498   SetLayerPropertiesForTesting(scroll_child.get(),
7499                                identity_transform,
7500                                gfx::Point3F(),
7501                                gfx::PointF(),
7502                                gfx::Size(50, 50),
7503                                true,
7504                                false);
7505
7506   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
7507   host->SetRootLayer(root);
7508
7509   ExecuteCalculateDrawProperties(root.get());
7510
7511   EXPECT_TRUE(root->render_surface());
7512
7513   EXPECT_EQ(gfx::Rect(0, 0, 20, 20).ToString(),
7514             scroll_child->clip_rect().ToString());
7515   EXPECT_TRUE(scroll_child->is_clipped());
7516
7517   // Despite the fact that we visited the above layers out of order to get the
7518   // correct clip, the layer lists should be unaffected.
7519   EXPECT_EQ(3u, root->render_surface()->layer_list().size());
7520   EXPECT_EQ(scroll_child.get(),
7521             root->render_surface()->layer_list().at(0).get());
7522   EXPECT_EQ(scroll_parent.get(),
7523             root->render_surface()->layer_list().at(1).get());
7524   EXPECT_EQ(scroll_grandparent.get(),
7525             root->render_surface()->layer_list().at(2).get());
7526 }
7527
7528 TEST_F(LayerTreeHostCommonTest, OutOfOrderClippingRequiresRSLLSorting) {
7529   // Ensures that even if we visit layers out of order, we still produce a
7530   // correctly ordered render surface layer list.
7531   // + root
7532   //   + scroll_child
7533   //   + scroll_parent_border
7534   //     + scroll_parent_clip
7535   //       + scroll_parent
7536   //         + render_surface1
7537   //   + scroll_grandparent_border
7538   //     + scroll_grandparent_clip
7539   //       + scroll_grandparent
7540   //         + render_surface2
7541   //
7542   scoped_refptr<LayerWithForcedDrawsContent> root =
7543       make_scoped_refptr(new LayerWithForcedDrawsContent);
7544
7545   scoped_refptr<Layer> scroll_parent_border = Layer::Create();
7546   scoped_refptr<Layer> scroll_parent_clip = Layer::Create();
7547   scoped_refptr<LayerWithForcedDrawsContent> scroll_parent =
7548       make_scoped_refptr(new LayerWithForcedDrawsContent);
7549   scoped_refptr<LayerWithForcedDrawsContent> render_surface1 =
7550       make_scoped_refptr(new LayerWithForcedDrawsContent);
7551
7552   scoped_refptr<Layer> scroll_grandparent_border = Layer::Create();
7553   scoped_refptr<Layer> scroll_grandparent_clip = Layer::Create();
7554   scoped_refptr<LayerWithForcedDrawsContent> scroll_grandparent =
7555       make_scoped_refptr(new LayerWithForcedDrawsContent);
7556   scoped_refptr<LayerWithForcedDrawsContent> render_surface2 =
7557       make_scoped_refptr(new LayerWithForcedDrawsContent);
7558
7559   scoped_refptr<LayerWithForcedDrawsContent> scroll_child =
7560       make_scoped_refptr(new LayerWithForcedDrawsContent);
7561
7562   root->AddChild(scroll_child);
7563
7564   root->AddChild(scroll_parent_border);
7565   scroll_parent_border->AddChild(scroll_parent_clip);
7566   scroll_parent_clip->AddChild(scroll_parent);
7567   scroll_parent->AddChild(render_surface2);
7568
7569   root->AddChild(scroll_grandparent_border);
7570   scroll_grandparent_border->AddChild(scroll_grandparent_clip);
7571   scroll_grandparent_clip->AddChild(scroll_grandparent);
7572   scroll_grandparent->AddChild(render_surface1);
7573
7574   scroll_parent_clip->SetMasksToBounds(true);
7575   scroll_grandparent_clip->SetMasksToBounds(true);
7576
7577   scroll_child->SetScrollParent(scroll_parent.get());
7578   scroll_parent_border->SetScrollParent(scroll_grandparent.get());
7579
7580   render_surface1->SetForceRenderSurface(true);
7581   render_surface2->SetForceRenderSurface(true);
7582
7583   gfx::Transform identity_transform;
7584   SetLayerPropertiesForTesting(root.get(),
7585                                identity_transform,
7586                                gfx::Point3F(),
7587                                gfx::PointF(),
7588                                gfx::Size(50, 50),
7589                                true,
7590                                false);
7591   SetLayerPropertiesForTesting(scroll_grandparent_border.get(),
7592                                identity_transform,
7593                                gfx::Point3F(),
7594                                gfx::PointF(),
7595                                gfx::Size(40, 40),
7596                                true,
7597                                false);
7598   SetLayerPropertiesForTesting(scroll_grandparent_clip.get(),
7599                                identity_transform,
7600                                gfx::Point3F(),
7601                                gfx::PointF(),
7602                                gfx::Size(20, 20),
7603                                true,
7604                                false);
7605   SetLayerPropertiesForTesting(scroll_grandparent.get(),
7606                                identity_transform,
7607                                gfx::Point3F(),
7608                                gfx::PointF(),
7609                                gfx::Size(50, 50),
7610                                true,
7611                                false);
7612   SetLayerPropertiesForTesting(render_surface1.get(),
7613                                identity_transform,
7614                                gfx::Point3F(),
7615                                gfx::PointF(),
7616                                gfx::Size(50, 50),
7617                                true,
7618                                false);
7619   SetLayerPropertiesForTesting(scroll_parent_border.get(),
7620                                identity_transform,
7621                                gfx::Point3F(),
7622                                gfx::PointF(),
7623                                gfx::Size(40, 40),
7624                                true,
7625                                false);
7626   SetLayerPropertiesForTesting(scroll_parent_clip.get(),
7627                                identity_transform,
7628                                gfx::Point3F(),
7629                                gfx::PointF(),
7630                                gfx::Size(30, 30),
7631                                true,
7632                                false);
7633   SetLayerPropertiesForTesting(scroll_parent.get(),
7634                                identity_transform,
7635                                gfx::Point3F(),
7636                                gfx::PointF(),
7637                                gfx::Size(50, 50),
7638                                true,
7639                                false);
7640   SetLayerPropertiesForTesting(render_surface2.get(),
7641                                identity_transform,
7642                                gfx::Point3F(),
7643                                gfx::PointF(),
7644                                gfx::Size(50, 50),
7645                                true,
7646                                false);
7647   SetLayerPropertiesForTesting(scroll_child.get(),
7648                                identity_transform,
7649                                gfx::Point3F(),
7650                                gfx::PointF(),
7651                                gfx::Size(50, 50),
7652                                true,
7653                                false);
7654
7655   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
7656   host->SetRootLayer(root);
7657
7658   RenderSurfaceLayerList render_surface_layer_list;
7659   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
7660       root.get(),
7661       root->bounds(),
7662       identity_transform,
7663       &render_surface_layer_list);
7664
7665   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
7666
7667   EXPECT_TRUE(root->render_surface());
7668
7669   EXPECT_EQ(gfx::Rect(0, 0, 20, 20).ToString(),
7670             scroll_child->clip_rect().ToString());
7671   EXPECT_TRUE(scroll_child->is_clipped());
7672
7673   // Despite the fact that we had to process the layers out of order to get the
7674   // right clip, our render_surface_layer_list's order should be unaffected.
7675   EXPECT_EQ(3u, render_surface_layer_list.size());
7676   EXPECT_EQ(root.get(), render_surface_layer_list.at(0));
7677   EXPECT_EQ(render_surface2.get(), render_surface_layer_list.at(1));
7678   EXPECT_EQ(render_surface1.get(), render_surface_layer_list.at(2));
7679   EXPECT_TRUE(render_surface_layer_list.at(0)->render_surface());
7680   EXPECT_TRUE(render_surface_layer_list.at(1)->render_surface());
7681   EXPECT_TRUE(render_surface_layer_list.at(2)->render_surface());
7682 }
7683
7684 TEST_F(LayerTreeHostCommonTest, FixedPositionWithInterveningRenderSurface) {
7685   // Ensures that when we have a render surface between a fixed position layer
7686   // and its container, we compute the fixed position layer's draw transform
7687   // with respect to that intervening render surface, not with respect to its
7688   // container's render target.
7689   //
7690   // + root
7691   //   + render_surface
7692   //     + fixed
7693   //
7694   scoped_refptr<Layer> root = Layer::Create();
7695   scoped_refptr<LayerWithForcedDrawsContent> render_surface =
7696       make_scoped_refptr(new LayerWithForcedDrawsContent());
7697   scoped_refptr<LayerWithForcedDrawsContent> fixed =
7698       make_scoped_refptr(new LayerWithForcedDrawsContent());
7699
7700   root->AddChild(render_surface);
7701   render_surface->AddChild(fixed);
7702
7703   root->SetIsContainerForFixedPositionLayers(true);
7704   render_surface->SetForceRenderSurface(true);
7705
7706   LayerPositionConstraint constraint;
7707   constraint.set_is_fixed_position(true);
7708   fixed->SetPositionConstraint(constraint);
7709
7710   SetLayerPropertiesForTesting(root.get(), gfx::Transform(), gfx::Point3F(),
7711                                gfx::PointF(), gfx::Size(50, 50), true, false);
7712   SetLayerPropertiesForTesting(render_surface.get(), gfx::Transform(),
7713                                gfx::Point3F(), gfx::PointF(7.f, 9.f),
7714                                gfx::Size(50, 50), true, false);
7715   SetLayerPropertiesForTesting(fixed.get(), gfx::Transform(), gfx::Point3F(),
7716                                gfx::PointF(10.f, 15.f), gfx::Size(50, 50), true,
7717                                false);
7718
7719   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
7720   host->SetRootLayer(root);
7721
7722   ExecuteCalculateDrawProperties(root.get());
7723
7724   gfx::Transform expected_draw_transform;
7725   expected_draw_transform.Translate(10.f, 15.f);
7726   EXPECT_EQ(expected_draw_transform, fixed->draw_transform());
7727
7728   gfx::Transform expected_screen_space_transform;
7729   expected_screen_space_transform.Translate(17.f, 24.f);
7730   EXPECT_EQ(expected_screen_space_transform, fixed->screen_space_transform());
7731 }
7732
7733 TEST_F(LayerTreeHostCommonTest, ScrollCompensationWithRounding) {
7734   // This test verifies that a scrolling layer that gets snapped to
7735   // integer coordinates doesn't move a fixed position child.
7736   //
7737   // + root
7738   //   + container
7739   //     + scroller
7740   //       + fixed
7741   //
7742   FakeImplProxy proxy;
7743   TestSharedBitmapManager shared_bitmap_manager;
7744   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager, nullptr);
7745   host_impl.CreatePendingTree();
7746   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
7747   scoped_ptr<LayerImpl> container =
7748       LayerImpl::Create(host_impl.active_tree(), 2);
7749   LayerImpl* container_layer = container.get();
7750   scoped_ptr<LayerImpl> scroller =
7751       LayerImpl::Create(host_impl.active_tree(), 3);
7752   LayerImpl* scroll_layer = scroller.get();
7753   scoped_ptr<LayerImpl> fixed = LayerImpl::Create(host_impl.active_tree(), 4);
7754   LayerImpl* fixed_layer = fixed.get();
7755
7756   container->SetIsContainerForFixedPositionLayers(true);
7757
7758   LayerPositionConstraint constraint;
7759   constraint.set_is_fixed_position(true);
7760   fixed->SetPositionConstraint(constraint);
7761
7762   scroller->SetScrollClipLayer(container->id());
7763
7764   gfx::Transform identity_transform;
7765   gfx::Transform container_transform;
7766   container_transform.Translate3d(10.0, 20.0, 0.0);
7767   gfx::Vector2dF container_offset = container_transform.To2dTranslation();
7768
7769   SetLayerPropertiesForTesting(root.get(), identity_transform, gfx::Point3F(),
7770                                gfx::PointF(), gfx::Size(50, 50), true, false,
7771                                true);
7772   SetLayerPropertiesForTesting(container.get(), container_transform,
7773                                gfx::Point3F(), gfx::PointF(), gfx::Size(40, 40),
7774                                true, false, false);
7775   SetLayerPropertiesForTesting(scroller.get(), identity_transform,
7776                                gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
7777                                true, false, false);
7778   SetLayerPropertiesForTesting(fixed.get(), identity_transform, gfx::Point3F(),
7779                                gfx::PointF(), gfx::Size(50, 50), true, false,
7780                                false);
7781
7782   scroller->AddChild(fixed.Pass());
7783   container->AddChild(scroller.Pass());
7784   root->AddChild(container.Pass());
7785
7786   // Rounded to integers already.
7787   {
7788     gfx::Vector2dF scroll_delta(3.0, 5.0);
7789     scroll_layer->SetScrollDelta(scroll_delta);
7790
7791     LayerImplList render_surface_layer_list;
7792     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
7793         root.get(), root->bounds(), &render_surface_layer_list);
7794     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
7795
7796     EXPECT_TRANSFORMATION_MATRIX_EQ(
7797         container_layer->draw_properties().screen_space_transform,
7798         fixed_layer->draw_properties().screen_space_transform);
7799     EXPECT_VECTOR_EQ(
7800         fixed_layer->draw_properties().screen_space_transform.To2dTranslation(),
7801         container_offset);
7802     EXPECT_VECTOR_EQ(scroll_layer->draw_properties()
7803                          .screen_space_transform.To2dTranslation(),
7804                      container_offset - scroll_delta);
7805   }
7806
7807   // Scroll delta requiring rounding.
7808   {
7809     gfx::Vector2dF scroll_delta(4.1f, 8.1f);
7810     scroll_layer->SetScrollDelta(scroll_delta);
7811
7812     gfx::Vector2dF rounded_scroll_delta(4.f, 8.f);
7813
7814     LayerImplList render_surface_layer_list;
7815     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
7816         root.get(), root->bounds(), &render_surface_layer_list);
7817     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
7818
7819     EXPECT_TRANSFORMATION_MATRIX_EQ(
7820         container_layer->draw_properties().screen_space_transform,
7821         fixed_layer->draw_properties().screen_space_transform);
7822     EXPECT_VECTOR_EQ(
7823         fixed_layer->draw_properties().screen_space_transform.To2dTranslation(),
7824         container_offset);
7825     EXPECT_VECTOR_EQ(scroll_layer->draw_properties()
7826                          .screen_space_transform.To2dTranslation(),
7827                      container_offset - rounded_scroll_delta);
7828   }
7829
7830   // Scale is applied earlier in the tree.
7831   {
7832     gfx::Transform scaled_container_transform = container_transform;
7833     scaled_container_transform.Scale3d(3.0, 3.0, 1.0);
7834     container_layer->SetTransform(scaled_container_transform);
7835
7836     gfx::Vector2dF scroll_delta(4.5f, 8.5f);
7837     scroll_layer->SetScrollDelta(scroll_delta);
7838
7839     LayerImplList render_surface_layer_list;
7840     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
7841         root.get(), root->bounds(), &render_surface_layer_list);
7842     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
7843
7844     EXPECT_TRANSFORMATION_MATRIX_EQ(
7845         container_layer->draw_properties().screen_space_transform,
7846         fixed_layer->draw_properties().screen_space_transform);
7847     EXPECT_VECTOR_EQ(
7848         fixed_layer->draw_properties().screen_space_transform.To2dTranslation(),
7849         container_offset);
7850
7851     container_layer->SetTransform(container_transform);
7852   }
7853
7854   // Scale is applied on the scroll layer itself.
7855   {
7856     gfx::Transform scale_transform;
7857     scale_transform.Scale3d(3.0, 3.0, 1.0);
7858     scroll_layer->SetTransform(scale_transform);
7859
7860     gfx::Vector2dF scroll_delta(4.5f, 8.5f);
7861     scroll_layer->SetScrollDelta(scroll_delta);
7862
7863     LayerImplList render_surface_layer_list;
7864     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
7865         root.get(), root->bounds(), &render_surface_layer_list);
7866     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
7867
7868     EXPECT_VECTOR_EQ(
7869         fixed_layer->draw_properties().screen_space_transform.To2dTranslation(),
7870         container_offset);
7871
7872     scroll_layer->SetTransform(identity_transform);
7873   }
7874 }
7875
7876 TEST_F(LayerTreeHostCommonTest,
7877        ScrollCompensationMainScrollOffsetFractionalPart) {
7878   // This test verifies that a scrolling layer that has fractional scroll offset
7879   // from main doesn't move a fixed position child.
7880   //
7881   // + root
7882   //   + container
7883   //     + scroller
7884   //       + fixed
7885   //
7886   FakeImplProxy proxy;
7887   TestSharedBitmapManager shared_bitmap_manager;
7888   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager, nullptr);
7889   host_impl.CreatePendingTree();
7890   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
7891   scoped_ptr<LayerImpl> container =
7892       LayerImpl::Create(host_impl.active_tree(), 2);
7893   LayerImpl* container_layer = container.get();
7894   scoped_ptr<LayerImpl> scroller =
7895       LayerImpl::Create(host_impl.active_tree(), 3);
7896   LayerImpl* scroll_layer = scroller.get();
7897   scoped_ptr<LayerImpl> fixed = LayerImpl::Create(host_impl.active_tree(), 4);
7898   LayerImpl* fixed_layer = fixed.get();
7899
7900   container->SetIsContainerForFixedPositionLayers(true);
7901
7902   LayerPositionConstraint constraint;
7903   constraint.set_is_fixed_position(true);
7904   fixed->SetPositionConstraint(constraint);
7905
7906   scroller->SetScrollClipLayer(container->id());
7907
7908   gfx::Transform identity_transform;
7909   gfx::Transform container_transform;
7910   container_transform.Translate3d(10.0, 20.0, 0.0);
7911   gfx::Vector2dF container_offset = container_transform.To2dTranslation();
7912
7913   SetLayerPropertiesForTesting(root.get(), identity_transform, gfx::Point3F(),
7914                                gfx::PointF(), gfx::Size(50, 50), true, false,
7915                                true);
7916   SetLayerPropertiesForTesting(container.get(), container_transform,
7917                                gfx::Point3F(), gfx::PointF(), gfx::Size(40, 40),
7918                                true, false, false);
7919   SetLayerPropertiesForTesting(scroller.get(), identity_transform,
7920                                gfx::Point3F(), gfx::PointF(0.0, 0.0),
7921                                gfx::Size(30, 30), true, false, false);
7922
7923   gfx::ScrollOffset scroll_offset(3.3, 4.2);
7924   gfx::Vector2dF main_scroll_fractional_part(0.3f, 0.2f);
7925   gfx::Vector2dF scroll_delta(0.1f, 0.4f);
7926   // Blink only uses the integer part of the scroll_offset for fixed
7927   // position layer.
7928   SetLayerPropertiesForTesting(fixed.get(), identity_transform, gfx::Point3F(),
7929                                gfx::PointF(3.0f, 4.0f), gfx::Size(50, 50), true,
7930                                false, false);
7931   scroll_layer->PushScrollOffsetFromMainThread(scroll_offset);
7932   scroll_layer->SetScrollDelta(scroll_delta);
7933   scroll_layer->SetScrollCompensationAdjustment(main_scroll_fractional_part);
7934
7935   scroller->AddChild(fixed.Pass());
7936   container->AddChild(scroller.Pass());
7937   root->AddChild(container.Pass());
7938
7939   LayerImplList render_surface_layer_list;
7940   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
7941       root.get(), root->bounds(), &render_surface_layer_list);
7942   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
7943
7944   EXPECT_TRANSFORMATION_MATRIX_EQ(
7945       container_layer->draw_properties().screen_space_transform,
7946       fixed_layer->draw_properties().screen_space_transform);
7947   EXPECT_VECTOR_EQ(
7948       fixed_layer->draw_properties().screen_space_transform.To2dTranslation(),
7949       container_offset);
7950
7951   gfx::ScrollOffset effective_scroll_offset =
7952       ScrollOffsetWithDelta(scroll_offset, scroll_delta);
7953   gfx::Vector2d rounded_effective_scroll_offset =
7954       ToRoundedVector2d(ScrollOffsetToVector2dF(effective_scroll_offset));
7955   EXPECT_VECTOR_EQ(
7956       scroll_layer->draw_properties().screen_space_transform.To2dTranslation(),
7957       container_offset - rounded_effective_scroll_offset);
7958 }
7959
7960 class AnimationScaleFactorTrackingLayerImpl : public LayerImpl {
7961  public:
7962   static scoped_ptr<AnimationScaleFactorTrackingLayerImpl> Create(
7963       LayerTreeImpl* tree_impl,
7964       int id) {
7965     return make_scoped_ptr(
7966         new AnimationScaleFactorTrackingLayerImpl(tree_impl, id));
7967   }
7968
7969   ~AnimationScaleFactorTrackingLayerImpl() override {}
7970
7971  private:
7972   explicit AnimationScaleFactorTrackingLayerImpl(LayerTreeImpl* tree_impl,
7973                                                  int id)
7974       : LayerImpl(tree_impl, id) {
7975     SetDrawsContent(true);
7976   }
7977 };
7978
7979 TEST_F(LayerTreeHostCommonTest, MaximumAnimationScaleFactor) {
7980   FakeImplProxy proxy;
7981   TestSharedBitmapManager shared_bitmap_manager;
7982   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager, nullptr);
7983   gfx::Transform identity_matrix;
7984   scoped_ptr<AnimationScaleFactorTrackingLayerImpl> grand_parent =
7985       AnimationScaleFactorTrackingLayerImpl::Create(host_impl.active_tree(), 1);
7986   scoped_ptr<AnimationScaleFactorTrackingLayerImpl> parent =
7987       AnimationScaleFactorTrackingLayerImpl::Create(host_impl.active_tree(), 2);
7988   scoped_ptr<AnimationScaleFactorTrackingLayerImpl> child =
7989       AnimationScaleFactorTrackingLayerImpl::Create(host_impl.active_tree(), 3);
7990   scoped_ptr<AnimationScaleFactorTrackingLayerImpl> grand_child =
7991       AnimationScaleFactorTrackingLayerImpl::Create(host_impl.active_tree(), 4);
7992
7993   AnimationScaleFactorTrackingLayerImpl* parent_raw = parent.get();
7994   AnimationScaleFactorTrackingLayerImpl* child_raw = child.get();
7995   AnimationScaleFactorTrackingLayerImpl* grand_child_raw = grand_child.get();
7996
7997   child->AddChild(grand_child.Pass());
7998   parent->AddChild(child.Pass());
7999   grand_parent->AddChild(parent.Pass());
8000
8001   SetLayerPropertiesForTesting(grand_parent.get(), identity_matrix,
8002                                gfx::Point3F(), gfx::PointF(), gfx::Size(1, 2),
8003                                true, false, true);
8004   SetLayerPropertiesForTesting(parent_raw, identity_matrix, gfx::Point3F(),
8005                                gfx::PointF(), gfx::Size(1, 2), true, false,
8006                                false);
8007   SetLayerPropertiesForTesting(child_raw, identity_matrix, gfx::Point3F(),
8008                                gfx::PointF(), gfx::Size(1, 2), true, false,
8009                                false);
8010
8011   SetLayerPropertiesForTesting(grand_child_raw, identity_matrix, gfx::Point3F(),
8012                                gfx::PointF(), gfx::Size(1, 2), true, false,
8013                                false);
8014
8015   ExecuteCalculateDrawProperties(grand_parent.get());
8016
8017   // No layers have animations.
8018   EXPECT_EQ(0.f,
8019             grand_parent->draw_properties().maximum_animation_contents_scale);
8020   EXPECT_EQ(0.f,
8021             parent_raw->draw_properties().maximum_animation_contents_scale);
8022   EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
8023   EXPECT_EQ(
8024       0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
8025
8026   TransformOperations translation;
8027   translation.AppendTranslate(1.f, 2.f, 3.f);
8028
8029   AddAnimatedTransformToLayer(
8030       parent_raw, 1.0, TransformOperations(), translation);
8031
8032   // No layers have scale-affecting animations.
8033   EXPECT_EQ(0.f,
8034             grand_parent->draw_properties().maximum_animation_contents_scale);
8035   EXPECT_EQ(0.f,
8036             parent_raw->draw_properties().maximum_animation_contents_scale);
8037   EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
8038   EXPECT_EQ(
8039       0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
8040
8041   TransformOperations scale;
8042   scale.AppendScale(5.f, 4.f, 3.f);
8043
8044   AddAnimatedTransformToLayer(child_raw, 1.0, TransformOperations(), scale);
8045   ExecuteCalculateDrawProperties(grand_parent.get());
8046
8047   // Only |child| has a scale-affecting animation.
8048   EXPECT_EQ(0.f,
8049             grand_parent->draw_properties().maximum_animation_contents_scale);
8050   EXPECT_EQ(0.f,
8051             parent_raw->draw_properties().maximum_animation_contents_scale);
8052   EXPECT_EQ(5.f, child_raw->draw_properties().maximum_animation_contents_scale);
8053   EXPECT_EQ(
8054       5.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
8055
8056   AddAnimatedTransformToLayer(
8057       grand_parent.get(), 1.0, TransformOperations(), scale);
8058   ExecuteCalculateDrawProperties(grand_parent.get());
8059
8060   // |grand_parent| and |child| have scale-affecting animations.
8061   EXPECT_EQ(5.f,
8062             grand_parent->draw_properties().maximum_animation_contents_scale);
8063   EXPECT_EQ(5.f,
8064             parent_raw->draw_properties().maximum_animation_contents_scale);
8065   // We don't support combining animated scales from two nodes; 0.f means
8066   // that the maximum scale could not be computed.
8067   EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
8068   EXPECT_EQ(
8069       0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
8070
8071   AddAnimatedTransformToLayer(parent_raw, 1.0, TransformOperations(), scale);
8072   ExecuteCalculateDrawProperties(grand_parent.get());
8073
8074   // |grand_parent|, |parent|, and |child| have scale-affecting animations.
8075   EXPECT_EQ(5.f,
8076             grand_parent->draw_properties().maximum_animation_contents_scale);
8077   EXPECT_EQ(0.f,
8078             parent_raw->draw_properties().maximum_animation_contents_scale);
8079   EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
8080   EXPECT_EQ(
8081       0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
8082
8083   grand_parent->layer_animation_controller()->AbortAnimations(
8084       Animation::TRANSFORM);
8085   parent_raw->layer_animation_controller()->AbortAnimations(
8086       Animation::TRANSFORM);
8087   child_raw->layer_animation_controller()->AbortAnimations(
8088       Animation::TRANSFORM);
8089
8090   TransformOperations perspective;
8091   perspective.AppendPerspective(10.f);
8092
8093   AddAnimatedTransformToLayer(
8094       child_raw, 1.0, TransformOperations(), perspective);
8095   ExecuteCalculateDrawProperties(grand_parent.get());
8096
8097   // |child| has a scale-affecting animation but computing the maximum of this
8098   // animation is not supported.
8099   EXPECT_EQ(0.f,
8100             grand_parent->draw_properties().maximum_animation_contents_scale);
8101   EXPECT_EQ(0.f,
8102             parent_raw->draw_properties().maximum_animation_contents_scale);
8103   EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
8104   EXPECT_EQ(
8105       0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
8106
8107   child_raw->layer_animation_controller()->AbortAnimations(
8108       Animation::TRANSFORM);
8109
8110   gfx::Transform scale_matrix;
8111   scale_matrix.Scale(1.f, 2.f);
8112   grand_parent->SetTransform(scale_matrix);
8113   parent_raw->SetTransform(scale_matrix);
8114   AddAnimatedTransformToLayer(parent_raw, 1.0, TransformOperations(), scale);
8115   ExecuteCalculateDrawProperties(grand_parent.get());
8116
8117   // |grand_parent| and |parent| each have scale 2.f. |parent| has a  scale
8118   // animation with maximum scale 5.f.
8119   EXPECT_EQ(0.f,
8120             grand_parent->draw_properties().maximum_animation_contents_scale);
8121   EXPECT_EQ(10.f,
8122             parent_raw->draw_properties().maximum_animation_contents_scale);
8123   EXPECT_EQ(10.f,
8124             child_raw->draw_properties().maximum_animation_contents_scale);
8125   EXPECT_EQ(
8126       10.f,
8127       grand_child_raw->draw_properties().maximum_animation_contents_scale);
8128
8129   gfx::Transform perspective_matrix;
8130   perspective_matrix.ApplyPerspectiveDepth(2.f);
8131   child_raw->SetTransform(perspective_matrix);
8132   ExecuteCalculateDrawProperties(grand_parent.get());
8133
8134   // |child| has a transform that's neither a translation nor a scale.
8135   EXPECT_EQ(0.f,
8136             grand_parent->draw_properties().maximum_animation_contents_scale);
8137   EXPECT_EQ(10.f,
8138             parent_raw->draw_properties().maximum_animation_contents_scale);
8139   EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
8140   EXPECT_EQ(
8141       0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
8142
8143   parent_raw->SetTransform(perspective_matrix);
8144   ExecuteCalculateDrawProperties(grand_parent.get());
8145
8146   // |parent| and |child| have transforms that are neither translations nor
8147   // scales.
8148   EXPECT_EQ(0.f,
8149             grand_parent->draw_properties().maximum_animation_contents_scale);
8150   EXPECT_EQ(0.f,
8151             parent_raw->draw_properties().maximum_animation_contents_scale);
8152   EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
8153   EXPECT_EQ(
8154       0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
8155
8156   parent_raw->SetTransform(identity_matrix);
8157   child_raw->SetTransform(identity_matrix);
8158   grand_parent->SetTransform(perspective_matrix);
8159
8160   ExecuteCalculateDrawProperties(grand_parent.get());
8161
8162   // |grand_parent| has a transform that's neither a translation nor a scale.
8163   EXPECT_EQ(0.f,
8164             grand_parent->draw_properties().maximum_animation_contents_scale);
8165   EXPECT_EQ(0.f,
8166             parent_raw->draw_properties().maximum_animation_contents_scale);
8167   EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
8168   EXPECT_EQ(
8169       0.f, grand_child_raw->draw_properties().maximum_animation_contents_scale);
8170 }
8171
8172 static int membership_id(LayerImpl* layer) {
8173   return layer->draw_properties().last_drawn_render_surface_layer_list_id;
8174 }
8175
8176 static void GatherDrawnLayers(LayerImplList* rsll,
8177                               std::set<LayerImpl*>* drawn_layers) {
8178   for (LayerIterator<LayerImpl> it = LayerIterator<LayerImpl>::Begin(rsll),
8179                                 end = LayerIterator<LayerImpl>::End(rsll);
8180        it != end;
8181        ++it) {
8182     LayerImpl* layer = *it;
8183     if (it.represents_itself())
8184       drawn_layers->insert(layer);
8185
8186     if (!it.represents_contributing_render_surface())
8187       continue;
8188
8189     if (layer->mask_layer())
8190       drawn_layers->insert(layer->mask_layer());
8191     if (layer->replica_layer() && layer->replica_layer()->mask_layer())
8192       drawn_layers->insert(layer->replica_layer()->mask_layer());
8193   }
8194 }
8195
8196 TEST_F(LayerTreeHostCommonTest, RenderSurfaceLayerListMembership) {
8197   FakeImplProxy proxy;
8198   TestSharedBitmapManager shared_bitmap_manager;
8199   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager, nullptr);
8200   gfx::Transform identity_matrix;
8201
8202   scoped_ptr<LayerImpl> grand_parent =
8203       LayerImpl::Create(host_impl.active_tree(), 1);
8204   scoped_ptr<LayerImpl> parent = LayerImpl::Create(host_impl.active_tree(), 3);
8205   scoped_ptr<LayerImpl> child = LayerImpl::Create(host_impl.active_tree(), 5);
8206   scoped_ptr<LayerImpl> grand_child1 =
8207       LayerImpl::Create(host_impl.active_tree(), 7);
8208   scoped_ptr<LayerImpl> grand_child2 =
8209       LayerImpl::Create(host_impl.active_tree(), 9);
8210
8211   LayerImpl* grand_parent_raw = grand_parent.get();
8212   LayerImpl* parent_raw = parent.get();
8213   LayerImpl* child_raw = child.get();
8214   LayerImpl* grand_child1_raw = grand_child1.get();
8215   LayerImpl* grand_child2_raw = grand_child2.get();
8216
8217   child->AddChild(grand_child1.Pass());
8218   child->AddChild(grand_child2.Pass());
8219   parent->AddChild(child.Pass());
8220   grand_parent->AddChild(parent.Pass());
8221
8222   SetLayerPropertiesForTesting(grand_parent_raw, identity_matrix,
8223                                gfx::Point3F(), gfx::PointF(), gfx::Size(1, 2),
8224                                true, false, true);
8225   SetLayerPropertiesForTesting(parent_raw, identity_matrix, gfx::Point3F(),
8226                                gfx::PointF(), gfx::Size(1, 2), true, false,
8227                                false);
8228
8229   SetLayerPropertiesForTesting(child_raw, identity_matrix, gfx::Point3F(),
8230                                gfx::PointF(), gfx::Size(1, 2), true, false,
8231                                false);
8232
8233   SetLayerPropertiesForTesting(grand_child1_raw, identity_matrix,
8234                                gfx::Point3F(), gfx::PointF(), gfx::Size(1, 2),
8235                                true, false, false);
8236
8237   SetLayerPropertiesForTesting(grand_child2_raw, identity_matrix,
8238                                gfx::Point3F(), gfx::PointF(), gfx::Size(1, 2),
8239                                true, false, false);
8240
8241   // Start with nothing being drawn.
8242   ExecuteCalculateDrawProperties(grand_parent_raw);
8243   int member_id = render_surface_layer_list_count();
8244
8245   EXPECT_NE(member_id, membership_id(grand_parent_raw));
8246   EXPECT_NE(member_id, membership_id(parent_raw));
8247   EXPECT_NE(member_id, membership_id(child_raw));
8248   EXPECT_NE(member_id, membership_id(grand_child1_raw));
8249   EXPECT_NE(member_id, membership_id(grand_child2_raw));
8250
8251   std::set<LayerImpl*> expected;
8252   std::set<LayerImpl*> actual;
8253   GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
8254   EXPECT_EQ(expected, actual);
8255
8256   // If we force render surface, but none of the layers are in the layer list,
8257   // then this layer should not appear in RSLL.
8258   grand_child1_raw->SetHasRenderSurface(true);
8259
8260   ExecuteCalculateDrawProperties(grand_parent_raw);
8261   member_id = render_surface_layer_list_count();
8262
8263   EXPECT_NE(member_id, membership_id(grand_parent_raw));
8264   EXPECT_NE(member_id, membership_id(parent_raw));
8265   EXPECT_NE(member_id, membership_id(child_raw));
8266   EXPECT_NE(member_id, membership_id(grand_child1_raw));
8267   EXPECT_NE(member_id, membership_id(grand_child2_raw));
8268
8269   expected.clear();
8270   actual.clear();
8271   GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
8272   EXPECT_EQ(expected, actual);
8273
8274   // However, if we say that this layer also draws content, it will appear in
8275   // RSLL.
8276   grand_child1_raw->SetDrawsContent(true);
8277
8278   ExecuteCalculateDrawProperties(grand_parent_raw);
8279   member_id = render_surface_layer_list_count();
8280
8281   EXPECT_NE(member_id, membership_id(grand_parent_raw));
8282   EXPECT_NE(member_id, membership_id(parent_raw));
8283   EXPECT_NE(member_id, membership_id(child_raw));
8284   EXPECT_EQ(member_id, membership_id(grand_child1_raw));
8285   EXPECT_NE(member_id, membership_id(grand_child2_raw));
8286
8287   expected.clear();
8288   expected.insert(grand_child1_raw);
8289
8290   actual.clear();
8291   GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
8292   EXPECT_EQ(expected, actual);
8293
8294   // Now child is forced to have a render surface, and one if its children draws
8295   // content.
8296   grand_child1_raw->SetDrawsContent(false);
8297   grand_child1_raw->SetHasRenderSurface(false);
8298   child_raw->SetHasRenderSurface(true);
8299   grand_child2_raw->SetDrawsContent(true);
8300
8301   ExecuteCalculateDrawProperties(grand_parent_raw);
8302   member_id = render_surface_layer_list_count();
8303
8304   EXPECT_NE(member_id, membership_id(grand_parent_raw));
8305   EXPECT_NE(member_id, membership_id(parent_raw));
8306   EXPECT_NE(member_id, membership_id(child_raw));
8307   EXPECT_NE(member_id, membership_id(grand_child1_raw));
8308   EXPECT_EQ(member_id, membership_id(grand_child2_raw));
8309
8310   expected.clear();
8311   expected.insert(grand_child2_raw);
8312
8313   actual.clear();
8314   GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
8315   EXPECT_EQ(expected, actual);
8316
8317   // Add a mask layer to child.
8318   child_raw->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 6).Pass());
8319
8320   ExecuteCalculateDrawProperties(grand_parent_raw);
8321   member_id = render_surface_layer_list_count();
8322
8323   EXPECT_NE(member_id, membership_id(grand_parent_raw));
8324   EXPECT_NE(member_id, membership_id(parent_raw));
8325   EXPECT_NE(member_id, membership_id(child_raw));
8326   EXPECT_EQ(member_id, membership_id(child_raw->mask_layer()));
8327   EXPECT_NE(member_id, membership_id(grand_child1_raw));
8328   EXPECT_EQ(member_id, membership_id(grand_child2_raw));
8329
8330   expected.clear();
8331   expected.insert(grand_child2_raw);
8332   expected.insert(child_raw->mask_layer());
8333
8334   expected.clear();
8335   expected.insert(grand_child2_raw);
8336   expected.insert(child_raw->mask_layer());
8337
8338   actual.clear();
8339   GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
8340   EXPECT_EQ(expected, actual);
8341
8342   // Add replica mask layer.
8343   scoped_ptr<LayerImpl> replica_layer =
8344       LayerImpl::Create(host_impl.active_tree(), 20);
8345   replica_layer->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 21));
8346   child_raw->SetReplicaLayer(replica_layer.Pass());
8347
8348   ExecuteCalculateDrawProperties(grand_parent_raw);
8349   member_id = render_surface_layer_list_count();
8350
8351   EXPECT_NE(member_id, membership_id(grand_parent_raw));
8352   EXPECT_NE(member_id, membership_id(parent_raw));
8353   EXPECT_NE(member_id, membership_id(child_raw));
8354   EXPECT_EQ(member_id, membership_id(child_raw->mask_layer()));
8355   EXPECT_EQ(member_id, membership_id(child_raw->replica_layer()->mask_layer()));
8356   EXPECT_NE(member_id, membership_id(grand_child1_raw));
8357   EXPECT_EQ(member_id, membership_id(grand_child2_raw));
8358
8359   expected.clear();
8360   expected.insert(grand_child2_raw);
8361   expected.insert(child_raw->mask_layer());
8362   expected.insert(child_raw->replica_layer()->mask_layer());
8363
8364   actual.clear();
8365   GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
8366   EXPECT_EQ(expected, actual);
8367
8368   child_raw->TakeReplicaLayer();
8369
8370   // With nothing drawing, we should have no layers.
8371   grand_child2_raw->SetDrawsContent(false);
8372
8373   ExecuteCalculateDrawProperties(grand_parent_raw);
8374   member_id = render_surface_layer_list_count();
8375
8376   EXPECT_NE(member_id, membership_id(grand_parent_raw));
8377   EXPECT_NE(member_id, membership_id(parent_raw));
8378   EXPECT_NE(member_id, membership_id(child_raw));
8379   EXPECT_NE(member_id, membership_id(child_raw->mask_layer()));
8380   EXPECT_NE(member_id, membership_id(grand_child1_raw));
8381   EXPECT_NE(member_id, membership_id(grand_child2_raw));
8382
8383   expected.clear();
8384   actual.clear();
8385   GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
8386   EXPECT_EQ(expected, actual);
8387
8388   // Child itself draws means that we should have the child and the mask in the
8389   // list.
8390   child_raw->SetDrawsContent(true);
8391
8392   ExecuteCalculateDrawProperties(grand_parent_raw);
8393   member_id = render_surface_layer_list_count();
8394
8395   EXPECT_NE(member_id, membership_id(grand_parent_raw));
8396   EXPECT_NE(member_id, membership_id(parent_raw));
8397   EXPECT_EQ(member_id, membership_id(child_raw));
8398   EXPECT_EQ(member_id, membership_id(child_raw->mask_layer()));
8399   EXPECT_NE(member_id, membership_id(grand_child1_raw));
8400   EXPECT_NE(member_id, membership_id(grand_child2_raw));
8401
8402   expected.clear();
8403   expected.insert(child_raw);
8404   expected.insert(child_raw->mask_layer());
8405   actual.clear();
8406   GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
8407   EXPECT_EQ(expected, actual);
8408
8409   child_raw->TakeMaskLayer();
8410
8411   // Now everyone's a member!
8412   grand_parent_raw->SetDrawsContent(true);
8413   parent_raw->SetDrawsContent(true);
8414   child_raw->SetDrawsContent(true);
8415   grand_child1_raw->SetDrawsContent(true);
8416   grand_child2_raw->SetDrawsContent(true);
8417
8418   ExecuteCalculateDrawProperties(grand_parent_raw);
8419   member_id = render_surface_layer_list_count();
8420
8421   EXPECT_EQ(member_id, membership_id(grand_parent_raw));
8422   EXPECT_EQ(member_id, membership_id(parent_raw));
8423   EXPECT_EQ(member_id, membership_id(child_raw));
8424   EXPECT_EQ(member_id, membership_id(grand_child1_raw));
8425   EXPECT_EQ(member_id, membership_id(grand_child2_raw));
8426
8427   expected.clear();
8428   expected.insert(grand_parent_raw);
8429   expected.insert(parent_raw);
8430   expected.insert(child_raw);
8431   expected.insert(grand_child1_raw);
8432   expected.insert(grand_child2_raw);
8433
8434   actual.clear();
8435   GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
8436   EXPECT_EQ(expected, actual);
8437 }
8438
8439 TEST_F(LayerTreeHostCommonTest, DrawPropertyScales) {
8440   FakeImplProxy proxy;
8441   TestSharedBitmapManager shared_bitmap_manager;
8442   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager, nullptr);
8443
8444   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
8445   LayerImpl* root_layer = root.get();
8446   scoped_ptr<LayerImpl> child1 = LayerImpl::Create(host_impl.active_tree(), 2);
8447   LayerImpl* child1_layer = child1.get();
8448   scoped_ptr<LayerImpl> child2 = LayerImpl::Create(host_impl.active_tree(), 3);
8449   LayerImpl* child2_layer = child2.get();
8450
8451   root->AddChild(child1.Pass());
8452   root->AddChild(child2.Pass());
8453   root->SetHasRenderSurface(true);
8454
8455   gfx::Transform identity_matrix, scale_transform_child1,
8456       scale_transform_child2;
8457   scale_transform_child1.Scale(2, 3);
8458   scale_transform_child2.Scale(4, 5);
8459
8460   SetLayerPropertiesForTesting(root_layer, identity_matrix, gfx::Point3F(),
8461                                gfx::PointF(), gfx::Size(1, 1), true, false,
8462                                true);
8463   SetLayerPropertiesForTesting(child1_layer, scale_transform_child1,
8464                                gfx::Point3F(), gfx::PointF(), gfx::Size(), true,
8465                                false, false);
8466
8467   child1_layer->SetMaskLayer(
8468       LayerImpl::Create(host_impl.active_tree(), 4).Pass());
8469
8470   scoped_ptr<LayerImpl> replica_layer =
8471       LayerImpl::Create(host_impl.active_tree(), 5);
8472   replica_layer->SetHasRenderSurface(true);
8473   replica_layer->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 6));
8474   child1_layer->SetReplicaLayer(replica_layer.Pass());
8475   child1_layer->SetHasRenderSurface(true);
8476
8477   ExecuteCalculateDrawProperties(root_layer);
8478
8479   TransformOperations scale;
8480   scale.AppendScale(5.f, 8.f, 3.f);
8481
8482   AddAnimatedTransformToLayer(child2_layer, 1.0, TransformOperations(), scale);
8483   SetLayerPropertiesForTesting(child2_layer, scale_transform_child2,
8484                                gfx::Point3F(), gfx::PointF(), gfx::Size(), true,
8485                                false, false);
8486
8487   ExecuteCalculateDrawProperties(root_layer);
8488
8489   EXPECT_FLOAT_EQ(1.f, root_layer->draw_properties().ideal_contents_scale);
8490   EXPECT_FLOAT_EQ(3.f, child1_layer->draw_properties().ideal_contents_scale);
8491   EXPECT_FLOAT_EQ(
8492       3.f, child1_layer->mask_layer()->draw_properties().ideal_contents_scale);
8493   EXPECT_FLOAT_EQ(3.f,
8494                   child1_layer->replica_layer()
8495                       ->mask_layer()
8496                       ->draw_properties()
8497                       .ideal_contents_scale);
8498   EXPECT_FLOAT_EQ(5.f, child2_layer->draw_properties().ideal_contents_scale);
8499
8500   EXPECT_FLOAT_EQ(
8501       0.f, root_layer->draw_properties().maximum_animation_contents_scale);
8502   EXPECT_FLOAT_EQ(
8503       0.f, child1_layer->draw_properties().maximum_animation_contents_scale);
8504   EXPECT_FLOAT_EQ(0.f,
8505                   child1_layer->mask_layer()
8506                       ->draw_properties()
8507                       .maximum_animation_contents_scale);
8508   EXPECT_FLOAT_EQ(0.f,
8509                   child1_layer->replica_layer()
8510                       ->mask_layer()
8511                       ->draw_properties()
8512                       .maximum_animation_contents_scale);
8513   EXPECT_FLOAT_EQ(
8514       8.f, child2_layer->draw_properties().maximum_animation_contents_scale);
8515
8516   EXPECT_FLOAT_EQ(1.f, root_layer->draw_properties().page_scale_factor);
8517   EXPECT_FLOAT_EQ(1.f, child1_layer->draw_properties().page_scale_factor);
8518   EXPECT_FLOAT_EQ(
8519       1.f, child1_layer->mask_layer()->draw_properties().page_scale_factor);
8520   EXPECT_FLOAT_EQ(1.f,
8521                   child1_layer->replica_layer()
8522                       ->mask_layer()
8523                       ->draw_properties()
8524                       .page_scale_factor);
8525   EXPECT_FLOAT_EQ(1.f, child2_layer->draw_properties().page_scale_factor);
8526
8527   EXPECT_FLOAT_EQ(1.f, root_layer->draw_properties().device_scale_factor);
8528   EXPECT_FLOAT_EQ(1.f, child1_layer->draw_properties().device_scale_factor);
8529   EXPECT_FLOAT_EQ(
8530       1.f, child1_layer->mask_layer()->draw_properties().device_scale_factor);
8531   EXPECT_FLOAT_EQ(1.f,
8532                   child1_layer->replica_layer()
8533                       ->mask_layer()
8534                       ->draw_properties()
8535                       .device_scale_factor);
8536   EXPECT_FLOAT_EQ(1.f, child2_layer->draw_properties().device_scale_factor);
8537
8538   // Changing page-scale would affect ideal_contents_scale and
8539   // maximum_animation_contents_scale.
8540
8541   float page_scale_factor = 3.f;
8542   float device_scale_factor = 1.0f;
8543   std::vector<LayerImpl*> render_surface_layer_list;
8544   gfx::Size device_viewport_size =
8545       gfx::Size(root_layer->bounds().width() * device_scale_factor,
8546                 root_layer->bounds().height() * device_scale_factor);
8547   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
8548       root_layer, device_viewport_size, &render_surface_layer_list);
8549
8550   inputs.page_scale_factor = page_scale_factor;
8551   inputs.can_adjust_raster_scales = true;
8552   inputs.page_scale_application_layer = root_layer;
8553   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
8554
8555   EXPECT_FLOAT_EQ(1.f, root_layer->draw_properties().ideal_contents_scale);
8556   EXPECT_FLOAT_EQ(9.f, child1_layer->draw_properties().ideal_contents_scale);
8557   EXPECT_FLOAT_EQ(
8558       9.f, child1_layer->mask_layer()->draw_properties().ideal_contents_scale);
8559   EXPECT_FLOAT_EQ(9.f,
8560                   child1_layer->replica_layer()
8561                       ->mask_layer()
8562                       ->draw_properties()
8563                       .ideal_contents_scale);
8564   EXPECT_FLOAT_EQ(15.f, child2_layer->draw_properties().ideal_contents_scale);
8565
8566   EXPECT_FLOAT_EQ(
8567       0.f, root_layer->draw_properties().maximum_animation_contents_scale);
8568   EXPECT_FLOAT_EQ(
8569       0.f, child1_layer->draw_properties().maximum_animation_contents_scale);
8570   EXPECT_FLOAT_EQ(0.f,
8571                   child1_layer->mask_layer()
8572                       ->draw_properties()
8573                       .maximum_animation_contents_scale);
8574   EXPECT_FLOAT_EQ(0.f,
8575                   child1_layer->replica_layer()
8576                       ->mask_layer()
8577                       ->draw_properties()
8578                       .maximum_animation_contents_scale);
8579   EXPECT_FLOAT_EQ(
8580       24.f, child2_layer->draw_properties().maximum_animation_contents_scale);
8581
8582   EXPECT_FLOAT_EQ(1.f, root_layer->draw_properties().page_scale_factor);
8583   EXPECT_FLOAT_EQ(3.f, child1_layer->draw_properties().page_scale_factor);
8584   EXPECT_FLOAT_EQ(
8585       3.f, child1_layer->mask_layer()->draw_properties().page_scale_factor);
8586   EXPECT_FLOAT_EQ(3.f,
8587                   child1_layer->replica_layer()
8588                       ->mask_layer()
8589                       ->draw_properties()
8590                       .page_scale_factor);
8591   EXPECT_FLOAT_EQ(3.f, child2_layer->draw_properties().page_scale_factor);
8592
8593   EXPECT_FLOAT_EQ(1.f, root_layer->draw_properties().device_scale_factor);
8594   EXPECT_FLOAT_EQ(1.f, child1_layer->draw_properties().device_scale_factor);
8595   EXPECT_FLOAT_EQ(
8596       1.f, child1_layer->mask_layer()->draw_properties().device_scale_factor);
8597   EXPECT_FLOAT_EQ(1.f,
8598                   child1_layer->replica_layer()
8599                       ->mask_layer()
8600                       ->draw_properties()
8601                       .device_scale_factor);
8602   EXPECT_FLOAT_EQ(1.f, child2_layer->draw_properties().device_scale_factor);
8603
8604   // Changing device-scale would affect ideal_contents_scale and
8605   // maximum_animation_contents_scale.
8606
8607   device_scale_factor = 4.0f;
8608   inputs.device_scale_factor = device_scale_factor;
8609   inputs.can_adjust_raster_scales = true;
8610   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
8611
8612   EXPECT_FLOAT_EQ(4.f, root_layer->draw_properties().ideal_contents_scale);
8613   EXPECT_FLOAT_EQ(36.f, child1_layer->draw_properties().ideal_contents_scale);
8614   EXPECT_FLOAT_EQ(
8615       36.f, child1_layer->mask_layer()->draw_properties().ideal_contents_scale);
8616   EXPECT_FLOAT_EQ(36.f,
8617                   child1_layer->replica_layer()
8618                       ->mask_layer()
8619                       ->draw_properties()
8620                       .ideal_contents_scale);
8621   EXPECT_FLOAT_EQ(60.f, child2_layer->draw_properties().ideal_contents_scale);
8622
8623   EXPECT_FLOAT_EQ(
8624       0.f, root_layer->draw_properties().maximum_animation_contents_scale);
8625   EXPECT_FLOAT_EQ(
8626       0.f, child1_layer->draw_properties().maximum_animation_contents_scale);
8627   EXPECT_FLOAT_EQ(0.f,
8628                   child1_layer->mask_layer()
8629                       ->draw_properties()
8630                       .maximum_animation_contents_scale);
8631   EXPECT_FLOAT_EQ(0.f,
8632                   child1_layer->replica_layer()
8633                       ->mask_layer()
8634                       ->draw_properties()
8635                       .maximum_animation_contents_scale);
8636   EXPECT_FLOAT_EQ(
8637       96.f, child2_layer->draw_properties().maximum_animation_contents_scale);
8638
8639   EXPECT_FLOAT_EQ(1.f, root_layer->draw_properties().page_scale_factor);
8640   EXPECT_FLOAT_EQ(3.f, child1_layer->draw_properties().page_scale_factor);
8641   EXPECT_FLOAT_EQ(
8642       3.f, child1_layer->mask_layer()->draw_properties().page_scale_factor);
8643   EXPECT_FLOAT_EQ(3.f,
8644                   child1_layer->replica_layer()
8645                       ->mask_layer()
8646                       ->draw_properties()
8647                       .page_scale_factor);
8648   EXPECT_FLOAT_EQ(3.f, child2_layer->draw_properties().page_scale_factor);
8649
8650   EXPECT_FLOAT_EQ(4.f, root_layer->draw_properties().device_scale_factor);
8651   EXPECT_FLOAT_EQ(4.f, child1_layer->draw_properties().device_scale_factor);
8652   EXPECT_FLOAT_EQ(
8653       4.f, child1_layer->mask_layer()->draw_properties().device_scale_factor);
8654   EXPECT_FLOAT_EQ(4.f,
8655                   child1_layer->replica_layer()
8656                       ->mask_layer()
8657                       ->draw_properties()
8658                       .device_scale_factor);
8659   EXPECT_FLOAT_EQ(4.f, child2_layer->draw_properties().device_scale_factor);
8660 }
8661
8662 TEST_F(LayerTreeHostCommonTest, VisibleContentRectInChildRenderSurface) {
8663   scoped_refptr<Layer> root = Layer::Create();
8664   SetLayerPropertiesForTesting(root.get(),
8665                                gfx::Transform(),
8666                                gfx::Point3F(),
8667                                gfx::PointF(),
8668                                gfx::Size(768 / 2, 3000),
8669                                true,
8670                                false);
8671   root->SetIsDrawable(true);
8672
8673   scoped_refptr<Layer> clip = Layer::Create();
8674   SetLayerPropertiesForTesting(clip.get(),
8675                                gfx::Transform(),
8676                                gfx::Point3F(),
8677                                gfx::PointF(),
8678                                gfx::Size(768 / 2, 10000),
8679                                true,
8680                                false);
8681   clip->SetMasksToBounds(true);
8682
8683   scoped_refptr<Layer> content = Layer::Create();
8684   SetLayerPropertiesForTesting(content.get(),
8685                                gfx::Transform(),
8686                                gfx::Point3F(),
8687                                gfx::PointF(),
8688                                gfx::Size(768 / 2, 10000),
8689                                true,
8690                                false);
8691   content->SetIsDrawable(true);
8692   content->SetForceRenderSurface(true);
8693
8694   root->AddChild(clip);
8695   clip->AddChild(content);
8696
8697   FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
8698   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create(&client);
8699   host->SetRootLayer(root);
8700
8701   gfx::Size device_viewport_size(768, 582);
8702   RenderSurfaceLayerList render_surface_layer_list;
8703   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
8704       host->root_layer(), device_viewport_size, &render_surface_layer_list);
8705   inputs.device_scale_factor = 2.f;
8706   inputs.page_scale_factor = 1.f;
8707   inputs.page_scale_application_layer = NULL;
8708   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
8709
8710   // Layers in the root render surface have their visible content rect clipped
8711   // by the viewport.
8712   EXPECT_EQ(gfx::Rect(768 / 2, 582 / 2), root->visible_content_rect());
8713
8714   // Layers drawing to a child render surface should still have their visible
8715   // content rect clipped by the viewport.
8716   EXPECT_EQ(gfx::Rect(768 / 2, 582 / 2), content->visible_content_rect());
8717 }
8718
8719 TEST_F(LayerTreeHostCommonTest, BoundsDeltaAffectVisibleContentRect) {
8720   FakeImplProxy proxy;
8721   TestSharedBitmapManager shared_bitmap_manager;
8722   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager, nullptr);
8723
8724   // Set two layers: the root layer clips it's child,
8725   // the child draws its content.
8726
8727   gfx::Size root_size = gfx::Size(300, 500);
8728
8729   // Sublayer should be bigger than the root enlarged by bounds_delta.
8730   gfx::Size sublayer_size = gfx::Size(300, 1000);
8731
8732   // Device viewport accomidated the root and the top controls.
8733   gfx::Size device_viewport_size = gfx::Size(300, 600);
8734   gfx::Transform identity_matrix;
8735
8736   host_impl.active_tree()->SetRootLayer(
8737       LayerImpl::Create(host_impl.active_tree(), 1));
8738
8739   LayerImpl* root = host_impl.active_tree()->root_layer();
8740   SetLayerPropertiesForTesting(root,
8741                                identity_matrix,
8742                                gfx::Point3F(),
8743                                gfx::PointF(),
8744                                root_size,
8745                                false,
8746                                false,
8747                                true);
8748
8749   root->SetContentBounds(root_size);
8750   root->SetMasksToBounds(true);
8751
8752   root->AddChild(LayerImpl::Create(host_impl.active_tree(), 2));
8753
8754   LayerImpl* sublayer = root->child_at(0);
8755   SetLayerPropertiesForTesting(sublayer,
8756                                identity_matrix,
8757                                gfx::Point3F(),
8758                                gfx::PointF(),
8759                                sublayer_size,
8760                                false,
8761                                false,
8762                                false);
8763
8764   sublayer->SetContentBounds(sublayer_size);
8765   sublayer->SetDrawsContent(true);
8766
8767   LayerImplList layer_impl_list;
8768   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
8769       root, device_viewport_size, &layer_impl_list);
8770
8771   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
8772
8773   EXPECT_EQ(gfx::Rect(root_size), sublayer->visible_content_rect());
8774
8775   root->SetBoundsDelta(gfx::Vector2dF(0.0, 50.0));
8776
8777   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
8778
8779   gfx::Rect affected_by_delta(0, 0, root_size.width(),
8780                               root_size.height() + 50);
8781   EXPECT_EQ(affected_by_delta, sublayer->visible_content_rect());
8782 }
8783
8784 TEST_F(LayerTreeHostCommonTest, VisibleContentRectForAnimatedLayer) {
8785   const gfx::Transform identity_matrix;
8786   scoped_refptr<Layer> root = Layer::Create();
8787   scoped_refptr<LayerWithForcedDrawsContent> animated =
8788       make_scoped_refptr(new LayerWithForcedDrawsContent());
8789
8790   root->AddChild(animated);
8791
8792   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
8793   host->SetRootLayer(root);
8794
8795   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
8796                                gfx::PointF(), gfx::Size(100, 100), true, false);
8797   SetLayerPropertiesForTesting(animated.get(), identity_matrix, gfx::Point3F(),
8798                                gfx::PointF(), gfx::Size(20, 20), true, false);
8799
8800   root->SetMasksToBounds(true);
8801   root->SetForceRenderSurface(true);
8802   animated->SetOpacity(0.f);
8803
8804   AddOpacityTransitionToController(animated->layer_animation_controller(), 10.0,
8805                                    0.f, 1.f, false);
8806
8807   ExecuteCalculateDrawProperties(root.get());
8808
8809   EXPECT_FALSE(animated->visible_rect_from_property_trees().IsEmpty());
8810 }
8811
8812 TEST_F(LayerTreeHostCommonTest,
8813        VisibleContentRectForAnimatedLayerWithSingularTransform) {
8814   const gfx::Transform identity_matrix;
8815   scoped_refptr<Layer> root = Layer::Create();
8816   scoped_refptr<Layer> clip = Layer::Create();
8817   scoped_refptr<LayerWithForcedDrawsContent> animated =
8818       make_scoped_refptr(new LayerWithForcedDrawsContent());
8819   scoped_refptr<LayerWithForcedDrawsContent> surface =
8820       make_scoped_refptr(new LayerWithForcedDrawsContent());
8821   scoped_refptr<LayerWithForcedDrawsContent> descendant_of_animation =
8822       make_scoped_refptr(new LayerWithForcedDrawsContent());
8823
8824   root->AddChild(clip);
8825   clip->AddChild(animated);
8826   animated->AddChild(surface);
8827   surface->AddChild(descendant_of_animation);
8828
8829   clip->SetMasksToBounds(true);
8830   surface->SetForceRenderSurface(true);
8831
8832   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
8833   host->SetRootLayer(root);
8834
8835   gfx::Transform uninvertible_matrix;
8836   uninvertible_matrix.Scale3d(6.f, 6.f, 0.f);
8837
8838   SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
8839                                gfx::PointF(), gfx::Size(100, 100), true, false);
8840   SetLayerPropertiesForTesting(clip.get(), identity_matrix, gfx::Point3F(),
8841                                gfx::PointF(), gfx::Size(10, 10), true, false);
8842   SetLayerPropertiesForTesting(animated.get(), uninvertible_matrix,
8843                                gfx::Point3F(), gfx::PointF(),
8844                                gfx::Size(120, 120), true, false);
8845   SetLayerPropertiesForTesting(surface.get(), identity_matrix, gfx::Point3F(),
8846                                gfx::PointF(), gfx::Size(100, 100), true, false);
8847   SetLayerPropertiesForTesting(descendant_of_animation.get(), identity_matrix,
8848                                gfx::Point3F(), gfx::PointF(),
8849                                gfx::Size(200, 200), true, false);
8850
8851   TransformOperations start_transform_operations;
8852   start_transform_operations.AppendMatrix(uninvertible_matrix);
8853   TransformOperations end_transform_operations;
8854
8855   AddAnimatedTransformToLayer(animated.get(), 10.0, start_transform_operations,
8856                               end_transform_operations);
8857
8858   ExecuteCalculateDrawProperties(root.get());
8859
8860   // The animated layer has a singular transform and maps to a non-empty rect in
8861   // clipped target space, so is treated as fully visible.
8862   EXPECT_EQ(gfx::Rect(120, 120), animated->visible_rect_from_property_trees());
8863
8864   // The singular transform on |animated| is flattened when inherited by
8865   // |surface|, and this happens to make it invertible.
8866   EXPECT_EQ(gfx::Rect(2, 2), surface->visible_rect_from_property_trees());
8867   EXPECT_EQ(gfx::Rect(2, 2),
8868             descendant_of_animation->visible_rect_from_property_trees());
8869
8870   gfx::Transform zero_matrix;
8871   zero_matrix.Scale3d(0.f, 0.f, 0.f);
8872   SetLayerPropertiesForTesting(animated.get(), zero_matrix, gfx::Point3F(),
8873                                gfx::PointF(), gfx::Size(120, 120), true, false);
8874
8875   ExecuteCalculateDrawProperties(root.get());
8876
8877   // The animated layer maps to the empty rect in clipped target space, so is
8878   // treated as having an empty visible rect.
8879   EXPECT_EQ(gfx::Rect(), animated->visible_rect_from_property_trees());
8880
8881   // This time, flattening does not make |animated|'s transform invertible. This
8882   // means the clip cannot be projected into |surface|'s space, so we treat
8883   // |surface| and layers that draw into it as fully visible.
8884   EXPECT_EQ(gfx::Rect(100, 100), surface->visible_rect_from_property_trees());
8885   EXPECT_EQ(gfx::Rect(200, 200),
8886             descendant_of_animation->visible_rect_from_property_trees());
8887 }
8888
8889 // Verify that having an animated filter (but no current filter, as these
8890 // are mutually exclusive) correctly creates a render surface.
8891 TEST_F(LayerTreeHostCommonTest, AnimatedFilterCreatesRenderSurface) {
8892   scoped_refptr<Layer> root = Layer::Create();
8893   scoped_refptr<Layer> child = Layer::Create();
8894   scoped_refptr<Layer> grandchild = Layer::Create();
8895   root->AddChild(child);
8896   child->AddChild(grandchild);
8897
8898   gfx::Transform identity_transform;
8899   SetLayerPropertiesForTesting(root.get(), identity_transform, gfx::Point3F(),
8900                                gfx::PointF(), gfx::Size(50, 50), true, false);
8901   SetLayerPropertiesForTesting(child.get(), identity_transform, gfx::Point3F(),
8902                                gfx::PointF(), gfx::Size(50, 50), true, false);
8903   SetLayerPropertiesForTesting(grandchild.get(), identity_transform,
8904                                gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50),
8905                                true, false);
8906   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
8907   host->SetRootLayer(root);
8908
8909   AddAnimatedFilterToLayer(child.get(), 10.0, 0.1f, 0.2f);
8910
8911   ExecuteCalculateDrawProperties(root.get());
8912
8913   EXPECT_TRUE(root->render_surface());
8914   EXPECT_TRUE(child->render_surface());
8915   EXPECT_FALSE(grandchild->render_surface());
8916
8917   EXPECT_TRUE(root->filters().IsEmpty());
8918   EXPECT_TRUE(child->filters().IsEmpty());
8919   EXPECT_TRUE(grandchild->filters().IsEmpty());
8920
8921   EXPECT_FALSE(root->FilterIsAnimating());
8922   EXPECT_TRUE(child->FilterIsAnimating());
8923   EXPECT_FALSE(grandchild->FilterIsAnimating());
8924 }
8925
8926 // Ensures that the property tree code accounts for offsets between fixed
8927 // position layers and their respective containers.
8928 TEST_F(LayerTreeHostCommonTest, PropertyTreesAccountForFixedParentOffset) {
8929   scoped_refptr<Layer> root = Layer::Create();
8930   scoped_refptr<Layer> child = Layer::Create();
8931   scoped_refptr<LayerWithForcedDrawsContent> grandchild =
8932       make_scoped_refptr(new LayerWithForcedDrawsContent());
8933
8934   root->AddChild(child);
8935   child->AddChild(grandchild);
8936
8937   gfx::Transform identity_transform;
8938   SetLayerPropertiesForTesting(root.get(), identity_transform, gfx::Point3F(),
8939                                gfx::PointF(), gfx::Size(50, 50), true, false);
8940   SetLayerPropertiesForTesting(child.get(), identity_transform, gfx::Point3F(),
8941                                gfx::PointF(1000, 1000), gfx::Size(50, 50), true,
8942                                false);
8943   SetLayerPropertiesForTesting(grandchild.get(), identity_transform,
8944                                gfx::Point3F(), gfx::PointF(-1000, -1000),
8945                                gfx::Size(50, 50), true, false);
8946
8947   root->SetMasksToBounds(true);
8948   root->SetIsContainerForFixedPositionLayers(true);
8949   LayerPositionConstraint constraint;
8950   constraint.set_is_fixed_position(true);
8951   grandchild->SetPositionConstraint(constraint);
8952
8953   root->SetIsContainerForFixedPositionLayers(true);
8954
8955   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
8956   host->SetRootLayer(root);
8957
8958   ExecuteCalculateDrawProperties(root.get());
8959
8960   EXPECT_EQ(gfx::Rect(0, 0, 50, 50),
8961             grandchild->visible_rect_from_property_trees());
8962 }
8963
8964 TEST_F(LayerTreeHostCommonTest, CombineClipsUsingContentTarget) {
8965   // In the following layer tree, the layer |box|'s render target is |surface|.
8966   // |surface| also creates a transform node. We want to combine clips for |box|
8967   // in the space of its target (i.e., |surface|), not its target's target. This
8968   // test ensures that happens.
8969
8970   gfx::Transform rotate;
8971   rotate.Rotate(5);
8972   gfx::Transform identity;
8973
8974   scoped_refptr<Layer> root = Layer::Create();
8975   SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
8976                                gfx::PointF(), gfx::Size(2500, 1500), true,
8977                                false);
8978
8979   scoped_refptr<Layer> frame_clip = Layer::Create();
8980   SetLayerPropertiesForTesting(frame_clip.get(), identity, gfx::Point3F(),
8981                                gfx::PointF(), gfx::Size(2500, 1500), true,
8982                                false);
8983   frame_clip->SetMasksToBounds(true);
8984
8985   scoped_refptr<Layer> rotated = Layer::Create();
8986   SetLayerPropertiesForTesting(rotated.get(), rotate,
8987                                gfx::Point3F(1250, 250, 0), gfx::PointF(),
8988                                gfx::Size(2500, 500), true, false);
8989
8990   scoped_refptr<Layer> surface = Layer::Create();
8991   SetLayerPropertiesForTesting(surface.get(), rotate, gfx::Point3F(),
8992                                gfx::PointF(), gfx::Size(2500, 500), true,
8993                                false);
8994   surface->SetOpacity(0.5);
8995
8996   scoped_refptr<LayerWithForcedDrawsContent> container =
8997       make_scoped_refptr(new LayerWithForcedDrawsContent());
8998   SetLayerPropertiesForTesting(container.get(), identity, gfx::Point3F(),
8999                                gfx::PointF(), gfx::Size(300, 300), true, false);
9000
9001   scoped_refptr<LayerWithForcedDrawsContent> box =
9002       make_scoped_refptr(new LayerWithForcedDrawsContent());
9003   SetLayerPropertiesForTesting(box.get(), identity, gfx::Point3F(),
9004                                gfx::PointF(), gfx::Size(100, 100), true, false);
9005
9006   root->AddChild(frame_clip);
9007   frame_clip->AddChild(rotated);
9008   rotated->AddChild(surface);
9009   surface->AddChild(container);
9010   surface->AddChild(box);
9011
9012   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
9013   host->SetRootLayer(root);
9014
9015   ExecuteCalculateDrawProperties(root.get());
9016 }
9017
9018 TEST_F(LayerTreeHostCommonTest, OnlyApplyFixedPositioningOnce) {
9019   gfx::Transform identity;
9020   gfx::Transform translate_z;
9021   translate_z.Translate3d(0, 0, 10);
9022
9023   scoped_refptr<Layer> root = Layer::Create();
9024   SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
9025                                gfx::PointF(), gfx::Size(800, 800), true, false);
9026   root->SetIsContainerForFixedPositionLayers(true);
9027
9028   scoped_refptr<Layer> frame_clip = Layer::Create();
9029   SetLayerPropertiesForTesting(frame_clip.get(), translate_z, gfx::Point3F(),
9030                                gfx::PointF(500, 100), gfx::Size(100, 100), true,
9031                                false);
9032   frame_clip->SetMasksToBounds(true);
9033
9034   scoped_refptr<LayerWithForcedDrawsContent> fixed =
9035       make_scoped_refptr(new LayerWithForcedDrawsContent());
9036   SetLayerPropertiesForTesting(fixed.get(), identity, gfx::Point3F(),
9037                                gfx::PointF(), gfx::Size(1000, 1000), true,
9038                                false);
9039
9040   LayerPositionConstraint constraint;
9041   constraint.set_is_fixed_position(true);
9042   fixed->SetPositionConstraint(constraint);
9043
9044   root->AddChild(frame_clip);
9045   frame_clip->AddChild(fixed);
9046
9047   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
9048   host->SetRootLayer(root);
9049
9050   ExecuteCalculateDrawProperties(root.get());
9051
9052   gfx::Rect expected(0, 0, 100, 100);
9053   EXPECT_EQ(expected, fixed->visible_rect_from_property_trees());
9054 }
9055
9056 TEST_F(LayerTreeHostCommonTest,
9057        PropertyTreesAccountForScrollCompensationAdjustment) {
9058   gfx::Transform identity;
9059   gfx::Transform translate_z;
9060   translate_z.Translate3d(0, 0, 10);
9061
9062   scoped_refptr<Layer> root = Layer::Create();
9063   SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
9064                                gfx::PointF(), gfx::Size(800, 800), true, false);
9065   root->SetIsContainerForFixedPositionLayers(true);
9066
9067   scoped_refptr<Layer> frame_clip = Layer::Create();
9068   SetLayerPropertiesForTesting(frame_clip.get(), translate_z, gfx::Point3F(),
9069                                gfx::PointF(500, 100), gfx::Size(100, 100), true,
9070                                false);
9071   frame_clip->SetMasksToBounds(true);
9072
9073   scoped_refptr<LayerWithForcedDrawsContent> scroller =
9074       make_scoped_refptr(new LayerWithForcedDrawsContent());
9075   SetLayerPropertiesForTesting(scroller.get(), identity, gfx::Point3F(),
9076                                gfx::PointF(), gfx::Size(1000, 1000), true,
9077                                false);
9078
9079   scroller->SetScrollCompensationAdjustment(gfx::Vector2dF(0.3f, 0.7f));
9080   scroller->SetScrollOffset(gfx::ScrollOffset(0.3, 0.7));
9081   scroller->SetScrollClipLayerId(frame_clip->id());
9082
9083   scoped_refptr<LayerWithForcedDrawsContent> fixed =
9084       make_scoped_refptr(new LayerWithForcedDrawsContent());
9085   SetLayerPropertiesForTesting(fixed.get(), identity, gfx::Point3F(),
9086                                gfx::PointF(), gfx::Size(50, 50), true, false);
9087
9088   LayerPositionConstraint constraint;
9089   constraint.set_is_fixed_position(true);
9090   fixed->SetPositionConstraint(constraint);
9091
9092   scoped_refptr<LayerWithForcedDrawsContent> fixed_child =
9093       make_scoped_refptr(new LayerWithForcedDrawsContent());
9094   SetLayerPropertiesForTesting(fixed_child.get(), identity, gfx::Point3F(),
9095                                gfx::PointF(), gfx::Size(10, 10), true, false);
9096
9097   fixed_child->SetPositionConstraint(constraint);
9098
9099   root->AddChild(frame_clip);
9100   frame_clip->AddChild(scroller);
9101   scroller->AddChild(fixed);
9102   fixed->AddChild(fixed_child);
9103
9104   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
9105   host->SetRootLayer(root);
9106
9107   ExecuteCalculateDrawProperties(root.get());
9108
9109   gfx::Rect expected(0, 0, 50, 50);
9110   EXPECT_EQ(expected, fixed->visible_rect_from_property_trees());
9111
9112   expected = gfx::Rect(0, 0, 10, 10);
9113   EXPECT_EQ(expected, fixed_child->visible_rect_from_property_trees());
9114 }
9115
9116 TEST_F(LayerTreeHostCommonTest, FixedClipsShouldBeAssociatedWithTheRightNode) {
9117   gfx::Transform identity;
9118
9119   scoped_refptr<Layer> root = Layer::Create();
9120   SetLayerPropertiesForTesting(root.get(), identity, gfx::Point3F(),
9121                                gfx::PointF(), gfx::Size(800, 800), true, false);
9122   root->SetIsContainerForFixedPositionLayers(true);
9123
9124   scoped_refptr<Layer> frame_clip = Layer::Create();
9125   SetLayerPropertiesForTesting(frame_clip.get(), identity, gfx::Point3F(),
9126                                gfx::PointF(500, 100), gfx::Size(100, 100), true,
9127                                false);
9128   frame_clip->SetMasksToBounds(true);
9129
9130   scoped_refptr<LayerWithForcedDrawsContent> scroller =
9131       make_scoped_refptr(new LayerWithForcedDrawsContent());
9132   SetLayerPropertiesForTesting(scroller.get(), identity, gfx::Point3F(),
9133                                gfx::PointF(), gfx::Size(1000, 1000), true,
9134                                false);
9135
9136   scroller->SetScrollOffset(gfx::ScrollOffset(100, 100));
9137   scroller->SetScrollClipLayerId(frame_clip->id());
9138
9139   scoped_refptr<LayerWithForcedDrawsContent> fixed =
9140       make_scoped_refptr(new LayerWithForcedDrawsContent());
9141   SetLayerPropertiesForTesting(fixed.get(), identity, gfx::Point3F(),
9142                                gfx::PointF(100, 100), gfx::Size(50, 50), true,
9143                                false);
9144
9145   LayerPositionConstraint constraint;
9146   constraint.set_is_fixed_position(true);
9147   fixed->SetPositionConstraint(constraint);
9148   fixed->SetForceRenderSurface(true);
9149   fixed->SetMasksToBounds(true);
9150
9151   root->AddChild(frame_clip);
9152   frame_clip->AddChild(scroller);
9153   scroller->AddChild(fixed);
9154
9155   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
9156   host->SetRootLayer(root);
9157
9158   ExecuteCalculateDrawProperties(root.get());
9159
9160   gfx::Rect expected(0, 0, 50, 50);
9161   EXPECT_EQ(expected, fixed->visible_rect_from_property_trees());
9162 }
9163
9164 }  // namespace
9165 }  // namespace cc