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

cc/output/renderer_pixeltest.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 "base/message_loop/message_loop.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/picture_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/resources/video_resource_updater.h"
@@ skipping 731 matching lines @@
       true, this->back_quad_state_, this->resource_provider_.get(),
       this->render_pass_.get());
 
   SCOPED_TRACE("IntersectingTexturedQuads");
   this->template AppendBackgroundAndRunTest<TextureDrawQuad>(
       FuzzyPixelComparator(false, 2.f, 0.f, 256.f, 256, 0.f));
 }
 
 TYPED_TEST(IntersectingQuadSoftwareTest, PictureQuads) {
   this->SetupQuadStateAndRenderPass();
-  gfx::RectF outer_rect(this->quad_rect_);
-  gfx::RectF inner_rect(this->quad_rect_.x() + (this->quad_rect_.width() / 4),
-                        this->quad_rect_.y() + (this->quad_rect_.height() / 4),
-                        this->quad_rect_.width() / 2,
-                        this->quad_rect_.height() / 2);
+  gfx::Rect outer_rect(this->quad_rect_);
+  gfx::Rect inner_rect(this->quad_rect_.x() + (this->quad_rect_.width() / 4),
+                       this->quad_rect_.y() + (this->quad_rect_.height() / 4),
+                       this->quad_rect_.width() / 2,
+                       this->quad_rect_.height() / 2);
 
   SkPaint black_paint;
   black_paint.setColor(SK_ColorBLACK);
   SkPaint blue_paint;
   blue_paint.setColor(SK_ColorBLUE);
   SkPaint green_paint;
   green_paint.setColor(SK_ColorGREEN);
 
   scoped_ptr<FakePicturePile> blue_recording =
       FakePicturePile::CreateFilledPile(gfx::Size(1000, 1000),
                                         this->quad_rect_.size());
   blue_recording->add_draw_rect_with_paint(outer_rect, black_paint);
   blue_recording->add_draw_rect_with_paint(inner_rect, blue_paint);
   blue_recording->Rerecord();
   scoped_refptr<FakePicturePileImpl> blue_pile =
       FakePicturePileImpl::CreateFromPile(blue_recording.get(), nullptr);
 
   PictureDrawQuad* blue_quad =
       this->render_pass_->template CreateAndAppendDrawQuad<PictureDrawQuad>();
 
   blue_quad->SetNew(this->front_quad_state_, this->quad_rect_, gfx::Rect(),
-                    this->quad_rect_, this->quad_rect_, this->quad_rect_.size(),
-                    false, RGBA_8888, this->quad_rect_, 1.f, blue_pile);
+                    this->quad_rect_, gfx::RectF(this->quad_rect_),
+                    this->quad_rect_.size(), false, RGBA_8888, this->quad_rect_,
+                    1.f, blue_pile);
 
   scoped_ptr<FakePicturePile> green_recording =
       FakePicturePile::CreateFilledPile(this->quad_rect_.size(),
                                         this->quad_rect_.size());
   green_recording->add_draw_rect_with_paint(outer_rect, green_paint);
   green_recording->add_draw_rect_with_paint(inner_rect, black_paint);
   green_recording->Rerecord();
   scoped_refptr<FakePicturePileImpl> green_pile =
       FakePicturePileImpl::CreateFromPile(green_recording.get(), nullptr);
 
   PictureDrawQuad* green_quad =
       this->render_pass_->template CreateAndAppendDrawQuad<PictureDrawQuad>();
   green_quad->SetNew(this->back_quad_state_, this->quad_rect_, gfx::Rect(),
-                     this->quad_rect_, this->quad_rect_,
+                     this->quad_rect_, gfx::RectF(this->quad_rect_),
                      this->quad_rect_.size(), false, RGBA_8888,
                      this->quad_rect_, 1.f, green_pile);
   SCOPED_TRACE("IntersectingPictureQuadsPass");
   this->template AppendBackgroundAndRunTest<PictureDrawQuad>(
       FuzzyPixelComparator(false, 2.f, 0.f, 256.f, 256, 0.f));
 }
 
 TYPED_TEST(IntersectingQuadPixelTest, RenderPassQuads) {
   this->SetupQuadStateAndRenderPass();
   RenderPassId child_pass_id1(2, 2);
@@ skipping 1387 matching lines @@
   red_paint.setColor(SK_ColorRED);
   blue_recording->add_draw_rect_with_paint(blue_rect, red_paint);
   SkPaint blue_paint;
   blue_paint.setColor(SK_ColorBLUE);
   blue_recording->add_draw_rect_with_paint(blue_clip_rect, blue_paint);
   blue_recording->Rerecord();
 
   scoped_refptr<FakePicturePileImpl> blue_pile =
       FakePicturePileImpl::CreateFromPile(blue_recording.get(), nullptr);
 
+  gfx::Vector2d offset(viewport.bottom_right() - blue_rect.bottom_right());
   gfx::Transform blue_quad_to_target_transform;
-  gfx::Vector2d offset(viewport.bottom_right() - blue_rect.bottom_right());
   blue_quad_to_target_transform.Translate(offset.x(), offset.y());
-  gfx::RectF blue_scissor_rect = blue_clip_rect;
-  blue_quad_to_target_transform.TransformRect(&blue_scissor_rect);
-  SharedQuadState* blue_shared_state = CreateTestSharedQuadStateClipped(
-      blue_quad_to_target_transform, blue_rect,
-      gfx::ToEnclosingRect(blue_scissor_rect), pass.get());
+  gfx::Rect blue_target_clip_rect = MathUtil::MapEnclosingClippedRect(
+      blue_quad_to_target_transform, blue_clip_rect);
+  SharedQuadState* blue_shared_state =
+      CreateTestSharedQuadStateClipped(blue_quad_to_target_transform, blue_rect,
+                                       blue_target_clip_rect, pass.get());
 
   PictureDrawQuad* blue_quad = pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
 
   blue_quad->SetNew(blue_shared_state,
                     viewport,  // Intentionally bigger than clip.
                     gfx::Rect(), viewport, gfx::RectF(viewport),
                     viewport.size(), nearest_neighbor, texture_format, viewport,
                     1.f, blue_pile.get());
 
   // One viewport-filling green quad.
@@ skipping 242 matching lines @@
   gfx::Transform transform_to_root;
   scoped_ptr<RenderPass> pass =
       CreateTestRenderPass(id, viewport, transform_to_root);
 
   gfx::Transform quad_to_target_transform;
   SharedQuadState* shared_state =
       CreateTestSharedQuadState(quad_to_target_transform, viewport, pass.get());
 
   TileDrawQuad* quad = pass->CreateAndAppendDrawQuad<TileDrawQuad>();
   quad->SetNew(shared_state, viewport, gfx::Rect(), viewport, resource,
-               gfx::Rect(tile_size), tile_size, swizzle_contents,
+               gfx::RectF(gfx::Rect(tile_size)), tile_size, swizzle_contents,
                nearest_neighbor);
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   EXPECT_TRUE(this->RunPixelTest(
       &pass_list,
       base::FilePath(FILE_PATH_LITERAL("four_blue_green_checkers.png")),
       ExactPixelComparator(true)));
 }
@@ skipping 193 matching lines @@
       FakePicturePile::CreateFilledPile(pile_tile_size, layer_rect.size());
 
   Region outside(layer_rect);
   outside.Subtract(gfx::ToEnclosingRect(union_layer_rect));
   for (Region::Iterator iter(outside); iter.has_rect(); iter.next()) {
     recording->add_draw_rect_with_paint(iter.rect(), red_paint);
   }
 
   SkPaint blue_paint;
   blue_paint.setColor(SK_ColorBLUE);
-  recording->add_draw_rect_with_paint(blue_layer_rect1, blue_paint);
-  recording->add_draw_rect_with_paint(blue_layer_rect2, blue_paint);
+  recording->add_draw_rectf_with_paint(blue_layer_rect1, blue_paint);
+  recording->add_draw_rectf_with_paint(blue_layer_rect2, blue_paint);
   recording->Rerecord();
   scoped_refptr<FakePicturePileImpl> pile =
       FakePicturePileImpl::CreateFromPile(recording.get(), nullptr);
 
   gfx::Rect content_rect(
       gfx::ScaleToEnclosingRect(layer_rect, contents_scale));
   gfx::Rect content_union_rect(
       gfx::ToEnclosingRect(gfx::ScaleRect(union_layer_rect, contents_scale)));
 
   // At a scale of 4x the rectangles with a width of 2.5 will take up 10 pixels,
@@ skipping 237 matching lines @@
   EXPECT_TRUE(this->RunPixelTest(
       &pass_list,
       base::FilePath(FILE_PATH_LITERAL("wrap_mode_repeat.png")),
       FuzzyPixelOffByOneComparator(true)));
 }
 
 #endif  // !defined(OS_ANDROID)
 
 }  // namespace
 }  // namespace cc