cc: Stop converting update rect from int to float to int.

cc/trees/damage_tracker_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/damage_tracker.h"
 
 #include "cc/base/math_util.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/output/filter_operation.h"
 #include "cc/output/filter_operations.h"
@@ skipping 211 matching lines @@
   EXPECT_EQ(gfx::Rect(500, 500).ToString(), root_damage_rect.ToString());
 }
 
 TEST_F(DamageTrackerTest, VerifyDamageForUpdateRects) {
   scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface();
   LayerImpl* child = root->children()[0];
 
   // CASE 1: Setting the update rect should cause the corresponding damage to
   //         the surface.
   ClearDamageForAllSurfaces(root.get());
-  child->SetUpdateRect(gfx::RectF(10.f, 11.f, 12.f, 13.f));
+  child->SetUpdateRect(gfx::Rect(10, 11, 12, 13));
   EmulateDrawingOneFrame(root.get());
 
   // Damage position on the surface should be: position of update_rect (10, 11)
   // relative to the child (100, 100).
   gfx::Rect root_damage_rect =
       root->render_surface()->damage_tracker()->current_damage_rect();
   EXPECT_EQ(gfx::Rect(110, 111, 12, 13).ToString(),
             root_damage_rect.ToString());
 
   // CASE 2: The same update rect twice in a row still produces the same
   //         damage.
   ClearDamageForAllSurfaces(root.get());
-  child->SetUpdateRect(gfx::RectF(10.f, 11.f, 12.f, 13.f));
+  child->SetUpdateRect(gfx::Rect(10, 11, 12, 13));
   EmulateDrawingOneFrame(root.get());
   root_damage_rect =
           root->render_surface()->damage_tracker()->current_damage_rect();
   EXPECT_EQ(gfx::Rect(110, 111, 12, 13).ToString(),
             root_damage_rect.ToString());
 
   // CASE 3: Setting a different update rect should cause damage on the new
   //         update region, but no additional exposed old region.
   ClearDamageForAllSurfaces(root.get());
-  child->SetUpdateRect(gfx::RectF(20.f, 25.f, 1.f, 2.f));
+  child->SetUpdateRect(gfx::Rect(20, 25, 1, 2));
   EmulateDrawingOneFrame(root.get());
 
   // Damage position on the surface should be: position of update_rect (20, 25)
   // relative to the child (100, 100).
   root_damage_rect =
           root->render_surface()->damage_tracker()->current_damage_rect();
   EXPECT_EQ(gfx::Rect(120, 125, 1, 2).ToString(), root_damage_rect.ToString());
 }
 
 TEST_F(DamageTrackerTest, VerifyDamageForLayerDamageRects) {
@@ skipping 49 matching lines @@
 }
 
 TEST_F(DamageTrackerTest, VerifyDamageForLayerUpdateAndDamageRects) {
   scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface();
   LayerImpl* child = root->children()[0];
 
   // CASE 1: Adding the layer damage rect and update rect should cause the
   // corresponding damage to the surface.
   ClearDamageForAllSurfaces(root.get());
   child->AddDamageRect(gfx::RectF(5.f, 6.f, 12.f, 13.f));
-  child->SetUpdateRect(gfx::RectF(15.f, 16.f, 14.f, 10.f));
+  child->SetUpdateRect(gfx::Rect(15, 16, 14, 10));
   EmulateDrawingOneFrame(root.get());
 
   // Damage position on the surface should be: position of unified layer
   // damage_rect and update rect (5, 6)
   // relative to the child (100, 100).
   gfx::Rect root_damage_rect =
       root->render_surface()->damage_tracker()->current_damage_rect();
   EXPECT_EQ(true, root_damage_rect.Contains(gfx::Rect(105, 106, 24, 20)));
 
   // CASE 2: The same layer damage rect and update rect twice in a row still
   // produces the same damage.
   ClearDamageForAllSurfaces(root.get());
   child->AddDamageRect(gfx::RectF(10.f, 11.f, 12.f, 13.f));
-  child->SetUpdateRect(gfx::RectF(10.f, 11.f, 14.f, 15.f));
+  child->SetUpdateRect(gfx::Rect(10, 11, 14, 15));
   EmulateDrawingOneFrame(root.get());
   root_damage_rect =
       root->render_surface()->damage_tracker()->current_damage_rect();
   EXPECT_EQ(true, root_damage_rect.Contains(gfx::Rect(110, 111, 14, 15)));
 
   // CASE 3: Adding a different layer damage rect and update rect should cause
   // damage on the new damaged region, but no additional exposed old region.
   ClearDamageForAllSurfaces(root.get());
   child->AddDamageRect(gfx::RectF(20.f, 25.f, 2.f, 3.f));
-  child->SetUpdateRect(gfx::RectF(5.f, 10.f, 7.f, 8.f));
+  child->SetUpdateRect(gfx::Rect(5, 10, 7, 8));
   EmulateDrawingOneFrame(root.get());
 
   // Damage position on the surface should be: position of unified layer damage
   // rect and update rect (5, 10) relative to the child (100, 100).
   root_damage_rect =
       root->render_surface()->damage_tracker()->current_damage_rect();
   EXPECT_EQ(true, root_damage_rect.Contains(gfx::Rect(105, 110, 17, 18)));
 }
 
 TEST_F(DamageTrackerTest, VerifyDamageForPropertyChanges) {
   scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface();
   LayerImpl* child = root->children()[0];
 
   // CASE 1: The layer's property changed flag takes priority over update rect.
   //
   ClearDamageForAllSurfaces(root.get());
-  child->SetUpdateRect(gfx::RectF(10.f, 11.f, 12.f, 13.f));
+  child->SetUpdateRect(gfx::Rect(10, 11, 12, 13));
   child->SetOpacity(0.5f);
   EmulateDrawingOneFrame(root.get());
 
   // Sanity check - we should not have accidentally created a separate render
   // surface for the translucent layer.
   ASSERT_FALSE(child->render_surface());
   ASSERT_EQ(2u, root->render_surface()->layer_list().size());
 
   // Damage should be the entire child layer in target_surface space.
   gfx::Rect expected_rect = gfx::Rect(100, 100, 30, 30);
@@ skipping 127 matching lines @@
   filters.GetOutsets(&outset_top, &outset_right, &outset_bottom, &outset_left);
 
   // Setting the filter will damage the whole surface.
   ClearDamageForAllSurfaces(root.get());
   surface->SetFilters(filters);
   EmulateDrawingOneFrame(root.get());
 
   // Setting the update rect should cause the corresponding damage to the
   // surface, blurred based on the size of the blur filter.
   ClearDamageForAllSurfaces(root.get());
-  child->SetUpdateRect(gfx::RectF(1.f, 2.f, 3.f, 4.f));
+  child->SetUpdateRect(gfx::Rect(1, 2, 3, 4));
   EmulateDrawingOneFrame(root.get());
 
   // Damage position on the surface should be: position of update_rect (1, 2)
   // relative to the child (300, 300), but expanded by the blur outsets.
   gfx::Rect root_damage_rect =
       root->render_surface()->damage_tracker()->current_damage_rect();
   gfx::Rect expected_damage_rect = gfx::Rect(301, 302, 3, 4);
 
   expected_damage_rect.Inset(-outset_left,
                              -outset_top,
@@ skipping 22 matching lines @@
   root_damage_rect =
           root->render_surface()->damage_tracker()->current_damage_rect();
   child_damage_rect =
           child->render_surface()->damage_tracker()->current_damage_rect();
   EXPECT_EQ(gfx::Rect(100, 100, 30, 30).ToString(),
             root_damage_rect.ToString());
   EXPECT_EQ(gfx::Rect(30, 30).ToString(), child_damage_rect.ToString());
 
   // CASE 1: Setting the update rect should damage the whole surface (for now)
   ClearDamageForAllSurfaces(root.get());
-  child->SetUpdateRect(gfx::RectF(1.f, 1.f));
+  child->SetUpdateRect(gfx::Rect(1, 1));
   EmulateDrawingOneFrame(root.get());
 
   root_damage_rect =
           root->render_surface()->damage_tracker()->current_damage_rect();
   child_damage_rect =
           child->render_surface()->damage_tracker()->current_damage_rect();
   EXPECT_EQ(gfx::Rect(100, 100, 30, 30).ToString(),
             root_damage_rect.ToString());
   EXPECT_EQ(gfx::Rect(30.f, 30.f).ToString(), child_damage_rect.ToString());
 }
@@ skipping 13 matching lines @@
 
   // Setting the filter will damage the whole surface.
   ClearDamageForAllSurfaces(root.get());
   child1->SetBackgroundFilters(filters);
   EmulateDrawingOneFrame(root.get());
 
   // CASE 1: Setting the update rect should cause the corresponding damage to
   //         the surface, blurred based on the size of the child's background
   //         blur filter.
   ClearDamageForAllSurfaces(root.get());
-  root->SetUpdateRect(gfx::RectF(297.f, 297.f, 2.f, 2.f));
+  root->SetUpdateRect(gfx::Rect(297, 297, 2, 2));
   EmulateDrawingOneFrame(root.get());
 
   gfx::Rect root_damage_rect =
       root->render_surface()->damage_tracker()->current_damage_rect();
   // Damage position on the surface should be a composition of the damage on
   // the root and on child2.  Damage on the root should be: position of
   // update_rect (297, 297), but expanded by the blur outsets.
   gfx::Rect expected_damage_rect = gfx::Rect(297, 297, 2, 2);
 
   expected_damage_rect.Inset(-outset_left,
                              -outset_top,
                              -outset_right,
                              -outset_bottom);
   EXPECT_EQ(expected_damage_rect.ToString(), root_damage_rect.ToString());
 
   // CASE 2: Setting the update rect should cause the corresponding damage to
   //         the surface, blurred based on the size of the child's background
   //         blur filter. Since the damage extends to the right/bottom outside
   //         of the blurred layer, only the left/top should end up expanded.
   ClearDamageForAllSurfaces(root.get());
-  root->SetUpdateRect(gfx::RectF(297.f, 297.f, 30.f, 30.f));
+  root->SetUpdateRect(gfx::Rect(297, 297, 30, 30));
   EmulateDrawingOneFrame(root.get());
 
   root_damage_rect =
           root->render_surface()->damage_tracker()->current_damage_rect();
   // Damage position on the surface should be a composition of the damage on
   // the root and on child2.  Damage on the root should be: position of
   // update_rect (297, 297), but expanded on the left/top by the blur outsets.
   expected_damage_rect = gfx::Rect(297, 297, 30, 30);
 
   expected_damage_rect.Inset(-outset_left,
                              -outset_top,
                              0,
                              0);
   EXPECT_EQ(expected_damage_rect.ToString(), root_damage_rect.ToString());
 
   // CASE 3: Setting this update rect outside the blurred content_bounds of the
   //         blurred child1 will not cause it to be expanded.
   ClearDamageForAllSurfaces(root.get());
-  root->SetUpdateRect(gfx::RectF(30.f, 30.f, 2.f, 2.f));
+  root->SetUpdateRect(gfx::Rect(30, 30, 2, 2));
   EmulateDrawingOneFrame(root.get());
 
   root_damage_rect =
           root->render_surface()->damage_tracker()->current_damage_rect();
   // Damage on the root should be: position of update_rect (30, 30), not
   // expanded.
   expected_damage_rect = gfx::Rect(30, 30, 2, 2);
 
   EXPECT_EQ(expected_damage_rect.ToString(), root_damage_rect.ToString());
 
   // CASE 4: Setting this update rect inside the blurred content_bounds but
   //         outside the original content_bounds of the blurred child1 will
   //         cause it to be expanded.
   ClearDamageForAllSurfaces(root.get());
-  root->SetUpdateRect(gfx::RectF(99.f, 99.f, 1.f, 1.f));
+  root->SetUpdateRect(gfx::Rect(99, 99, 1, 1));
   EmulateDrawingOneFrame(root.get());
 
   root_damage_rect =
           root->render_surface()->damage_tracker()->current_damage_rect();
   // Damage on the root should be: position of update_rect (99, 99), expanded by
   // the blurring on child1, but since it is 1 pixel outside the layer, the
   // expanding should be reduced by 1.
   expected_damage_rect = gfx::Rect(99, 99, 1, 1);
 
   expected_damage_rect.Inset(-outset_left + 1,
                              -outset_top + 1,
                              -outset_right,
                              -outset_bottom);
   EXPECT_EQ(expected_damage_rect.ToString(), root_damage_rect.ToString());
 
   // CASE 5: Setting the update rect on child2, which is above child1, will
   // not get blurred by child1, so it does not need to get expanded.
   ClearDamageForAllSurfaces(root.get());
-  child2->SetUpdateRect(gfx::RectF(0.f, 0.f, 1.f, 1.f));
+  child2->SetUpdateRect(gfx::Rect(1, 1));
   EmulateDrawingOneFrame(root.get());
 
   root_damage_rect =
           root->render_surface()->damage_tracker()->current_damage_rect();
   // Damage on child2 should be: position of update_rect offset by the child's
   // position (11, 11), and not expanded by anything.
   expected_damage_rect = gfx::Rect(11, 11, 1, 1);
 
   EXPECT_EQ(expected_damage_rect.ToString(), root_damage_rect.ToString());
 
   // CASE 6: Setting the update rect on child1 will also blur the damage, so
   //         that any pixels needed for the blur are redrawn in the current
   //         frame.
   ClearDamageForAllSurfaces(root.get());
-  child1->SetUpdateRect(gfx::RectF(0.f, 0.f, 1.f, 1.f));
+  child1->SetUpdateRect(gfx::Rect(1, 1));
   EmulateDrawingOneFrame(root.get());
 
   root_damage_rect =
           root->render_surface()->damage_tracker()->current_damage_rect();
   // Damage on child1 should be: position of update_rect offset by the child's
   // position (100, 100), and expanded by the damage.
   expected_damage_rect = gfx::Rect(100, 100, 1, 1);
 
   expected_damage_rect.Inset(-outset_left,
                              -outset_top,
@@ skipping 100 matching lines @@
     child2->SetDrawsContent(true);
     root->AddChild(child2.Pass());
   }
   LayerImpl* child2 = root->children()[1];
   EmulateDrawingOneFrame(root.get());
 
   // Damaging two layers simultaneously should cause combined damage.
   // - child1 update rect in surface space: gfx::Rect(100, 100, 1, 2);
   // - child2 update rect in surface space: gfx::Rect(400, 380, 3, 4);
   ClearDamageForAllSurfaces(root.get());
-  child1->SetUpdateRect(gfx::RectF(0.f, 0.f, 1.f, 2.f));
-  child2->SetUpdateRect(gfx::RectF(0.f, 0.f, 3.f, 4.f));
+  child1->SetUpdateRect(gfx::Rect(1, 2));
+  child2->SetUpdateRect(gfx::Rect(3, 4));
   EmulateDrawingOneFrame(root.get());
   gfx::Rect root_damage_rect =
       root->render_surface()->damage_tracker()->current_damage_rect();
   EXPECT_EQ(gfx::Rect(100, 100, 303, 284).ToString(),
             root_damage_rect.ToString());
 }
 
 TEST_F(DamageTrackerTest, VerifyDamageForNestedSurfaces) {
   scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces();
   LayerImpl* child1 = root->children()[0];
@@ skipping 190 matching lines @@
 
 TEST_F(DamageTrackerTest, VerifyNoDamageForUpdateRectThatDoesNotDrawContent) {
   scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces();
   LayerImpl* child1 = root->children()[0];
   gfx::Rect child_damage_rect;
   gfx::Rect root_damage_rect;
 
   // In our specific tree, the update rect of child1 should not cause any
   // damage to any surface because it does not actually draw content.
   ClearDamageForAllSurfaces(root.get());
-  child1->SetUpdateRect(gfx::RectF(0.f, 0.f, 1.f, 2.f));
+  child1->SetUpdateRect(gfx::Rect(1, 2));
   EmulateDrawingOneFrame(root.get());
   child_damage_rect =
           child1->render_surface()->damage_tracker()->current_damage_rect();
   root_damage_rect =
           root->render_surface()->damage_tracker()->current_damage_rect();
   EXPECT_TRUE(child_damage_rect.IsEmpty());
   EXPECT_TRUE(root_damage_rect.IsEmpty());
 }
 
 TEST_F(DamageTrackerTest, VerifyDamageForReplica) {
@@ skipping 132 matching lines @@
     child->AddChild(grand_child.Pass());
   }
   EmulateDrawingOneFrame(root.get());
 
   // Sanity check that a new surface was created for the child.
   ASSERT_TRUE(child->render_surface());
 
   // CASE 1: the update_rect on a mask layer should damage the entire target
   //         surface.
   ClearDamageForAllSurfaces(root.get());
-  mask_layer->SetUpdateRect(gfx::RectF(1.f, 2.f, 3.f, 4.f));
+  mask_layer->SetUpdateRect(gfx::Rect(1, 2, 3, 4));
   EmulateDrawingOneFrame(root.get());
   gfx::Rect child_damage_rect =
       child->render_surface()->damage_tracker()->current_damage_rect();
   EXPECT_EQ(gfx::Rect(30, 30).ToString(), child_damage_rect.ToString());
 
   // CASE 2: a property change on the mask layer should damage the entire
   //         target surface.
 
   // Advance one frame without damage so that we know the damage rect is not
   // leftover from the previous case.
@@ skipping 166 matching lines @@
 }
 
 TEST_F(DamageTrackerTest, DamageWhenAddedExternally) {
   scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithOneSurface();
   LayerImpl* child = root->children()[0];
 
   // Case 1: This test ensures that when the tracker is given damage, that
   //         it is included with any other partial damage.
   //
   ClearDamageForAllSurfaces(root.get());
-  child->SetUpdateRect(gfx::RectF(10, 11, 12, 13));
+  child->SetUpdateRect(gfx::Rect(10, 11, 12, 13));
   root->render_surface()->damage_tracker()->AddDamageNextUpdate(
       gfx::Rect(15, 16, 32, 33));
   EmulateDrawingOneFrame(root.get());
   gfx::Rect root_damage_rect =
       root->render_surface()->damage_tracker()->current_damage_rect();
   EXPECT_EQ(gfx::UnionRects(gfx::Rect(15, 16, 32, 33),
                             gfx::Rect(100 + 10, 100 + 11, 12, 13)).ToString(),
             root_damage_rect.ToString());
 
   // Case 2: An additional sanity check that adding damage works even when
@@ skipping 42 matching lines @@
   child->SetUpdateRect(gfx::Rect(10.f, 11.f, 1.f, 2.f));
   EmulateDrawingOneFrame(root.get());
 
   // Sanity check damage after the first frame; this isnt the actual test yet.
   gfx::Rect root_damage_rect =
       root->render_surface()->damage_tracker()->current_damage_rect();
   EXPECT_EQ(gfx::Rect(110, 111, 1, 2).ToString(), root_damage_rect.ToString());
 
   // New damage, without having cleared the previous damage, should be unioned
   // to the previous one.
-  child->SetUpdateRect(gfx::RectF(20.f, 25.f, 1.f, 2.f));
+  child->SetUpdateRect(gfx::Rect(20, 25, 1, 2));
   EmulateDrawingOneFrame(root.get());
   root_damage_rect =
           root->render_surface()->damage_tracker()->current_damage_rect();
   EXPECT_EQ(gfx::Rect(110, 111, 11, 16).ToString(),
             root_damage_rect.ToString());
 
   // If we notify the damage tracker that we drew the damaged area, then damage
   // should be emptied.
   root->render_surface()->damage_tracker()->DidDrawDamagedArea();
   root_damage_rect =
@@ skipping 35 matching lines @@
     gfx::Rect root_damage_rect =
         root->render_surface()->damage_tracker()->current_damage_rect();
     gfx::Rect damage_we_care_about = gfx::Rect(i, i);
     EXPECT_LE(damage_we_care_about.right(), root_damage_rect.right());
     EXPECT_LE(damage_we_care_about.bottom(), root_damage_rect.bottom());
   }
 }
 
 }  // namespace
 }  // namespace cc