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

cc/trees/occlusion_tracker_unittest.cc

 // Copyright 2012 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/occlusion_tracker.h"
 
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
@@ skipping 357 matching lines @@
  protected:
   explicit OcclusionTrackerTestRotatedChild(bool opaque_layers)
       : OcclusionTrackerTest(opaque_layers) {}
   void RunMyTest() override {
     gfx::Transform layer_transform;
     layer_transform.Translate(250.0, 250.0);
     layer_transform.Rotate(90.0);
     layer_transform.Translate(-250.0, -250.0);
 
     TestContentLayerImpl* root = this->CreateRoot(
-        this->identity_matrix, gfx::Point(0, 0), gfx::Size(200, 200));
+        this->identity_matrix, gfx::PointF(), gfx::Size(200, 200));
     TestContentLayerImpl* parent = this->CreateDrawingLayer(
         root, this->identity_matrix, gfx::PointF(), gfx::Size(100, 100), true);
     TestContentLayerImpl* layer = this->CreateDrawingLayer(
         parent, layer_transform, gfx::PointF(30.f, 30.f), gfx::Size(500, 500),
         true);
     parent->SetMasksToBounds(true);
     this->CalcDrawEtc(root);
 
     TestOcclusionTrackerWithClip occlusion(gfx::Rect(0, 0, 1000, 1000));
 
@@ skipping 1080 matching lines @@
           break;
         case TOP:
           occlusion_rect = gfx::Rect(0, 0, 200, 50);
           break;
         case BOTTOM:
           occlusion_rect = gfx::Rect(0, 100, 200, 50);
           break;
       }
 
       LayerImpl* occluding_layer = this->CreateDrawingLayer(
-          parent, this->identity_matrix, occlusion_rect.origin(),
+          parent, this->identity_matrix, gfx::PointF(occlusion_rect.origin()),
           occlusion_rect.size(), true);
       this->CalcDrawEtc(parent);
 
       TestOcclusionTrackerWithClip occlusion(gfx::Rect(0, 0, 200, 200));
 
       // This layer occludes pixels directly beside the filtered_surface.
       // Because filtered surface blends pixels in a radius, it will need to see
       // some of the pixels (up to radius far) underneath the occluding layers.
       this->VisitLayer(occluding_layer, &occlusion);
 
@@ skipping 508 matching lines @@
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestScaledLayerInSurfaceIsClipped)
 
 class OcclusionTrackerTestCopyRequestDoesOcclude : public OcclusionTrackerTest {
  protected:
   explicit OcclusionTrackerTestCopyRequestDoesOcclude(bool opaque_layers)
       : OcclusionTrackerTest(opaque_layers) {}
   void RunMyTest() override {
     TestContentLayerImpl* root = this->CreateRoot(
-        this->identity_matrix, gfx::Point(), gfx::Size(400, 400));
+        this->identity_matrix, gfx::PointF(), gfx::Size(400, 400));
     TestContentLayerImpl* parent = this->CreateDrawingLayer(
-        root, this->identity_matrix, gfx::Point(), gfx::Size(400, 400), true);
-    LayerImpl* copy = this->CreateLayer(
-        parent, this->identity_matrix, gfx::Point(100, 0), gfx::Size(200, 400));
+        root, this->identity_matrix, gfx::PointF(), gfx::Size(400, 400), true);
+    LayerImpl* copy =
+        this->CreateLayer(parent, this->identity_matrix, gfx::PointF(100, 0),
+                          gfx::Size(200, 400));
     this->AddCopyRequest(copy);
     LayerImpl* copy_child = this->CreateDrawingLayer(
         copy, this->identity_matrix, gfx::PointF(), gfx::Size(200, 400), true);
     LayerImpl* top_layer =
         this->CreateDrawingLayer(root, this->identity_matrix,
                                  gfx::PointF(50, 0), gfx::Size(50, 400), true);
     this->CalcDrawEtc(root);
 
     TestOcclusionTrackerWithClip occlusion(gfx::Rect(0, 0, 1000, 1000));
 
@@ skipping 24 matching lines @@
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestCopyRequestDoesOcclude)
 
 class OcclusionTrackerTestHiddenCopyRequestDoesNotOcclude
     : public OcclusionTrackerTest {
  protected:
   explicit OcclusionTrackerTestHiddenCopyRequestDoesNotOcclude(
       bool opaque_layers)
       : OcclusionTrackerTest(opaque_layers) {}
   void RunMyTest() override {
     TestContentLayerImpl* root = this->CreateRoot(
-        this->identity_matrix, gfx::Point(), gfx::Size(400, 400));
+        this->identity_matrix, gfx::PointF(), gfx::Size(400, 400));
     TestContentLayerImpl* parent = this->CreateDrawingLayer(
-        root, this->identity_matrix, gfx::Point(), gfx::Size(400, 400), true);
+        root, this->identity_matrix, gfx::PointF(), gfx::Size(400, 400), true);
     LayerImpl* hide = this->CreateLayer(parent, this->identity_matrix,
-                                        gfx::Point(), gfx::Size());
-    LayerImpl* copy = this->CreateLayer(
-        hide, this->identity_matrix, gfx::Point(100, 0), gfx::Size(200, 400));
+                                        gfx::PointF(), gfx::Size());
+    LayerImpl* copy =
+        this->CreateLayer(hide, this->identity_matrix, gfx::PointF(100.f, 0.f),
+                          gfx::Size(200, 400));
     this->AddCopyRequest(copy);
     LayerImpl* copy_child = this->CreateDrawingLayer(
         copy, this->identity_matrix, gfx::PointF(), gfx::Size(200, 400), true);
 
     // The |copy| layer is hidden but since it is being copied, it will be
     // drawn.
     hide->SetHideLayerAndSubtree(true);
 
     this->CalcDrawEtc(root);
 
@@ skipping 19 matching lines @@
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestHiddenCopyRequestDoesNotOcclude)
 
 class OcclusionTrackerTestOccludedLayer : public OcclusionTrackerTest {
  protected:
   explicit OcclusionTrackerTestOccludedLayer(bool opaque_layers)
       : OcclusionTrackerTest(opaque_layers) {}
   void RunMyTest() override {
     gfx::Transform translate;
     translate.Translate(10.0, 20.0);
     TestContentLayerImpl* root = this->CreateRoot(
-        this->identity_matrix, gfx::Point(), gfx::Size(200, 200));
-    LayerImpl* surface = this->CreateSurface(root, this->identity_matrix,
-                                             gfx::Point(), gfx::Size(200, 200));
+        this->identity_matrix, gfx::PointF(), gfx::Size(200, 200));
+    LayerImpl* surface = this->CreateSurface(
+        root, this->identity_matrix, gfx::PointF(), gfx::Size(200, 200));
     LayerImpl* layer = this->CreateDrawingLayer(
-        surface, translate, gfx::Point(), gfx::Size(200, 200), false);
+        surface, translate, gfx::PointF(), gfx::Size(200, 200), false);
     TestContentLayerImpl* outside_layer = this->CreateDrawingLayer(
-        root, this->identity_matrix, gfx::Point(), gfx::Size(200, 200), false);
+        root, this->identity_matrix, gfx::PointF(), gfx::Size(200, 200), false);
     this->CalcDrawEtc(root);
 
     TestOcclusionTrackerWithClip occlusion(gfx::Rect(0, 0, 200, 200));
     this->VisitLayer(outside_layer, &occlusion);
     this->EnterLayer(layer, &occlusion);
 
     // No occlusion, is not occluded.
     occlusion.set_occlusion_from_outside_target(SimpleEnclosedRegion());
     occlusion.set_occlusion_from_inside_target(SimpleEnclosedRegion());
     EXPECT_FALSE(occlusion.OccludedLayer(layer, gfx::Rect(100, 100)));
@@ skipping 61 matching lines @@
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestOccludedLayer)
 
 class OcclusionTrackerTestUnoccludedLayerQuery : public OcclusionTrackerTest {
  protected:
   explicit OcclusionTrackerTestUnoccludedLayerQuery(bool opaque_layers)
       : OcclusionTrackerTest(opaque_layers) {}
   void RunMyTest() override {
     gfx::Transform translate;
     translate.Translate(10.0, 20.0);
     TestContentLayerImpl* root = this->CreateRoot(
-        this->identity_matrix, gfx::Point(), gfx::Size(200, 200));
-    LayerImpl* surface = this->CreateSurface(root, this->identity_matrix,
-                                             gfx::Point(), gfx::Size(200, 200));
+        this->identity_matrix, gfx::PointF(), gfx::Size(200, 200));
+    LayerImpl* surface = this->CreateSurface(
+        root, this->identity_matrix, gfx::PointF(), gfx::Size(200, 200));
     LayerImpl* layer = this->CreateDrawingLayer(
-        surface, translate, gfx::Point(), gfx::Size(200, 200), false);
+        surface, translate, gfx::PointF(), gfx::Size(200, 200), false);
     TestContentLayerImpl* outside_layer = this->CreateDrawingLayer(
-        root, this->identity_matrix, gfx::Point(), gfx::Size(200, 200), false);
+        root, this->identity_matrix, gfx::PointF(), gfx::Size(200, 200), false);
     this->CalcDrawEtc(root);
 
     TestOcclusionTrackerWithClip occlusion(gfx::Rect(0, 0, 200, 200));
     this->VisitLayer(outside_layer, &occlusion);
     this->EnterLayer(layer, &occlusion);
 
     // No occlusion, is not occluded.
     occlusion.set_occlusion_from_outside_target(SimpleEnclosedRegion());
     occlusion.set_occlusion_from_inside_target(SimpleEnclosedRegion());
     EXPECT_EQ(gfx::Rect(100, 100),
@@ skipping 136 matching lines @@
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestUnoccludedLayerQuery)
 
 class OcclusionTrackerTestUnoccludedSurfaceQuery : public OcclusionTrackerTest {
  protected:
   explicit OcclusionTrackerTestUnoccludedSurfaceQuery(bool opaque_layers)
       : OcclusionTrackerTest(opaque_layers) {}
   void RunMyTest() override {
     gfx::Transform translate;
     translate.Translate(10.0, 20.0);
     TestContentLayerImpl* root = this->CreateRoot(
-        this->identity_matrix, gfx::Point(), gfx::Size(200, 200));
-    LayerImpl* surface =
-        this->CreateSurface(root, translate, gfx::Point(), gfx::Size(200, 200));
+        this->identity_matrix, gfx::PointF(), gfx::Size(200, 200));
+    LayerImpl* surface = this->CreateSurface(root, translate, gfx::PointF(),
+                                             gfx::Size(200, 200));
     LayerImpl* layer =
-        this->CreateDrawingLayer(surface, this->identity_matrix, gfx::Point(),
+        this->CreateDrawingLayer(surface, this->identity_matrix, gfx::PointF(),
                                  gfx::Size(200, 200), false);
     TestContentLayerImpl* outside_layer = this->CreateDrawingLayer(
-        root, this->identity_matrix, gfx::Point(), gfx::Size(200, 200), false);
+        root, this->identity_matrix, gfx::PointF(), gfx::Size(200, 200), false);
     this->CalcDrawEtc(root);
 
     TestOcclusionTrackerWithClip occlusion(gfx::Rect(0, 0, 200, 200));
     this->VisitLayer(outside_layer, &occlusion);
     this->VisitLayer(layer, &occlusion);
     this->EnterContributingSurface(surface, &occlusion);
 
     // No occlusion, is not occluded.
     occlusion.set_occlusion_on_contributing_surface_from_outside_target(
         SimpleEnclosedRegion());
@@ skipping 136 matching lines @@
     EXPECT_EQ(gfx::Rect(),
               occlusion.UnoccludedSurfaceContentRect(
                   surface, gfx::Rect(80, 70, 50, 50)));
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestUnoccludedSurfaceQuery)
 
 }  // namespace
 }  // namespace cc