cc: Fix hit-testing in zero-opacity layers.

cc/trees/layer_tree_host_common_unittest.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/layer_tree_host_common.h"
 
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/content_layer_client.h"
@@ skipping 5551 matching lines @@
   EXPECT_EQ(3, result_layer->id());
 
   // Hit testing for a point inside the mousewheel layer should return it.
   test_point = gfx::Point(75, 75);
   result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
           test_point, render_surface_layer_list);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(4, result_layer->id());
 }
 
+TEST_F(LayerTreeHostCommonTest, HitTestForZeroOpacityLayers) {
+  FakeImplProxy proxy;
+  FakeLayerTreeHostImpl host_impl(&proxy);
+  const int kRootId = 1;
+  const int kTouchHandlerId = 2;
+  const int kWheelHandlerId = 3;
+  const int kNoHandlerId = 4;
+  const int kGrandChildWithEventId = 5;
+
+  scoped_ptr<LayerImpl> root =
+      LayerImpl::Create(host_impl.active_tree(), 1);
+  gfx::Transform identity_matrix;
+  gfx::PointF anchor;
+  gfx::PointF position;
+  gfx::Size bounds(100, 100);
+  SetLayerPropertiesForTesting(root.get(),
+                               identity_matrix,
+                               identity_matrix,
+                               anchor,
+                               position,
+                               bounds,
+                               false);
+  root->SetDrawsContent(true);
+
+  {
+    // Child 1 - Zero opacity, without any event handler.
+    gfx::PointF position(10.f, 10.f);
+    gfx::Size bounds(30, 30);
+    scoped_ptr<LayerImpl> child =
+        LayerImpl::Create(host_impl.active_tree(), kNoHandlerId);
+    SetLayerPropertiesForTesting(child.get(),
+                                 identity_matrix,
+                                 identity_matrix,
+                                 anchor,
+                                 position,
+                                 bounds,
+                                 false);
+    child->SetOpacity(0.f);
+
+    // Grandchild - with a wheel handler.
+    scoped_ptr<LayerImpl> grand_child =
+        LayerImpl::Create(host_impl.active_tree(), kGrandChildWithEventId);
+    SetLayerPropertiesForTesting(grand_child.get(),
+                                 identity_matrix,
+                                 identity_matrix,
+                                 gfx::PointF(),
+                                 gfx::PointF(10, 10),
+                                 gfx::Size(10, 10),
+                                 false);
+    grand_child->SetHaveWheelEventHandlers(true);
+    child->AddChild(grand_child.Pass());
+    root->AddChild(child.Pass());
+  }
+
+  {
+    // Child 2 - Zero opacity, with touch event handler.
+    gfx::PointF position(70.f, 10.f);
+    gfx::Size bounds(30, 30);
+    scoped_ptr<LayerImpl> child =
+        LayerImpl::Create(host_impl.active_tree(), kTouchHandlerId);
+    SetLayerPropertiesForTesting(child.get(),
+                                 identity_matrix,
+                                 identity_matrix,
+                                 anchor,
+                                 position,
+                                 bounds,
+                                 false);
+    child->SetOpacity(0.f);
+    child->SetTouchEventHandlerRegion(gfx::Rect(10, 10, 10, 10));
+    root->AddChild(child.Pass());
+  }
+
+  {
+    // Child 3 - Zero opacity, with wheel event handler.
+    gfx::PointF position(10.f, 50.f);
+    gfx::Size bounds(30, 30);
+    scoped_ptr<LayerImpl> child =
+        LayerImpl::Create(host_impl.active_tree(), kWheelHandlerId);
+    SetLayerPropertiesForTesting(child.get(),
+                                 identity_matrix,
+                                 identity_matrix,
+                                 anchor,
+                                 position,
+                                 bounds,
+                                 false);
+    child->SetOpacity(0.f);
+    child->SetHaveWheelEventHandlers(true);
+    root->AddChild(child.Pass());
+  }
+
+  LayerImplList render_surface_layer_list;
+  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
+      root.get(), root->bounds(), &render_surface_layer_list);
+  inputs.can_adjust_raster_scales = true;
+  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
+
+  // Verify that the root layer and zero-opacity layers with touch/wheel
+  // handlers (but not the zero-opacity layer without a touch handler) are in
+  // the RSSL.
+  ASSERT_EQ(1u, render_surface_layer_list.size());
+  EXPECT_EQ(kRootId, render_surface_layer_list[0]->id());
+  ASSERT_EQ(4u, root->render_surface()->layer_list().size());
+  EXPECT_EQ(kRootId, root->render_surface()->layer_list().at(0)->id());
+  EXPECT_EQ(kGrandChildWithEventId,
+            root->render_surface()->layer_list().at(1)->id());
+  EXPECT_EQ(kTouchHandlerId, root->render_surface()->layer_list().at(2)->id());
+  EXPECT_EQ(kWheelHandlerId, root->render_surface()->layer_list().at(3)->id());
+
+  // Hit testing for a point inside the zero-opacity no-handler layer should
+  // return the root layer.
+  gfx::Point test_point = gfx::Point(15, 15);
+  LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
+      test_point, render_surface_layer_list);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(kRootId, result_layer->id());
+
+  // Hit testing for a point inside the child of the zero-opacity no-handler
+  // layer should return the child layer, since that layer has mousewheel
+  // handler.
+  test_point = gfx::Point(25, 25);
+  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
+      test_point, render_surface_layer_list);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(kGrandChildWithEventId, result_layer->id());
+
+  // Hit testing for a point inside the touch handler layer should return it.
+  test_point = gfx::Point(85, 25);
+  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
+          test_point, render_surface_layer_list);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(kTouchHandlerId, result_layer->id());
+
+  // Hit testing for a point inside the mousewheel layer should return it.
+  test_point = gfx::Point(15, 55);
+  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
+          test_point, render_surface_layer_list);
+  ASSERT_TRUE(result_layer);
+  EXPECT_EQ(kWheelHandlerId, result_layer->id());
+}
+
 TEST_F(LayerTreeHostCommonTest,
        HitCheckingTouchHandlerRegionsForEmptyLayerList) {
   // Hit checking on an empty render_surface_layer_list should return a null
   // pointer.
   LayerImplList render_surface_layer_list;
 
   gfx::Point test_point(0, 0);
   LayerImpl* result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point, render_surface_layer_list);
@@ skipping 3551 matching lines @@
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_EQ(1u, render_surface_layer_list()->size());
   EXPECT_EQ(0u,
             render_surface_layer_list()->at(0)
                 ->render_surface()->layer_list().size());
 }
 
 }  // namespace
 }  // namespace cc