Hit test on the layer tree rather than the RSLL

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 <set>
 
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/animation/transform_operations.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/content_layer_client.h"
-#include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_client.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/layer_iterator.h"
 #include "cc/layers/render_surface.h"
 #include "cc/layers/render_surface_impl.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/test/animation_test_common.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/geometry_test_utils.h"
+#include "cc/test/layer_tree_host_common_test.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/proxy.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/quad_f.h"
-#include "ui/gfx/size_conversions.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 namespace {
 
-class LayerTreeHostCommonTestBase {
- protected:
-  LayerTreeHostCommonTestBase() : render_surface_layer_list_count_(0) {}
-
-  template <typename LayerType>
-  void SetLayerPropertiesForTestingInternal(
-      LayerType* layer,
-      const gfx::Transform& transform,
-      const gfx::PointF& anchor,
-      const gfx::PointF& position,
-      const gfx::Size& bounds,
-      bool flatten_transform,
-      bool is_3d_sorted) {
-    layer->SetTransform(transform);
-    layer->SetAnchorPoint(anchor);
-    layer->SetPosition(position);
-    layer->SetBounds(bounds);
-    layer->SetShouldFlattenTransform(flatten_transform);
-    layer->SetIs3dSorted(is_3d_sorted);
-  }
-
-  void SetLayerPropertiesForTesting(Layer* layer,
-                                    const gfx::Transform& transform,
-                                    const gfx::PointF& anchor,
-                                    const gfx::PointF& position,
-                                    const gfx::Size& bounds,
-                                    bool flatten_transform,
-                                    bool is_3d_sorted) {
-    SetLayerPropertiesForTestingInternal<Layer>(layer,
-                                                transform,
-                                                anchor,
-                                                position,
-                                                bounds,
-                                                flatten_transform,
-                                                is_3d_sorted);
-  }
-
-  void SetLayerPropertiesForTesting(LayerImpl* layer,
-                                    const gfx::Transform& transform,
-                                    const gfx::PointF& anchor,
-                                    const gfx::PointF& position,
-                                    const gfx::Size& bounds,
-                                    bool flatten_transform,
-                                    bool is_3d_sorted) {
-    SetLayerPropertiesForTestingInternal<LayerImpl>(layer,
-                                                    transform,
-                                                    anchor,
-                                                    position,
-                                                    bounds,
-                                                    flatten_transform,
-                                                    is_3d_sorted);
-    layer->SetContentBounds(bounds);
-  }
-
-  void ExecuteCalculateDrawProperties(Layer* root_layer,
-                                      float device_scale_factor,
-                                      float page_scale_factor,
-                                      Layer* page_scale_application_layer,
-                                      bool can_use_lcd_text) {
-    EXPECT_TRUE(page_scale_application_layer || (page_scale_factor == 1.f));
-    gfx::Transform identity_matrix;
-    gfx::Size device_viewport_size =
-        gfx::Size(root_layer->bounds().width() * device_scale_factor,
-                  root_layer->bounds().height() * device_scale_factor);
-
-    render_surface_layer_list_.reset(new RenderSurfaceLayerList);
-
-    // We are probably not testing what is intended if the root_layer bounds are
-    // empty.
-    DCHECK(!root_layer->bounds().IsEmpty());
-    LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root_layer, device_viewport_size, render_surface_layer_list_.get());
-    inputs.device_scale_factor = device_scale_factor;
-    inputs.page_scale_factor = page_scale_factor;
-    inputs.page_scale_application_layer = page_scale_application_layer;
-    inputs.can_use_lcd_text = can_use_lcd_text;
-    inputs.can_adjust_raster_scales = true;
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
-  }
-
-  void ExecuteCalculateDrawProperties(LayerImpl* root_layer,
-                                      float device_scale_factor,
-                                      float page_scale_factor,
-                                      LayerImpl* page_scale_application_layer,
-                                      bool can_use_lcd_text) {
-    gfx::Transform identity_matrix;
-    gfx::Size device_viewport_size =
-        gfx::Size(root_layer->bounds().width() * device_scale_factor,
-                  root_layer->bounds().height() * device_scale_factor);
-
-    render_surface_layer_list_impl_.reset(new LayerImplList);
-
-    // We are probably not testing what is intended if the root_layer bounds are
-    // empty.
-    DCHECK(!root_layer->bounds().IsEmpty());
-    LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root_layer,
-        device_viewport_size,
-        render_surface_layer_list_impl_.get());
-    inputs.device_scale_factor = device_scale_factor;
-    inputs.page_scale_factor = page_scale_factor;
-    inputs.page_scale_application_layer = page_scale_application_layer;
-    inputs.can_use_lcd_text = can_use_lcd_text;
-    inputs.can_adjust_raster_scales = true;
-
-    ++render_surface_layer_list_count_;
-    inputs.current_render_surface_layer_list_id =
-        render_surface_layer_list_count_;
-
-    LayerTreeHostCommon::CalculateDrawProperties(&inputs);
-  }
-
-  template <class LayerType>
-  void ExecuteCalculateDrawProperties(LayerType* root_layer) {
-    LayerType* page_scale_application_layer = NULL;
-    ExecuteCalculateDrawProperties(
-        root_layer, 1.f, 1.f, page_scale_application_layer, false);
-  }
-
-  template <class LayerType>
-  void ExecuteCalculateDrawProperties(LayerType* root_layer,
-                                      float device_scale_factor) {
-    LayerType* page_scale_application_layer = NULL;
-    ExecuteCalculateDrawProperties(root_layer,
-                                   device_scale_factor,
-                                   1.f,
-                                   page_scale_application_layer,
-                                   false);
-  }
-
-  template <class LayerType>
-  void ExecuteCalculateDrawProperties(LayerType* root_layer,
-                                      float device_scale_factor,
-                                      float page_scale_factor,
-                                      LayerType* page_scale_application_layer) {
-    ExecuteCalculateDrawProperties(root_layer,
-                                   device_scale_factor,
-                                   page_scale_factor,
-                                   page_scale_application_layer,
-                                   false);
-  }
-
-  RenderSurfaceLayerList* render_surface_layer_list() const {
-    return render_surface_layer_list_.get();
-  }
-
-  LayerImplList* render_surface_layer_list_impl() const {
-    return render_surface_layer_list_impl_.get();
-  }
-
-  int render_surface_layer_list_count() const {
-    return render_surface_layer_list_count_;
-  }
-
- private:
-  scoped_ptr<RenderSurfaceLayerList> render_surface_layer_list_;
-  scoped_ptr<LayerImplList> render_surface_layer_list_impl_;
-
-  int render_surface_layer_list_count_;
-};
-
-class LayerTreeHostCommonTest : public LayerTreeHostCommonTestBase,
-                                public testing::Test {
-};
-
 class LayerWithForcedDrawsContent : public Layer {
  public:
   LayerWithForcedDrawsContent() : Layer(), last_device_scale_factor_(0.f) {}
 
   virtual bool DrawsContent() const OVERRIDE;
   virtual void CalculateContentsScale(float ideal_contents_scale,
                                       float device_scale_factor,
                                       float page_scale_factor,
                                       float maximum_animation_contents_scale,
                                       bool animating_transform_to_screen,
@@ skipping 3939 matching lines @@
       2u,
       render_surface_layer_list.at(1)->render_surface()->layer_list().size());
   EXPECT_EQ(front_facing_surface->id(),
             render_surface_layer_list.at(1)
                 ->render_surface()->layer_list().at(0)->id());
   EXPECT_EQ(child1->id(),
             render_surface_layer_list.at(1)
                 ->render_surface()->layer_list().at(1)->id());
 }
 
-
-TEST_F(LayerTreeHostCommonTest, HitTestingForEmptyLayerList) {
-  // Hit testing 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::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(10, 20);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-}
-
-TEST_F(LayerTreeHostCommonTest, HitTestingForSingleLayer) {
-  FakeImplProxy proxy;
-  TestSharedBitmapManager shared_bitmap_manager;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-  scoped_ptr<LayerImpl> root =
-      LayerImpl::Create(host_impl.active_tree(), 12345);
-
-  gfx::Transform identity_matrix;
-  gfx::PointF anchor;
-  gfx::PointF position;
-  gfx::Size bounds(100, 100);
-  SetLayerPropertiesForTesting(root.get(),
-                               identity_matrix,
-                               anchor,
-                               position,
-                               bounds,
-                               true,
-                               false);
-  root->SetDrawsContent(true);
-
-  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);
-
-  // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, render_surface_layer_list.size());
-  ASSERT_EQ(1u, root->render_surface()->layer_list().size());
-
-  // Hit testing for a point outside the layer should return a null pointer.
-  gfx::Point test_point(101, 101);
-  LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(-1, -1);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  // Hit testing for a point inside should return the root layer.
-  test_point = gfx::Point(1, 1);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(12345, result_layer->id());
-
-  test_point = gfx::Point(99, 99);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(12345, result_layer->id());
-}
-
-TEST_F(LayerTreeHostCommonTest, HitTestingForSingleLayerAndHud) {
-  FakeImplProxy proxy;
-  TestSharedBitmapManager shared_bitmap_manager;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-  scoped_ptr<LayerImpl> root =
-      LayerImpl::Create(host_impl.active_tree(), 12345);
-  scoped_ptr<HeadsUpDisplayLayerImpl> hud =
-      HeadsUpDisplayLayerImpl::Create(host_impl.active_tree(), 11111);
-
-  gfx::Transform identity_matrix;
-  gfx::PointF anchor;
-  gfx::PointF position;
-  gfx::Size bounds(100, 100);
-  SetLayerPropertiesForTesting(root.get(),
-                               identity_matrix,
-                               anchor,
-                               position,
-                               bounds,
-                               true,
-                               false);
-  root->SetDrawsContent(true);
-
-  // Create hud and add it as a child of root.
-  gfx::Size hud_bounds(200, 200);
-  SetLayerPropertiesForTesting(hud.get(),
-                               identity_matrix,
-                               anchor,
-                               position,
-                               hud_bounds,
-                               true,
-                               false);
-  hud->SetDrawsContent(true);
-
-  host_impl.active_tree()->set_hud_layer(hud.get());
-  root->AddChild(hud.PassAs<LayerImpl>());
-
-  LayerImplList render_surface_layer_list;
-  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), hud_bounds, &render_surface_layer_list);
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
-
-  // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, render_surface_layer_list.size());
-  ASSERT_EQ(2u, root->render_surface()->layer_list().size());
-
-  // Hit testing for a point inside HUD, but outside root should return null
-  gfx::Point test_point(101, 101);
-  LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(-1, -1);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  // Hit testing for a point inside should return the root layer, never the HUD
-  // layer.
-  test_point = gfx::Point(1, 1);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(12345, result_layer->id());
-
-  test_point = gfx::Point(99, 99);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(12345, result_layer->id());
-}
-
-TEST_F(LayerTreeHostCommonTest, HitTestingForUninvertibleTransform) {
-  FakeImplProxy proxy;
-  TestSharedBitmapManager shared_bitmap_manager;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-  scoped_ptr<LayerImpl> root =
-      LayerImpl::Create(host_impl.active_tree(), 12345);
-
-  gfx::Transform uninvertible_transform;
-  uninvertible_transform.matrix().set(0, 0, 0.0);
-  uninvertible_transform.matrix().set(1, 1, 0.0);
-  uninvertible_transform.matrix().set(2, 2, 0.0);
-  uninvertible_transform.matrix().set(3, 3, 0.0);
-  ASSERT_FALSE(uninvertible_transform.IsInvertible());
-
-  gfx::Transform identity_matrix;
-  gfx::PointF anchor;
-  gfx::PointF position;
-  gfx::Size bounds(100, 100);
-  SetLayerPropertiesForTesting(root.get(),
-                               uninvertible_transform,
-                               anchor,
-                               position,
-                               bounds,
-                               true,
-                               false);
-  root->SetDrawsContent(true);
-
-  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);
-
-  // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, render_surface_layer_list.size());
-  ASSERT_EQ(1u, root->render_surface()->layer_list().size());
-  ASSERT_FALSE(root->screen_space_transform().IsInvertible());
-
-  // Hit testing any point should not hit the layer. If the invertible matrix is
-  // accidentally ignored and treated like an identity, then the hit testing
-  // will incorrectly hit the layer when it shouldn't.
-  gfx::Point test_point(1, 1);
-  LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(10, 10);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(10, 30);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(50, 50);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(67, 48);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(99, 99);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(-1, -1);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-}
-
-TEST_F(LayerTreeHostCommonTest, HitTestingForSinglePositionedLayer) {
-  FakeImplProxy proxy;
-  TestSharedBitmapManager shared_bitmap_manager;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-  scoped_ptr<LayerImpl> root =
-      LayerImpl::Create(host_impl.active_tree(), 12345);
-
-  gfx::Transform identity_matrix;
-  gfx::PointF anchor;
-  // this layer is positioned, and hit testing should correctly know where the
-  // layer is located.
-  gfx::PointF position(50.f, 50.f);
-  gfx::Size bounds(100, 100);
-  SetLayerPropertiesForTesting(root.get(),
-                               identity_matrix,
-                               anchor,
-                               position,
-                               bounds,
-                               true,
-                               false);
-  root->SetDrawsContent(true);
-
-  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);
-
-  // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, render_surface_layer_list.size());
-  ASSERT_EQ(1u, root->render_surface()->layer_list().size());
-
-  // Hit testing for a point outside the layer should return a null pointer.
-  gfx::Point test_point(49, 49);
-  LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  // Even though the layer exists at (101, 101), it should not be visible there
-  // since the root render surface would clamp it.
-  test_point = gfx::Point(101, 101);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  // Hit testing for a point inside should return the root layer.
-  test_point = gfx::Point(51, 51);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(12345, result_layer->id());
-
-  test_point = gfx::Point(99, 99);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(12345, result_layer->id());
-}
-
-TEST_F(LayerTreeHostCommonTest, HitTestingForSingleRotatedLayer) {
-  FakeImplProxy proxy;
-  TestSharedBitmapManager shared_bitmap_manager;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-  scoped_ptr<LayerImpl> root =
-      LayerImpl::Create(host_impl.active_tree(), 12345);
-
-  gfx::Transform identity_matrix;
-  gfx::Transform rotation45_degrees_about_center;
-  rotation45_degrees_about_center.Translate(50.0, 50.0);
-  rotation45_degrees_about_center.RotateAboutZAxis(45.0);
-  rotation45_degrees_about_center.Translate(-50.0, -50.0);
-  gfx::PointF anchor;
-  gfx::PointF position;
-  gfx::Size bounds(100, 100);
-  SetLayerPropertiesForTesting(root.get(),
-                               rotation45_degrees_about_center,
-                               anchor,
-                               position,
-                               bounds,
-                               true,
-                               false);
-  root->SetDrawsContent(true);
-
-  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);
-
-  // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, render_surface_layer_list.size());
-  ASSERT_EQ(1u, root->render_surface()->layer_list().size());
-
-  // Hit testing for points outside the layer.
-  // These corners would have been inside the un-transformed layer, but they
-  // should not hit the correctly transformed layer.
-  gfx::Point test_point(99, 99);
-  LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(1, 1);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  // Hit testing for a point inside should return the root layer.
-  test_point = gfx::Point(1, 50);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(12345, result_layer->id());
-
-  // Hit testing the corners that would overlap the unclipped layer, but are
-  // outside the clipped region.
-  test_point = gfx::Point(50, -1);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_FALSE(result_layer);
-
-  test_point = gfx::Point(-1, 50);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_FALSE(result_layer);
-}
-
-TEST_F(LayerTreeHostCommonTest, HitTestingForSinglePerspectiveLayer) {
-  FakeImplProxy proxy;
-  TestSharedBitmapManager shared_bitmap_manager;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-  scoped_ptr<LayerImpl> root =
-      LayerImpl::Create(host_impl.active_tree(), 12345);
-
-  gfx::Transform identity_matrix;
-
-  // perspective_projection_about_center * translation_by_z is designed so that
-  // the 100 x 100 layer becomes 50 x 50, and remains centered at (50, 50).
-  gfx::Transform perspective_projection_about_center;
-  perspective_projection_about_center.Translate(50.0, 50.0);
-  perspective_projection_about_center.ApplyPerspectiveDepth(1.0);
-  perspective_projection_about_center.Translate(-50.0, -50.0);
-  gfx::Transform translation_by_z;
-  translation_by_z.Translate3d(0.0, 0.0, -1.0);
-
-  gfx::PointF anchor;
-  gfx::PointF position;
-  gfx::Size bounds(100, 100);
-  SetLayerPropertiesForTesting(
-      root.get(),
-      perspective_projection_about_center * translation_by_z,
-      anchor,
-      position,
-      bounds,
-      true,
-      false);
-  root->SetDrawsContent(true);
-
-  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);
-
-  // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, render_surface_layer_list.size());
-  ASSERT_EQ(1u, root->render_surface()->layer_list().size());
-
-  // Hit testing for points outside the layer.
-  // These corners would have been inside the un-transformed layer, but they
-  // should not hit the correctly transformed layer.
-  gfx::Point test_point(24, 24);
-  LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(76, 76);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  // Hit testing for a point inside should return the root layer.
-  test_point = gfx::Point(26, 26);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(12345, result_layer->id());
-
-  test_point = gfx::Point(74, 74);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(12345, result_layer->id());
-}
-
-TEST_F(LayerTreeHostCommonTest, HitTestingForSingleLayerWithScaledContents) {
-  // A layer's visible content rect is actually in the layer's content space.
-  // The screen space transform converts from the layer's origin space to screen
-  // space. This test makes sure that hit testing works correctly accounts for
-  // the contents scale.  A contents scale that is not 1 effectively forces a
-  // non-identity transform between layer's content space and layer's origin
-  // space. The hit testing code must take this into account.
-  //
-  // To test this, the layer is positioned at (25, 25), and is size (50, 50). If
-  // contents scale is ignored, then hit testing will mis-interpret the visible
-  // content rect as being larger than the actual bounds of the layer.
-  //
-  FakeImplProxy proxy;
-  TestSharedBitmapManager shared_bitmap_manager;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-  scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
-
-  gfx::Transform identity_matrix;
-  gfx::PointF anchor;
-
-  SetLayerPropertiesForTesting(root.get(),
-                               identity_matrix,
-                               anchor,
-                               gfx::PointF(),
-                               gfx::Size(100, 100),
-                               true,
-                               false);
-  {
-    gfx::PointF position(25.f, 25.f);
-    gfx::Size bounds(50, 50);
-    scoped_ptr<LayerImpl> test_layer =
-        LayerImpl::Create(host_impl.active_tree(), 12345);
-    SetLayerPropertiesForTesting(test_layer.get(),
-                                 identity_matrix,
-                                 anchor,
-                                 position,
-                                 bounds,
-                                 true,
-                                 false);
-
-    // override content bounds and contents scale
-    test_layer->SetContentBounds(gfx::Size(100, 100));
-    test_layer->SetContentsScale(2, 2);
-
-    test_layer->SetDrawsContent(true);
-    root->AddChild(test_layer.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);
-
-  // Sanity check the scenario we just created.
-  // The visible content rect for test_layer is actually 100x100, even though
-  // its layout size is 50x50, positioned at 25x25.
-  LayerImpl* test_layer = root->children()[0];
-  EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100),
-                 test_layer->visible_content_rect());
-  ASSERT_EQ(1u, render_surface_layer_list.size());
-  ASSERT_EQ(1u, root->render_surface()->layer_list().size());
-
-  // Hit testing for a point outside the layer should return a null pointer (the
-  // root layer does not draw content, so it will not be hit tested either).
-  gfx::Point test_point(101, 101);
-  LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(24, 24);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(76, 76);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  // Hit testing for a point inside should return the test layer.
-  test_point = gfx::Point(26, 26);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(12345, result_layer->id());
-
-  test_point = gfx::Point(74, 74);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(12345, result_layer->id());
-}
-
-TEST_F(LayerTreeHostCommonTest, HitTestingForSimpleClippedLayer) {
-  // Test that hit-testing will only work for the visible portion of a layer,
-  // and not the entire layer bounds. Here we just test the simple axis-aligned
-  // case.
-  gfx::Transform identity_matrix;
-  gfx::PointF anchor;
-
-  FakeImplProxy proxy;
-  TestSharedBitmapManager shared_bitmap_manager;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-  scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
-  SetLayerPropertiesForTesting(root.get(),
-                               identity_matrix,
-                               anchor,
-                               gfx::PointF(),
-                               gfx::Size(100, 100),
-                               true,
-                               false);
-  {
-    scoped_ptr<LayerImpl> clipping_layer =
-        LayerImpl::Create(host_impl.active_tree(), 123);
-    // this layer is positioned, and hit testing should correctly know where the
-    // layer is located.
-    gfx::PointF position(25.f, 25.f);
-    gfx::Size bounds(50, 50);
-    SetLayerPropertiesForTesting(clipping_layer.get(),
-                                 identity_matrix,
-                                 anchor,
-                                 position,
-                                 bounds,
-                                 true,
-                                 false);
-    clipping_layer->SetMasksToBounds(true);
-
-    scoped_ptr<LayerImpl> child =
-        LayerImpl::Create(host_impl.active_tree(), 456);
-    position = gfx::PointF(-50.f, -50.f);
-    bounds = gfx::Size(300, 300);
-    SetLayerPropertiesForTesting(child.get(),
-                                 identity_matrix,
-                                 anchor,
-                                 position,
-                                 bounds,
-                                 true,
-                                 false);
-    child->SetDrawsContent(true);
-    clipping_layer->AddChild(child.Pass());
-    root->AddChild(clipping_layer.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);
-
-  // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, render_surface_layer_list.size());
-  ASSERT_EQ(1u, root->render_surface()->layer_list().size());
-  ASSERT_EQ(456, root->render_surface()->layer_list().at(0)->id());
-
-  // Hit testing for a point outside the layer should return a null pointer.
-  // Despite the child layer being very large, it should be clipped to the root
-  // layer's bounds.
-  gfx::Point test_point(24, 24);
-  LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  // Even though the layer exists at (101, 101), it should not be visible there
-  // since the clipping_layer would clamp it.
-  test_point = gfx::Point(76, 76);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  // Hit testing for a point inside should return the child layer.
-  test_point = gfx::Point(26, 26);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(456, result_layer->id());
-
-  test_point = gfx::Point(74, 74);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(456, result_layer->id());
-}
-
-TEST_F(LayerTreeHostCommonTest, HitTestingForMultiClippedRotatedLayer) {
-  // This test checks whether hit testing correctly avoids hit testing with
-  // multiple ancestors that clip in non axis-aligned ways. To pass this test,
-  // the hit testing algorithm needs to recognize that multiple parent layers
-  // may clip the layer, and should not actually hit those clipped areas.
-  //
-  // The child and grand_child layers are both initialized to clip the
-  // rotated_leaf. The child layer is rotated about the top-left corner, so that
-  // the root + child clips combined create a triangle. The rotated_leaf will
-  // only be visible where it overlaps this triangle.
-  //
-  FakeImplProxy proxy;
-  TestSharedBitmapManager shared_bitmap_manager;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-  scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 123);
-
-  gfx::Transform identity_matrix;
-  gfx::PointF anchor;
-  gfx::PointF position;
-  gfx::Size bounds(100, 100);
-  SetLayerPropertiesForTesting(root.get(),
-                               identity_matrix,
-                               anchor,
-                               position,
-                               bounds,
-                               true,
-                               false);
-  root->SetMasksToBounds(true);
-  {
-    scoped_ptr<LayerImpl> child =
-        LayerImpl::Create(host_impl.active_tree(), 456);
-    scoped_ptr<LayerImpl> grand_child =
-        LayerImpl::Create(host_impl.active_tree(), 789);
-    scoped_ptr<LayerImpl> rotated_leaf =
-        LayerImpl::Create(host_impl.active_tree(), 2468);
-
-    position = gfx::PointF(10.f, 10.f);
-    bounds = gfx::Size(80, 80);
-    SetLayerPropertiesForTesting(child.get(),
-                                 identity_matrix,
-                                 anchor,
-                                 position,
-                                 bounds,
-                                 true,
-                                 false);
-    child->SetMasksToBounds(true);
-
-    gfx::Transform rotation45_degrees_about_corner;
-    rotation45_degrees_about_corner.RotateAboutZAxis(45.0);
-
-    // remember, positioned with respect to its parent which is already at 10,
-    // 10
-    position = gfx::PointF();
-    bounds =
-        gfx::Size(200, 200);  // to ensure it covers at least sqrt(2) * 100.
-    SetLayerPropertiesForTesting(grand_child.get(),
-                                 rotation45_degrees_about_corner,
-                                 anchor,
-                                 position,
-                                 bounds,
-                                 true,
-                                 false);
-    grand_child->SetMasksToBounds(true);
-
-    // Rotates about the center of the layer
-    gfx::Transform rotated_leaf_transform;
-    rotated_leaf_transform.Translate(
-        -10.0, -10.0);  // cancel out the grand_parent's position
-    rotated_leaf_transform.RotateAboutZAxis(
-        -45.0);  // cancel out the corner 45-degree rotation of the parent.
-    rotated_leaf_transform.Translate(50.0, 50.0);
-    rotated_leaf_transform.RotateAboutZAxis(45.0);
-    rotated_leaf_transform.Translate(-50.0, -50.0);
-    position = gfx::PointF();
-    bounds = gfx::Size(100, 100);
-    SetLayerPropertiesForTesting(rotated_leaf.get(),
-                                 rotated_leaf_transform,
-                                 anchor,
-                                 position,
-                                 bounds,
-                                 true,
-                                 false);
-    rotated_leaf->SetDrawsContent(true);
-
-    grand_child->AddChild(rotated_leaf.Pass());
-    child->AddChild(grand_child.Pass());
-    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);
-
-  // Sanity check the scenario we just created.
-  // The grand_child is expected to create a render surface because it
-  // MasksToBounds and is not axis aligned.
-  ASSERT_EQ(2u, render_surface_layer_list.size());
-  ASSERT_EQ(
-      1u,
-      render_surface_layer_list.at(0)->render_surface()->layer_list().size());
-  ASSERT_EQ(789,
-            render_surface_layer_list.at(0)->render_surface()->layer_list().at(
-                0)->id());  // grand_child's surface.
-  ASSERT_EQ(
-      1u,
-      render_surface_layer_list.at(1)->render_surface()->layer_list().size());
-  ASSERT_EQ(
-      2468,
-      render_surface_layer_list[1]->render_surface()->layer_list().at(0)->id());
-
-  // (11, 89) is close to the the bottom left corner within the clip, but it is
-  // not inside the layer.
-  gfx::Point test_point(11, 89);
-  LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  // Closer inwards from the bottom left will overlap the layer.
-  test_point = gfx::Point(25, 75);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(2468, result_layer->id());
-
-  // (4, 50) is inside the unclipped layer, but that corner of the layer should
-  // be clipped away by the grandparent and should not get hit. If hit testing
-  // blindly uses visible content rect without considering how parent may clip
-  // the layer, then hit testing would accidentally think that the point
-  // successfully hits the layer.
-  test_point = gfx::Point(4, 50);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  // (11, 50) is inside the layer and within the clipped area.
-  test_point = gfx::Point(11, 50);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(2468, result_layer->id());
-
-  // Around the middle, just to the right and up, would have hit the layer
-  // except that that area should be clipped away by the parent.
-  test_point = gfx::Point(51, 49);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  // Around the middle, just to the left and down, should successfully hit the
-  // layer.
-  test_point = gfx::Point(49, 51);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(2468, result_layer->id());
-}
-
-TEST_F(LayerTreeHostCommonTest, HitTestingForNonClippingIntermediateLayer) {
-  // This test checks that hit testing code does not accidentally clip to layer
-  // bounds for a layer that actually does not clip.
-  gfx::Transform identity_matrix;
-  gfx::PointF anchor;
-
-  FakeImplProxy proxy;
-  TestSharedBitmapManager shared_bitmap_manager;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-  scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
-  SetLayerPropertiesForTesting(root.get(),
-                               identity_matrix,
-                               anchor,
-                               gfx::PointF(),
-                               gfx::Size(100, 100),
-                               true,
-                               false);
-  {
-    scoped_ptr<LayerImpl> intermediate_layer =
-        LayerImpl::Create(host_impl.active_tree(), 123);
-    // this layer is positioned, and hit testing should correctly know where the
-    // layer is located.
-    gfx::PointF position(10.f, 10.f);
-    gfx::Size bounds(50, 50);
-    SetLayerPropertiesForTesting(intermediate_layer.get(),
-                                 identity_matrix,
-                                 anchor,
-                                 position,
-                                 bounds,
-                                 true,
-                                 false);
-    // Sanity check the intermediate layer should not clip.
-    ASSERT_FALSE(intermediate_layer->masks_to_bounds());
-    ASSERT_FALSE(intermediate_layer->mask_layer());
-
-    // The child of the intermediate_layer is translated so that it does not
-    // overlap intermediate_layer at all.  If child is incorrectly clipped, we
-    // would not be able to hit it successfully.
-    scoped_ptr<LayerImpl> child =
-        LayerImpl::Create(host_impl.active_tree(), 456);
-    position = gfx::PointF(60.f, 60.f);  // 70, 70 in screen space
-    bounds = gfx::Size(20, 20);
-    SetLayerPropertiesForTesting(child.get(),
-                                 identity_matrix,
-                                 anchor,
-                                 position,
-                                 bounds,
-                                 true,
-                                 false);
-    child->SetDrawsContent(true);
-    intermediate_layer->AddChild(child.Pass());
-    root->AddChild(intermediate_layer.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);
-
-  // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, render_surface_layer_list.size());
-  ASSERT_EQ(1u, root->render_surface()->layer_list().size());
-  ASSERT_EQ(456, root->render_surface()->layer_list().at(0)->id());
-
-  // Hit testing for a point outside the layer should return a null pointer.
-  gfx::Point test_point(69, 69);
-  LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(91, 91);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  // Hit testing for a point inside should return the child layer.
-  test_point = gfx::Point(71, 71);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(456, result_layer->id());
-
-  test_point = gfx::Point(89, 89);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(456, result_layer->id());
-}
-
-TEST_F(LayerTreeHostCommonTest, HitTestingForMultipleLayers) {
-  FakeImplProxy proxy;
-  TestSharedBitmapManager shared_bitmap_manager;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-  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,
-                               anchor,
-                               position,
-                               bounds,
-                               true,
-                               false);
-  root->SetDrawsContent(true);
-  {
-    // child 1 and child2 are initialized to overlap between x=50 and x=60.
-    // grand_child is set to overlap both child1 and child2 between y=50 and
-    // y=60.  The expected stacking order is: (front) child2, (second)
-    // grand_child, (third) child1, and (back) the root layer behind all other
-    // layers.
-
-    scoped_ptr<LayerImpl> child1 =
-        LayerImpl::Create(host_impl.active_tree(), 2);
-    scoped_ptr<LayerImpl> child2 =
-        LayerImpl::Create(host_impl.active_tree(), 3);
-    scoped_ptr<LayerImpl> grand_child1 =
-        LayerImpl::Create(host_impl.active_tree(), 4);
-
-    position = gfx::PointF(10.f, 10.f);
-    bounds = gfx::Size(50, 50);
-    SetLayerPropertiesForTesting(child1.get(),
-                                 identity_matrix,
-                                 anchor,
-                                 position,
-                                 bounds,
-                                 true,
-                                 false);
-    child1->SetDrawsContent(true);
-
-    position = gfx::PointF(50.f, 10.f);
-    bounds = gfx::Size(50, 50);
-    SetLayerPropertiesForTesting(child2.get(),
-                                 identity_matrix,
-                                 anchor,
-                                 position,
-                                 bounds,
-                                 true,
-                                 false);
-    child2->SetDrawsContent(true);
-
-    // Remember that grand_child is positioned with respect to its parent (i.e.
-    // child1).  In screen space, the intended position is (10, 50), with size
-    // 100 x 50.
-    position = gfx::PointF(0.f, 40.f);
-    bounds = gfx::Size(100, 50);
-    SetLayerPropertiesForTesting(grand_child1.get(),
-                                 identity_matrix,
-                                 anchor,
-                                 position,
-                                 bounds,
-                                 true,
-                                 false);
-    grand_child1->SetDrawsContent(true);
-
-    child1->AddChild(grand_child1.Pass());
-    root->AddChild(child1.Pass());
-    root->AddChild(child2.Pass());
-  }
-
-  LayerImpl* child1 = root->children()[0];
-  LayerImpl* child2 = root->children()[1];
-  LayerImpl* grand_child1 = child1->children()[0];
-
-  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);
-
-  // Sanity check the scenario we just created.
-  ASSERT_TRUE(child1);
-  ASSERT_TRUE(child2);
-  ASSERT_TRUE(grand_child1);
-  ASSERT_EQ(1u, render_surface_layer_list.size());
-
-  RenderSurfaceImpl* root_render_surface = root->render_surface();
-  ASSERT_EQ(4u, root_render_surface->layer_list().size());
-  ASSERT_EQ(1, root_render_surface->layer_list().at(0)->id());  // root layer
-  ASSERT_EQ(2, root_render_surface->layer_list().at(1)->id());  // child1
-  ASSERT_EQ(4, root_render_surface->layer_list().at(2)->id());  // grand_child1
-  ASSERT_EQ(3, root_render_surface->layer_list().at(3)->id());  // child2
-
-  // Nothing overlaps the root_layer at (1, 1), so hit testing there should find
-  // the root layer.
-  gfx::Point test_point = gfx::Point(1, 1);
-  LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(1, result_layer->id());
-
-  // At (15, 15), child1 and root are the only layers. child1 is expected to be
-  // on top.
-  test_point = gfx::Point(15, 15);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(2, result_layer->id());
-
-  // At (51, 20), child1 and child2 overlap. child2 is expected to be on top.
-  test_point = gfx::Point(51, 20);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(3, result_layer->id());
-
-  // At (80, 51), child2 and grand_child1 overlap. child2 is expected to be on
-  // top.
-  test_point = gfx::Point(80, 51);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(3, result_layer->id());
-
-  // At (51, 51), all layers overlap each other. child2 is expected to be on top
-  // of all other layers.
-  test_point = gfx::Point(51, 51);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(3, result_layer->id());
-
-  // At (20, 51), child1 and grand_child1 overlap. grand_child1 is expected to
-  // be on top.
-  test_point = gfx::Point(20, 51);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(4, result_layer->id());
-}
-
-TEST_F(LayerTreeHostCommonTest, HitTestingForMultipleLayerLists) {
-  //
-  // The geometry is set up similarly to the previous case, but
-  // all layers are forced to be render surfaces now.
-  //
-  FakeImplProxy proxy;
-  TestSharedBitmapManager shared_bitmap_manager;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-  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,
-                               anchor,
-                               position,
-                               bounds,
-                               true,
-                               false);
-  root->SetDrawsContent(true);
-  {
-    // child 1 and child2 are initialized to overlap between x=50 and x=60.
-    // grand_child is set to overlap both child1 and child2 between y=50 and
-    // y=60.  The expected stacking order is: (front) child2, (second)
-    // grand_child, (third) child1, and (back) the root layer behind all other
-    // layers.
-
-    scoped_ptr<LayerImpl> child1 =
-        LayerImpl::Create(host_impl.active_tree(), 2);
-    scoped_ptr<LayerImpl> child2 =
-        LayerImpl::Create(host_impl.active_tree(), 3);
-    scoped_ptr<LayerImpl> grand_child1 =
-        LayerImpl::Create(host_impl.active_tree(), 4);
-
-    position = gfx::PointF(10.f, 10.f);
-    bounds = gfx::Size(50, 50);
-    SetLayerPropertiesForTesting(child1.get(),
-                                 identity_matrix,
-                                 anchor,
-                                 position,
-                                 bounds,
-                                 true,
-                                 false);
-    child1->SetDrawsContent(true);
-    child1->SetForceRenderSurface(true);
-
-    position = gfx::PointF(50.f, 10.f);
-    bounds = gfx::Size(50, 50);
-    SetLayerPropertiesForTesting(child2.get(),
-                                 identity_matrix,
-                                 anchor,
-                                 position,
-                                 bounds,
-                                 true,
-                                 false);
-    child2->SetDrawsContent(true);
-    child2->SetForceRenderSurface(true);
-
-    // Remember that grand_child is positioned with respect to its parent (i.e.
-    // child1).  In screen space, the intended position is (10, 50), with size
-    // 100 x 50.
-    position = gfx::PointF(0.f, 40.f);
-    bounds = gfx::Size(100, 50);
-    SetLayerPropertiesForTesting(grand_child1.get(),
-                                 identity_matrix,
-                                 anchor,
-                                 position,
-                                 bounds,
-                                 true,
-                                 false);
-    grand_child1->SetDrawsContent(true);
-    grand_child1->SetForceRenderSurface(true);
-
-    child1->AddChild(grand_child1.Pass());
-    root->AddChild(child1.Pass());
-    root->AddChild(child2.Pass());
-  }
-
-  LayerImpl* child1 = root->children()[0];
-  LayerImpl* child2 = root->children()[1];
-  LayerImpl* grand_child1 = child1->children()[0];
-
-  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);
-
-  // Sanity check the scenario we just created.
-  ASSERT_TRUE(child1);
-  ASSERT_TRUE(child2);
-  ASSERT_TRUE(grand_child1);
-  ASSERT_TRUE(child1->render_surface());
-  ASSERT_TRUE(child2->render_surface());
-  ASSERT_TRUE(grand_child1->render_surface());
-  ASSERT_EQ(4u, render_surface_layer_list.size());
-  // The root surface has the root layer, and child1's and child2's render
-  // surfaces.
-  ASSERT_EQ(3u, root->render_surface()->layer_list().size());
-  // The child1 surface has the child1 layer and grand_child1's render surface.
-  ASSERT_EQ(2u, child1->render_surface()->layer_list().size());
-  ASSERT_EQ(1u, child2->render_surface()->layer_list().size());
-  ASSERT_EQ(1u, grand_child1->render_surface()->layer_list().size());
-  ASSERT_EQ(1, render_surface_layer_list.at(0)->id());  // root layer
-  ASSERT_EQ(2, render_surface_layer_list[1]->id());  // child1
-  ASSERT_EQ(4, render_surface_layer_list.at(2)->id());  // grand_child1
-  ASSERT_EQ(3, render_surface_layer_list[3]->id());  // child2
-
-  // Nothing overlaps the root_layer at (1, 1), so hit testing there should find
-  // the root layer.
-  gfx::Point test_point = gfx::Point(1, 1);
-  LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(1, result_layer->id());
-
-  // At (15, 15), child1 and root are the only layers. child1 is expected to be
-  // on top.
-  test_point = gfx::Point(15, 15);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(2, result_layer->id());
-
-  // At (51, 20), child1 and child2 overlap. child2 is expected to be on top.
-  test_point = gfx::Point(51, 20);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(3, result_layer->id());
-
-  // At (80, 51), child2 and grand_child1 overlap. child2 is expected to be on
-  // top.
-  test_point = gfx::Point(80, 51);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(3, result_layer->id());
-
-  // At (51, 51), all layers overlap each other. child2 is expected to be on top
-  // of all other layers.
-  test_point = gfx::Point(51, 51);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(3, result_layer->id());
-
-  // At (20, 51), child1 and grand_child1 overlap. grand_child1 is expected to
-  // be on top.
-  test_point = gfx::Point(20, 51);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-      test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(4, result_layer->id());
-}
-
-TEST_F(LayerTreeHostCommonTest, HitTestingForEmptyLayers) {
-  FakeImplProxy proxy;
-  TestSharedBitmapManager shared_bitmap_manager;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-
-  // Layer 1 - root
-  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,
-                               anchor,
-                               position,
-                               bounds,
-                               true,
-                               false);
-  root->SetDrawsContent(true);
-
-  {
-    // Layer 2 - empty: drawsContent=false
-    gfx::PointF position(10.f, 10.f);
-    gfx::Size bounds(30, 30);
-    scoped_ptr<LayerImpl> empty_layer =
-        LayerImpl::Create(host_impl.active_tree(), 2);
-    SetLayerPropertiesForTesting(empty_layer.get(),
-                                 identity_matrix,
-                                 anchor,
-                                 position,
-                                 bounds,
-                                 true,
-                                 false);
-
-    empty_layer->SetDrawsContent(false);
-    root->AddChild(empty_layer.Pass());
-  }
-
-  {
-    // Layer 3 - empty, but has touch handler
-    gfx::PointF position(10.f, 60.f);
-    gfx::Size bounds(30, 30);
-    scoped_ptr<LayerImpl> test_layer =
-        LayerImpl::Create(host_impl.active_tree(), 3);
-    SetLayerPropertiesForTesting(test_layer.get(),
-                                 identity_matrix,
-                                 anchor,
-                                 position,
-                                 bounds,
-                                 true,
-                                 false);
-
-    test_layer->SetDrawsContent(false);
-    Region touch_handler_region(gfx::Rect(10, 10, 10, 10));
-    test_layer->SetTouchEventHandlerRegion(touch_handler_region);
-    root->AddChild(test_layer.Pass());
-  }
-
-  {
-    // Layer 4 - empty, but has mousewheel handler
-    gfx::PointF position(60.f, 60.f);
-    gfx::Size bounds(30, 30);
-    scoped_ptr<LayerImpl> test_layer =
-        LayerImpl::Create(host_impl.active_tree(), 4);
-    SetLayerPropertiesForTesting(test_layer.get(),
-                                 identity_matrix,
-                                 anchor,
-                                 position,
-                                 bounds,
-                                 true,
-                                 false);
-
-    test_layer->SetDrawsContent(false);
-    test_layer->SetHaveWheelEventHandlers(true);
-    root->AddChild(test_layer.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 empty layers with touch/wheel handlers
-  // (but not the empty layer without a touch handler) are in the RSSL.
-  ASSERT_EQ(1u, render_surface_layer_list.size());
-  EXPECT_EQ(1, render_surface_layer_list[0]->id());
-  ASSERT_EQ(3u, root->render_surface()->layer_list().size());
-  EXPECT_EQ(1, root->render_surface()->layer_list().at(0)->id());
-  EXPECT_EQ(3, root->render_surface()->layer_list().at(1)->id());
-  EXPECT_EQ(4, root->render_surface()->layer_list().at(2)->id());
-
-  // Hit testing for a point inside the empty no-handlers 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(1, result_layer->id());
-
-  // Hit testing for a point inside the touch handler layer should return it.
-  test_point = gfx::Point(15, 75);
-  result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-          test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  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,
-       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);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(10, 20);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-}
-
-TEST_F(LayerTreeHostCommonTest, HitCheckingTouchHandlerRegionsForSingleLayer) {
-  FakeImplProxy proxy;
-  TestSharedBitmapManager shared_bitmap_manager;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-  scoped_ptr<LayerImpl> root =
-      LayerImpl::Create(host_impl.active_tree(), 12345);
-
-  gfx::Transform identity_matrix;
-  Region touch_handler_region(gfx::Rect(10, 10, 50, 50));
-  gfx::PointF anchor;
-  gfx::PointF position;
-  gfx::Size bounds(100, 100);
-  SetLayerPropertiesForTesting(root.get(),
-                               identity_matrix,
-                               anchor,
-                               position,
-                               bounds,
-                               true,
-                               false);
-  root->SetDrawsContent(true);
-
-  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);
-
-  // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, render_surface_layer_list.size());
-  ASSERT_EQ(1u, root->render_surface()->layer_list().size());
-
-  // Hit checking for any point should return a null pointer for a layer without
-  // any touch event handler regions.
-  gfx::Point test_point(11, 11);
-  LayerImpl* result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  root->SetTouchEventHandlerRegion(touch_handler_region);
-  // Hit checking for a point outside the layer should return a null pointer.
-  test_point = gfx::Point(101, 101);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(-1, -1);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  // Hit checking for a point inside the layer, but outside the touch handler
-  // region should return a null pointer.
-  test_point = gfx::Point(1, 1);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(99, 99);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  // Hit checking for a point inside the touch event handler region should
-  // return the root layer.
-  test_point = gfx::Point(11, 11);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(12345, result_layer->id());
-
-  test_point = gfx::Point(59, 59);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(12345, result_layer->id());
-}
-
-TEST_F(LayerTreeHostCommonTest,
-     HitCheckingTouchHandlerRegionsForUninvertibleTransform) {
-  FakeImplProxy proxy;
-  TestSharedBitmapManager shared_bitmap_manager;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-  scoped_ptr<LayerImpl> root =
-      LayerImpl::Create(host_impl.active_tree(), 12345);
-
-  gfx::Transform uninvertible_transform;
-  uninvertible_transform.matrix().set(0, 0, 0.0);
-  uninvertible_transform.matrix().set(1, 1, 0.0);
-  uninvertible_transform.matrix().set(2, 2, 0.0);
-  uninvertible_transform.matrix().set(3, 3, 0.0);
-  ASSERT_FALSE(uninvertible_transform.IsInvertible());
-
-  gfx::Transform identity_matrix;
-  Region touch_handler_region(gfx::Rect(10, 10, 50, 50));
-  gfx::PointF anchor;
-  gfx::PointF position;
-  gfx::Size bounds(100, 100);
-  SetLayerPropertiesForTesting(root.get(),
-                               uninvertible_transform,
-                               anchor,
-                               position,
-                               bounds,
-                               true,
-                               false);
-  root->SetDrawsContent(true);
-  root->SetTouchEventHandlerRegion(touch_handler_region);
-
-  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);
-
-  // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, render_surface_layer_list.size());
-  ASSERT_EQ(1u, root->render_surface()->layer_list().size());
-  ASSERT_FALSE(root->screen_space_transform().IsInvertible());
-
-  // Hit checking any point should not hit the touch handler region on the
-  // layer. If the invertible matrix is accidentally ignored and treated like an
-  // identity, then the hit testing will incorrectly hit the layer when it
-  // shouldn't.
-  gfx::Point test_point(1, 1);
-  LayerImpl* result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(10, 10);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(10, 30);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(50, 50);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(67, 48);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(99, 99);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(-1, -1);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-}
-
-TEST_F(LayerTreeHostCommonTest,
-     HitCheckingTouchHandlerRegionsForSinglePositionedLayer) {
-  FakeImplProxy proxy;
-  TestSharedBitmapManager shared_bitmap_manager;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-  scoped_ptr<LayerImpl> root =
-      LayerImpl::Create(host_impl.active_tree(), 12345);
-
-  gfx::Transform identity_matrix;
-  Region touch_handler_region(gfx::Rect(10, 10, 50, 50));
-  gfx::PointF anchor;
-  // this layer is positioned, and hit testing should correctly know where the
-  // layer is located.
-  gfx::PointF position(50.f, 50.f);
-  gfx::Size bounds(100, 100);
-  SetLayerPropertiesForTesting(root.get(),
-                               identity_matrix,
-                               anchor,
-                               position,
-                               bounds,
-                               true,
-                               false);
-  root->SetDrawsContent(true);
-  root->SetTouchEventHandlerRegion(touch_handler_region);
-
-  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);
-
-  // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, render_surface_layer_list.size());
-  ASSERT_EQ(1u, root->render_surface()->layer_list().size());
-
-  // Hit checking for a point outside the layer should return a null pointer.
-  gfx::Point test_point(49, 49);
-  LayerImpl* result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  // Even though the layer has a touch handler region containing (101, 101), it
-  // should not be visible there since the root render surface would clamp it.
-  test_point = gfx::Point(101, 101);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  // Hit checking for a point inside the layer, but outside the touch handler
-  // region should return a null pointer.
-  test_point = gfx::Point(51, 51);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  // Hit checking for a point inside the touch event handler region should
-  // return the root layer.
-  test_point = gfx::Point(61, 61);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(12345, result_layer->id());
-
-  test_point = gfx::Point(99, 99);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(12345, result_layer->id());
-}
-
-TEST_F(LayerTreeHostCommonTest,
-     HitCheckingTouchHandlerRegionsForSingleLayerWithScaledContents) {
-  // A layer's visible content rect is actually in the layer's content space.
-  // The screen space transform converts from the layer's origin space to screen
-  // space. This test makes sure that hit testing works correctly accounts for
-  // the contents scale.  A contents scale that is not 1 effectively forces a
-  // non-identity transform between layer's content space and layer's origin
-  // space. The hit testing code must take this into account.
-  //
-  // To test this, the layer is positioned at (25, 25), and is size (50, 50). If
-  // contents scale is ignored, then hit checking will mis-interpret the visible
-  // content rect as being larger than the actual bounds of the layer.
-  //
-  FakeImplProxy proxy;
-  TestSharedBitmapManager shared_bitmap_manager;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-  scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
-
-  gfx::Transform identity_matrix;
-  gfx::PointF anchor;
-
-  SetLayerPropertiesForTesting(root.get(),
-                               identity_matrix,
-                               anchor,
-                               gfx::PointF(),
-                               gfx::Size(100, 100),
-                               true,
-                               false);
-  {
-    Region touch_handler_region(gfx::Rect(10, 10, 30, 30));
-    gfx::PointF position(25.f, 25.f);
-    gfx::Size bounds(50, 50);
-    scoped_ptr<LayerImpl> test_layer =
-        LayerImpl::Create(host_impl.active_tree(), 12345);
-    SetLayerPropertiesForTesting(test_layer.get(),
-                                 identity_matrix,
-                                 anchor,
-                                 position,
-                                 bounds,
-                                 true,
-                                 false);
-
-    // override content bounds and contents scale
-    test_layer->SetContentBounds(gfx::Size(100, 100));
-    test_layer->SetContentsScale(2, 2);
-
-    test_layer->SetDrawsContent(true);
-    test_layer->SetTouchEventHandlerRegion(touch_handler_region);
-    root->AddChild(test_layer.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);
-
-  // Sanity check the scenario we just created.
-  // The visible content rect for test_layer is actually 100x100, even though
-  // its layout size is 50x50, positioned at 25x25.
-  LayerImpl* test_layer = root->children()[0];
-  EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), test_layer->visible_content_rect());
-  ASSERT_EQ(1u, render_surface_layer_list.size());
-  ASSERT_EQ(1u, root->render_surface()->layer_list().size());
-
-  // Hit checking for a point outside the layer should return a null pointer
-  // (the root layer does not draw content, so it will not be tested either).
-  gfx::Point test_point(76, 76);
-  LayerImpl* result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  // Hit checking for a point inside the layer, but outside the touch handler
-  // region should return a null pointer.
-  test_point = gfx::Point(26, 26);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(34, 34);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(65, 65);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(74, 74);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  // Hit checking for a point inside the touch event handler region should
-  // return the root layer.
-  test_point = gfx::Point(35, 35);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(12345, result_layer->id());
-
-  test_point = gfx::Point(64, 64);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(12345, result_layer->id());
-}
-
-TEST_F(LayerTreeHostCommonTest,
-     HitCheckingTouchHandlerRegionsForSingleLayerWithDeviceScale) {
-  // The layer's device_scale_factor and page_scale_factor should scale the
-  // content rect and we should be able to hit the touch handler region by
-  // scaling the points accordingly.
-  FakeImplProxy proxy;
-  TestSharedBitmapManager shared_bitmap_manager;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-  scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
-
-  gfx::Transform identity_matrix;
-  gfx::PointF anchor;
-  // Set the bounds of the root layer big enough to fit the child when scaled.
-  SetLayerPropertiesForTesting(root.get(),
-                               identity_matrix,
-                               anchor,
-                               gfx::PointF(),
-                               gfx::Size(100, 100),
-                               true,
-                               false);
-  {
-    Region touch_handler_region(gfx::Rect(10, 10, 30, 30));
-    gfx::PointF position(25.f, 25.f);
-    gfx::Size bounds(50, 50);
-    scoped_ptr<LayerImpl> test_layer =
-        LayerImpl::Create(host_impl.active_tree(), 12345);
-    SetLayerPropertiesForTesting(test_layer.get(),
-                                 identity_matrix,
-                                 anchor,
-                                 position,
-                                 bounds,
-                                 true,
-                                 false);
-
-    test_layer->SetDrawsContent(true);
-    test_layer->SetTouchEventHandlerRegion(touch_handler_region);
-    root->AddChild(test_layer.Pass());
-  }
-
-  LayerImplList render_surface_layer_list;
-  float device_scale_factor = 3.f;
-  float page_scale_factor = 5.f;
-  gfx::Size scaled_bounds_for_root = gfx::ToCeiledSize(
-      gfx::ScaleSize(root->bounds(), device_scale_factor * page_scale_factor));
-
-  LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), scaled_bounds_for_root, &render_surface_layer_list);
-  inputs.device_scale_factor = device_scale_factor;
-  inputs.page_scale_factor = page_scale_factor;
-  inputs.page_scale_application_layer = root.get();
-  inputs.can_adjust_raster_scales = true;
-  LayerTreeHostCommon::CalculateDrawProperties(&inputs);
-
-  // Sanity check the scenario we just created.
-  // The visible content rect for test_layer is actually 100x100, even though
-  // its layout size is 50x50, positioned at 25x25.
-  LayerImpl* test_layer = root->children()[0];
-  ASSERT_EQ(1u, render_surface_layer_list.size());
-  ASSERT_EQ(1u, root->render_surface()->layer_list().size());
-
-  // Check whether the child layer fits into the root after scaled.
-  EXPECT_RECT_EQ(gfx::Rect(test_layer->content_bounds()),
-                 test_layer->visible_content_rect());
-
-  // Hit checking for a point outside the layer should return a null pointer
-  // (the root layer does not draw content, so it will not be tested either).
-  gfx::PointF test_point(76.f, 76.f);
-  test_point =
-      gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
-  LayerImpl* result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  // Hit checking for a point inside the layer, but outside the touch handler
-  // region should return a null pointer.
-  test_point = gfx::Point(26, 26);
-  test_point =
-      gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(34, 34);
-  test_point =
-      gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(65, 65);
-  test_point =
-      gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(74, 74);
-  test_point =
-      gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  // Hit checking for a point inside the touch event handler region should
-  // return the root layer.
-  test_point = gfx::Point(35, 35);
-  test_point =
-      gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(12345, result_layer->id());
-
-  test_point = gfx::Point(64, 64);
-  test_point =
-      gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(12345, result_layer->id());
-}
-
-TEST_F(LayerTreeHostCommonTest,
-     HitCheckingTouchHandlerRegionsForSimpleClippedLayer) {
-  // Test that hit-checking will only work for the visible portion of a layer,
-  // and not the entire layer bounds. Here we just test the simple axis-aligned
-  // case.
-  gfx::Transform identity_matrix;
-  gfx::PointF anchor;
-
-  FakeImplProxy proxy;
-  TestSharedBitmapManager shared_bitmap_manager;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-  scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
-  SetLayerPropertiesForTesting(root.get(),
-                               identity_matrix,
-                               anchor,
-                               gfx::PointF(),
-                               gfx::Size(100, 100),
-                               true,
-                               false);
-  {
-    scoped_ptr<LayerImpl> clipping_layer =
-        LayerImpl::Create(host_impl.active_tree(), 123);
-    // this layer is positioned, and hit testing should correctly know where the
-    // layer is located.
-    gfx::PointF position(25.f, 25.f);
-    gfx::Size bounds(50, 50);
-    SetLayerPropertiesForTesting(clipping_layer.get(),
-                                 identity_matrix,
-                                 anchor,
-                                 position,
-                                 bounds,
-                                 true,
-                                 false);
-    clipping_layer->SetMasksToBounds(true);
-
-    scoped_ptr<LayerImpl> child =
-        LayerImpl::Create(host_impl.active_tree(), 456);
-    Region touch_handler_region(gfx::Rect(10, 10, 50, 50));
-    position = gfx::PointF(-50.f, -50.f);
-    bounds = gfx::Size(300, 300);
-    SetLayerPropertiesForTesting(child.get(),
-                                 identity_matrix,
-                                 anchor,
-                                 position,
-                                 bounds,
-                                 true,
-                                 false);
-    child->SetDrawsContent(true);
-    child->SetTouchEventHandlerRegion(touch_handler_region);
-    clipping_layer->AddChild(child.Pass());
-    root->AddChild(clipping_layer.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);
-
-  // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, render_surface_layer_list.size());
-  ASSERT_EQ(1u, root->render_surface()->layer_list().size());
-  ASSERT_EQ(456, root->render_surface()->layer_list().at(0)->id());
-
-  // Hit checking for a point outside the layer should return a null pointer.
-  // Despite the child layer being very large, it should be clipped to the root
-  // layer's bounds.
-  gfx::Point test_point(24, 24);
-  LayerImpl* result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  // Hit checking for a point inside the layer, but outside the touch handler
-  // region should return a null pointer.
-  test_point = gfx::Point(35, 35);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  test_point = gfx::Point(74, 74);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-
-  // Hit checking for a point inside the touch event handler region should
-  // return the root layer.
-  test_point = gfx::Point(25, 25);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(456, result_layer->id());
-
-  test_point = gfx::Point(34, 34);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(456, result_layer->id());
-}
-
-TEST_F(LayerTreeHostCommonTest,
-       HitCheckingTouchHandlerOverlappingRegions) {
-  gfx::Transform identity_matrix;
-  gfx::PointF anchor;
-
-  FakeImplProxy proxy;
-  TestSharedBitmapManager shared_bitmap_manager;
-  FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
-  scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
-  SetLayerPropertiesForTesting(root.get(),
-                               identity_matrix,
-                               anchor,
-                               gfx::PointF(),
-                               gfx::Size(100, 100),
-                               true,
-                               false);
-  {
-    scoped_ptr<LayerImpl> touch_layer =
-        LayerImpl::Create(host_impl.active_tree(), 123);
-    // this layer is positioned, and hit testing should correctly know where the
-    // layer is located.
-    gfx::PointF position;
-    gfx::Size bounds(50, 50);
-    SetLayerPropertiesForTesting(touch_layer.get(),
-                                 identity_matrix,
-                                 anchor,
-                                 position,
-                                 bounds,
-                                 true,
-                                 false);
-    touch_layer->SetDrawsContent(true);
-    touch_layer->SetTouchEventHandlerRegion(gfx::Rect(0, 0, 50, 50));
-    root->AddChild(touch_layer.Pass());
-  }
-
-  {
-    scoped_ptr<LayerImpl> notouch_layer =
-        LayerImpl::Create(host_impl.active_tree(), 1234);
-    // this layer is positioned, and hit testing should correctly know where the
-    // layer is located.
-    gfx::PointF position(0, 25);
-    gfx::Size bounds(50, 50);
-    SetLayerPropertiesForTesting(notouch_layer.get(),
-                                 identity_matrix,
-                                 anchor,
-                                 position,
-                                 bounds,
-                                 true,
-                                 false);
-    notouch_layer->SetDrawsContent(true);
-    root->AddChild(notouch_layer.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);
-
-  // Sanity check the scenario we just created.
-  ASSERT_EQ(1u, render_surface_layer_list.size());
-  ASSERT_EQ(2u, root->render_surface()->layer_list().size());
-  ASSERT_EQ(123, root->render_surface()->layer_list().at(0)->id());
-  ASSERT_EQ(1234, root->render_surface()->layer_list().at(1)->id());
-
-  gfx::Point test_point(35, 35);
-  LayerImpl* result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-
-  // We should have passed through the no-touch layer and found the layer
-  // behind it.
-  EXPECT_TRUE(result_layer);
-
-  host_impl.active_tree()->LayerById(1234)->SetContentsOpaque(true);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-
-  // Even with an opaque layer in the middle, we should still find the layer
-  // with
-  // the touch handler behind it (since we can't assume that opaque layers are
-  // opaque to hit testing).
-  EXPECT_TRUE(result_layer);
-
-  test_point = gfx::Point(35, 15);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  ASSERT_TRUE(result_layer);
-  EXPECT_EQ(123, result_layer->id());
-
-  test_point = gfx::Point(35, 65);
-  result_layer =
-      LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-          test_point, render_surface_layer_list);
-  EXPECT_FALSE(result_layer);
-}
-
 class NoScaleContentLayer : public ContentLayer {
  public:
   static scoped_refptr<NoScaleContentLayer> Create(ContentLayerClient* client) {
     return make_scoped_refptr(new NoScaleContentLayer(client));
   }
 
   virtual void CalculateContentsScale(float ideal_contents_scale,
                                       float device_scale_factor,
                                       float page_scale_factor,
                                       float maximum_animation_contents_scale,
@@ skipping 4298 matching lines @@
   expected.insert(child_raw);
   expected.insert(grand_child1_raw);
   expected.insert(grand_child2_raw);
 
   actual.clear();
   GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
   EXPECT_EQ(expected, actual);
 }
 }  // namespace
 }  // namespace cc