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;
+  const int kGrandChildWithoutEventId = 6;
+
+  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.

[danakj, 2013/10/08 18:32:32]

Can you add a case where there is

- Opacity 0 layer that DrawsContent()
+-- Render surface owning layer (SetForceRenderSurface(true)) that
DrawsContent() 
  +-- Touch handler layer.

In this case, the 2 ancestors own render surfaces so they should appear in the
RSLL. But not in any surface layer_list(). And the touch handler layer should
appear in a layer_list() of the latter surface. None of the layers or surfaces
should generate any quads in CalculateRenderPasses.

I think you need a separate set of tests to verify update (main thread) append
quads (impl thread) isn't happening for these layers in each of the cases you're
testing here. (And code to make it not happen.)

I think you also need a test to verify we don't make tiles for invisible layers
since we're going to now call UpdateTilePriorities() on them when we would not
have before.

If I may suggest, the easiest way to go about all of this would be to decouple
UpdateTilePrios and Choosing to Update()/AppendQuads() entirely from this
complicated logic around opacity and such. If CalcDrawProps has an output
variable (a draw property) that says if the layer should be drawn as part of the
frame or not, then these other systems can key off that. And you only need 1
test for each other system to ensure it is using said key, and all your tests
for CalcDrawProps can ensure the right key output. I think that I would
recommend doing that as a first step, making a "draws_content" (or some better
name?) draw property, and having Occlusion/Damage/AppendQuads/Update/Tiling use
that value instead of the input-variable "DrawsContent()".

Along this train of thought, I had suggested in IRC maybe it would be nice to
have compiler enforce this type of thing by only allowing access to draw
properties via the RSLL so there's no confusion about what properties make sense
and are being used in all these systems, by storing a DrawLayer(Impl) in RSLL
and layer_list() instead of Layer(Impl*) directly, and having it wrap access to
the underlying draw_properties() and AppendQuads() stuff and prevent access to
anything else. I'm not sure enne@ bought into that idea though, so maybe it's
not worth going that far.

+    gfx::PointF position(10.f, 10.f);
+    gfx::Size bounds(30, 30);

[danakj, 2013/10/08 18:32:32]

Can you add a case where the touch handler layer owns a render surface as well?

- Opacity 0 layer that DrawsContent()
+-- Touch handler layer with SetForceRenderSurface(true)

And maybe

- Opacity 0 layer that DrawsContent() and SetForceRenderSurface(true) and has
touch handler.

+    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);

[danakj, 2013/10/08 18:32:32]

Can you make all of the layers in this test DrawsContent(true) so that we
generate render surfaces for them with opacity < 1.

+
+    // 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());
+    }
+
+    // Grandchild - without any event handlers.
+    {
+      scoped_ptr<LayerImpl> grand_child =
+          LayerImpl::Create(host_impl.active_tree(), kGrandChildWithoutEventId);
+      SetLayerPropertiesForTesting(grand_child.get(),
+                                   identity_matrix,
+                                   identity_matrix,
+                                   gfx::PointF(),
+                                   gfx::PointF(20, 10),
+                                   gfx::Size(10, 10),
+                                   false);
+      child->AddChild(grand_child.Pass());
+    }
+    root->AddChild(child.Pass());
+  }
+
+  {
+    // Child 2 - Zero opacity, with touch event handler.

[danakj, 2013/10/08 18:32:32]

Can you add multiple drawing children of this layer so that it would own a
surface.

+    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.

[danakj, 2013/10/08 18:32:32]

Could you split each of these 3 children cases into separate tests so each test
is smaller/easier to read.

+    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