cc: Remove implicit conversions from Rect to RectF in src/cc/.

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 560 matching lines @@
   const DebugBorderProgram* program = GetDebugBorderProgram();
   DCHECK(program && (program->initialized() || IsContextLost()));
   SetUseProgram(program->program());
 
   // Use the full quad_rect for debug quads to not move the edges based on
   // partial swaps.
   gfx::Rect layer_rect = quad->rect;
   gfx::Transform render_matrix;
   QuadRectTransform(&render_matrix,
                     quad->shared_quad_state->quad_to_target_transform,
-                    layer_rect);
+                    gfx::RectF(layer_rect));
   GLRenderer::ToGLMatrix(&gl_matrix[0],
                          frame->projection_matrix * render_matrix);
   gl_->UniformMatrix4fv(program->vertex_shader().matrix_location(), 1, false,
                         &gl_matrix[0]);
 
   SkColor color = quad->color;
   float alpha = SkColorGetA(color) * (1.0f / 255.0f);
 
   gl_->Uniform4f(program->fragment_shader().color_location(),
                  (SkColorGetR(color) * (1.0f / 255.0f)) * alpha,
@@ skipping 282 matching lines @@
                                     const RenderPassDrawQuad* quad,
                                     const gfx::QuadF* clip_region) {
   ScopedResource* contents_texture =
       render_pass_textures_.get(quad->render_pass_id);
   DCHECK(contents_texture);
   DCHECK(contents_texture->id());
 
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix,
                     quad->shared_quad_state->quad_to_target_transform,
-                    quad->rect);
+                    gfx::RectF(quad->rect));
   gfx::Transform contents_device_transform =
       frame->window_matrix * frame->projection_matrix * quad_rect_matrix;
   contents_device_transform.FlattenTo2d();
 
   // Can only draw surface if device matrix is invertible.
   if (!contents_device_transform.IsInvertible())
     return;
 
   gfx::QuadF surface_quad = SharedGeometryQuad();
 
@@ skipping 308 matching lines @@
                                                 GL_TEXTURE0 + last_texture_unit,
                                                 GL_LINEAR));
       DCHECK_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
                 shader_background_sampler_lock->target());
     }
   }
 
   SetShaderOpacity(quad->shared_quad_state->opacity, locations.alpha);
   SetShaderQuadF(surface_quad, locations.quad);
   DrawQuadGeometry(frame, quad->shared_quad_state->quad_to_target_transform,
-                   quad->rect, locations.matrix);
+                   gfx::RectF(quad->rect), locations.matrix);
 
   // Flush the compositor context before the filter bitmap goes out of
   // scope, so the draw gets processed before the filter texture gets deleted.
   if (filter_image_id)
     gl_->Flush();
 
   if (!use_shaders_for_blending)
     RestoreBlendFuncToDefault(blend_mode);
 }
 
@@ skipping 68 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 = quad->visible_rect;
+  gfx::RectF 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 149 matching lines @@
       (is_top(local_clip_region, quad) && is_left(local_clip_region, quad) &&
        is_bottom(local_clip_region, quad) && is_right(local_clip_region, quad));
 
   bool use_aa_on_all_four_edges =
       !local_clip_region && region_contains_all_outside_edges;
 
   gfx::QuadF device_quad;
   if (use_aa_on_all_four_edges) {
     device_quad = device_layer_edges.ToQuadF();
   } else {
-    gfx::QuadF tile_quad(local_clip_region ? *local_clip_region
-                                           : gfx::QuadF(quad->visible_rect));
+    gfx::QuadF tile_quad(local_clip_region
+                             ? *local_clip_region
+                             : gfx::QuadF(gfx::RectF(quad->visible_rect)));
     device_quad = GetDeviceQuadWithAntialiasingOnExteriorEdges(
         device_layer_edges, device_transform, tile_quad, local_clip_region,
         quad);
   }
 
   *local_quad = MapQuadToLocalSpace(device_transform, device_quad);
 }
 
 // static
 void GLRenderer::SetupRenderPassQuadForClippingAndAntialiasing(
@@ skipping 16 matching lines @@
     return;
   }
 
   LayerQuad device_layer_edges(*aa_quad);
   InflateAntiAliasingDistances(*aa_quad, &device_layer_edges, edge);
 
   gfx::QuadF device_quad;
 
   // Apply anti-aliasing only to the edges that are not being clipped
   if (local_clip_region) {
-    gfx::QuadF tile_quad(quad->visible_rect);
+    gfx::QuadF tile_quad(gfx::RectF(quad->visible_rect));
     GetScaledRegion(quad->rect, local_clip_region, &tile_quad);
     device_quad = GetDeviceQuadWithAntialiasingOnExteriorEdges(
         device_layer_edges, device_transform, tile_quad, local_clip_region,
         quad);
   } else {
     device_quad = device_layer_edges.ToQuadF();
   }
 
   *local_quad = MapQuadToLocalSpace(device_transform, device_quad);
 }
@@ skipping 24 matching lines @@
   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(
         device_transform,
-        gfx::QuadF(quad->shared_quad_state->visible_quad_layer_rect), &clipped);
+        gfx::QuadF(
+            gfx::RectF(quad->shared_quad_state->visible_quad_layer_rect)),
+        &clipped);
     use_aa = ShouldAntialiasQuad(device_layer_quad, clipped, force_aa);
   }
 
   float edge[24];
   const gfx::QuadF* aa_quad = use_aa ? &device_layer_quad : nullptr;
   SetupQuadForClippingAndAntialiasing(device_transform, quad, aa_quad,
                                       clip_region, &local_quad, edge);
 
   SolidColorProgramUniforms uniforms;
   if (use_aa) {
@@ skipping 97 matching lines @@
   device_transform.FlattenTo2d();
 
   gfx::QuadF device_layer_quad;
   bool use_aa = false;
   bool allow_aa = settings_->allow_antialiasing && quad->IsEdge();
   if (allow_aa) {
     bool clipped = false;
     bool force_aa = false;
     device_layer_quad = MathUtil::MapQuad(
         device_transform,
-        gfx::QuadF(quad->shared_quad_state->visible_quad_layer_rect), &clipped);
+        gfx::QuadF(
+            gfx::RectF(quad->shared_quad_state->visible_quad_layer_rect)),
+        &clipped);
     use_aa = ShouldAntialiasQuad(device_layer_quad, clipped, force_aa);
   }
 
   // TODO(timav): simplify coordinate transformations in DrawContentQuadAA
   // similar to the way DrawContentQuadNoAA works and then consider
   // combining DrawContentQuadAA and DrawContentQuadNoAA into one method.
   if (use_aa)
     DrawContentQuadAA(frame, quad, resource_id, device_transform,
                       device_layer_quad, clip_region);
   else
     DrawContentQuadNoAA(frame, quad, resource_id, clip_region);
 }
 
 void GLRenderer::DrawContentQuadAA(const DrawingFrame* frame,
                                    const ContentDrawQuadBase* quad,
                                    ResourceId resource_id,
                                    const gfx::Transform& device_transform,
                                    const gfx::QuadF& aa_quad,
                                    const gfx::QuadF* clip_region) {
   if (!device_transform.IsInvertible())
     return;
 
   gfx::Rect tile_rect = quad->visible_rect;
 
   gfx::RectF tex_coord_rect = MathUtil::ScaleRectProportional(
-      quad->tex_coord_rect, quad->rect, tile_rect);
+      quad->tex_coord_rect, gfx::RectF(quad->rect), gfx::RectF(tile_rect));
   float tex_to_geom_scale_x = quad->rect.width() / quad->tex_coord_rect.width();
   float tex_to_geom_scale_y =
       quad->rect.height() / quad->tex_coord_rect.height();
 
   gfx::RectF clamp_geom_rect(tile_rect);
   gfx::RectF clamp_tex_rect(tex_coord_rect);
   // Clamp texture coordinates to avoid sampling outside the layer
   // by deflating the tile region half a texel or half a texel
   // minus epsilon for one pixel layers. The resulting clamp region
   // is mapped to the unit square by the vertex shader and mapped
@@ skipping 93 matching lines @@
       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, quad->rect, quad->visible_rect);
+      quad->tex_coord_rect, gfx::RectF(quad->rect),
+      gfx::RectF(quad->visible_rect));
   float tex_to_geom_scale_x = quad->rect.width() / quad->tex_coord_rect.width();
   float tex_to_geom_scale_y =
       quad->rect.height() / quad->tex_coord_rect.height();
 
   bool scaled = (tex_to_geom_scale_x != 1.f || tex_to_geom_scale_y != 1.f);
   GLenum filter = (scaled ||
                    !quad->shared_quad_state->quad_to_target_transform
                         .IsIdentityOrIntegerTranslation()) &&
                           !quad->nearest_neighbor
                       ? GL_LINEAR
@@ skipping 49 matching lines @@
                  vertex_tex_scale_y);
 
   SetBlendEnabled(quad->ShouldDrawWithBlending());
 
   SetShaderOpacity(quad->shared_quad_state->opacity, uniforms.alpha_location);
 
   // Pass quad coordinates to the uniform in the same order as GeometryBinding
   // does, then vertices will match the texture mapping in the vertex buffer.
   // The method SetShaderQuadF() changes the order of vertices and so it's
   // not used here.
-  gfx::QuadF tile_rect(quad->visible_rect);
+  gfx::QuadF tile_quad(gfx::RectF(quad->visible_rect));
   float width = quad->visible_rect.width();
   float height = quad->visible_rect.height();
   gfx::PointF top_left = quad->visible_rect.origin();
   if (clip_region) {
-    tile_rect = *clip_region;
+    tile_quad = *clip_region;
     float gl_uv[8] = {
-        (tile_rect.p4().x() - top_left.x()) / width,
-        (tile_rect.p4().y() - top_left.y()) / height,
-        (tile_rect.p1().x() - top_left.x()) / width,
-        (tile_rect.p1().y() - top_left.y()) / height,
-        (tile_rect.p2().x() - top_left.x()) / width,
-        (tile_rect.p2().y() - top_left.y()) / height,
-        (tile_rect.p3().x() - top_left.x()) / width,
-        (tile_rect.p3().y() - top_left.y()) / height,
+        (tile_quad.p4().x() - top_left.x()) / width,
+        (tile_quad.p4().y() - top_left.y()) / height,
+        (tile_quad.p1().x() - top_left.x()) / width,
+        (tile_quad.p1().y() - top_left.y()) / height,
+        (tile_quad.p2().x() - top_left.x()) / width,
+        (tile_quad.p2().y() - top_left.y()) / height,
+        (tile_quad.p3().x() - top_left.x()) / width,
+        (tile_quad.p3().y() - top_left.y()) / height,
     };
     PrepareGeometry(CLIPPED_BINDING);
     clipped_geometry_->InitializeCustomQuadWithUVs(
-        gfx::QuadF(quad->visible_rect), gl_uv);
+        gfx::QuadF(gfx::RectF(quad->visible_rect)), gl_uv);
   } else {
     PrepareGeometry(SHARED_BINDING);
   }
   float gl_quad[8] = {
-      tile_rect.p4().x(),
-      tile_rect.p4().y(),
-      tile_rect.p1().x(),
-      tile_rect.p1().y(),
-      tile_rect.p2().x(),
-      tile_rect.p2().y(),
-      tile_rect.p3().x(),
-      tile_rect.p3().y(),
+      tile_quad.p4().x(), tile_quad.p4().y(), tile_quad.p1().x(),
+      tile_quad.p1().y(), tile_quad.p2().x(), tile_quad.p2().y(),
+      tile_quad.p3().x(), tile_quad.p3().y(),
   };
   gl_->Uniform2fv(uniforms.quad_location, 4, gl_quad);
 
   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]);
 
   gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0);
@@ skipping 186 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 = quad->rect;
+  gfx::RectF 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 31 matching lines @@
                                           quad->resource_id());
   DCHECK_EQ(GL_TEXTURE0, GetActiveTextureUnit(gl_));
   gl_->BindTexture(GL_TEXTURE_EXTERNAL_OES, lock.texture_id());
 
   gl_->Uniform1i(program->fragment_shader().sampler_location(), 0);
 
   SetShaderOpacity(quad->shared_quad_state->opacity,
                    program->fragment_shader().alpha_location());
   if (!clip_region) {
     DrawQuadGeometry(frame, quad->shared_quad_state->quad_to_target_transform,
-                     quad->rect, program->vertex_shader().matrix_location());
+                     gfx::RectF(quad->rect),
+                     program->vertex_shader().matrix_location());
   } else {
     gfx::QuadF region_quad(*clip_region);
     region_quad.Scale(1.0f / quad->rect.width(), 1.0f / quad->rect.height());
     region_quad -= gfx::Vector2dF(0.5f, 0.5f);
     float uvs[8] = {0};
     GetScaledUVs(quad->visible_rect, clip_region, uvs);
     DrawQuadGeometryClippedByQuadF(
-        frame, quad->shared_quad_state->quad_to_target_transform, quad->rect,
-        region_quad, program->vertex_shader().matrix_location(), uvs);
+        frame, quad->shared_quad_state->quad_to_target_transform,
+        gfx::RectF(quad->rect), region_quad,
+        program->vertex_shader().matrix_location(), uvs);
   }
 }
 
 struct TextureProgramBinding {
   template <class Program>
   void Set(Program* program) {
     DCHECK(program);
     program_id = program->program();
     sampler_location = program->fragment_shader().sampler_location();
     matrix_location = program->vertex_shader().matrix_location();
@@ skipping 159 matching lines @@
   const float opacity = quad->shared_quad_state->opacity;
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[0] * opacity);
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[1] * opacity);
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[2] * opacity);
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[3] * opacity);
 
   // Generate the transform matrix
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix,
                     quad->shared_quad_state->quad_to_target_transform,
-                    quad->rect);
+                    gfx::RectF(quad->rect));
   quad_rect_matrix = frame->projection_matrix * quad_rect_matrix;
 
   Float16 m;
   quad_rect_matrix.matrix().asColMajorf(m.data);
   draw_cache_.matrix_data.push_back(m);
 
   if (clip_region) {
     gfx::QuadF scaled_region;
     if (!GetScaledRegion(quad->rect, clip_region, &scaled_region)) {
       scaled_region = SharedGeometryQuad().BoundingBox();
@@ skipping 45 matching lines @@
                                   quad->shared_quad_state->opacity};
   gl_->Uniform1fv(binding.vertex_opacity_location, 4, vertex_opacity);
 
   ResourceProvider::ScopedReadLockGL lock(resource_provider_,
                                           quad->io_surface_resource_id());
   DCHECK_EQ(GL_TEXTURE0, GetActiveTextureUnit(gl_));
   gl_->BindTexture(GL_TEXTURE_RECTANGLE_ARB, lock.texture_id());
 
   if (!clip_region) {
     DrawQuadGeometry(frame, quad->shared_quad_state->quad_to_target_transform,
-                     quad->rect, binding.matrix_location);
+                     gfx::RectF(quad->rect), binding.matrix_location);
   } else {
     float uvs[8] = {0};
     GetScaledUVs(quad->visible_rect, clip_region, uvs);
     DrawQuadGeometryClippedByQuadF(
-        frame, quad->shared_quad_state->quad_to_target_transform, quad->rect,
-        *clip_region, binding.matrix_location, uvs);
+        frame, quad->shared_quad_state->quad_to_target_transform,
+        gfx::RectF(quad->rect), *clip_region, binding.matrix_location, uvs);
   }
 
   gl_->BindTexture(GL_TEXTURE_RECTANGLE_ARB, 0);
 }
 
 void GLRenderer::FinishDrawingFrame(DrawingFrame* frame) {
   if (use_sync_query_) {
     DCHECK(current_sync_query_);
     current_sync_query_->End();
     pending_sync_queries_.push_back(current_sync_query_.Pass());
   }
 
   current_framebuffer_lock_ = nullptr;
-  swap_buffer_rect_.Union(gfx::ToEnclosingRect(frame->root_damage_rect));
+  swap_buffer_rect_.Union(frame->root_damage_rect);
 
   gl_->Disable(GL_BLEND);
   blend_shadow_ = false;
 
   ScheduleOverlays(frame);
 }
 
 void GLRenderer::FinishDrawingQuadList() {
   FlushTextureQuadCache(SHARED_BINDING);
 }
@@ skipping 1067 matching lines @@
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order,
         overlay.transform,
         pending_overlay_resources_.back()->texture_id(),
         ToNearestRect(overlay.display_rect),
         overlay.uv_rect);
   }
 }
 
 }  // namespace cc