gfx: Make conversions from gfx::Point to PointF explicit.

cc/trees/layer_tree_impl_unittest.cc

 // Copyright 2014 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_impl.h"
 
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/solid_color_scrollbar_layer_impl.h"
 #include "cc/test/fake_impl_proxy.h"
@@ skipping 49 matching lines @@
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
 
   // Hit testing for a point outside the layer should return a null pointer.
-  gfx::Point test_point(101, 101);
+  gfx::PointF test_point(101.f, 101.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
-  test_point = gfx::Point(-1, -1);
+  test_point = gfx::PointF(-1.f, -1.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
   // Hit testing for a point inside should return the root layer.
-  test_point = gfx::Point(1, 1);
+  test_point = gfx::PointF(1.f, 1.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 
-  test_point = gfx::Point(99, 99);
+  test_point = gfx::PointF(99.f, 99.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 }
 
 TEST_F(LayerTreeImplTest, UpdateViewportAndHitTest) {
   // Ensures that the viewport rect is correctly updated by the clip tree.
   TestSharedBitmapManager shared_bitmap_manager;
   TestTaskGraphRunner task_graph_runner;
@@ skipping 20 matching lines @@
   host_impl->active_tree()->SetRootLayer(root.Pass());
   host_impl->UpdateNumChildrenAndDrawPropertiesForActiveTree();
   EXPECT_EQ(
       gfx::RectF(gfx::SizeF(bounds)),
       host_impl->active_tree()->property_trees()->clip_tree.ViewportClip());
   EXPECT_EQ(gfx::Rect(bounds),
             host_impl->RootLayer()->visible_rect_from_property_trees());
 
   gfx::Size new_bounds(50, 50);
   host_impl->SetViewportSize(new_bounds);
-  gfx::Point test_point(51, 51);
+  gfx::PointF test_point(51.f, 51.f);
   host_impl->active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_EQ(
       gfx::RectF(gfx::SizeF(new_bounds)),
       host_impl->active_tree()->property_trees()->clip_tree.ViewportClip());
   EXPECT_EQ(gfx::Rect(new_bounds),
             host_impl->RootLayer()->visible_rect_from_property_trees());
 }
 
 TEST_F(LayerTreeImplTest, HitTestingForSingleLayerAndHud) {
   scoped_ptr<LayerImpl> root =
@@ skipping 20 matching lines @@
 
   host_impl().SetViewportSize(hud_bounds);
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(2u, root_layer()->render_surface()->layer_list().size());
 
   // Hit testing for a point inside HUD, but outside root should return null
-  gfx::Point test_point(101, 101);
+  gfx::PointF test_point(101.f, 101.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
-  test_point = gfx::Point(-1, -1);
+  test_point = gfx::PointF(-1.f, -1.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   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);
+  test_point = gfx::PointF(1.f, 1.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 
-  test_point = gfx::Point(99, 99);
+  test_point = gfx::PointF(99.f, 99.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 }
 
 TEST_F(LayerTreeImplTest, HitTestingForUninvertibleTransform) {
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl().active_tree(), 12345);
 
@@ skipping 17 matching lines @@
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
   ASSERT_FALSE(root_layer()->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);
+  gfx::PointF test_point(1.f, 1.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
-  test_point = gfx::Point(10, 10);
+  test_point = gfx::PointF(10.f, 10.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
-  test_point = gfx::Point(10, 30);
+  test_point = gfx::PointF(10.f, 30.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
-  test_point = gfx::Point(50, 50);
+  test_point = gfx::PointF(50.f, 50.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
-  test_point = gfx::Point(67, 48);
+  test_point = gfx::PointF(67.f, 48.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
-  test_point = gfx::Point(99, 99);
+  test_point = gfx::PointF(99.f, 99.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
-  test_point = gfx::Point(-1, -1);
+  test_point = gfx::PointF(-1.f, -1.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 }
 
 TEST_F(LayerTreeImplTest, HitTestingForSinglePositionedLayer) {
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl().active_tree(), 12345);
 
   gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
   // 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, transform_origin,
                                position, bounds, true, false, true);
   root->SetDrawsContent(true);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
 
   // Hit testing for a point outside the layer should return a null pointer.
-  gfx::Point test_point(49, 49);
+  gfx::PointF test_point(49.f, 49.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   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);
+  test_point = gfx::PointF(101.f, 101.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
   // Hit testing for a point inside should return the root layer.
-  test_point = gfx::Point(51, 51);
+  test_point = gfx::PointF(51.f, 51.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 
-  test_point = gfx::Point(99, 99);
+  test_point = gfx::PointF(99.f, 99.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 }
 
 TEST_F(LayerTreeImplTest, HitTestingForSingleRotatedLayer) {
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl().active_tree(), 12345);
 
@@ skipping 14 matching lines @@
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->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);
+  gfx::PointF test_point(99.f, 99.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
-  test_point = gfx::Point(1, 1);
+  test_point = gfx::PointF(1.f, 1.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
   // Hit testing for a point inside should return the root layer.
-  test_point = gfx::Point(1, 50);
+  test_point = gfx::PointF(1.f, 50.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   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);
+  test_point = gfx::PointF(50.f, -1.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_FALSE(result_layer);
 
-  test_point = gfx::Point(-1, 50);
+  test_point = gfx::PointF(-1.f, 50.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_FALSE(result_layer);
 }
 
 TEST_F(LayerTreeImplTest, HitTestingForSinglePerspectiveLayer) {
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl().active_tree(), 12345);
 
   gfx::Transform identity_matrix;
@@ skipping 19 matching lines @@
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->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);
+  gfx::PointF test_point(24.f, 24.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
-  test_point = gfx::Point(76, 76);
+  test_point = gfx::PointF(76.f, 76.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
   // Hit testing for a point inside should return the root layer.
-  test_point = gfx::Point(26, 26);
+  test_point = gfx::PointF(26.f, 26.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 
-  test_point = gfx::Point(74, 74);
+  test_point = gfx::PointF(74.f, 74.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 }
 
 TEST_F(LayerTreeImplTest, 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.
@@ skipping 32 matching lines @@
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
   ASSERT_EQ(456, root_layer()->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);
+  gfx::PointF test_point(24.f, 24.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   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);
+  test_point = gfx::PointF(76.f, 76.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
   // Hit testing for a point inside should return the child layer.
-  test_point = gfx::Point(26, 26);
+  test_point = gfx::PointF(26.f, 26.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(456, result_layer->id());
 
-  test_point = gfx::Point(74, 74);
+  test_point = gfx::PointF(74.f, 74.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(456, result_layer->id());
 }
 
 TEST_F(LayerTreeImplTest, 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
@@ skipping 61 matching lines @@
     child->AddChild(grand_child.Pass());
     root->AddChild(child.Pass());
   }
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // (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);
+  gfx::PointF test_point(11.f, 89.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
   // Closer inwards from the bottom left will overlap the layer.
-  test_point = gfx::Point(25, 75);
+  test_point = gfx::PointF(25.f, 75.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   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);
+  test_point = gfx::PointF(4.f, 50.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
   // (11, 50) is inside the layer and within the clipped area.
-  test_point = gfx::Point(11, 50);
+  test_point = gfx::PointF(11.f, 50.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   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);
+  test_point = gfx::PointF(51.f, 49.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
   // Around the middle, just to the left and down, should successfully hit the
   // layer.
-  test_point = gfx::Point(49, 51);
+  test_point = gfx::PointF(49.f, 51.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(2468, result_layer->id());
 }
 
 TEST_F(LayerTreeImplTest, 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;
@@ skipping 34 matching lines @@
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
   ASSERT_EQ(456, root_layer()->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);
+  gfx::PointF test_point(69.f, 69.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
-  test_point = gfx::Point(91, 91);
+  test_point = gfx::PointF(91.f, 91.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   EXPECT_FALSE(result_layer);
 
   // Hit testing for a point inside should return the child layer.
-  test_point = gfx::Point(71, 71);
+  test_point = gfx::PointF(71.f, 71.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(456, result_layer->id());
 
-  test_point = gfx::Point(89, 89);
+  test_point = gfx::PointF(89.f, 89.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(456, result_layer->id());
 }
 
 TEST_F(LayerTreeImplTest, HitTestingForMultipleLayers) {
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
 
   gfx::Transform identity_matrix;
@@ skipping 62 matching lines @@
 
   RenderSurfaceImpl* root_render_surface = root_layer()->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);
+  gfx::PointF test_point = gfx::PointF(1.f, 1.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   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);
+  test_point = gfx::PointF(15.f, 15.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   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);
+  test_point = gfx::PointF(51.f, 20.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   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);
+  test_point = gfx::PointF(80.f, 51.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   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);
+  test_point = gfx::PointF(51.f, 51.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   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);
+  test_point = gfx::PointF(20.f, 51.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(4, result_layer->id());
 }
 
 TEST_F(LayerTreeImplTest, HitTestingForMultipleLayersAtVaryingDepths) {
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
 
   gfx::Transform identity_matrix;
@@ skipping 63 matching lines @@
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_TRUE(child1);
   ASSERT_TRUE(child2);
   ASSERT_TRUE(grand_child1);
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
 
   // 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);
+  gfx::PointF test_point = gfx::PointF(1.f, 1.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   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);
+  test_point = gfx::PointF(15.f, 15.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(2, result_layer->id());
 
   // At (51, 20), child1 and child2 overlap. child2 is expected to be on top.
   // (because 3 is transformed to the back).
-  test_point = gfx::Point(51, 20);
+  test_point = gfx::PointF(51.f, 20.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(2, result_layer->id());
 
   // 3 Would have been on top if it hadn't been transformed to the background.
   // Make sure that it isn't hit.
-  test_point = gfx::Point(80, 51);
+  test_point = gfx::PointF(80.f, 51.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(4, result_layer->id());
 
   // 3 Would have been on top if it hadn't been transformed to the background.
   // Make sure that it isn't hit.
-  test_point = gfx::Point(51, 51);
+  test_point = gfx::PointF(51.f, 51.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(4, 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);
+  test_point = gfx::PointF(20.f, 51.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(4, result_layer->id());
 }
 
 TEST_F(LayerTreeImplTest, HitTestingRespectsClipParents) {
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
   gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
@@ skipping 27 matching lines @@
     grand_child->SetClipParent(root.get());
 
     child->AddChild(grand_child.Pass());
     root->AddChild(child.Pass());
   }
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
-  gfx::Point test_point = gfx::Point(12, 52);
+  gfx::PointF test_point(12.f, 52.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(4, result_layer->id());
 }
 
 TEST_F(LayerTreeImplTest, HitTestingRespectsScrollParents) {
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
   gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
@@ skipping 39 matching lines @@
 
     scroll_child->AddChild(grand_child.Pass());
     root->AddChild(scroll_child.Pass());
     root->AddChild(child.Pass());
   }
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
-  gfx::Point test_point = gfx::Point(12, 52);
+  gfx::PointF test_point(12.f, 52.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   // The |test_point| should have been clipped away by |child|, the scroll
   // parent, so the only thing that should be hit is |root|.
   ASSERT_TRUE(result_layer);
   ASSERT_EQ(1, result_layer->id());
 }
 TEST_F(LayerTreeImplTest, HitTestingForMultipleLayerLists) {
   //
   // The geometry is set up similarly to the previous case, but
@@ skipping 77 matching lines @@
   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, RenderSurfaceLayerList().at(0)->id());  // root layer
   ASSERT_EQ(2, RenderSurfaceLayerList()[1]->id());     // child1
   ASSERT_EQ(4, RenderSurfaceLayerList().at(2)->id());  // grand_child1
   ASSERT_EQ(3, RenderSurfaceLayerList()[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);
+  gfx::PointF test_point(1.f, 1.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   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);
+  test_point = gfx::PointF(15.f, 15.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   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);
+  test_point = gfx::PointF(51.f, 20.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   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);
+  test_point = gfx::PointF(80.f, 51.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   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);
+  test_point = gfx::PointF(51.f, 51.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   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);
+  test_point = gfx::PointF(20.f, 51.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPoint(test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(4, result_layer->id());
 }
 
 TEST_F(LayerTreeImplTest, HitCheckingTouchHandlerRegionsForSingleLayer) {
   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::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(), identity_matrix, transform_origin,
                                position, bounds, true, false, true);
   root->SetDrawsContent(true);
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->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);
+  gfx::PointF test_point(11.f, 11.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   EXPECT_FALSE(result_layer);
 
   host_impl().active_tree()->root_layer()->SetTouchEventHandlerRegion(
       touch_handler_region);
   // Hit checking for a point outside the layer should return a null pointer.
-  test_point = gfx::Point(101, 101);
+  test_point = gfx::PointF(101.f, 101.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   EXPECT_FALSE(result_layer);
 
-  test_point = gfx::Point(-1, -1);
+  test_point = gfx::PointF(-1.f, -1.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   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);
+  test_point = gfx::PointF(1.f, 1.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   EXPECT_FALSE(result_layer);
 
-  test_point = gfx::Point(99, 99);
+  test_point = gfx::PointF(99.f, 99.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   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);
+  test_point = gfx::PointF(11.f, 11.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 
-  test_point = gfx::Point(59, 59);
+  test_point = gfx::PointF(59.f, 59.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 }
 
 TEST_F(LayerTreeImplTest,
        HitCheckingTouchHandlerRegionsForUninvertibleTransform) {
   scoped_ptr<LayerImpl> root =
@@ skipping 23 matching lines @@
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
   ASSERT_FALSE(root_layer()->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);
+  gfx::PointF test_point(1.f, 1.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   EXPECT_FALSE(result_layer);
 
-  test_point = gfx::Point(10, 10);
+  test_point = gfx::PointF(10.f, 10.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   EXPECT_FALSE(result_layer);
 
-  test_point = gfx::Point(10, 30);
+  test_point = gfx::PointF(10.f, 30.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   EXPECT_FALSE(result_layer);
 
-  test_point = gfx::Point(50, 50);
+  test_point = gfx::PointF(50.f, 50.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   EXPECT_FALSE(result_layer);
 
-  test_point = gfx::Point(67, 48);
+  test_point = gfx::PointF(67.f, 48.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   EXPECT_FALSE(result_layer);
 
-  test_point = gfx::Point(99, 99);
+  test_point = gfx::PointF(99.f, 99.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   EXPECT_FALSE(result_layer);
 
-  test_point = gfx::Point(-1, -1);
+  test_point = gfx::PointF(-1.f, -1.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   EXPECT_FALSE(result_layer);
 }
 
 TEST_F(LayerTreeImplTest, MakeScrollbarsInvisibleNearMinPageScale) {
   const int kThumbThickness = 10;
   const int kTrackStart = 0;
   const bool kIsLeftSideVerticalScrollbar = false;
@@ skipping 80 matching lines @@
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
 
   // Hit checking for a point outside the layer should return a null pointer.
-  gfx::Point test_point(49, 49);
+  gfx::PointF test_point(49.f, 49.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   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);
+  test_point = gfx::PointF(101.f, 101.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   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);
+  test_point = gfx::PointF(51.f, 51.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   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);
+  test_point = gfx::PointF(61.f, 61.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 
-  test_point = gfx::Point(99, 99);
+  test_point = gfx::PointF(99.f, 99.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 }
 
 TEST_F(LayerTreeImplTest,
        HitCheckingTouchHandlerRegionsForSingleLayerWithDeviceScale) {
   // The layer's device_scale_factor and page_scale_factor should scale the
@@ skipping 53 matching lines @@
   gfx::PointF test_point(76.f, 76.f);
   test_point =
       gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   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::PointF(26.f, 26.f);
   test_point =
       gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   EXPECT_FALSE(result_layer);
 
-  test_point = gfx::Point(34, 34);
+  test_point = gfx::PointF(34.f, 34.f);
   test_point =
       gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   EXPECT_FALSE(result_layer);
 
-  test_point = gfx::Point(65, 65);
+  test_point = gfx::PointF(65.f, 65.f);
   test_point =
       gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   EXPECT_FALSE(result_layer);
 
-  test_point = gfx::Point(74, 74);
+  test_point = gfx::PointF(74.f, 74.f);
   test_point =
       gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   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::PointF(35.f, 35.f);
   test_point =
       gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 
-  test_point = gfx::Point(64, 64);
+  test_point = gfx::PointF(64.f, 64.f);
   test_point =
       gfx::ScalePoint(test_point, device_scale_factor * page_scale_factor);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(12345, result_layer->id());
 }
 
 TEST_F(LayerTreeImplTest, HitCheckingTouchHandlerRegionsForSimpleClippedLayer) {
@@ skipping 37 matching lines @@
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
   ASSERT_EQ(456, root_layer()->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);
+  gfx::PointF test_point(24.f, 24.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   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);
+  test_point = gfx::PointF(35.f, 35.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   EXPECT_FALSE(result_layer);
 
-  test_point = gfx::Point(74, 74);
+  test_point = gfx::PointF(74.f, 74.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   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);
+  test_point = gfx::PointF(25.f, 25.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(456, result_layer->id());
 
-  test_point = gfx::Point(34, 34);
+  test_point = gfx::PointF(34.f, 34.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(456, result_layer->id());
 }
 
 TEST_F(LayerTreeImplTest, HitCheckingTouchHandlerOverlappingRegions) {
   gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
@@ skipping 34 matching lines @@
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(2u, root_layer()->render_surface()->layer_list().size());
   ASSERT_EQ(123, root_layer()->render_surface()->layer_list().at(0)->id());
   ASSERT_EQ(1234, root_layer()->render_surface()->layer_list().at(1)->id());
 
-  gfx::Point test_point(35, 35);
+  gfx::PointF test_point(35.f, 35.f);
   LayerImpl* result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
 
   // 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 =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
 
   // 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);
+  test_point = gfx::PointF(35.f, 15.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(123, result_layer->id());
 
-  test_point = gfx::Point(35, 65);
+  test_point = gfx::PointF(35.f, 65.f);
   result_layer =
       host_impl().active_tree()->FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point);
   EXPECT_FALSE(result_layer);
 }
 
 TEST_F(LayerTreeImplTest, SelectionBoundsForSingleLayer) {
   int root_layer_id = 12345;
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl().active_tree(), root_layer_id);
@@ skipping 10 matching lines @@
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
   ASSERT_EQ(1u, root_layer()->render_surface()->layer_list().size());
 
   LayerSelection input;
 
   input.start.type = SELECTION_BOUND_LEFT;
-  input.start.edge_top = gfx::PointF(10, 10);
-  input.start.edge_bottom = gfx::PointF(10, 20);
+  input.start.edge_top = gfx::Point(10, 10);
+  input.start.edge_bottom = gfx::Point(10, 20);
   input.start.layer_id = root_layer_id;
 
   input.end.type = SELECTION_BOUND_RIGHT;
-  input.end.edge_top = gfx::PointF(50, 10);
-  input.end.edge_bottom = gfx::PointF(50, 30);
+  input.end.edge_top = gfx::Point(50, 10);
+  input.end.edge_bottom = gfx::Point(50, 30);
   input.end.layer_id = root_layer_id;
 
   ViewportSelection output;
 
   // Empty input bounds should produce empty output bounds.
   host_impl().active_tree()->GetViewportSelection(&output);
   EXPECT_EQ(ViewportSelectionBound(), output.start);
   EXPECT_EQ(ViewportSelectionBound(), output.end);
 
   // Selection bounds should produce distinct left and right bounds.
   host_impl().active_tree()->RegisterSelection(input);
   host_impl().active_tree()->GetViewportSelection(&output);
   EXPECT_EQ(input.start.type, output.start.type);
-  EXPECT_EQ(input.start.edge_bottom, output.start.edge_bottom);
-  EXPECT_EQ(input.start.edge_top, output.start.edge_top);
+  EXPECT_EQ(gfx::PointF(input.start.edge_bottom), output.start.edge_bottom);
+  EXPECT_EQ(gfx::PointF(input.start.edge_top), output.start.edge_top);
   EXPECT_TRUE(output.start.visible);
   EXPECT_EQ(input.end.type, output.end.type);
-  EXPECT_EQ(input.end.edge_bottom, output.end.edge_bottom);
-  EXPECT_EQ(input.end.edge_top, output.end.edge_top);
+  EXPECT_EQ(gfx::PointF(input.end.edge_bottom), output.end.edge_bottom);
+  EXPECT_EQ(gfx::PointF(input.end.edge_top), output.end.edge_top);
   EXPECT_TRUE(output.end.visible);
   EXPECT_EQ(input.is_editable, output.is_editable);
   EXPECT_EQ(input.is_empty_text_form_control,
             output.is_empty_text_form_control);
 
   // Insertion bounds should produce identical left and right bounds.
   LayerSelection insertion_input;
   insertion_input.start.type = SELECTION_BOUND_CENTER;
-  insertion_input.start.edge_top = gfx::PointF(15, 10);
-  insertion_input.start.edge_bottom = gfx::PointF(15, 30);
+  insertion_input.start.edge_top = gfx::Point(15, 10);
+  insertion_input.start.edge_bottom = gfx::Point(15, 30);
   insertion_input.start.layer_id = root_layer_id;
   insertion_input.is_editable = true;
   insertion_input.is_empty_text_form_control = true;
   insertion_input.end = insertion_input.start;
   host_impl().active_tree()->RegisterSelection(insertion_input);
   host_impl().active_tree()->GetViewportSelection(&output);
   EXPECT_EQ(insertion_input.start.type, output.start.type);
-  EXPECT_EQ(insertion_input.start.edge_bottom, output.start.edge_bottom);
-  EXPECT_EQ(insertion_input.start.edge_top, output.start.edge_top);
+  EXPECT_EQ(gfx::PointF(insertion_input.start.edge_bottom),
+            output.start.edge_bottom);
+  EXPECT_EQ(gfx::PointF(insertion_input.start.edge_top), output.start.edge_top);
   EXPECT_EQ(insertion_input.is_editable, output.is_editable);
   EXPECT_EQ(insertion_input.is_empty_text_form_control,
             output.is_empty_text_form_control);
   EXPECT_TRUE(output.start.visible);
   EXPECT_EQ(output.start, output.end);
 }
 
 TEST_F(LayerTreeImplTest, SelectionBoundsForPartialOccludedLayers) {
   int root_layer_id = 12345;
   int clip_layer_id = 1234;
@@ skipping 35 matching lines @@
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
 
   LayerSelection input;
   input.start.type = SELECTION_BOUND_LEFT;
-  input.start.edge_top = gfx::PointF(25, 10);
-  input.start.edge_bottom = gfx::PointF(25, 30);
+  input.start.edge_top = gfx::Point(25, 10);
+  input.start.edge_bottom = gfx::Point(25, 30);
   input.start.layer_id = clipped_layer_id;
 
   input.end.type = SELECTION_BOUND_RIGHT;
-  input.end.edge_top = gfx::PointF(75, 10);
-  input.end.edge_bottom = gfx::PointF(75, 30);
+  input.end.edge_top = gfx::Point(75, 10);
+  input.end.edge_bottom = gfx::Point(75, 30);
   input.end.layer_id = clipped_layer_id;
   host_impl().active_tree()->RegisterSelection(input);
 
   // The left bound should be occluded by the clip layer.
   ViewportSelection output;
   host_impl().active_tree()->GetViewportSelection(&output);
   EXPECT_EQ(input.start.type, output.start.type);
-  gfx::PointF expected_output_start_top = input.start.edge_top;
-  gfx::PointF expected_output_edge_botom = input.start.edge_bottom;
+  auto expected_output_start_top = gfx::PointF(input.start.edge_top);
+  auto expected_output_edge_botom = gfx::PointF(input.start.edge_bottom);
   expected_output_start_top.Offset(clipping_offset.x(), clipping_offset.y());
   expected_output_edge_botom.Offset(clipping_offset.x(), clipping_offset.y());
   EXPECT_EQ(expected_output_start_top, output.start.edge_top);
   EXPECT_EQ(expected_output_edge_botom, output.start.edge_bottom);
   EXPECT_TRUE(output.start.visible);
   EXPECT_EQ(input.end.type, output.end.type);
-  gfx::PointF expected_output_end_top = input.end.edge_top;
-  gfx::PointF expected_output_end_bottom = input.end.edge_bottom;
+  auto expected_output_end_top = gfx::PointF(input.end.edge_top);
+  auto expected_output_end_bottom = gfx::PointF(input.end.edge_bottom);
   expected_output_end_bottom.Offset(clipping_offset.x(), clipping_offset.y());
   expected_output_end_top.Offset(clipping_offset.x(), clipping_offset.y());
   EXPECT_EQ(expected_output_end_top, output.end.edge_top);
   EXPECT_EQ(expected_output_end_bottom, output.end.edge_bottom);
   EXPECT_FALSE(output.end.visible);
 
   // Handles outside the viewport bounds should be marked invisible.
-  input.start.edge_top = gfx::PointF(-25, 0);
-  input.start.edge_bottom = gfx::PointF(-25, 20);
+  input.start.edge_top = gfx::Point(-25, 0);
+  input.start.edge_bottom = gfx::Point(-25, 20);
   host_impl().active_tree()->RegisterSelection(input);
   host_impl().active_tree()->GetViewportSelection(&output);
   EXPECT_FALSE(output.start.visible);
 
-  input.start.edge_top = gfx::PointF(0, -25);
-  input.start.edge_bottom = gfx::PointF(0, -5);
+  input.start.edge_top = gfx::Point(0, -25);
+  input.start.edge_bottom = gfx::Point(0, -5);
   host_impl().active_tree()->RegisterSelection(input);
   host_impl().active_tree()->GetViewportSelection(&output);
   EXPECT_FALSE(output.start.visible);
 
   // If the handle bottom is partially visible, the handle is marked visible.
-  input.start.edge_top = gfx::PointF(0, -20);
-  input.start.edge_bottom = gfx::PointF(0, 1);
+  input.start.edge_top = gfx::Point(0, -20);
+  input.start.edge_bottom = gfx::Point(0, 1);
   host_impl().active_tree()->RegisterSelection(input);
   host_impl().active_tree()->GetViewportSelection(&output);
   EXPECT_TRUE(output.start.visible);
 }
 
 TEST_F(LayerTreeImplTest, SelectionBoundsForScaledLayers) {
   int root_layer_id = 1;
   int sub_layer_id = 2;
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl().active_tree(), root_layer_id);
@@ skipping 32 matching lines @@
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().active_tree()->SetViewportLayersFromIds(Layer::INVALID_ID, 1, 1,
                                                       Layer::INVALID_ID);
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   // Sanity check the scenario we just created.
   ASSERT_EQ(1u, RenderSurfaceLayerList().size());
 
   LayerSelection input;
   input.start.type = SELECTION_BOUND_LEFT;
-  input.start.edge_top = gfx::PointF(10, 10);
-  input.start.edge_bottom = gfx::PointF(10, 30);
+  input.start.edge_top = gfx::Point(10, 10);
+  input.start.edge_bottom = gfx::Point(10, 30);
   input.start.layer_id = root_layer_id;
 
   input.end.type = SELECTION_BOUND_RIGHT;
-  input.end.edge_top = gfx::PointF(0, 0);
-  input.end.edge_bottom = gfx::PointF(0, 20);
+  input.end.edge_top = gfx::Point(0, 0);
+  input.end.edge_bottom = gfx::Point(0, 20);
   input.end.layer_id = sub_layer_id;
   host_impl().active_tree()->RegisterSelection(input);
 
   // The viewport bounds should be properly scaled by the page scale, but should
   // remain in DIP coordinates.
   ViewportSelection output;
   host_impl().active_tree()->GetViewportSelection(&output);
   EXPECT_EQ(input.start.type, output.start.type);
-  gfx::PointF expected_output_start_top = input.start.edge_top;
-  gfx::PointF expected_output_edge_bottom = input.start.edge_bottom;
+  auto expected_output_start_top = gfx::PointF(input.start.edge_top);
+  auto expected_output_edge_bottom = gfx::PointF(input.start.edge_bottom);
   expected_output_start_top.Scale(page_scale_factor);
   expected_output_edge_bottom.Scale(page_scale_factor);
   EXPECT_EQ(expected_output_start_top, output.start.edge_top);
   EXPECT_EQ(expected_output_edge_bottom, output.start.edge_bottom);
   EXPECT_TRUE(output.start.visible);
   EXPECT_EQ(input.end.type, output.end.type);
 
-  gfx::PointF expected_output_end_top = input.end.edge_top;
-  gfx::PointF expected_output_end_bottom = input.end.edge_bottom;
+  auto expected_output_end_top = gfx::PointF(input.end.edge_top);
+  auto expected_output_end_bottom = gfx::PointF(input.end.edge_bottom);
   expected_output_end_top.Offset(sub_layer_offset.x(), sub_layer_offset.y());
   expected_output_end_bottom.Offset(sub_layer_offset.x(), sub_layer_offset.y());
   expected_output_end_top.Scale(page_scale_factor);
   expected_output_end_bottom.Scale(page_scale_factor);
   EXPECT_EQ(expected_output_end_top, output.end.edge_top);
   EXPECT_EQ(expected_output_end_bottom, output.end.edge_bottom);
   EXPECT_TRUE(output.end.visible);
 }
 
 TEST_F(LayerTreeImplTest, SelectionBoundsWithLargeTransforms) {
@@ skipping 32 matching lines @@
     root->AddChild(child.Pass());
   }
 
   host_impl().SetViewportSize(root->bounds());
   host_impl().active_tree()->SetRootLayer(root.Pass());
   host_impl().UpdateNumChildrenAndDrawPropertiesForActiveTree();
 
   LayerSelection input;
 
   input.start.type = SELECTION_BOUND_LEFT;
-  input.start.edge_top = gfx::PointF(10, 10);
-  input.start.edge_bottom = gfx::PointF(10, 20);
+  input.start.edge_top = gfx::Point(10, 10);
+  input.start.edge_bottom = gfx::Point(10, 20);
   input.start.layer_id = grand_child_id;
 
   input.end.type = SELECTION_BOUND_RIGHT;
-  input.end.edge_top = gfx::PointF(50, 10);
-  input.end.edge_bottom = gfx::PointF(50, 30);
+  input.end.edge_top = gfx::Point(50, 10);
+  input.end.edge_bottom = gfx::Point(50, 30);
   input.end.layer_id = grand_child_id;
 
   host_impl().active_tree()->RegisterSelection(input);
 
   ViewportSelection output;
   host_impl().active_tree()->GetViewportSelection(&output);
 
   // edge_bottom and edge_top aren't allowed to have NaNs, so the selection
   // should be empty.
   EXPECT_EQ(ViewportSelectionBound(), output.start);
@@ skipping 10 matching lines @@
   EXPECT_EQ(0u, host_impl().active_tree()->NumLayers());
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl().active_tree(), 1);
   root->AddChild(LayerImpl::Create(host_impl().active_tree(), 2));
   root->AddChild(LayerImpl::Create(host_impl().active_tree(), 3));
   root->child_at(1)->AddChild(LayerImpl::Create(host_impl().active_tree(), 4));
   EXPECT_EQ(4u, host_impl().active_tree()->NumLayers());
 }
 
 }  // namespace
 }  // namespace cc