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