cc: Remove implicit conversions from Rect to RectF in src/cc/.

cc/trees/layer_tree_host_unittest_damage.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/layer_tree_host.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/time/time.h"
@@ skipping 37 matching lines @@
     }
   }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_EQ(DRAW_SUCCESS, draw_result);
 
     RenderSurfaceImpl* root_surface =
         impl->active_tree()->root_layer()->render_surface();
-    gfx::RectF root_damage =
+    gfx::Rect root_damage =
         root_surface->damage_tracker()->current_damage_rect();
 
     switch (draw_count_) {
       case 0:
         // The first frame has full damage.
-        EXPECT_EQ(gfx::RectF(10.f, 10.f).ToString(), root_damage.ToString());
+        EXPECT_EQ(gfx::Rect(10, 10), root_damage);
         break;
       case 1:
         // The second frame has full damage.
-        EXPECT_EQ(gfx::RectF(10.f, 10.f).ToString(), root_damage.ToString());
+        EXPECT_EQ(gfx::Rect(10, 10), root_damage);
         EndTest();
         break;
       case 2:
         NOTREACHED();
     }
 
     ++draw_count_;
     return draw_result;
   }
 
@@ skipping 31 matching lines @@
     }
   }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_EQ(DRAW_SUCCESS, draw_result);
 
     RenderSurfaceImpl* root_surface =
         impl->active_tree()->root_layer()->render_surface();
-    gfx::RectF root_damage =
+    gfx::Rect root_damage =
         root_surface->damage_tracker()->current_damage_rect();
 
     switch (draw_count_) {
       case 0:
         // The first frame has full damage.
-        EXPECT_EQ(gfx::RectF(10.f, 10.f).ToString(), root_damage.ToString());
+        EXPECT_EQ(gfx::Rect(10, 10), root_damage);
         break;
       case 1:
         // The second frame has full damage.
-        EXPECT_EQ(gfx::RectF(15.f, 15.f).ToString(), root_damage.ToString());
+        EXPECT_EQ(gfx::Rect(15, 15), root_damage);
         EndTest();
         break;
       case 2:
         NOTREACHED();
     }
 
     ++draw_count_;
     return draw_result;
   }
 
@@ skipping 112 matching lines @@
     LayerTreeHostDamageTest::SetupTree();
   }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_EQ(DRAW_SUCCESS, draw_result);
 
     RenderSurfaceImpl* root_surface =
         host_impl->active_tree()->root_layer()->render_surface();
-    gfx::RectF root_damage =
+    gfx::Rect root_damage =
         root_surface->damage_tracker()->current_damage_rect();
     root_damage.Intersect(root_surface->content_rect());
 
     int source_frame = host_impl->active_tree()->source_frame_number();
     switch (source_frame) {
       case 0:
         // The first frame draws and clears any damage.
-        EXPECT_EQ(gfx::RectF(root_surface->content_rect()).ToString(),
-                  root_damage.ToString());
+        EXPECT_EQ(root_surface->content_rect(), root_damage);
         EXPECT_FALSE(frame_data->has_no_damage);
         break;
       case 1:
         // If we get a frame without damage then we don't draw.
-        EXPECT_EQ(gfx::RectF().ToString(), root_damage.ToString());
+        EXPECT_EQ(gfx::Rect(), root_damage);
         EXPECT_TRUE(frame_data->has_no_damage);
 
         // Then we set full damage for the next frame.
         host_impl->SetFullRootLayerDamage();
         break;
       case 2:
         // The whole frame should be damaged as requested.
-        EXPECT_EQ(gfx::RectF(root_surface->content_rect()).ToString(),
-                  root_damage.ToString());
+        EXPECT_EQ(root_surface->content_rect(), root_damage);
         EXPECT_FALSE(frame_data->has_no_damage);
 
         // Just a part of the next frame should be damaged.
         child_damage_rect_ = gfx::Rect(10, 11, 12, 13);
         break;
       case 3:
         // The update rect in the child should be damaged and the damaged area
         // should match the invalidation.
-        EXPECT_EQ(gfx::RectF(100+10, 100+11, 12, 13).ToString(),
-                  root_damage.ToString());
+        EXPECT_EQ(gfx::Rect(100 + 10, 100 + 11, 12, 13), root_damage);
         EXPECT_FALSE(frame_data->has_no_damage);
 
         // If we damage part of the frame, but also damage the full
         // frame, then the whole frame should be damaged.
         child_damage_rect_ = gfx::Rect(10, 11, 12, 13);
         host_impl->SetFullRootLayerDamage();
         break;
       case 4:
         // The whole frame is damaged.
-        EXPECT_EQ(gfx::RectF(root_surface->content_rect()).ToString(),
-                  root_damage.ToString());
+        EXPECT_EQ(root_surface->content_rect(), root_damage);
         EXPECT_FALSE(frame_data->has_no_damage);
 
         EndTest();
         break;
     }
     return draw_result;
   }
 
   void DidCommitAndDrawFrame() override {
     if (!TestEnded())
@@ skipping 62 matching lines @@
     did_swaps_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_EQ(DRAW_SUCCESS, draw_result);
     RenderSurfaceImpl* root_surface =
         host_impl->active_tree()->root_layer()->render_surface();
-    gfx::RectF root_damage =
+    gfx::Rect root_damage =
         root_surface->damage_tracker()->current_damage_rect();
     root_damage.Intersect(root_surface->content_rect());
     switch (did_swaps_) {
       case 0:
         // The first frame has damage, so we should draw and swap.
         break;
       case 1:
         // The second frame should not damage the scrollbars.
         EXPECT_FALSE(root_damage.Intersects(gfx::Rect(300, 300, 10, 100)));
         break;
@@ skipping 70 matching lines @@
     did_swaps_ = 0;
     PostSetNeedsCommitToMainThread();
   }
 
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
     EXPECT_EQ(DRAW_SUCCESS, draw_result);
     RenderSurfaceImpl* root_surface =
         host_impl->active_tree()->root_layer()->render_surface();
-    gfx::RectF root_damage =
+    gfx::Rect root_damage =
         root_surface->damage_tracker()->current_damage_rect();
     root_damage.Intersect(root_surface->content_rect());
     int frame = host_impl->active_tree()->source_frame_number();
     switch (did_swaps_) {
       case 0:
         // The first frame has damage, so we should draw and swap.
         EXPECT_EQ(0, frame);
         break;
       case 1:
         // The second frame has scrolled, so the scrollbar should be damaged.
@@ skipping 41 matching lines @@
 
   void AfterTest() override { EXPECT_EQ(3, did_swaps_); }
 
   int did_swaps_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostDamageTestScrollbarCommitDoesNoDamage);
 
 }  // namespace
 }  // namespace cc