src/cc/trees/layer_tree_impl_unittest.cc

   1 // Copyright 2014 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_impl.h"
   6
   7 #include "cc/layers/heads_up_display_layer_impl.h"
   8 #include "cc/layers/layer.h"
   9 #include "cc/test/fake_impl_proxy.h"
  10 #include "cc/test/fake_layer_tree_host_impl.h"
  11 #include "cc/test/fake_output_surface.h"
  12 #include "cc/test/geometry_test_utils.h"
  13 #include "cc/test/layer_tree_host_common_test.h"
  14 #include "cc/test/test_shared_bitmap_manager.h"
  15 #include "cc/trees/layer_tree_host_impl.h"
  16 #include "ui/gfx/size_conversions.h"
  17
  18 namespace cc {
  19 namespace {
  20
  21 class LayerTreeImplTest : public LayerTreeHostCommonTest {
  22  public:
  23   LayerTreeImplTest() {
  24     LayerTreeSettings settings;
  25     settings.layer_transforms_should_scale_layer_contents = true;
  26     host_impl_.reset(
  27         new FakeLayerTreeHostImpl(settings, &proxy_, &shared_bitmap_manager_));
  28     EXPECT_TRUE(host_impl_->InitializeRenderer(
  29         FakeOutputSurface::Create3d().PassAs<OutputSurface>()));
  30   }
  31
  32   FakeLayerTreeHostImpl& host_impl() { return *host_impl_; }
  33
  34   LayerImpl* root_layer() { return host_impl_->active_tree()->root_layer(); }
  35
  36   const LayerImplList& RenderSurfaceLayerList() const {
  37     return host_impl_->active_tree()->RenderSurfaceLayerList();
  38   }
  39
  40  private:
  41   TestSharedBitmapManager shared_bitmap_manager_;
  42   FakeImplProxy proxy_;
  43   scoped_ptr<FakeLayerTreeHostImpl> host_impl_;
  44 };
  45
  46 TEST_F(LayerTreeImplTest, HitTestingForSingleLayer) {
  47   scoped_ptr<LayerImpl> root =
  48       LayerImpl::Create(host_impl().active_tree(), 12345);
  49
  50   gfx::Transform identity_matrix;
  51   gfx::Point3F transform_origin;
  52   gfx::PointF position;
  53   gfx::Size bounds(100, 100);
  54   SetLayerPropertiesForTesting(root.get(),
  55                                identity_matrix,
  56                                transform_origin,
  57                                position,
  58                                bounds,
  59                                true,
  60                                false);
  61   root->SetDrawsContent(true);
  62
  63   host_impl().SetViewportSize(root->bounds());
  64   host_impl().active_tree()->SetRootLayer(root.Pass());
  65   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
  66
  67   // Sanity check the scenario we just created.
  68   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
  69   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
  70
  71   // Hit testing for a point outside the layer should return a null pointer.
  72   gfx::Point test_point(101, 101);
  73   LayerImpl* result_layer =
  74       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
  75   EXPECT_FALSE(result_layer);
  76
  77   test_point = gfx::Point(-1, -1);
  78   result_layer =
  79       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
  80   EXPECT_FALSE(result_layer);
  81
  82   // Hit testing for a point inside should return the root layer.
  83   test_point = gfx::Point(1, 1);
  84   result_layer =
  85       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
  86   ASSERT_TRUE(result_layer);
  87   EXPECT_EQ(12345, result_layer->id());
  88
  89   test_point = gfx::Point(99, 99);
  90   result_layer =
  91       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
  92   ASSERT_TRUE(result_layer);
  93   EXPECT_EQ(12345, result_layer->id());
  94 }
  95
  96 TEST_F(LayerTreeImplTest, HitTestingForSingleLayerAndHud) {
  97   scoped_ptr<LayerImpl> root =
  98       LayerImpl::Create(host_impl().active_tree(), 12345);
  99   scoped_ptr<HeadsUpDisplayLayerImpl> hud =
 100       HeadsUpDisplayLayerImpl::Create(host_impl().active_tree(), 11111);
 101
 102   gfx::Transform identity_matrix;
 103   gfx::Point3F transform_origin;
 104   gfx::PointF position;
 105   gfx::Size bounds(100, 100);
 106   SetLayerPropertiesForTesting(root.get(),
 107                                identity_matrix,
 108                                transform_origin,
 109                                position,
 110                                bounds,
 111                                true,
 112                                false);
 113   root->SetDrawsContent(true);
 114
 115   // Create hud and add it as a child of root.
 116   gfx::Size hud_bounds(200, 200);
 117   SetLayerPropertiesForTesting(hud.get(),
 118                                identity_matrix,
 119                                transform_origin,
 120                                position,
 121                                hud_bounds,
 122                                true,
 123                                false);
 124   hud->SetDrawsContent(true);
 125
 126   host_impl().active_tree()->set_hud_layer(hud.get());
 127   root->AddChild(hud.PassAs<LayerImpl>());
 128
 129   host_impl().SetViewportSize(hud_bounds);
 130   host_impl().active_tree()->SetRootLayer(root.Pass());
 131   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 132
 133   // Sanity check the scenario we just created.
 134   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
 135   ASSERT_EQ(2u, root_layer()->render_surface()->layer_list().size());
 136
 137   // Hit testing for a point inside HUD, but outside root should return null
 138   gfx::Point test_point(101, 101);
 139   LayerImpl* result_layer =
 140       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 141   EXPECT_FALSE(result_layer);
 142
 143   test_point = gfx::Point(-1, -1);
 144   result_layer =
 145       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 146   EXPECT_FALSE(result_layer);
 147
 148   // Hit testing for a point inside should return the root layer, never the HUD
 149   // layer.
 150   test_point = gfx::Point(1, 1);
 151   result_layer =
 152       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 153   ASSERT_TRUE(result_layer);
 154   EXPECT_EQ(12345, result_layer->id());
 155
 156   test_point = gfx::Point(99, 99);
 157   result_layer =
 158       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 159   ASSERT_TRUE(result_layer);
 160   EXPECT_EQ(12345, result_layer->id());
 161 }
 162
 163 TEST_F(LayerTreeImplTest, HitTestingForUninvertibleTransform) {
 164   scoped_ptr<LayerImpl> root =
 165       LayerImpl::Create(host_impl().active_tree(), 12345);
 166
 167   gfx::Transform uninvertible_transform;
 168   uninvertible_transform.matrix().set(0, 0, 0.0);
 169   uninvertible_transform.matrix().set(1, 1, 0.0);
 170   uninvertible_transform.matrix().set(2, 2, 0.0);
 171   uninvertible_transform.matrix().set(3, 3, 0.0);
 172   ASSERT_FALSE(uninvertible_transform.IsInvertible());
 173
 174   gfx::Transform identity_matrix;
 175   gfx::Point3F transform_origin;
 176   gfx::PointF position;
 177   gfx::Size bounds(100, 100);
 178   SetLayerPropertiesForTesting(root.get(),
 179                                uninvertible_transform,
 180                                transform_origin,
 181                                position,
 182                                bounds,
 183                                true,
 184                                false);
 185   root->SetDrawsContent(true);
 186
 187   host_impl().SetViewportSize(root->bounds());
 188   host_impl().active_tree()->SetRootLayer(root.Pass());
 189   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 190   // Sanity check the scenario we just created.
 191   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
 192   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
 193   ASSERT_FALSE(root_layer()->screen_space_transform().IsInvertible());
 194
 195   // Hit testing any point should not hit the layer. If the invertible matrix is
 196   // accidentally ignored and treated like an identity, then the hit testing
 197   // will incorrectly hit the layer when it shouldn't.
 198   gfx::Point test_point(1, 1);
 199   LayerImpl* result_layer =
 200       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 201   EXPECT_FALSE(result_layer);
 202
 203   test_point = gfx::Point(10, 10);
 204   result_layer =
 205       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 206   EXPECT_FALSE(result_layer);
 207
 208   test_point = gfx::Point(10, 30);
 209   result_layer =
 210       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 211   EXPECT_FALSE(result_layer);
 212
 213   test_point = gfx::Point(50, 50);
 214   result_layer =
 215       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 216   EXPECT_FALSE(result_layer);
 217
 218   test_point = gfx::Point(67, 48);
 219   result_layer =
 220       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 221   EXPECT_FALSE(result_layer);
 222
 223   test_point = gfx::Point(99, 99);
 224   result_layer =
 225       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 226   EXPECT_FALSE(result_layer);
 227
 228   test_point = gfx::Point(-1, -1);
 229   result_layer =
 230       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 231   EXPECT_FALSE(result_layer);
 232 }
 233
 234 TEST_F(LayerTreeImplTest, HitTestingForSinglePositionedLayer) {
 235   scoped_ptr<LayerImpl> root =
 236       LayerImpl::Create(host_impl().active_tree(), 12345);
 237
 238   gfx::Transform identity_matrix;
 239   gfx::Point3F transform_origin;
 240   // this layer is positioned, and hit testing should correctly know where the
 241   // layer is located.
 242   gfx::PointF position(50.f, 50.f);
 243   gfx::Size bounds(100, 100);
 244   SetLayerPropertiesForTesting(root.get(),
 245                                identity_matrix,
 246                                transform_origin,
 247                                position,
 248                                bounds,
 249                                true,
 250                                false);
 251   root->SetDrawsContent(true);
 252
 253   host_impl().SetViewportSize(root->bounds());
 254   host_impl().active_tree()->SetRootLayer(root.Pass());
 255   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 256
 257   // Sanity check the scenario we just created.
 258   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
 259   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
 260
 261   // Hit testing for a point outside the layer should return a null pointer.
 262   gfx::Point test_point(49, 49);
 263   LayerImpl* result_layer =
 264       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 265   EXPECT_FALSE(result_layer);
 266
 267   // Even though the layer exists at (101, 101), it should not be visible there
 268   // since the root render surface would clamp it.
 269   test_point = gfx::Point(101, 101);
 270   result_layer =
 271       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 272   EXPECT_FALSE(result_layer);
 273
 274   // Hit testing for a point inside should return the root layer.
 275   test_point = gfx::Point(51, 51);
 276   result_layer =
 277       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 278   ASSERT_TRUE(result_layer);
 279   EXPECT_EQ(12345, result_layer->id());
 280
 281   test_point = gfx::Point(99, 99);
 282   result_layer =
 283       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 284   ASSERT_TRUE(result_layer);
 285   EXPECT_EQ(12345, result_layer->id());
 286 }
 287
 288 TEST_F(LayerTreeImplTest, HitTestingForSingleRotatedLayer) {
 289   scoped_ptr<LayerImpl> root =
 290       LayerImpl::Create(host_impl().active_tree(), 12345);
 291
 292   gfx::Transform identity_matrix;
 293   gfx::Transform rotation45_degrees_about_center;
 294   rotation45_degrees_about_center.Translate(50.0, 50.0);
 295   rotation45_degrees_about_center.RotateAboutZAxis(45.0);
 296   rotation45_degrees_about_center.Translate(-50.0, -50.0);
 297   gfx::Point3F transform_origin;
 298   gfx::PointF position;
 299   gfx::Size bounds(100, 100);
 300   SetLayerPropertiesForTesting(root.get(),
 301                                rotation45_degrees_about_center,
 302                                transform_origin,
 303                                position,
 304                                bounds,
 305                                true,
 306                                false);
 307   root->SetDrawsContent(true);
 308
 309   host_impl().SetViewportSize(root->bounds());
 310   host_impl().active_tree()->SetRootLayer(root.Pass());
 311   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 312
 313   // Sanity check the scenario we just created.
 314   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
 315   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
 316
 317   // Hit testing for points outside the layer.
 318   // These corners would have been inside the un-transformed layer, but they
 319   // should not hit the correctly transformed layer.
 320   gfx::Point test_point(99, 99);
 321   LayerImpl* result_layer =
 322       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 323   EXPECT_FALSE(result_layer);
 324
 325   test_point = gfx::Point(1, 1);
 326   result_layer =
 327       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 328   EXPECT_FALSE(result_layer);
 329
 330   // Hit testing for a point inside should return the root layer.
 331   test_point = gfx::Point(1, 50);
 332   result_layer =
 333       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 334   ASSERT_TRUE(result_layer);
 335   EXPECT_EQ(12345, result_layer->id());
 336
 337   // Hit testing the corners that would overlap the unclipped layer, but are
 338   // outside the clipped region.
 339   test_point = gfx::Point(50, -1);
 340   result_layer =
 341       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 342   ASSERT_FALSE(result_layer);
 343
 344   test_point = gfx::Point(-1, 50);
 345   result_layer =
 346       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 347   ASSERT_FALSE(result_layer);
 348 }
 349
 350 TEST_F(LayerTreeImplTest, HitTestingForSinglePerspectiveLayer) {
 351   scoped_ptr<LayerImpl> root =
 352       LayerImpl::Create(host_impl().active_tree(), 12345);
 353
 354   gfx::Transform identity_matrix;
 355
 356   // perspective_projection_about_center * translation_by_z is designed so that
 357   // the 100 x 100 layer becomes 50 x 50, and remains centered at (50, 50).
 358   gfx::Transform perspective_projection_about_center;
 359   perspective_projection_about_center.Translate(50.0, 50.0);
 360   perspective_projection_about_center.ApplyPerspectiveDepth(1.0);
 361   perspective_projection_about_center.Translate(-50.0, -50.0);
 362   gfx::Transform translation_by_z;
 363   translation_by_z.Translate3d(0.0, 0.0, -1.0);
 364
 365   gfx::Point3F transform_origin;
 366   gfx::PointF position;
 367   gfx::Size bounds(100, 100);
 368   SetLayerPropertiesForTesting(
 369       root.get(),
 370       perspective_projection_about_center * translation_by_z,
 371       transform_origin,
 372       position,
 373       bounds,
 374       true,
 375       false);
 376   root->SetDrawsContent(true);
 377
 378   host_impl().SetViewportSize(root->bounds());
 379   host_impl().active_tree()->SetRootLayer(root.Pass());
 380   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 381
 382   // Sanity check the scenario we just created.
 383   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
 384   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
 385
 386   // Hit testing for points outside the layer.
 387   // These corners would have been inside the un-transformed layer, but they
 388   // should not hit the correctly transformed layer.
 389   gfx::Point test_point(24, 24);
 390   LayerImpl* result_layer =
 391       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 392   EXPECT_FALSE(result_layer);
 393
 394   test_point = gfx::Point(76, 76);
 395   result_layer =
 396       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 397   EXPECT_FALSE(result_layer);
 398
 399   // Hit testing for a point inside should return the root layer.
 400   test_point = gfx::Point(26, 26);
 401   result_layer =
 402       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 403   ASSERT_TRUE(result_layer);
 404   EXPECT_EQ(12345, result_layer->id());
 405
 406   test_point = gfx::Point(74, 74);
 407   result_layer =
 408       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 409   ASSERT_TRUE(result_layer);
 410   EXPECT_EQ(12345, result_layer->id());
 411 }
 412
 413 TEST_F(LayerTreeImplTest, HitTestingForSingleLayerWithScaledContents) {
 414   // A layer's visible content rect is actually in the layer's content space.
 415   // The screen space transform converts from the layer's origin space to screen
 416   // space. This test makes sure that hit testing works correctly accounts for
 417   // the contents scale.  A contents scale that is not 1 effectively forces a
 418   // non-identity transform between layer's content space and layer's origin
 419   // space. The hit testing code must take this into account.
 420   //
 421   // To test this, the layer is positioned at (25, 25), and is size (50, 50). If
 422   // contents scale is ignored, then hit testing will mis-interpret the visible
 423   // content rect as being larger than the actual bounds of the layer.
 424   //
 425   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
 426
 427   gfx::Transform identity_matrix;
 428   gfx::Point3F transform_origin;
 429
 430   SetLayerPropertiesForTesting(root.get(),
 431                                identity_matrix,
 432                                transform_origin,
 433                                gfx::PointF(),
 434                                gfx::Size(100, 100),
 435                                true,
 436                                false);
 437   {
 438     gfx::PointF position(25.f, 25.f);
 439     gfx::Size bounds(50, 50);
 440     scoped_ptr<LayerImpl> test_layer =
 441         LayerImpl::Create(host_impl().active_tree(), 12345);
 442     SetLayerPropertiesForTesting(test_layer.get(),
 443                                  identity_matrix,
 444                                  transform_origin,
 445                                  position,
 446                                  bounds,
 447                                  true,
 448                                  false);
 449
 450     // override content bounds and contents scale
 451     test_layer->SetContentBounds(gfx::Size(100, 100));
 452     test_layer->SetContentsScale(2, 2);
 453
 454     test_layer->SetDrawsContent(true);
 455     root->AddChild(test_layer.Pass());
 456   }
 457
 458   host_impl().SetViewportSize(root->bounds());
 459   host_impl().active_tree()->SetRootLayer(root.Pass());
 460   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 461
 462   // Sanity check the scenario we just created.
 463   // The visible content rect for test_layer is actually 100x100, even though
 464   // its layout size is 50x50, positioned at 25x25.
 465   LayerImpl* test_layer =
 466       host_impl().active_tree()->root_layer()->children()[0];
 467   EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), test_layer->visible_content_rect());
 468   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
 469   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
 470
 471   // Hit testing for a point outside the layer should return a null pointer (the
 472   // root layer does not draw content, so it will not be hit tested either).
 473   gfx::Point test_point(101, 101);
 474   LayerImpl* result_layer =
 475       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 476   EXPECT_FALSE(result_layer);
 477
 478   test_point = gfx::Point(24, 24);
 479   result_layer =
 480       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 481   EXPECT_FALSE(result_layer);
 482
 483   test_point = gfx::Point(76, 76);
 484   result_layer =
 485       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 486   EXPECT_FALSE(result_layer);
 487
 488   // Hit testing for a point inside should return the test layer.
 489   test_point = gfx::Point(26, 26);
 490   result_layer =
 491       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 492   ASSERT_TRUE(result_layer);
 493   EXPECT_EQ(12345, result_layer->id());
 494
 495   test_point = gfx::Point(74, 74);
 496   result_layer =
 497       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 498   ASSERT_TRUE(result_layer);
 499   EXPECT_EQ(12345, result_layer->id());
 500 }
 501
 502 TEST_F(LayerTreeImplTest, HitTestingForSimpleClippedLayer) {
 503   // Test that hit-testing will only work for the visible portion of a layer,
 504   // and not the entire layer bounds. Here we just test the simple axis-aligned
 505   // case.
 506   gfx::Transform identity_matrix;
 507   gfx::Point3F transform_origin;
 508
 509   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
 510   SetLayerPropertiesForTesting(root.get(),
 511                                identity_matrix,
 512                                transform_origin,
 513                                gfx::PointF(),
 514                                gfx::Size(100, 100),
 515                                true,
 516                                false);
 517   {
 518     scoped_ptr<LayerImpl> clipping_layer =
 519         LayerImpl::Create(host_impl().active_tree(), 123);
 520     // this layer is positioned, and hit testing should correctly know where the
 521     // layer is located.
 522     gfx::PointF position(25.f, 25.f);
 523     gfx::Size bounds(50, 50);
 524     SetLayerPropertiesForTesting(clipping_layer.get(),
 525                                  identity_matrix,
 526                                  transform_origin,
 527                                  position,
 528                                  bounds,
 529                                  true,
 530                                  false);
 531     clipping_layer->SetMasksToBounds(true);
 532
 533     scoped_ptr<LayerImpl> child =
 534         LayerImpl::Create(host_impl().active_tree(), 456);
 535     position = gfx::PointF(-50.f, -50.f);
 536     bounds = gfx::Size(300, 300);
 537     SetLayerPropertiesForTesting(child.get(),
 538                                  identity_matrix,
 539                                  transform_origin,
 540                                  position,
 541                                  bounds,
 542                                  true,
 543                                  false);
 544     child->SetDrawsContent(true);
 545     clipping_layer->AddChild(child.Pass());
 546     root->AddChild(clipping_layer.Pass());
 547   }
 548
 549   host_impl().SetViewportSize(root->bounds());
 550   host_impl().active_tree()->SetRootLayer(root.Pass());
 551   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 552
 553   // Sanity check the scenario we just created.
 554   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
 555   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
 556   ASSERT_EQ(456, root_layer()->render_surface()->layer_list().at(0)->id());
 557
 558   // Hit testing for a point outside the layer should return a null pointer.
 559   // Despite the child layer being very large, it should be clipped to the root
 560   // layer's bounds.
 561   gfx::Point test_point(24, 24);
 562   LayerImpl* result_layer =
 563       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 564   EXPECT_FALSE(result_layer);
 565
 566   // Even though the layer exists at (101, 101), it should not be visible there
 567   // since the clipping_layer would clamp it.
 568   test_point = gfx::Point(76, 76);
 569   result_layer =
 570       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 571   EXPECT_FALSE(result_layer);
 572
 573   // Hit testing for a point inside should return the child layer.
 574   test_point = gfx::Point(26, 26);
 575   result_layer =
 576       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 577   ASSERT_TRUE(result_layer);
 578   EXPECT_EQ(456, result_layer->id());
 579
 580   test_point = gfx::Point(74, 74);
 581   result_layer =
 582       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 583   ASSERT_TRUE(result_layer);
 584   EXPECT_EQ(456, result_layer->id());
 585 }
 586
 587 TEST_F(LayerTreeImplTest, HitTestingForMultiClippedRotatedLayer) {
 588   // This test checks whether hit testing correctly avoids hit testing with
 589   // multiple ancestors that clip in non axis-aligned ways. To pass this test,
 590   // the hit testing algorithm needs to recognize that multiple parent layers
 591   // may clip the layer, and should not actually hit those clipped areas.
 592   //
 593   // The child and grand_child layers are both initialized to clip the
 594   // rotated_leaf. The child layer is rotated about the top-left corner, so that
 595   // the root + child clips combined create a triangle. The rotated_leaf will
 596   // only be visible where it overlaps this triangle.
 597   //
 598   scoped_ptr<LayerImpl> root =
 599       LayerImpl::Create(host_impl().active_tree(), 123);
 600
 601   gfx::Transform identity_matrix;
 602   gfx::Point3F transform_origin;
 603   gfx::PointF position;
 604   gfx::Size bounds(100, 100);
 605   SetLayerPropertiesForTesting(root.get(),
 606                                identity_matrix,
 607                                transform_origin,
 608                                position,
 609                                bounds,
 610                                true,
 611                                false);
 612   root->SetMasksToBounds(true);
 613   {
 614     scoped_ptr<LayerImpl> child =
 615         LayerImpl::Create(host_impl().active_tree(), 456);
 616     scoped_ptr<LayerImpl> grand_child =
 617         LayerImpl::Create(host_impl().active_tree(), 789);
 618     scoped_ptr<LayerImpl> rotated_leaf =
 619         LayerImpl::Create(host_impl().active_tree(), 2468);
 620
 621     position = gfx::PointF(10.f, 10.f);
 622     bounds = gfx::Size(80, 80);
 623     SetLayerPropertiesForTesting(child.get(),
 624                                  identity_matrix,
 625                                  transform_origin,
 626                                  position,
 627                                  bounds,
 628                                  true,
 629                                  false);
 630     child->SetMasksToBounds(true);
 631
 632     gfx::Transform rotation45_degrees_about_corner;
 633     rotation45_degrees_about_corner.RotateAboutZAxis(45.0);
 634
 635     // remember, positioned with respect to its parent which is already at 10,
 636     // 10
 637     position = gfx::PointF();
 638     bounds =
 639         gfx::Size(200, 200);  // to ensure it covers at least sqrt(2) * 100.
 640     SetLayerPropertiesForTesting(grand_child.get(),
 641                                  rotation45_degrees_about_corner,
 642                                  transform_origin,
 643                                  position,
 644                                  bounds,
 645                                  true,
 646                                  false);
 647     grand_child->SetMasksToBounds(true);
 648
 649     // Rotates about the center of the layer
 650     gfx::Transform rotated_leaf_transform;
 651     rotated_leaf_transform.Translate(
 652         -10.0, -10.0);  // cancel out the grand_parent's position
 653     rotated_leaf_transform.RotateAboutZAxis(
 654         -45.0);  // cancel out the corner 45-degree rotation of the parent.
 655     rotated_leaf_transform.Translate(50.0, 50.0);
 656     rotated_leaf_transform.RotateAboutZAxis(45.0);
 657     rotated_leaf_transform.Translate(-50.0, -50.0);
 658     position = gfx::PointF();
 659     bounds = gfx::Size(100, 100);
 660     SetLayerPropertiesForTesting(rotated_leaf.get(),
 661                                  rotated_leaf_transform,
 662                                  transform_origin,
 663                                  position,
 664                                  bounds,
 665                                  true,
 666                                  false);
 667     rotated_leaf->SetDrawsContent(true);
 668
 669     grand_child->AddChild(rotated_leaf.Pass());
 670     child->AddChild(grand_child.Pass());
 671     root->AddChild(child.Pass());
 672   }
 673
 674   host_impl().SetViewportSize(root->bounds());
 675   host_impl().active_tree()->SetRootLayer(root.Pass());
 676   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 677
 678   // Sanity check the scenario we just created.
 679   // The grand_child is expected to create a render surface because it
 680   // MasksToBounds and is not axis aligned.
 681   ASSERT_EQ(2u, RenderSurfaceLayerList().size());
 682   ASSERT_EQ(
 683       1u,
 684       RenderSurfaceLayerList().at(0)->render_surface()->layer_list().size());
 685   ASSERT_EQ(789,
 686             RenderSurfaceLayerList()
 687                 .at(0)
 688                 ->render_surface()
 689                 ->layer_list()
 690                 .at(0)
 691                 ->id());  // grand_child's surface.
 692   ASSERT_EQ(
 693       1u,
 694       RenderSurfaceLayerList().at(1)->render_surface()->layer_list().size());
 695   ASSERT_EQ(
 696       2468,
 697       RenderSurfaceLayerList()[1]->render_surface()->layer_list().at(0)->id());
 698
 699   // (11, 89) is close to the the bottom left corner within the clip, but it is
 700   // not inside the layer.
 701   gfx::Point test_point(11, 89);
 702   LayerImpl* result_layer =
 703       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 704   EXPECT_FALSE(result_layer);
 705
 706   // Closer inwards from the bottom left will overlap the layer.
 707   test_point = gfx::Point(25, 75);
 708   result_layer =
 709       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 710   ASSERT_TRUE(result_layer);
 711   EXPECT_EQ(2468, result_layer->id());
 712
 713   // (4, 50) is inside the unclipped layer, but that corner of the layer should
 714   // be clipped away by the grandparent and should not get hit. If hit testing
 715   // blindly uses visible content rect without considering how parent may clip
 716   // the layer, then hit testing would accidentally think that the point
 717   // successfully hits the layer.
 718   test_point = gfx::Point(4, 50);
 719   result_layer =
 720       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 721   EXPECT_FALSE(result_layer);
 722
 723   // (11, 50) is inside the layer and within the clipped area.
 724   test_point = gfx::Point(11, 50);
 725   result_layer =
 726       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 727   ASSERT_TRUE(result_layer);
 728   EXPECT_EQ(2468, result_layer->id());
 729
 730   // Around the middle, just to the right and up, would have hit the layer
 731   // except that that area should be clipped away by the parent.
 732   test_point = gfx::Point(51, 49);
 733   result_layer =
 734       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 735   EXPECT_FALSE(result_layer);
 736
 737   // Around the middle, just to the left and down, should successfully hit the
 738   // layer.
 739   test_point = gfx::Point(49, 51);
 740   result_layer =
 741       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 742   ASSERT_TRUE(result_layer);
 743   EXPECT_EQ(2468, result_layer->id());
 744 }
 745
 746 TEST_F(LayerTreeImplTest, HitTestingForNonClippingIntermediateLayer) {
 747   // This test checks that hit testing code does not accidentally clip to layer
 748   // bounds for a layer that actually does not clip.
 749   gfx::Transform identity_matrix;
 750   gfx::Point3F transform_origin;
 751
 752   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
 753   SetLayerPropertiesForTesting(root.get(),
 754                                identity_matrix,
 755                                transform_origin,
 756                                gfx::PointF(),
 757                                gfx::Size(100, 100),
 758                                true,
 759                                false);
 760   {
 761     scoped_ptr<LayerImpl> intermediate_layer =
 762         LayerImpl::Create(host_impl().active_tree(), 123);
 763     // this layer is positioned, and hit testing should correctly know where the
 764     // layer is located.
 765     gfx::PointF position(10.f, 10.f);
 766     gfx::Size bounds(50, 50);
 767     SetLayerPropertiesForTesting(intermediate_layer.get(),
 768                                  identity_matrix,
 769                                  transform_origin,
 770                                  position,
 771                                  bounds,
 772                                  true,
 773                                  false);
 774     // Sanity check the intermediate layer should not clip.
 775     ASSERT_FALSE(intermediate_layer->masks_to_bounds());
 776     ASSERT_FALSE(intermediate_layer->mask_layer());
 777
 778     // The child of the intermediate_layer is translated so that it does not
 779     // overlap intermediate_layer at all.  If child is incorrectly clipped, we
 780     // would not be able to hit it successfully.
 781     scoped_ptr<LayerImpl> child =
 782         LayerImpl::Create(host_impl().active_tree(), 456);
 783     position = gfx::PointF(60.f, 60.f);  // 70, 70 in screen space
 784     bounds = gfx::Size(20, 20);
 785     SetLayerPropertiesForTesting(child.get(),
 786                                  identity_matrix,
 787                                  transform_origin,
 788                                  position,
 789                                  bounds,
 790                                  true,
 791                                  false);
 792     child->SetDrawsContent(true);
 793     intermediate_layer->AddChild(child.Pass());
 794     root->AddChild(intermediate_layer.Pass());
 795   }
 796
 797   host_impl().SetViewportSize(root->bounds());
 798   host_impl().active_tree()->SetRootLayer(root.Pass());
 799   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 800
 801   // Sanity check the scenario we just created.
 802   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
 803   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
 804   ASSERT_EQ(456, root_layer()->render_surface()->layer_list().at(0)->id());
 805
 806   // Hit testing for a point outside the layer should return a null pointer.
 807   gfx::Point test_point(69, 69);
 808   LayerImpl* result_layer =
 809       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 810   EXPECT_FALSE(result_layer);
 811
 812   test_point = gfx::Point(91, 91);
 813   result_layer =
 814       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 815   EXPECT_FALSE(result_layer);
 816
 817   // Hit testing for a point inside should return the child layer.
 818   test_point = gfx::Point(71, 71);
 819   result_layer =
 820       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 821   ASSERT_TRUE(result_layer);
 822   EXPECT_EQ(456, result_layer->id());
 823
 824   test_point = gfx::Point(89, 89);
 825   result_layer =
 826       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 827   ASSERT_TRUE(result_layer);
 828   EXPECT_EQ(456, result_layer->id());
 829 }
 830
 831 TEST_F(LayerTreeImplTest, HitTestingForMultipleLayers) {
 832   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
 833
 834   gfx::Transform identity_matrix;
 835   gfx::Point3F transform_origin;
 836   gfx::PointF position;
 837   gfx::Size bounds(100, 100);
 838   SetLayerPropertiesForTesting(root.get(),
 839                                identity_matrix,
 840                                transform_origin,
 841                                position,
 842                                bounds,
 843                                true,
 844                                false);
 845   root->SetDrawsContent(true);
 846   {
 847     // child 1 and child2 are initialized to overlap between x=50 and x=60.
 848     // grand_child is set to overlap both child1 and child2 between y=50 and
 849     // y=60.  The expected stacking order is: (front) child2, (second)
 850     // grand_child, (third) child1, and (back) the root layer behind all other
 851     // layers.
 852
 853     scoped_ptr<LayerImpl> child1 =
 854         LayerImpl::Create(host_impl().active_tree(), 2);
 855     scoped_ptr<LayerImpl> child2 =
 856         LayerImpl::Create(host_impl().active_tree(), 3);
 857     scoped_ptr<LayerImpl> grand_child1 =
 858         LayerImpl::Create(host_impl().active_tree(), 4);
 859
 860     position = gfx::PointF(10.f, 10.f);
 861     bounds = gfx::Size(50, 50);
 862     SetLayerPropertiesForTesting(child1.get(),
 863                                  identity_matrix,
 864                                  transform_origin,
 865                                  position,
 866                                  bounds,
 867                                  true,
 868                                  false);
 869     child1->SetDrawsContent(true);
 870
 871     position = gfx::PointF(50.f, 10.f);
 872     bounds = gfx::Size(50, 50);
 873     SetLayerPropertiesForTesting(child2.get(),
 874                                  identity_matrix,
 875                                  transform_origin,
 876                                  position,
 877                                  bounds,
 878                                  true,
 879                                  false);
 880     child2->SetDrawsContent(true);
 881
 882     // Remember that grand_child is positioned with respect to its parent (i.e.
 883     // child1).  In screen space, the intended position is (10, 50), with size
 884     // 100 x 50.
 885     position = gfx::PointF(0.f, 40.f);
 886     bounds = gfx::Size(100, 50);
 887     SetLayerPropertiesForTesting(grand_child1.get(),
 888                                  identity_matrix,
 889                                  transform_origin,
 890                                  position,
 891                                  bounds,
 892                                  true,
 893                                  false);
 894     grand_child1->SetDrawsContent(true);
 895
 896     child1->AddChild(grand_child1.Pass());
 897     root->AddChild(child1.Pass());
 898     root->AddChild(child2.Pass());
 899   }
 900
 901   LayerImpl* child1 = root->children()[0];
 902   LayerImpl* child2 = root->children()[1];
 903   LayerImpl* grand_child1 = child1->children()[0];
 904
 905   host_impl().SetViewportSize(root->bounds());
 906   host_impl().active_tree()->SetRootLayer(root.Pass());
 907   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 908
 909   // Sanity check the scenario we just created.
 910   ASSERT_TRUE(child1);
 911   ASSERT_TRUE(child2);
 912   ASSERT_TRUE(grand_child1);
 913   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
 914
 915   RenderSurfaceImpl* root_render_surface = root_layer()->render_surface();
 916   ASSERT_EQ(4u, root_render_surface->layer_list().size());
 917   ASSERT_EQ(1, root_render_surface->layer_list().at(0)->id());  // root layer
 918   ASSERT_EQ(2, root_render_surface->layer_list().at(1)->id());  // child1
 919   ASSERT_EQ(4, root_render_surface->layer_list().at(2)->id());  // grand_child1
 920   ASSERT_EQ(3, root_render_surface->layer_list().at(3)->id());  // child2
 921
 922   // Nothing overlaps the root_layer at (1, 1), so hit testing there should find
 923   // the root layer.
 924   gfx::Point test_point = gfx::Point(1, 1);
 925   LayerImpl* result_layer =
 926       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 927   ASSERT_TRUE(result_layer);
 928   EXPECT_EQ(1, result_layer->id());
 929
 930   // At (15, 15), child1 and root are the only layers. child1 is expected to be
 931   // on top.
 932   test_point = gfx::Point(15, 15);
 933   result_layer =
 934       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 935   ASSERT_TRUE(result_layer);
 936   EXPECT_EQ(2, result_layer->id());
 937
 938   // At (51, 20), child1 and child2 overlap. child2 is expected to be on top.
 939   test_point = gfx::Point(51, 20);
 940   result_layer =
 941       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 942   ASSERT_TRUE(result_layer);
 943   EXPECT_EQ(3, result_layer->id());
 944
 945   // At (80, 51), child2 and grand_child1 overlap. child2 is expected to be on
 946   // top.
 947   test_point = gfx::Point(80, 51);
 948   result_layer =
 949       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 950   ASSERT_TRUE(result_layer);
 951   EXPECT_EQ(3, result_layer->id());
 952
 953   // At (51, 51), all layers overlap each other. child2 is expected to be on top
 954   // of all other layers.
 955   test_point = gfx::Point(51, 51);
 956   result_layer =
 957       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 958   ASSERT_TRUE(result_layer);
 959   EXPECT_EQ(3, result_layer->id());
 960
 961   // At (20, 51), child1 and grand_child1 overlap. grand_child1 is expected to
 962   // be on top.
 963   test_point = gfx::Point(20, 51);
 964   result_layer =
 965       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
 966   ASSERT_TRUE(result_layer);
 967   EXPECT_EQ(4, result_layer->id());
 968 }
 969
 970 TEST_F(LayerTreeImplTest, HitTestingForMultipleLayersAtVaryingDepths) {
 971   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
 972
 973   gfx::Transform identity_matrix;
 974   gfx::Point3F transform_origin;
 975   gfx::PointF position;
 976   gfx::Size bounds(100, 100);
 977   SetLayerPropertiesForTesting(root.get(),
 978                                identity_matrix,
 979                                transform_origin,
 980                                position,
 981                                bounds,
 982                                true,
 983                                false);
 984   root->SetDrawsContent(true);
 985   root->SetShouldFlattenTransform(false);
 986   root->Set3dSortingContextId(1);
 987   {
 988     // child 1 and child2 are initialized to overlap between x=50 and x=60.
 989     // grand_child is set to overlap both child1 and child2 between y=50 and
 990     // y=60.  The expected stacking order is: (front) child2, (second)
 991     // grand_child, (third) child1, and (back) the root layer behind all other
 992     // layers.
 993
 994     scoped_ptr<LayerImpl> child1 =
 995         LayerImpl::Create(host_impl().active_tree(), 2);
 996     scoped_ptr<LayerImpl> child2 =
 997         LayerImpl::Create(host_impl().active_tree(), 3);
 998     scoped_ptr<LayerImpl> grand_child1 =
 999         LayerImpl::Create(host_impl().active_tree(), 4);
1000
1001     position = gfx::PointF(10.f, 10.f);
1002     bounds = gfx::Size(50, 50);
1003     SetLayerPropertiesForTesting(child1.get(),
1004                                  identity_matrix,
1005                                  transform_origin,
1006                                  position,
1007                                  bounds,
1008                                  true,
1009                                  false);
1010     child1->SetDrawsContent(true);
1011     child1->SetShouldFlattenTransform(false);
1012     child1->Set3dSortingContextId(1);
1013
1014     position = gfx::PointF(50.f, 10.f);
1015     bounds = gfx::Size(50, 50);
1016     gfx::Transform translate_z;
1017     translate_z.Translate3d(0, 0, -10.f);
1018     SetLayerPropertiesForTesting(child2.get(),
1019                                  translate_z,
1020                                  transform_origin,
1021                                  position,
1022                                  bounds,
1023                                  true,
1024                                  false);
1025     child2->SetDrawsContent(true);
1026     child2->SetShouldFlattenTransform(false);
1027     child2->Set3dSortingContextId(1);
1028
1029     // Remember that grand_child is positioned with respect to its parent (i.e.
1030     // child1).  In screen space, the intended position is (10, 50), with size
1031     // 100 x 50.
1032     position = gfx::PointF(0.f, 40.f);
1033     bounds = gfx::Size(100, 50);
1034     SetLayerPropertiesForTesting(grand_child1.get(),
1035                                  identity_matrix,
1036                                  transform_origin,
1037                                  position,
1038                                  bounds,
1039                                  true,
1040                                  false);
1041     grand_child1->SetDrawsContent(true);
1042     grand_child1->SetShouldFlattenTransform(false);
1043
1044     child1->AddChild(grand_child1.Pass());
1045     root->AddChild(child1.Pass());
1046     root->AddChild(child2.Pass());
1047   }
1048
1049   LayerImpl* child1 = root->children()[0];
1050   LayerImpl* child2 = root->children()[1];
1051   LayerImpl* grand_child1 = child1->children()[0];
1052
1053   host_impl().SetViewportSize(root->bounds());
1054   host_impl().active_tree()->SetRootLayer(root.Pass());
1055   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
1056
1057   // Sanity check the scenario we just created.
1058   ASSERT_TRUE(child1);
1059   ASSERT_TRUE(child2);
1060   ASSERT_TRUE(grand_child1);
1061   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
1062
1063   RenderSurfaceImpl* root_render_surface =
1064       host_impl().active_tree()->root_layer()->render_surface();
1065   ASSERT_EQ(4u, root_render_surface->layer_list().size());
1066   ASSERT_EQ(3, root_render_surface->layer_list().at(0)->id());
1067   ASSERT_EQ(1, root_render_surface->layer_list().at(1)->id());
1068   ASSERT_EQ(2, root_render_surface->layer_list().at(2)->id());
1069   ASSERT_EQ(4, root_render_surface->layer_list().at(3)->id());
1070
1071   // Nothing overlaps the root_layer at (1, 1), so hit testing there should find
1072   // the root layer.
1073   gfx::Point test_point = gfx::Point(1, 1);
1074   LayerImpl* result_layer =
1075       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
1076   ASSERT_TRUE(result_layer);
1077   EXPECT_EQ(1, result_layer->id());
1078
1079   // At (15, 15), child1 and root are the only layers. child1 is expected to be
1080   // on top.
1081   test_point = gfx::Point(15, 15);
1082   result_layer =
1083       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
1084   ASSERT_TRUE(result_layer);
1085   EXPECT_EQ(2, result_layer->id());
1086
1087   // At (51, 20), child1 and child2 overlap. child2 is expected to be on top.
1088   // (because 3 is transformed to the back).
1089   test_point = gfx::Point(51, 20);
1090   result_layer =
1091       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
1092   ASSERT_TRUE(result_layer);
1093   EXPECT_EQ(2, result_layer->id());
1094
1095   // 3 Would have been on top if it hadn't been transformed to the background.
1096   // Make sure that it isn't hit.
1097   test_point = gfx::Point(80, 51);
1098   result_layer =
1099       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
1100   ASSERT_TRUE(result_layer);
1101   EXPECT_EQ(4, result_layer->id());
1102
1103   // 3 Would have been on top if it hadn't been transformed to the background.
1104   // Make sure that it isn't hit.
1105   test_point = gfx::Point(51, 51);
1106   result_layer =
1107       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
1108   ASSERT_TRUE(result_layer);
1109   EXPECT_EQ(4, result_layer->id());
1110
1111   // At (20, 51), child1 and grand_child1 overlap. grand_child1 is expected to
1112   // be on top.
1113   test_point = gfx::Point(20, 51);
1114   result_layer =
1115       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
1116   ASSERT_TRUE(result_layer);
1117   EXPECT_EQ(4, result_layer->id());
1118 }
1119
1120 TEST_F(LayerTreeImplTest, HitTestingRespectsClipParents) {
1121   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
1122   gfx::Transform identity_matrix;
1123   gfx::Point3F transform_origin;
1124   gfx::PointF position;
1125   gfx::Size bounds(100, 100);
1126   SetLayerPropertiesForTesting(root.get(),
1127                                identity_matrix,
1128                                transform_origin,
1129                                position,
1130                                bounds,
1131                                true,
1132                                false);
1133   root->SetDrawsContent(true);
1134   {
1135     scoped_ptr<LayerImpl> child =
1136         LayerImpl::Create(host_impl().active_tree(), 2);
1137     scoped_ptr<LayerImpl> grand_child =
1138         LayerImpl::Create(host_impl().active_tree(), 4);
1139
1140     position = gfx::PointF(10.f, 10.f);
1141     bounds = gfx::Size(1, 1);
1142     SetLayerPropertiesForTesting(child.get(),
1143                                  identity_matrix,
1144                                  transform_origin,
1145                                  position,
1146                                  bounds,
1147                                  true,
1148                                  false);
1149     child->SetDrawsContent(true);
1150     child->SetMasksToBounds(true);
1151
1152     position = gfx::PointF(0.f, 40.f);
1153     bounds = gfx::Size(100, 50);
1154     SetLayerPropertiesForTesting(grand_child.get(),
1155                                  identity_matrix,
1156                                  transform_origin,
1157                                  position,
1158                                  bounds,
1159                                  true,
1160                                  false);
1161     grand_child->SetDrawsContent(true);
1162     grand_child->SetForceRenderSurface(true);
1163
1164     // This should let |grand_child| "escape" |child|'s clip.
1165     grand_child->SetClipParent(root.get());
1166
1167     child->AddChild(grand_child.Pass());
1168     root->AddChild(child.Pass());
1169   }
1170
1171   host_impl().SetViewportSize(root->bounds());
1172   host_impl().active_tree()->SetRootLayer(root.Pass());
1173   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
1174
1175   gfx::Point test_point = gfx::Point(12, 52);
1176   LayerImpl* result_layer =
1177       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
1178   ASSERT_TRUE(result_layer);
1179   EXPECT_EQ(4, result_layer->id());
1180 }
1181
1182 TEST_F(LayerTreeImplTest, HitTestingRespectsScrollParents) {
1183   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
1184   gfx::Transform identity_matrix;
1185   gfx::Point3F transform_origin;
1186   gfx::PointF position;
1187   gfx::Size bounds(100, 100);
1188   SetLayerPropertiesForTesting(root.get(),
1189                                identity_matrix,
1190                                transform_origin,
1191                                position,
1192                                bounds,
1193                                true,
1194                                false);
1195   root->SetDrawsContent(true);
1196   {
1197     scoped_ptr<LayerImpl> child =
1198         LayerImpl::Create(host_impl().active_tree(), 2);
1199     scoped_ptr<LayerImpl> scroll_child =
1200         LayerImpl::Create(host_impl().active_tree(), 3);
1201     scoped_ptr<LayerImpl> grand_child =
1202         LayerImpl::Create(host_impl().active_tree(), 4);
1203
1204     position = gfx::PointF(10.f, 10.f);
1205     bounds = gfx::Size(1, 1);
1206     SetLayerPropertiesForTesting(child.get(),
1207                                  identity_matrix,
1208                                  transform_origin,
1209                                  position,
1210                                  bounds,
1211                                  true,
1212                                  false);
1213     child->SetDrawsContent(true);
1214     child->SetMasksToBounds(true);
1215
1216     position = gfx::PointF();
1217     bounds = gfx::Size(200, 200);
1218     SetLayerPropertiesForTesting(scroll_child.get(),
1219                                  identity_matrix,
1220                                  transform_origin,
1221                                  position,
1222                                  bounds,
1223                                  true,
1224                                  false);
1225     scroll_child->SetDrawsContent(true);
1226
1227     // This should cause scroll child and its descendants to be affected by
1228     // |child|'s clip.
1229     scroll_child->SetScrollParent(child.get());
1230
1231     SetLayerPropertiesForTesting(grand_child.get(),
1232                                  identity_matrix,
1233                                  transform_origin,
1234                                  position,
1235                                  bounds,
1236                                  true,
1237                                  false);
1238     grand_child->SetDrawsContent(true);
1239     grand_child->SetForceRenderSurface(true);
1240
1241     scroll_child->AddChild(grand_child.Pass());
1242     root->AddChild(scroll_child.Pass());
1243     root->AddChild(child.Pass());
1244   }
1245
1246   host_impl().SetViewportSize(root->bounds());
1247   host_impl().active_tree()->SetRootLayer(root.Pass());
1248   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
1249
1250   gfx::Point test_point = gfx::Point(12, 52);
1251   LayerImpl* result_layer =
1252       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
1253   // The |test_point| should have been clipped away by |child|, the scroll
1254   // parent, so the only thing that should be hit is |root|.
1255   ASSERT_TRUE(result_layer);
1256   ASSERT_EQ(1, result_layer->id());
1257 }
1258 TEST_F(LayerTreeImplTest, HitTestingForMultipleLayerLists) {
1259   //
1260   // The geometry is set up similarly to the previous case, but
1261   // all layers are forced to be render surfaces now.
1262   //
1263   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
1264
1265   gfx::Transform identity_matrix;
1266   gfx::Point3F transform_origin;
1267   gfx::PointF position;
1268   gfx::Size bounds(100, 100);
1269   SetLayerPropertiesForTesting(root.get(),
1270                                identity_matrix,
1271                                transform_origin,
1272                                position,
1273                                bounds,
1274                                true,
1275                                false);
1276   root->SetDrawsContent(true);
1277   {
1278     // child 1 and child2 are initialized to overlap between x=50 and x=60.
1279     // grand_child is set to overlap both child1 and child2 between y=50 and
1280     // y=60.  The expected stacking order is: (front) child2, (second)
1281     // grand_child, (third) child1, and (back) the root layer behind all other
1282     // layers.
1283
1284     scoped_ptr<LayerImpl> child1 =
1285         LayerImpl::Create(host_impl().active_tree(), 2);
1286     scoped_ptr<LayerImpl> child2 =
1287         LayerImpl::Create(host_impl().active_tree(), 3);
1288     scoped_ptr<LayerImpl> grand_child1 =
1289         LayerImpl::Create(host_impl().active_tree(), 4);
1290
1291     position = gfx::PointF(10.f, 10.f);
1292     bounds = gfx::Size(50, 50);
1293     SetLayerPropertiesForTesting(child1.get(),
1294                                  identity_matrix,
1295                                  transform_origin,
1296                                  position,
1297                                  bounds,
1298                                  true,
1299                                  false);
1300     child1->SetDrawsContent(true);
1301     child1->SetForceRenderSurface(true);
1302
1303     position = gfx::PointF(50.f, 10.f);
1304     bounds = gfx::Size(50, 50);
1305     SetLayerPropertiesForTesting(child2.get(),
1306                                  identity_matrix,
1307                                  transform_origin,
1308                                  position,
1309                                  bounds,
1310                                  true,
1311                                  false);
1312     child2->SetDrawsContent(true);
1313     child2->SetForceRenderSurface(true);
1314
1315     // Remember that grand_child is positioned with respect to its parent (i.e.
1316     // child1).  In screen space, the intended position is (10, 50), with size
1317     // 100 x 50.
1318     position = gfx::PointF(0.f, 40.f);
1319     bounds = gfx::Size(100, 50);
1320     SetLayerPropertiesForTesting(grand_child1.get(),
1321                                  identity_matrix,
1322                                  transform_origin,
1323                                  position,
1324                                  bounds,
1325                                  true,
1326                                  false);
1327     grand_child1->SetDrawsContent(true);
1328     grand_child1->SetForceRenderSurface(true);
1329
1330     child1->AddChild(grand_child1.Pass());
1331     root->AddChild(child1.Pass());
1332     root->AddChild(child2.Pass());
1333   }
1334
1335   LayerImpl* child1 = root->children()[0];
1336   LayerImpl* child2 = root->children()[1];
1337   LayerImpl* grand_child1 = child1->children()[0];
1338
1339   host_impl().SetViewportSize(root->bounds());
1340   host_impl().active_tree()->SetRootLayer(root.Pass());
1341   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
1342
1343   // Sanity check the scenario we just created.
1344   ASSERT_TRUE(child1);
1345   ASSERT_TRUE(child2);
1346   ASSERT_TRUE(grand_child1);
1347   ASSERT_TRUE(child1->render_surface());
1348   ASSERT_TRUE(child2->render_surface());
1349   ASSERT_TRUE(grand_child1->render_surface());
1350   ASSERT_EQ(4u, RenderSurfaceLayerList().size());
1351   // The root surface has the root layer, and child1's and child2's render
1352   // surfaces.
1353   ASSERT_EQ(3u, root_layer()->render_surface()->layer_list().size());
1354   // The child1 surface has the child1 layer and grand_child1's render surface.
1355   ASSERT_EQ(2u, child1->render_surface()->layer_list().size());
1356   ASSERT_EQ(1u, child2->render_surface()->layer_list().size());
1357   ASSERT_EQ(1u, grand_child1->render_surface()->layer_list().size());
1358   ASSERT_EQ(1, RenderSurfaceLayerList().at(0)->id());  // root layer
1359   ASSERT_EQ(2, RenderSurfaceLayerList()[1]->id());     // child1
1360   ASSERT_EQ(4, RenderSurfaceLayerList().at(2)->id());  // grand_child1
1361   ASSERT_EQ(3, RenderSurfaceLayerList()[3]->id());     // child2
1362
1363   // Nothing overlaps the root_layer at (1, 1), so hit testing there should find
1364   // the root layer.
1365   gfx::Point test_point = gfx::Point(1, 1);
1366   LayerImpl* result_layer =
1367       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
1368   ASSERT_TRUE(result_layer);
1369   EXPECT_EQ(1, result_layer->id());
1370
1371   // At (15, 15), child1 and root are the only layers. child1 is expected to be
1372   // on top.
1373   test_point = gfx::Point(15, 15);
1374   result_layer =
1375       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
1376   ASSERT_TRUE(result_layer);
1377   EXPECT_EQ(2, result_layer->id());
1378
1379   // At (51, 20), child1 and child2 overlap. child2 is expected to be on top.
1380   test_point = gfx::Point(51, 20);
1381   result_layer =
1382       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
1383   ASSERT_TRUE(result_layer);
1384   EXPECT_EQ(3, result_layer->id());
1385
1386   // At (80, 51), child2 and grand_child1 overlap. child2 is expected to be on
1387   // top.
1388   test_point = gfx::Point(80, 51);
1389   result_layer =
1390       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
1391   ASSERT_TRUE(result_layer);
1392   EXPECT_EQ(3, result_layer->id());
1393
1394   // At (51, 51), all layers overlap each other. child2 is expected to be on top
1395   // of all other layers.
1396   test_point = gfx::Point(51, 51);
1397   result_layer =
1398       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
1399   ASSERT_TRUE(result_layer);
1400   EXPECT_EQ(3, result_layer->id());
1401
1402   // At (20, 51), child1 and grand_child1 overlap. grand_child1 is expected to
1403   // be on top.
1404   test_point = gfx::Point(20, 51);
1405   result_layer =
1406       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
1407   ASSERT_TRUE(result_layer);
1408   EXPECT_EQ(4, result_layer->id());
1409 }
1410
1411 TEST_F(LayerTreeImplTest, HitCheckingTouchHandlerRegionsForSingleLayer) {
1412   scoped_ptr<LayerImpl> root =
1413       LayerImpl::Create(host_impl().active_tree(), 12345);
1414
1415   gfx::Transform identity_matrix;
1416   Region touch_handler_region(gfx::Rect(10, 10, 50, 50));
1417   gfx::Point3F transform_origin;
1418   gfx::PointF position;
1419   gfx::Size bounds(100, 100);
1420   SetLayerPropertiesForTesting(root.get(),
1421                                identity_matrix,
1422                                transform_origin,
1423                                position,
1424                                bounds,
1425                                true,
1426                                false);
1427   root->SetDrawsContent(true);
1428
1429   host_impl().SetViewportSize(root->bounds());
1430   host_impl().active_tree()->SetRootLayer(root.Pass());
1431   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
1432
1433   // Sanity check the scenario we just created.
1434   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
1435   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
1436
1437   // Hit checking for any point should return a null pointer for a layer without
1438   // any touch event handler regions.
1439   gfx::Point test_point(11, 11);
1440   LayerImpl* result_layer =
1441       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1442           test_point);
1443   EXPECT_FALSE(result_layer);
1444
1445   host_impl().active_tree()->root_layer()->SetTouchEventHandlerRegion(
1446       touch_handler_region);
1447   // Hit checking for a point outside the layer should return a null pointer.
1448   test_point = gfx::Point(101, 101);
1449   result_layer =
1450       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1451           test_point);
1452   EXPECT_FALSE(result_layer);
1453
1454   test_point = gfx::Point(-1, -1);
1455   result_layer =
1456       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1457           test_point);
1458   EXPECT_FALSE(result_layer);
1459
1460   // Hit checking for a point inside the layer, but outside the touch handler
1461   // region should return a null pointer.
1462   test_point = gfx::Point(1, 1);
1463   result_layer =
1464       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1465           test_point);
1466   EXPECT_FALSE(result_layer);
1467
1468   test_point = gfx::Point(99, 99);
1469   result_layer =
1470       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1471           test_point);
1472   EXPECT_FALSE(result_layer);
1473
1474   // Hit checking for a point inside the touch event handler region should
1475   // return the root layer.
1476   test_point = gfx::Point(11, 11);
1477   result_layer =
1478       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1479           test_point);
1480   ASSERT_TRUE(result_layer);
1481   EXPECT_EQ(12345, result_layer->id());
1482
1483   test_point = gfx::Point(59, 59);
1484   result_layer =
1485       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1486           test_point);
1487   ASSERT_TRUE(result_layer);
1488   EXPECT_EQ(12345, result_layer->id());
1489 }
1490
1491 TEST_F(LayerTreeImplTest,
1492        HitCheckingTouchHandlerRegionsForUninvertibleTransform) {
1493   scoped_ptr<LayerImpl> root =
1494       LayerImpl::Create(host_impl().active_tree(), 12345);
1495
1496   gfx::Transform uninvertible_transform;
1497   uninvertible_transform.matrix().set(0, 0, 0.0);
1498   uninvertible_transform.matrix().set(1, 1, 0.0);
1499   uninvertible_transform.matrix().set(2, 2, 0.0);
1500   uninvertible_transform.matrix().set(3, 3, 0.0);
1501   ASSERT_FALSE(uninvertible_transform.IsInvertible());
1502
1503   gfx::Transform identity_matrix;
1504   Region touch_handler_region(gfx::Rect(10, 10, 50, 50));
1505   gfx::Point3F transform_origin;
1506   gfx::PointF position;
1507   gfx::Size bounds(100, 100);
1508   SetLayerPropertiesForTesting(root.get(),
1509                                uninvertible_transform,
1510                                transform_origin,
1511                                position,
1512                                bounds,
1513                                true,
1514                                false);
1515   root->SetDrawsContent(true);
1516   root->SetTouchEventHandlerRegion(touch_handler_region);
1517
1518   host_impl().SetViewportSize(root->bounds());
1519   host_impl().active_tree()->SetRootLayer(root.Pass());
1520   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
1521
1522   // Sanity check the scenario we just created.
1523   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
1524   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
1525   ASSERT_FALSE(root_layer()->screen_space_transform().IsInvertible());
1526
1527   // Hit checking any point should not hit the touch handler region on the
1528   // layer. If the invertible matrix is accidentally ignored and treated like an
1529   // identity, then the hit testing will incorrectly hit the layer when it
1530   // shouldn't.
1531   gfx::Point test_point(1, 1);
1532   LayerImpl* result_layer =
1533       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1534           test_point);
1535   EXPECT_FALSE(result_layer);
1536
1537   test_point = gfx::Point(10, 10);
1538   result_layer =
1539       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1540           test_point);
1541   EXPECT_FALSE(result_layer);
1542
1543   test_point = gfx::Point(10, 30);
1544   result_layer =
1545       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1546           test_point);
1547   EXPECT_FALSE(result_layer);
1548
1549   test_point = gfx::Point(50, 50);
1550   result_layer =
1551       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1552           test_point);
1553   EXPECT_FALSE(result_layer);
1554
1555   test_point = gfx::Point(67, 48);
1556   result_layer =
1557       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1558           test_point);
1559   EXPECT_FALSE(result_layer);
1560
1561   test_point = gfx::Point(99, 99);
1562   result_layer =
1563       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1564           test_point);
1565   EXPECT_FALSE(result_layer);
1566
1567   test_point = gfx::Point(-1, -1);
1568   result_layer =
1569       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1570           test_point);
1571   EXPECT_FALSE(result_layer);
1572 }
1573
1574 TEST_F(LayerTreeImplTest,
1575        HitCheckingTouchHandlerRegionsForSinglePositionedLayer) {
1576   scoped_ptr<LayerImpl> root =
1577       LayerImpl::Create(host_impl().active_tree(), 12345);
1578
1579   gfx::Transform identity_matrix;
1580   Region touch_handler_region(gfx::Rect(10, 10, 50, 50));
1581   gfx::Point3F transform_origin;
1582   // this layer is positioned, and hit testing should correctly know where the
1583   // layer is located.
1584   gfx::PointF position(50.f, 50.f);
1585   gfx::Size bounds(100, 100);
1586   SetLayerPropertiesForTesting(root.get(),
1587                                identity_matrix,
1588                                transform_origin,
1589                                position,
1590                                bounds,
1591                                true,
1592                                false);
1593   root->SetDrawsContent(true);
1594   root->SetTouchEventHandlerRegion(touch_handler_region);
1595
1596   host_impl().SetViewportSize(root->bounds());
1597   host_impl().active_tree()->SetRootLayer(root.Pass());
1598   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
1599
1600   // Sanity check the scenario we just created.
1601   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
1602   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
1603
1604   // Hit checking for a point outside the layer should return a null pointer.
1605   gfx::Point test_point(49, 49);
1606   LayerImpl* result_layer =
1607       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1608           test_point);
1609   EXPECT_FALSE(result_layer);
1610
1611   // Even though the layer has a touch handler region containing (101, 101), it
1612   // should not be visible there since the root render surface would clamp it.
1613   test_point = gfx::Point(101, 101);
1614   result_layer =
1615       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1616           test_point);
1617   EXPECT_FALSE(result_layer);
1618
1619   // Hit checking for a point inside the layer, but outside the touch handler
1620   // region should return a null pointer.
1621   test_point = gfx::Point(51, 51);
1622   result_layer =
1623       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1624           test_point);
1625   EXPECT_FALSE(result_layer);
1626
1627   // Hit checking for a point inside the touch event handler region should
1628   // return the root layer.
1629   test_point = gfx::Point(61, 61);
1630   result_layer =
1631       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1632           test_point);
1633   ASSERT_TRUE(result_layer);
1634   EXPECT_EQ(12345, result_layer->id());
1635
1636   test_point = gfx::Point(99, 99);
1637   result_layer =
1638       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1639           test_point);
1640   ASSERT_TRUE(result_layer);
1641   EXPECT_EQ(12345, result_layer->id());
1642 }
1643
1644 TEST_F(LayerTreeImplTest,
1645        HitCheckingTouchHandlerRegionsForSingleLayerWithScaledContents) {
1646   // A layer's visible content rect is actually in the layer's content space.
1647   // The screen space transform converts from the layer's origin space to screen
1648   // space. This test makes sure that hit testing works correctly accounts for
1649   // the contents scale.  A contents scale that is not 1 effectively forces a
1650   // non-identity transform between layer's content space and layer's origin
1651   // space. The hit testing code must take this into account.
1652   //
1653   // To test this, the layer is positioned at (25, 25), and is size (50, 50). If
1654   // contents scale is ignored, then hit checking will mis-interpret the visible
1655   // content rect as being larger than the actual bounds of the layer.
1656   //
1657   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
1658
1659   gfx::Transform identity_matrix;
1660   gfx::Point3F transform_origin;
1661
1662   SetLayerPropertiesForTesting(root.get(),
1663                                identity_matrix,
1664                                transform_origin,
1665                                gfx::PointF(),
1666                                gfx::Size(100, 100),
1667                                true,
1668                                false);
1669   {
1670     Region touch_handler_region(gfx::Rect(10, 10, 30, 30));
1671     gfx::PointF position(25.f, 25.f);
1672     gfx::Size bounds(50, 50);
1673     scoped_ptr<LayerImpl> test_layer =
1674         LayerImpl::Create(host_impl().active_tree(), 12345);
1675     SetLayerPropertiesForTesting(test_layer.get(),
1676                                  identity_matrix,
1677                                  transform_origin,
1678                                  position,
1679                                  bounds,
1680                                  true,
1681                                  false);
1682
1683     // override content bounds and contents scale
1684     test_layer->SetContentBounds(gfx::Size(100, 100));
1685     test_layer->SetContentsScale(2, 2);
1686
1687     test_layer->SetDrawsContent(true);
1688     test_layer->SetTouchEventHandlerRegion(touch_handler_region);
1689     root->AddChild(test_layer.Pass());
1690   }
1691
1692   host_impl().SetViewportSize(root->bounds());
1693   host_impl().active_tree()->SetRootLayer(root.Pass());
1694   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
1695
1696   // Sanity check the scenario we just created.
1697   // The visible content rect for test_layer is actually 100x100, even though
1698   // its layout size is 50x50, positioned at 25x25.
1699   LayerImpl* test_layer =
1700       host_impl().active_tree()->root_layer()->children()[0];
1701   EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), test_layer->visible_content_rect());
1702   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
1703   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
1704
1705   // Hit checking for a point outside the layer should return a null pointer
1706   // (the root layer does not draw content, so it will not be tested either).
1707   gfx::Point test_point(76, 76);
1708   LayerImpl* result_layer =
1709       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1710           test_point);
1711   EXPECT_FALSE(result_layer);
1712
1713   // Hit checking for a point inside the layer, but outside the touch handler
1714   // region should return a null pointer.
1715   test_point = gfx::Point(26, 26);
1716   result_layer =
1717       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1718           test_point);
1719   EXPECT_FALSE(result_layer);
1720
1721   test_point = gfx::Point(34, 34);
1722   result_layer =
1723       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1724           test_point);
1725   EXPECT_FALSE(result_layer);
1726
1727   test_point = gfx::Point(65, 65);
1728   result_layer =
1729       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1730           test_point);
1731   EXPECT_FALSE(result_layer);
1732
1733   test_point = gfx::Point(74, 74);
1734   result_layer =
1735       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1736           test_point);
1737   EXPECT_FALSE(result_layer);
1738
1739   // Hit checking for a point inside the touch event handler region should
1740   // return the root layer.
1741   test_point = gfx::Point(35, 35);
1742   result_layer =
1743       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1744           test_point);
1745   ASSERT_TRUE(result_layer);
1746   EXPECT_EQ(12345, result_layer->id());
1747
1748   test_point = gfx::Point(64, 64);
1749   result_layer =
1750       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1751           test_point);
1752   ASSERT_TRUE(result_layer);
1753   EXPECT_EQ(12345, result_layer->id());
1754 }
1755
1756 TEST_F(LayerTreeImplTest,
1757        HitCheckingTouchHandlerRegionsForSingleLayerWithDeviceScale) {
1758   // The layer's device_scale_factor and page_scale_factor should scale the
1759   // content rect and we should be able to hit the touch handler region by
1760   // scaling the points accordingly.
1761   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
1762
1763   gfx::Transform identity_matrix;
1764   gfx::Point3F transform_origin;
1765   // Set the bounds of the root layer big enough to fit the child when scaled.
1766   SetLayerPropertiesForTesting(root.get(),
1767                                identity_matrix,
1768                                transform_origin,
1769                                gfx::PointF(),
1770                                gfx::Size(100, 100),
1771                                true,
1772                                false);
1773   {
1774     Region touch_handler_region(gfx::Rect(10, 10, 30, 30));
1775     gfx::PointF position(25.f, 25.f);
1776     gfx::Size bounds(50, 50);
1777     scoped_ptr<LayerImpl> test_layer =
1778         LayerImpl::Create(host_impl().active_tree(), 12345);
1779     SetLayerPropertiesForTesting(test_layer.get(),
1780                                  identity_matrix,
1781                                  transform_origin,
1782                                  position,
1783                                  bounds,
1784                                  true,
1785                                  false);
1786
1787     test_layer->SetDrawsContent(true);
1788     test_layer->SetTouchEventHandlerRegion(touch_handler_region);
1789     root->AddChild(test_layer.Pass());
1790   }
1791
1792   float device_scale_factor = 3.f;
1793   float page_scale_factor = 5.f;
1794   gfx::Size scaled_bounds_for_root = gfx::ToCeiledSize(
1795       gfx::ScaleSize(root->bounds(), device_scale_factor * page_scale_factor));
1796   host_impl().SetViewportSize(scaled_bounds_for_root);
1797
1798   host_impl().SetDeviceScaleFactor(device_scale_factor);
1799   host_impl().active_tree()->SetPageScaleFactorAndLimits(
1800       page_scale_factor, page_scale_factor, page_scale_factor);
1801   host_impl().active_tree()->SetRootLayer(root.Pass());
1802   host_impl().active_tree()->SetViewportLayersFromIds(1, 1, Layer::INVALID_ID);
1803   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
1804
1805   // Sanity check the scenario we just created.
1806   // The visible content rect for test_layer is actually 100x100, even though
1807   // its layout size is 50x50, positioned at 25x25.
1808   LayerImpl* test_layer =
1809       host_impl().active_tree()->root_layer()->children()[0];
1810   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
1811   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
1812
1813   // Check whether the child layer fits into the root after scaled.
1814   EXPECT_RECT_EQ(gfx::Rect(test_layer->content_bounds()),
1815                  test_layer->visible_content_rect());
1816
1817   // Hit checking for a point outside the layer should return a null pointer
1818   // (the root layer does not draw content, so it will not be tested either).
1819   gfx::PointF test_point(76.f, 76.f);
1820   test_point =
1821       gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
1822   LayerImpl* result_layer =
1823       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1824           test_point);
1825   EXPECT_FALSE(result_layer);
1826
1827   // Hit checking for a point inside the layer, but outside the touch handler
1828   // region should return a null pointer.
1829   test_point = gfx::Point(26, 26);
1830   test_point =
1831       gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
1832   result_layer =
1833       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1834           test_point);
1835   EXPECT_FALSE(result_layer);
1836
1837   test_point = gfx::Point(34, 34);
1838   test_point =
1839       gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
1840   result_layer =
1841       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1842           test_point);
1843   EXPECT_FALSE(result_layer);
1844
1845   test_point = gfx::Point(65, 65);
1846   test_point =
1847       gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
1848   result_layer =
1849       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1850           test_point);
1851   EXPECT_FALSE(result_layer);
1852
1853   test_point = gfx::Point(74, 74);
1854   test_point =
1855       gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
1856   result_layer =
1857       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1858           test_point);
1859   EXPECT_FALSE(result_layer);
1860
1861   // Hit checking for a point inside the touch event handler region should
1862   // return the root layer.
1863   test_point = gfx::Point(35, 35);
1864   test_point =
1865       gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
1866   result_layer =
1867       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1868           test_point);
1869   ASSERT_TRUE(result_layer);
1870   EXPECT_EQ(12345, result_layer->id());
1871
1872   test_point = gfx::Point(64, 64);
1873   test_point =
1874       gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
1875   result_layer =
1876       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1877           test_point);
1878   ASSERT_TRUE(result_layer);
1879   EXPECT_EQ(12345, result_layer->id());
1880 }
1881
1882 TEST_F(LayerTreeImplTest, HitCheckingTouchHandlerRegionsForSimpleClippedLayer) {
1883   // Test that hit-checking will only work for the visible portion of a layer,
1884   // and not the entire layer bounds. Here we just test the simple axis-aligned
1885   // case.
1886   gfx::Transform identity_matrix;
1887   gfx::Point3F transform_origin;
1888
1889   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
1890   SetLayerPropertiesForTesting(root.get(),
1891                                identity_matrix,
1892                                transform_origin,
1893                                gfx::PointF(),
1894                                gfx::Size(100, 100),
1895                                true,
1896                                false);
1897   {
1898     scoped_ptr<LayerImpl> clipping_layer =
1899         LayerImpl::Create(host_impl().active_tree(), 123);
1900     // this layer is positioned, and hit testing should correctly know where the
1901     // layer is located.
1902     gfx::PointF position(25.f, 25.f);
1903     gfx::Size bounds(50, 50);
1904     SetLayerPropertiesForTesting(clipping_layer.get(),
1905                                  identity_matrix,
1906                                  transform_origin,
1907                                  position,
1908                                  bounds,
1909                                  true,
1910                                  false);
1911     clipping_layer->SetMasksToBounds(true);
1912
1913     scoped_ptr<LayerImpl> child =
1914         LayerImpl::Create(host_impl().active_tree(), 456);
1915     Region touch_handler_region(gfx::Rect(10, 10, 50, 50));
1916     position = gfx::PointF(-50.f, -50.f);
1917     bounds = gfx::Size(300, 300);
1918     SetLayerPropertiesForTesting(child.get(),
1919                                  identity_matrix,
1920                                  transform_origin,
1921                                  position,
1922                                  bounds,
1923                                  true,
1924                                  false);
1925     child->SetDrawsContent(true);
1926     child->SetTouchEventHandlerRegion(touch_handler_region);
1927     clipping_layer->AddChild(child.Pass());
1928     root->AddChild(clipping_layer.Pass());
1929   }
1930
1931   host_impl().SetViewportSize(root->bounds());
1932   host_impl().active_tree()->SetRootLayer(root.Pass());
1933   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
1934
1935   // Sanity check the scenario we just created.
1936   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
1937   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
1938   ASSERT_EQ(456, root_layer()->render_surface()->layer_list().at(0)->id());
1939
1940   // Hit checking for a point outside the layer should return a null pointer.
1941   // Despite the child layer being very large, it should be clipped to the root
1942   // layer's bounds.
1943   gfx::Point test_point(24, 24);
1944   LayerImpl* result_layer =
1945       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1946           test_point);
1947   EXPECT_FALSE(result_layer);
1948
1949   // Hit checking for a point inside the layer, but outside the touch handler
1950   // region should return a null pointer.
1951   test_point = gfx::Point(35, 35);
1952   result_layer =
1953       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1954           test_point);
1955   EXPECT_FALSE(result_layer);
1956
1957   test_point = gfx::Point(74, 74);
1958   result_layer =
1959       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1960           test_point);
1961   EXPECT_FALSE(result_layer);
1962
1963   // Hit checking for a point inside the touch event handler region should
1964   // return the root layer.
1965   test_point = gfx::Point(25, 25);
1966   result_layer =
1967       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1968           test_point);
1969   ASSERT_TRUE(result_layer);
1970   EXPECT_EQ(456, result_layer->id());
1971
1972   test_point = gfx::Point(34, 34);
1973   result_layer =
1974       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
1975           test_point);
1976   ASSERT_TRUE(result_layer);
1977   EXPECT_EQ(456, result_layer->id());
1978 }
1979
1980 TEST_F(LayerTreeImplTest, HitCheckingTouchHandlerOverlappingRegions) {
1981   gfx::Transform identity_matrix;
1982   gfx::Point3F transform_origin;
1983
1984   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
1985   SetLayerPropertiesForTesting(root.get(),
1986                                identity_matrix,
1987                                transform_origin,
1988                                gfx::PointF(),
1989                                gfx::Size(100, 100),
1990                                true,
1991                                false);
1992   {
1993     scoped_ptr<LayerImpl> touch_layer =
1994         LayerImpl::Create(host_impl().active_tree(), 123);
1995     // this layer is positioned, and hit testing should correctly know where the
1996     // layer is located.
1997     gfx::PointF position;
1998     gfx::Size bounds(50, 50);
1999     SetLayerPropertiesForTesting(touch_layer.get(),
2000                                  identity_matrix,
2001                                  transform_origin,
2002                                  position,
2003                                  bounds,
2004                                  true,
2005                                  false);
2006     touch_layer->SetDrawsContent(true);
2007     touch_layer->SetTouchEventHandlerRegion(gfx::Rect(0, 0, 50, 50));
2008     root->AddChild(touch_layer.Pass());
2009   }
2010
2011   {
2012     scoped_ptr<LayerImpl> notouch_layer =
2013         LayerImpl::Create(host_impl().active_tree(), 1234);
2014     // this layer is positioned, and hit testing should correctly know where the
2015     // layer is located.
2016     gfx::PointF position(0, 25);
2017     gfx::Size bounds(50, 50);
2018     SetLayerPropertiesForTesting(notouch_layer.get(),
2019                                  identity_matrix,
2020                                  transform_origin,
2021                                  position,
2022                                  bounds,
2023                                  true,
2024                                  false);
2025     notouch_layer->SetDrawsContent(true);
2026     root->AddChild(notouch_layer.Pass());
2027   }
2028
2029   host_impl().SetViewportSize(root->bounds());
2030   host_impl().active_tree()->SetRootLayer(root.Pass());
2031   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
2032
2033   // Sanity check the scenario we just created.
2034   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
2035   ASSERT_EQ(2u, root_layer()->render_surface()->layer_list().size());
2036   ASSERT_EQ(123, root_layer()->render_surface()->layer_list().at(0)->id());
2037   ASSERT_EQ(1234, root_layer()->render_surface()->layer_list().at(1)->id());
2038
2039   gfx::Point test_point(35, 35);
2040   LayerImpl* result_layer =
2041       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
2042           test_point);
2043
2044   // We should have passed through the no-touch layer and found the layer
2045   // behind it.
2046   EXPECT_TRUE(result_layer);
2047
2048   host_impl().active_tree()->LayerById(1234)->SetContentsOpaque(true);
2049   result_layer =
2050       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
2051           test_point);
2052
2053   // Even with an opaque layer in the middle, we should still find the layer
2054   // with
2055   // the touch handler behind it (since we can't assume that opaque layers are
2056   // opaque to hit testing).
2057   EXPECT_TRUE(result_layer);
2058
2059   test_point = gfx::Point(35, 15);
2060   result_layer =
2061       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
2062           test_point);
2063   ASSERT_TRUE(result_layer);
2064   EXPECT_EQ(123, result_layer->id());
2065
2066   test_point = gfx::Point(35, 65);
2067   result_layer =
2068       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
2069           test_point);
2070   EXPECT_FALSE(result_layer);
2071 }
2072
2073 TEST_F(LayerTreeImplTest, SelectionBoundsForSingleLayer) {
2074   int root_layer_id = 12345;
2075   scoped_ptr<LayerImpl> root =
2076       LayerImpl::Create(host_impl().active_tree(), root_layer_id);
2077
2078   gfx::Transform identity_matrix;
2079   gfx::Point3F transform_origin;
2080   gfx::PointF position;
2081   gfx::Size bounds(100, 100);
2082   SetLayerPropertiesForTesting(root.get(),
2083                                identity_matrix,
2084                                transform_origin,
2085                                position,
2086                                bounds,
2087                                true,
2088                                false);
2089   root->SetDrawsContent(true);
2090
2091   host_impl().SetViewportSize(root->bounds());
2092   host_impl().active_tree()->SetRootLayer(root.Pass());
2093   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
2094
2095   // Sanity check the scenario we just created.
2096   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
2097   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
2098
2099   LayerSelectionBound left_input;
2100   left_input.type = SELECTION_BOUND_LEFT;
2101   left_input.edge_top = gfx::PointF(10, 10);
2102   left_input.edge_bottom = gfx::PointF(10, 20);
2103   left_input.layer_id = root_layer_id;
2104
2105   LayerSelectionBound right_input;
2106   right_input.type = SELECTION_BOUND_RIGHT;
2107   right_input.edge_top = gfx::PointF(50, 10);
2108   right_input.edge_bottom = gfx::PointF(50, 30);
2109   right_input.layer_id = root_layer_id;
2110
2111   ViewportSelectionBound left_output, right_output;
2112
2113   // Empty input bounds should produce empty output bounds.
2114   host_impl().active_tree()->GetViewportSelection(&left_output, &right_output);
2115   EXPECT_EQ(ViewportSelectionBound(), left_output);
2116   EXPECT_EQ(ViewportSelectionBound(), right_output);
2117
2118   // Selection bounds should produce distinct left and right bounds.
2119   host_impl().active_tree()->RegisterSelection(left_input, right_input);
2120   host_impl().active_tree()->GetViewportSelection(&left_output, &right_output);
2121   EXPECT_EQ(left_input.type, left_output.type);
2122   EXPECT_EQ(left_input.edge_bottom, left_output.edge_bottom);
2123   EXPECT_EQ(left_input.edge_top, left_output.edge_top);
2124   EXPECT_TRUE(left_output.visible);
2125   EXPECT_EQ(right_input.type, right_output.type);
2126   EXPECT_EQ(right_input.edge_bottom, right_output.edge_bottom);
2127   EXPECT_EQ(right_input.edge_top, right_output.edge_top);
2128   EXPECT_TRUE(right_output.visible);
2129
2130   // Insertion bounds should produce identical left and right bounds.
2131   LayerSelectionBound insertion_input;
2132   insertion_input.type = SELECTION_BOUND_CENTER;
2133   insertion_input.edge_top = gfx::PointF(15, 10);
2134   insertion_input.edge_bottom = gfx::PointF(15, 30);
2135   insertion_input.layer_id = root_layer_id;
2136   host_impl().active_tree()->RegisterSelection(insertion_input,
2137                                                LayerSelectionBound());
2138   host_impl().active_tree()->GetViewportSelection(&left_output, &right_output);
2139   EXPECT_EQ(insertion_input.type, left_output.type);
2140   EXPECT_EQ(insertion_input.edge_bottom, left_output.edge_bottom);
2141   EXPECT_EQ(insertion_input.edge_top, left_output.edge_top);
2142   EXPECT_TRUE(left_output.visible);
2143   EXPECT_EQ(left_output, right_output);
2144 }
2145
2146 TEST_F(LayerTreeImplTest, SelectionBoundsForPartialOccludedLayers) {
2147   int root_layer_id = 12345;
2148   int clip_layer_id = 1234;
2149   int clipped_layer_id = 123;
2150   scoped_ptr<LayerImpl> root =
2151       LayerImpl::Create(host_impl().active_tree(), root_layer_id);
2152   root->SetDrawsContent(true);
2153
2154   gfx::Transform identity_matrix;
2155   gfx::Point3F transform_origin;
2156   gfx::PointF position;
2157   gfx::Size bounds(100, 100);
2158   SetLayerPropertiesForTesting(root.get(),
2159                                identity_matrix,
2160                                transform_origin,
2161                                position,
2162                                bounds,
2163                                true,
2164                                false);
2165
2166   gfx::Vector2dF clipping_offset(10, 10);
2167   {
2168     scoped_ptr<LayerImpl> clipping_layer =
2169         LayerImpl::Create(host_impl().active_tree(), clip_layer_id);
2170     // The clipping layer should occlude the right selection bound.
2171     gfx::PointF position = gfx::PointF() + clipping_offset;
2172     gfx::Size bounds(50, 50);
2173     SetLayerPropertiesForTesting(clipping_layer.get(),
2174                                  identity_matrix,
2175                                  transform_origin,
2176                                  position,
2177                                  bounds,
2178                                  true,
2179                                  false);
2180     clipping_layer->SetMasksToBounds(true);
2181
2182     scoped_ptr<LayerImpl> clipped_layer =
2183         LayerImpl::Create(host_impl().active_tree(), clipped_layer_id);
2184     position = gfx::PointF();
2185     bounds = gfx::Size(100, 100);
2186     SetLayerPropertiesForTesting(clipped_layer.get(),
2187                                  identity_matrix,
2188                                  transform_origin,
2189                                  position,
2190                                  bounds,
2191                                  true,
2192                                  false);
2193     clipped_layer->SetDrawsContent(true);
2194     clipping_layer->AddChild(clipped_layer.Pass());
2195     root->AddChild(clipping_layer.Pass());
2196   }
2197
2198   host_impl().SetViewportSize(root->bounds());
2199   host_impl().active_tree()->SetRootLayer(root.Pass());
2200   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
2201
2202   // Sanity check the scenario we just created.
2203   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
2204
2205   LayerSelectionBound left_input;
2206   left_input.type = SELECTION_BOUND_LEFT;
2207   left_input.edge_top = gfx::PointF(25, 10);
2208   left_input.edge_bottom = gfx::PointF(25, 30);
2209   left_input.layer_id = clipped_layer_id;
2210
2211   LayerSelectionBound right_input;
2212   right_input.type = SELECTION_BOUND_RIGHT;
2213   right_input.edge_top = gfx::PointF(75, 10);
2214   right_input.edge_bottom = gfx::PointF(75, 30);
2215   right_input.layer_id = clipped_layer_id;
2216   host_impl().active_tree()->RegisterSelection(left_input, right_input);
2217
2218   // The left bound should be occluded by the clip layer.
2219   ViewportSelectionBound left_output, right_output;
2220   host_impl().active_tree()->GetViewportSelection(&left_output, &right_output);
2221   EXPECT_EQ(left_input.type, left_output.type);
2222   gfx::PointF expected_left_output_top = left_input.edge_top;
2223   gfx::PointF expected_left_output_bottom = left_input.edge_bottom;
2224   expected_left_output_top.Offset(clipping_offset.x(), clipping_offset.y());
2225   expected_left_output_bottom.Offset(clipping_offset.x(), clipping_offset.y());
2226   EXPECT_EQ(expected_left_output_top, left_output.edge_top);
2227   EXPECT_EQ(expected_left_output_bottom, left_output.edge_bottom);
2228   EXPECT_TRUE(left_output.visible);
2229   EXPECT_EQ(right_input.type, right_output.type);
2230   gfx::PointF expected_right_output_top = right_input.edge_top;
2231   gfx::PointF expected_right_output_bottom = right_input.edge_bottom;
2232   expected_right_output_bottom.Offset(clipping_offset.x(), clipping_offset.y());
2233   expected_right_output_top.Offset(clipping_offset.x(), clipping_offset.y());
2234   EXPECT_EQ(expected_right_output_top, right_output.edge_top);
2235   EXPECT_EQ(expected_right_output_bottom, right_output.edge_bottom);
2236   EXPECT_FALSE(right_output.visible);
2237
2238   // Handles outside the viewport bounds should be marked invisible.
2239   left_input.edge_top = gfx::PointF(-25, 0);
2240   left_input.edge_bottom = gfx::PointF(-25, 20);
2241   host_impl().active_tree()->RegisterSelection(left_input, right_input);
2242   host_impl().active_tree()->GetViewportSelection(&left_output, &right_output);
2243   EXPECT_FALSE(left_output.visible);
2244
2245   left_input.edge_top = gfx::PointF(0, -25);
2246   left_input.edge_bottom = gfx::PointF(0, -5);
2247   host_impl().active_tree()->RegisterSelection(left_input, right_input);
2248   host_impl().active_tree()->GetViewportSelection(&left_output, &right_output);
2249   EXPECT_FALSE(left_output.visible);
2250
2251   // If the handle bottom is partially visible, the handle is marked visible.
2252   left_input.edge_top = gfx::PointF(0, -20);
2253   left_input.edge_bottom = gfx::PointF(0, 1);
2254   host_impl().active_tree()->RegisterSelection(left_input, right_input);
2255   host_impl().active_tree()->GetViewportSelection(&left_output, &right_output);
2256   EXPECT_TRUE(left_output.visible);
2257 }
2258
2259 TEST_F(LayerTreeImplTest, SelectionBoundsForScaledLayers) {
2260   int root_layer_id = 1;
2261   int sub_layer_id = 2;
2262   scoped_ptr<LayerImpl> root =
2263       LayerImpl::Create(host_impl().active_tree(), root_layer_id);
2264   root->SetDrawsContent(true);
2265
2266   gfx::Transform identity_matrix;
2267   gfx::Point3F transform_origin;
2268   gfx::PointF position;
2269   gfx::Size bounds(100, 100);
2270   SetLayerPropertiesForTesting(root.get(),
2271                                identity_matrix,
2272                                transform_origin,
2273                                position,
2274                                bounds,
2275                                true,
2276                                false);
2277
2278   gfx::Vector2dF sub_layer_offset(10, 0);
2279   {
2280     scoped_ptr<LayerImpl> sub_layer =
2281         LayerImpl::Create(host_impl().active_tree(), sub_layer_id);
2282     gfx::PointF position = gfx::PointF() + sub_layer_offset;
2283     gfx::Size bounds(50, 50);
2284     SetLayerPropertiesForTesting(sub_layer.get(),
2285                                  identity_matrix,
2286                                  transform_origin,
2287                                  position,
2288                                  bounds,
2289                                  true,
2290                                  false);
2291     sub_layer->SetDrawsContent(true);
2292     root->AddChild(sub_layer.Pass());
2293   }
2294
2295   float device_scale_factor = 3.f;
2296   float page_scale_factor = 5.f;
2297   gfx::Size scaled_bounds_for_root = gfx::ToCeiledSize(
2298       gfx::ScaleSize(root->bounds(), device_scale_factor * page_scale_factor));
2299   host_impl().SetViewportSize(scaled_bounds_for_root);
2300
2301   host_impl().SetDeviceScaleFactor(device_scale_factor);
2302   host_impl().active_tree()->SetPageScaleFactorAndLimits(
2303       page_scale_factor, page_scale_factor, page_scale_factor);
2304   host_impl().active_tree()->SetRootLayer(root.Pass());
2305   host_impl().active_tree()->SetViewportLayersFromIds(1, 1, Layer::INVALID_ID);
2306   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
2307
2308   // Sanity check the scenario we just created.
2309   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
2310
2311   LayerSelectionBound left_input;
2312   left_input.type = SELECTION_BOUND_LEFT;
2313   left_input.edge_top = gfx::PointF(10, 10);
2314   left_input.edge_bottom = gfx::PointF(10, 30);
2315   left_input.layer_id = root_layer_id;
2316
2317   LayerSelectionBound right_input;
2318   right_input.type = SELECTION_BOUND_RIGHT;
2319   right_input.edge_top = gfx::PointF(0, 0);
2320   right_input.edge_bottom = gfx::PointF(0, 20);
2321   right_input.layer_id = sub_layer_id;
2322   host_impl().active_tree()->RegisterSelection(left_input, right_input);
2323
2324   // The viewport bounds should be properly scaled by the page scale, but should
2325   // remain in DIP coordinates.
2326   ViewportSelectionBound left_output, right_output;
2327   host_impl().active_tree()->GetViewportSelection(&left_output, &right_output);
2328   EXPECT_EQ(left_input.type, left_output.type);
2329   gfx::PointF expected_left_output_top = left_input.edge_top;
2330   gfx::PointF expected_left_output_bottom = left_input.edge_bottom;
2331   expected_left_output_top.Scale(page_scale_factor);
2332   expected_left_output_bottom.Scale(page_scale_factor);
2333   EXPECT_EQ(left_input.edge_top, left_output.edge_top);
2334   EXPECT_EQ(left_input.edge_bottom, left_output.edge_bottom);
2335   EXPECT_TRUE(left_output.visible);
2336   EXPECT_EQ(right_input.type, right_output.type);
2337
2338   gfx::PointF expected_right_output_top = right_input.edge_top;
2339   gfx::PointF expected_right_output_bottom = right_input.edge_bottom;
2340   expected_right_output_top.Offset(sub_layer_offset.x(), sub_layer_offset.y());
2341   expected_right_output_bottom.Offset(sub_layer_offset.x(),
2342                                       sub_layer_offset.y());
2343   expected_right_output_top.Scale(page_scale_factor);
2344   expected_right_output_bottom.Scale(page_scale_factor);
2345   EXPECT_EQ(expected_right_output_top, right_output.edge_top);
2346   EXPECT_EQ(expected_right_output_bottom, right_output.edge_bottom);
2347   EXPECT_TRUE(right_output.visible);
2348 }
2349
2350 TEST_F(LayerTreeImplTest, NumLayersTestOne) {
2351   EXPECT_EQ(0u, host_impl().active_tree()->NumLayers());
2352   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
2353   EXPECT_EQ(1u, host_impl().active_tree()->NumLayers());
2354 }
2355
2356 TEST_F(LayerTreeImplTest, NumLayersSmallTree) {
2357   EXPECT_EQ(0u, host_impl().active_tree()->NumLayers());
2358   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
2359   root->AddChild(LayerImpl::Create(host_impl().active_tree(), 2));
2360   root->AddChild(LayerImpl::Create(host_impl().active_tree(), 3));
2361   root->child_at(1)->AddChild(LayerImpl::Create(host_impl().active_tree(), 4));
2362   EXPECT_EQ(4u, host_impl().active_tree()->NumLayers());
2363 }
2364
2365 }  // namespace
2366 }  // namespace cc