Converted LayerImpl::bounds() to return SizeF.

cc/trees/damage_tracker.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 <algorithm>
 
 #include "cc/base/math_util.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/render_surface_impl.h"
 #include "cc/output/filter_operations.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "ui/gfx/geometry/rect_conversions.h"
+#include "ui/gfx/geometry/size_conversions.h"
 
 namespace cc {
 
 scoped_ptr<DamageTracker> DamageTracker::Create() {
   return make_scoped_ptr(new DamageTracker());
 }
 
 DamageTracker::DamageTracker()
   : mailboxId_(0) {}
 
@@ skipping 175 matching lines @@
   gfx::Rect damage_rect;
 
   if (!target_surface_mask_layer)
     return damage_rect;
 
   // Currently, if there is any change to the mask, we choose to damage the
   // entire surface. This could potentially be optimized later, but it is not
   // expected to be a common case.
   if (target_surface_mask_layer->LayerPropertyChanged() ||
       !target_surface_mask_layer->update_rect().IsEmpty()) {
-    damage_rect = gfx::Rect(target_surface_mask_layer->bounds());
+    damage_rect = gfx::Rect(
+        gfx::ToCeiledSize(target_surface_mask_layer->bounds()));
   }
 
   return damage_rect;
 }
 
 void DamageTracker::PrepareRectHistoryForUpdate() {
   mailboxId_++;
 }
 
 gfx::Rect DamageTracker::TrackDamageFromLeftoverRects() {
@@ skipping 148 matching lines @@
   if (layer->replica_layer() && layer->replica_layer()->mask_layer()) {
     LayerImpl* replica_mask_layer = layer->replica_layer()->mask_layer();
 
     bool replica_is_new = false;
     RectMapData& data =
         RectDataForLayer(replica_mask_layer->id(), &replica_is_new);
 
     const gfx::Transform& replica_draw_transform =
         render_surface->replica_draw_transform();
     gfx::Rect replica_mask_layer_rect = MathUtil::MapEnclosingClippedRect(
-        replica_draw_transform, gfx::Rect(replica_mask_layer->bounds()));
+        replica_draw_transform,
+        gfx::Rect(gfx::ToCeiledSize(replica_mask_layer->bounds())));
     data.Update(replica_mask_layer_rect, mailboxId_);
 
     // In the current implementation, a change in the replica mask damages the
     // entire replica region.
     if (replica_is_new ||
         replica_mask_layer->LayerPropertyChanged() ||
         !replica_mask_layer->update_rect().IsEmpty())
       target_damage_rect->Union(replica_mask_layer_rect);
   }
 
   // If the layer has a background filter, this may cause pixels in our surface
   // to be expanded, so we will need to expand any damage at or below this
   // layer. We expand the damage from this layer too, as we need to readback
   // those pixels from the surface with only the contents of layers below this
   // one in them. This means we need to redraw any pixels in the surface being
   // used for the blur in this layer this frame.
   if (layer->background_filters().HasFilterThatMovesPixels()) {
     ExpandDamageRectInsideRectWithFilters(target_damage_rect,
                                           surface_rect_in_target_space,
                                           layer->background_filters());
   }
 }
 
 }  // namespace cc