gfx: Make conversions from Size to SizeF be explicit.

cc/layers/layer_impl.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/layers/layer_impl.h"
 
 #include "base/json/json_reader.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 307 matching lines @@
                 draw_properties_.visible_layer_rect, draw_properties_.clip_rect,
                 is_clipped_, draw_properties_.opacity, draw_blend_mode_,
                 sorting_context_id_);
 }
 
 void LayerImpl::PopulateScaledSharedQuadState(SharedQuadState* state,
                                               float scale) const {
   gfx::Transform scaled_draw_transform =
       draw_properties_.target_space_transform;
   scaled_draw_transform.Scale(SK_MScalar1 / scale, SK_MScalar1 / scale);
-  gfx::Size scaled_bounds = gfx::ToCeiledSize(gfx::ScaleSize(bounds(), scale));
+  gfx::Size scaled_bounds = gfx::ScaleToCeiledSize(bounds(), scale);
   gfx::Rect scaled_visible_layer_rect =
       gfx::ScaleToEnclosingRect(visible_layer_rect(), scale);
   scaled_visible_layer_rect.Intersect(gfx::Rect(scaled_bounds));
 
   state->SetAll(scaled_draw_transform, scaled_bounds, scaled_visible_layer_rect,
                 draw_properties().clip_rect, is_clipped_,
                 draw_properties().opacity, draw_blend_mode_,
                 sorting_context_id_);
 }
 
@@ skipping 638 matching lines @@
     transform_tree.SetOuterViewportBoundsDelta(bounds_delta);
 
   ScrollbarParametersDidChange(true);
 
   if (masks_to_bounds()) {
     // If layer is clipping, then update the clip node using the new bounds.
     ClipNode* clip_node =
         layer_tree_impl()->property_trees()->clip_tree.Node(clip_tree_index());
     if (clip_node) {
       DCHECK(id() == clip_node->owner_id);
-      clip_node->data.clip =
-          gfx::RectF(gfx::PointF() + offset_to_transform_parent(), bounds());
+      clip_node->data.clip = gfx::RectF(
+          gfx::PointF() + offset_to_transform_parent(), gfx::SizeF(bounds()));
       layer_tree_impl()->property_trees()->clip_tree.set_needs_update(true);
     }
 
     NoteLayerPropertyChangedForSubtree();
   } else {
     NoteLayerPropertyChanged();
   }
 }
 
 void LayerImpl::SetMaskLayer(scoped_ptr<LayerImpl> mask_layer) {
@@ skipping 522 matching lines @@
 
   float scale_factor = 1.f;
   for (LayerImpl const* current_layer = this;
        current_layer != scroll_clip_layer_->parent();
        current_layer = current_layer->parent()) {
     if (current_layer == page_scale_layer)
       scale_factor = layer_tree_impl()->current_page_scale_factor();
   }
 
   gfx::SizeF scaled_scroll_bounds =
-      gfx::ToFlooredSize(gfx::ScaleSize(BoundsForScrolling(), scale_factor));
-  scaled_scroll_bounds = gfx::ToFlooredSize(scaled_scroll_bounds);
+      gfx::ScaleSize(BoundsForScrolling(), scale_factor);
+  scaled_scroll_bounds.SetSize(std::floor(scaled_scroll_bounds.width()),
+                               std::floor(scaled_scroll_bounds.height()));
 
   gfx::ScrollOffset max_offset(
       scaled_scroll_bounds.width() - scroll_clip_layer_->bounds().width(),
       scaled_scroll_bounds.height() - scroll_clip_layer_->bounds().height());
   // We need the final scroll offset to be in CSS coords.
   max_offset.Scale(1 / scale_factor);
   max_offset.SetToMax(gfx::ScrollOffset());
   return max_offset;
 }
 
@@ skipping 352 matching lines @@
 
 gfx::Rect LayerImpl::GetEnclosingRectInTargetSpace() const {
   return MathUtil::MapEnclosingClippedRect(
       draw_properties_.target_space_transform, gfx::Rect(bounds()));
 }
 
 gfx::Rect LayerImpl::GetScaledEnclosingRectInTargetSpace(float scale) const {
   gfx::Transform scaled_draw_transform =
       draw_properties_.target_space_transform;
   scaled_draw_transform.Scale(SK_MScalar1 / scale, SK_MScalar1 / scale);
-  gfx::Size scaled_bounds = gfx::ToCeiledSize(gfx::ScaleSize(bounds(), scale));
+  gfx::Size scaled_bounds = gfx::ScaleToCeiledSize(bounds(), scale);
   return MathUtil::MapEnclosingClippedRect(scaled_draw_transform,
                                            gfx::Rect(scaled_bounds));
 }
 
 float LayerImpl::GetIdealContentsScale() const {
   float page_scale = IsAffectedByPageScale()
                          ? layer_tree_impl()->current_page_scale_factor()
                          : 1.f;
   float device_scale = layer_tree_impl()->device_scale_factor();
 
   float default_scale = page_scale * device_scale;
   if (!layer_tree_impl()
            ->settings()
            .layer_transforms_should_scale_layer_contents) {
     return default_scale;
   }
 
   // TODO(enne): the transform needs to come from property trees instead of
   // draw properties.
   gfx::Vector2dF transform_scales = MathUtil::ComputeTransform2dScaleComponents(
       draw_properties().target_space_transform, default_scale);
   return std::max(transform_scales.x(), transform_scales.y());
 }
 
 }  // namespace cc