gfx: Make conversions from Size to SizeF be explicit.

cc/output/gl_renderer.cc

 // Copyright 2010 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/output/gl_renderer.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 836 matching lines @@
   }
   return device_background_texture.Pass();
 }
 
 skia::RefPtr<SkImage> GLRenderer::ApplyBackgroundFilters(
     DrawingFrame* frame,
     const RenderPassDrawQuad* quad,
     ScopedResource* background_texture) {
   DCHECK(ShouldApplyBackgroundFilters(quad));
   skia::RefPtr<SkImageFilter> filter = RenderSurfaceFilters::BuildImageFilter(
-      quad->background_filters, background_texture->size());
+      quad->background_filters, gfx::SizeF(background_texture->size()));
 
   skia::RefPtr<SkImage> background_with_filters = ApplyImageFilter(
       ScopedUseGrContext::Create(this, frame), resource_provider_, quad->rect,
       quad->filters_scale, filter.get(), background_texture);
   return background_with_filters;
 }
 
 void GLRenderer::DrawRenderPassQuad(DrawingFrame* frame,
                                     const RenderPassDrawQuad* quad,
                                     const gfx::QuadF* clip_region) {
@@ skipping 95 matching lines @@
       (quad->ShouldDrawWithBlending() || !IsDefaultBlendMode(blend_mode)));
 
   // TODO(senorblanco): Cache this value so that we don't have to do it for both
   // the surface and its replica.  Apply filters to the contents texture.
   skia::RefPtr<SkImage> filter_image;
   GLuint filter_image_id = 0;
   SkScalar color_matrix[20];
   bool use_color_matrix = false;
   if (!quad->filters.IsEmpty()) {
     skia::RefPtr<SkImageFilter> filter = RenderSurfaceFilters::BuildImageFilter(
-        quad->filters, contents_texture->size());
+        quad->filters, gfx::SizeF(contents_texture->size()));
     if (filter) {
       skia::RefPtr<SkColorFilter> cf;
 
       {
         SkColorFilter* colorfilter_rawptr = NULL;
         filter->asColorFilter(&colorfilter_rawptr);
         cf = skia::AdoptRef(colorfilter_rawptr);
       }
 
       if (cf && cf->asColorMatrix(color_matrix) && !filter->getInput(0)) {
@@ skipping 300 matching lines @@
              kAntiAliasingEpsilon;
 }
 }  // anonymous namespace
 
 static gfx::QuadF GetDeviceQuadWithAntialiasingOnExteriorEdges(
     const LayerQuad& device_layer_edges,
     const gfx::Transform& device_transform,
     const gfx::QuadF& tile_quad,
     const gfx::QuadF* clip_region,
     const DrawQuad* quad) {
-  gfx::RectF tile_rect = gfx::RectF(quad->visible_rect);
+  auto tile_rect = gfx::RectF(quad->visible_rect);
 
   gfx::PointF bottom_right = tile_quad.p3();
   gfx::PointF bottom_left = tile_quad.p4();
   gfx::PointF top_left = tile_quad.p1();
   gfx::PointF top_right = tile_quad.p2();
   bool clipped = false;
 
   // Map points to device space. We ignore |clipped|, since the result of
   // |MapPoint()| still produces a valid point to draw the quad with. When
   // clipped, the point will be outside of the viewport. See crbug.com/416367.
@@ skipping 42 matching lines @@
   return (clipped_quad->p1() - ideal_rect->p1()).LengthSquared() +
          (clipped_quad->p2() - ideal_rect->p2()).LengthSquared() +
          (clipped_quad->p3() - ideal_rect->p3()).LengthSquared() +
          (clipped_quad->p4() - ideal_rect->p4()).LengthSquared();
 }
 
 // Attempt to rotate the clipped quad until it lines up the most
 // correctly. This is necessary because we check the edges of this
 // quad against the expected left/right/top/bottom for anti-aliasing.
 void AlignQuadToBoundingBox(gfx::QuadF* clipped_quad) {
-  gfx::QuadF bounding_quad = gfx::QuadF(clipped_quad->BoundingBox());
+  auto bounding_quad = gfx::QuadF(clipped_quad->BoundingBox());
   gfx::QuadF best_rotation = *clipped_quad;
   float least_error_amount = GetTotalQuadError(clipped_quad, &bounding_quad);
   for (size_t i = 1; i < 4; ++i) {
     clipped_quad->Realign(1);
     float new_error = GetTotalQuadError(clipped_quad, &bounding_quad);
     if (new_error < least_error_amount) {
       least_error_amount = new_error;
       best_rotation = *clipped_quad;
     }
   }
@@ skipping 158 matching lines @@
       quad->ShouldDrawWithBlending())
     return;
 
   gfx::Transform device_transform =
       frame->window_matrix * frame->projection_matrix *
       quad->shared_quad_state->quad_to_target_transform;
   device_transform.FlattenTo2d();
   if (!device_transform.IsInvertible())
     return;
 
-  gfx::QuadF local_quad = gfx::QuadF(gfx::RectF(tile_rect));
+  auto local_quad = gfx::QuadF(gfx::RectF(tile_rect));
 
   gfx::QuadF device_layer_quad;
   bool use_aa = false;
   bool allow_aa = settings_->allow_antialiasing &&
                   !quad->force_anti_aliasing_off && quad->IsEdge();
 
   if (allow_aa) {
     bool clipped = false;
     bool force_aa = false;
     device_layer_quad = MathUtil::MapQuad(
@@ skipping 44 matching lines @@
 
     SetShaderQuadF(local_quad, uniforms.quad_location);
 
     // The transform and vertex data are used to figure out the extents that the
     // un-antialiased quad should have and which vertex this is and the float
     // quad passed in via uniform is the actual geometry that gets used to draw
     // it. This is why this centered rect is used and not the original
     // quad_rect.
     gfx::RectF centered_rect(
         gfx::PointF(-0.5f * tile_rect.width(), -0.5f * tile_rect.height()),
-        tile_rect.size());
+        gfx::SizeF(tile_rect.size()));
     DrawQuadGeometry(frame, quad->shared_quad_state->quad_to_target_transform,
                      centered_rect, uniforms.matrix_location);
   } else {
     PrepareGeometry(SHARED_BINDING);
     SetShaderQuadF(local_quad, uniforms.quad_location);
     static float gl_matrix[16];
     ToGLMatrix(&gl_matrix[0],
                frame->projection_matrix *
                    quad->shared_quad_state->quad_to_target_transform);
     gl_->UniformMatrix4fv(uniforms.matrix_location, 1, false, &gl_matrix[0]);
@@ skipping 110 matching lines @@
   // Map clamping rectangle to unit square.
   float vertex_tex_translate_x = -clamp_geom_rect.x() / clamp_geom_rect.width();
   float vertex_tex_translate_y =
       -clamp_geom_rect.y() / clamp_geom_rect.height();
   float vertex_tex_scale_x = tile_rect.width() / clamp_geom_rect.width();
   float vertex_tex_scale_y = tile_rect.height() / clamp_geom_rect.height();
 
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
       gl_, &highp_threshold_cache_, highp_threshold_min_, quad->texture_size);
 
-  gfx::QuadF local_quad = gfx::QuadF(gfx::RectF(tile_rect));
+  auto local_quad = gfx::QuadF(gfx::RectF(tile_rect));
   float edge[24];
   SetupQuadForClippingAndAntialiasing(device_transform, quad, &aa_quad,
                                       clip_region, &local_quad, edge);
   ResourceProvider::ScopedSamplerGL quad_resource_lock(
       resource_provider_, resource_id,
       quad->nearest_neighbor ? GL_NEAREST : GL_LINEAR);
   SamplerType sampler =
       SamplerTypeFromTextureTarget(quad_resource_lock.target());
 
   float fragment_tex_translate_x = clamp_tex_rect.x();
@@ skipping 47 matching lines @@
 
   SetShaderOpacity(quad->shared_quad_state->opacity, uniforms.alpha_location);
   SetShaderQuadF(local_quad, uniforms.quad_location);
 
   // The transform and vertex data are used to figure out the extents that the
   // un-antialiased quad should have and which vertex this is and the float
   // quad passed in via uniform is the actual geometry that gets used to draw
   // it. This is why this centered rect is used and not the original quad_rect.
   gfx::RectF centered_rect(
       gfx::PointF(-0.5f * tile_rect.width(), -0.5f * tile_rect.height()),
-      tile_rect.size());
+      gfx::SizeF(tile_rect.size()));
   DrawQuadGeometry(frame, quad->shared_quad_state->quad_to_target_transform,
                    centered_rect, uniforms.matrix_location);
 }
 
 void GLRenderer::DrawContentQuadNoAA(const DrawingFrame* frame,
                                      const ContentDrawQuadBase* quad,
                                      ResourceId resource_id,
                                      const gfx::QuadF* clip_region) {
   gfx::RectF tex_coord_rect = MathUtil::ScaleRectProportional(
       quad->tex_coord_rect, gfx::RectF(quad->rect),
@@ skipping 292 matching lines @@
     case YUVVideoDrawQuad::JPEG:
       yuv_to_rgb = yuv_to_rgb_jpeg;
       yuv_adjust = yuv_adjust_full;
       break;
   }
 
   // The transform and vertex data are used to figure out the extents that the
   // un-antialiased quad should have and which vertex this is and the float
   // quad passed in via uniform is the actual geometry that gets used to draw
   // it. This is why this centered rect is used and not the original quad_rect.
-  gfx::RectF tile_rect = gfx::RectF(quad->rect);
+  auto tile_rect = gfx::RectF(quad->rect);
   gl_->UniformMatrix3fv(yuv_matrix_location, 1, 0, yuv_to_rgb);
   gl_->Uniform3fv(yuv_adj_location, 1, yuv_adjust);
 
   SetShaderOpacity(quad->shared_quad_state->opacity, alpha_location);
   if (!clip_region) {
     DrawQuadGeometry(frame, quad->shared_quad_state->quad_to_target_transform,
                      tile_rect, matrix_location);
   } else {
     float uvs[8] = {0};
     GetScaledUVs(quad->visible_rect, clip_region, uvs);
@@ skipping 1406 matching lines @@
       texture_id = pending_overlay_resources_.back()->texture_id();
     }
 
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order, overlay.transform, texture_id,
         ToNearestRect(overlay.display_rect), overlay.uv_rect);
   }
 }
 
 }  // namespace cc