gfx: Make conversions from Size to SizeF be explicit.

cc/layers/picture_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/picture_layer_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <set>
@@ skipping 179 matching lines @@
     geometry_rect.Intersect(scaled_recorded_viewport);
     opaque_rect.Intersect(scaled_recorded_viewport);
     visible_geometry_rect.Intersect(scaled_recorded_viewport);
 
     if (visible_geometry_rect.IsEmpty())
       return;
 
     DCHECK(raster_source_->HasRecordings());
     gfx::Rect quad_content_rect = shared_quad_state->visible_quad_layer_rect;
     gfx::Size texture_size = quad_content_rect.size();
-    gfx::RectF texture_rect = gfx::RectF(texture_size);
+    gfx::RectF texture_rect = gfx::RectF(gfx::SizeF(texture_size));
 
     PictureDrawQuad* quad =
         render_pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
     quad->SetNew(shared_quad_state, geometry_rect, opaque_rect,
                  visible_geometry_rect, texture_rect, texture_size,
                  nearest_neighbor_, RGBA_8888, quad_content_rect,
                  max_contents_scale, raster_source_);
     ValidateQuadResources(quad);
     return;
   }
@@ skipping 762 matching lines @@
   // smaller than what we would choose otherwise, then it's always better off
   // for us memory-wise. But otherwise, we don't choose a scale at which this
   // layer's rastered content would become larger than the viewport.
   if (draw_properties().screen_space_transform_is_animating &&
       !ShouldAdjustRasterScaleDuringScaleAnimations()) {
     bool can_raster_at_maximum_scale = false;
     bool should_raster_at_starting_scale = false;
     float maximum_scale = draw_properties().maximum_animation_contents_scale;
     float starting_scale = draw_properties().starting_animation_contents_scale;
     if (maximum_scale) {
-      gfx::Size bounds_at_maximum_scale = gfx::ToCeiledSize(
-          gfx::ScaleSize(raster_source_->GetSize(), maximum_scale));
+      gfx::Size bounds_at_maximum_scale =
+          gfx::ScaleToCeiledSize(raster_source_->GetSize(), maximum_scale);
       int64 maximum_area = static_cast<int64>(bounds_at_maximum_scale.width()) *
                            static_cast<int64>(bounds_at_maximum_scale.height());
       gfx::Size viewport = layer_tree_impl()->device_viewport_size();
       int64 viewport_area = static_cast<int64>(viewport.width()) *
                             static_cast<int64>(viewport.height());
       if (maximum_area <= viewport_area)
         can_raster_at_maximum_scale = true;
     }
     if (starting_scale && starting_scale > maximum_scale) {
-      gfx::Size bounds_at_starting_scale = gfx::ToCeiledSize(
-          gfx::ScaleSize(raster_source_->GetSize(), starting_scale));
+      gfx::Size bounds_at_starting_scale =
+          gfx::ScaleToCeiledSize(raster_source_->GetSize(), starting_scale);
       int64 start_area = static_cast<int64>(bounds_at_starting_scale.width()) *
                          static_cast<int64>(bounds_at_starting_scale.height());
       gfx::Size viewport = layer_tree_impl()->device_viewport_size();
       int64 viewport_area = static_cast<int64>(viewport.width()) *
                             static_cast<int64>(viewport.height());
       if (start_area <= viewport_area)
         should_raster_at_starting_scale = true;
     }
     // Use the computed scales for the raster scale directly, do not try to use
     // the ideal scale here. The current ideal scale may be way too large in the
     // case of an animation with scale, and will be constantly changing.
     if (should_raster_at_starting_scale)
       raster_contents_scale_ = starting_scale;
     else if (can_raster_at_maximum_scale)
       raster_contents_scale_ = maximum_scale;
     else
       raster_contents_scale_ = 1.f * ideal_page_scale_ * ideal_device_scale_;
   }
 
   raster_contents_scale_ =
       std::max(raster_contents_scale_, MinimumContentsScale());
   raster_contents_scale_ =
       std::min(raster_contents_scale_, MaximumContentsScale());
   DCHECK_GE(raster_contents_scale_, MinimumContentsScale());
   DCHECK_LE(raster_contents_scale_, MaximumContentsScale());
 
   // If this layer would create zero or one tiles at this content scale,
   // don't create a low res tiling.
-  gfx::Size raster_bounds = gfx::ToCeiledSize(
-      gfx::ScaleSize(raster_source_->GetSize(), raster_contents_scale_));
+  gfx::Size raster_bounds =
+      gfx::ScaleToCeiledSize(raster_source_->GetSize(), raster_contents_scale_);
   gfx::Size tile_size = CalculateTileSize(raster_bounds);
   bool tile_covers_bounds = tile_size.width() >= raster_bounds.width() &&
                             tile_size.height() >= raster_bounds.height();
   if (tile_size.IsEmpty() || tile_covers_bounds) {
     low_res_raster_contents_scale_ = raster_contents_scale_;
     return;
   }
 
   float low_res_factor =
       layer_tree_impl()->settings().low_res_contents_scale_factor;
@@ skipping 210 matching lines @@
 
 bool PictureLayerImpl::IsOnActiveOrPendingTree() const {
   return !layer_tree_impl()->IsRecycleTree();
 }
 
 bool PictureLayerImpl::HasValidTilePriorities() const {
   return IsOnActiveOrPendingTree() && IsDrawnRenderSurfaceLayerListMember();
 }
 
 }  // namespace cc