cc: Remove separate x/y raster scales.

cc/playback/recording_source_unittest.cc

 // Copyright 2015 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 <vector>
 
 #include "base/memory/ptr_util.h"
 #include "cc/base/region.h"
 #include "cc/playback/raster_source.h"
 #include "cc/test/fake_client_picture_cache.h"
@@ skipping 60 matching lines @@
   recording_source->Rerecord();
 
   bool can_use_lcd_text = true;
   scoped_refptr<RasterSource> raster_source =
       RasterSource::CreateFromRecordingSource(recording_source.get(),
                                               can_use_lcd_text);
 
   // Tile sized iterators. These should find only one pixel ref.
   {
     std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 128, 128),
-                                              gfx::SizeF(1.f, 1.f), &images);
+    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 128, 128), 1.f,
+                                              &images);
     EXPECT_EQ(2u, images.size());
     EXPECT_TRUE(images[0].image() == discardable_image[0][0]);
     EXPECT_TRUE(images[1].image() == discardable_image[1][1]);
   }
 
   // Shifted tile sized iterators. These should find only one pixel ref.
   {
     std::vector<DrawImage> images;
     raster_source->GetDiscardableImagesInRect(gfx::Rect(130, 140, 128, 128),
-                                              gfx::SizeF(1.f, 1.f), &images);
+                                              1.f, &images);
     EXPECT_EQ(1u, images.size());
     EXPECT_TRUE(images[0].image() == discardable_image[1][1]);
   }
 
   // The rotated bitmap would still be in the top right tile.
   {
     std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(130, 0, 128, 128),
-                                              gfx::SizeF(1.f, 1.f), &images);
+    raster_source->GetDiscardableImagesInRect(gfx::Rect(130, 0, 128, 128), 1.f,
+                                              &images);
     EXPECT_EQ(1u, images.size());
     EXPECT_TRUE(images[0].image() == discardable_image[1][1]);
   }
 
   // Layer sized iterators. These should find all pixel refs.
   {
     std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 256, 256),
-                                              gfx::SizeF(1.f, 1.f), &images);
+    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 256, 256), 1.f,
+                                              &images);
     EXPECT_EQ(3u, images.size());
     // Top left tile with bitmap[0][0] and bitmap[1][1].
     EXPECT_TRUE(images[0].image() == discardable_image[0][0]);
     EXPECT_TRUE(images[1].image() == discardable_image[1][0]);
     EXPECT_TRUE(images[2].image() == discardable_image[1][1]);
   }
 
   // Verify different raster scales
-  for (float x_scale = 1.f; x_scale <= 5.f; x_scale += 0.5f) {
-    for (float y_scale = 1.f; y_scale <= 5.f; y_scale += 0.5f) {
-      std::vector<DrawImage> images;
-      raster_source->GetDiscardableImagesInRect(
-          gfx::Rect(130, 0, 128, 128), gfx::SizeF(x_scale, y_scale), &images);
-      EXPECT_EQ(1u, images.size());
-      EXPECT_FLOAT_EQ(x_scale, images[0].scale().width());
-      EXPECT_FLOAT_EQ(y_scale, images[0].scale().height());
-    }
+  for (float scale = 1.f; scale <= 5.f; scale += 0.5f) {
+    std::vector<DrawImage> images;
+    raster_source->GetDiscardableImagesInRect(gfx::Rect(130, 0, 128, 128),
+                                              scale, &images);
+    EXPECT_EQ(1u, images.size());
+    EXPECT_FLOAT_EQ(scale, images[0].scale().width());
+    EXPECT_FLOAT_EQ(scale, images[0].scale().height());
   }
 }
 
 TEST(RecordingSourceTest, NoGatherImageEmptyImages) {
   gfx::Rect recorded_viewport(0, 0, 256, 256);
 
   std::unique_ptr<FakeRecordingSource> recording_source =
       CreateRecordingSource(recorded_viewport);
   recording_source->SetGenerateDiscardableImagesMetadata(false);
   recording_source->Rerecord();
 
   scoped_refptr<RasterSource> raster_source =
       CreateRasterSource(recording_source.get());
 
   // If recording source do not gather images, raster source is not going to
   // get images.
   {
     std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(recorded_viewport,
-                                              gfx::SizeF(1.f, 1.f), &images);
+    raster_source->GetDiscardableImagesInRect(recorded_viewport, 1.f, &images);
     EXPECT_TRUE(images.empty());
   }
 }
 
 TEST(RecordingSourceTest, EmptyImages) {
   gfx::Rect recorded_viewport(0, 0, 256, 256);
 
   std::unique_ptr<FakeRecordingSource> recording_source =
       CreateRecordingSource(recorded_viewport);
   recording_source->SetGenerateDiscardableImagesMetadata(true);
   recording_source->Rerecord();
 
   scoped_refptr<RasterSource> raster_source =
       CreateRasterSource(recording_source.get());
 
   // Tile sized iterators.
   {
     std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 128, 128),
-                                              gfx::SizeF(1.f, 1.f), &images);
+    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 128, 128), 1.f,
+                                              &images);
     EXPECT_TRUE(images.empty());
   }
   // Shifted tile sized iterators.
   {
     std::vector<DrawImage> images;
     raster_source->GetDiscardableImagesInRect(gfx::Rect(140, 140, 128, 128),
-                                              gfx::SizeF(1.f, 1.f), &images);
+                                              1.f, &images);
     EXPECT_TRUE(images.empty());
   }
   // Layer sized iterators.
   {
     std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 256, 256),
-                                              gfx::SizeF(1.f, 1.f), &images);
+    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 256, 256), 1.f,
+                                              &images);
     EXPECT_TRUE(images.empty());
   }
 }
 
 TEST(RecordingSourceTest, NoDiscardableImages) {
   gfx::Rect recorded_viewport(0, 0, 256, 256);
 
   std::unique_ptr<FakeRecordingSource> recording_source =
       CreateRecordingSource(recorded_viewport);
 
@@ skipping 19 matching lines @@
   recording_source->add_draw_image(non_discardable_image, gfx::Point(150, 150));
   recording_source->SetGenerateDiscardableImagesMetadata(true);
   recording_source->Rerecord();
 
   scoped_refptr<RasterSource> raster_source =
       CreateRasterSource(recording_source.get());
 
   // Tile sized iterators.
   {
     std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 128, 128),
-                                              gfx::SizeF(1.f, 1.f), &images);
+    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 128, 128), 1.f,
+                                              &images);
     EXPECT_TRUE(images.empty());
   }
   // Shifted tile sized iterators.
   {
     std::vector<DrawImage> images;
     raster_source->GetDiscardableImagesInRect(gfx::Rect(140, 140, 128, 128),
-                                              gfx::SizeF(1.f, 1.f), &images);
+                                              1.f, &images);
     EXPECT_TRUE(images.empty());
   }
   // Layer sized iterators.
   {
     std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 256, 256),
-                                              gfx::SizeF(1.f, 1.f), &images);
+    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 256, 256), 1.f,
+                                              &images);
     EXPECT_TRUE(images.empty());
   }
 }
 
 TEST(RecordingSourceTest, DiscardableImages) {
   gfx::Rect recorded_viewport(0, 0, 256, 256);
 
   std::unique_ptr<FakeRecordingSource> recording_source =
       CreateRecordingSource(recorded_viewport);
 
@@ skipping 14 matching lines @@
                                    gfx::Point(140, 140));
   recording_source->SetGenerateDiscardableImagesMetadata(true);
   recording_source->Rerecord();
 
   scoped_refptr<RasterSource> raster_source =
       CreateRasterSource(recording_source.get());
 
   // Tile sized iterators. These should find only one image.
   {
     std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 128, 128),
-                                              gfx::SizeF(1.f, 1.f), &images);
+    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 128, 128), 1.f,
+                                              &images);
     EXPECT_EQ(1u, images.size());
     EXPECT_TRUE(images[0].image() == discardable_image[0][0]);
   }
 
   // Shifted tile sized iterators. These should find only one image.
   {
     std::vector<DrawImage> images;
     raster_source->GetDiscardableImagesInRect(gfx::Rect(140, 140, 128, 128),
-                                              gfx::SizeF(1.f, 1.f), &images);
+                                              1.f, &images);
     EXPECT_EQ(1u, images.size());
     EXPECT_TRUE(images[0].image() == discardable_image[1][1]);
   }
 
   // Ensure there's no discardable images in the empty cell
   {
     std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(140, 0, 128, 128),
-                                              gfx::SizeF(1.f, 1.f), &images);
+    raster_source->GetDiscardableImagesInRect(gfx::Rect(140, 0, 128, 128), 1.f,
+                                              &images);
     EXPECT_TRUE(images.empty());
   }
 
   // Layer sized iterators. These should find all 3 images.
   {
     std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 256, 256),
-                                              gfx::SizeF(1.f, 1.f), &images);
+    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 256, 256), 1.f,
+                                              &images);
     EXPECT_EQ(3u, images.size());
     EXPECT_TRUE(images[0].image() == discardable_image[0][0]);
     EXPECT_TRUE(images[1].image() == discardable_image[1][0]);
     EXPECT_TRUE(images[2].image() == discardable_image[1][1]);
   }
 }
 
 TEST(RecordingSourceTest, DiscardableImagesBaseNonDiscardable) {
   gfx::Rect recorded_viewport(0, 0, 512, 512);
 
@@ skipping 25 matching lines @@
                                    gfx::Point(260, 260));
   recording_source->SetGenerateDiscardableImagesMetadata(true);
   recording_source->Rerecord();
 
   scoped_refptr<RasterSource> raster_source =
       CreateRasterSource(recording_source.get());
 
   // Tile sized iterators. These should find only one image.
   {
     std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 256, 256),
-                                              gfx::SizeF(1.f, 1.f), &images);
+    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 256, 256), 1.f,
+                                              &images);
     EXPECT_EQ(1u, images.size());
     EXPECT_TRUE(images[0].image() == discardable_image[0][0]);
   }
   // Shifted tile sized iterators. These should find only one image.
   {
     std::vector<DrawImage> images;
     raster_source->GetDiscardableImagesInRect(gfx::Rect(260, 260, 256, 256),
-                                              gfx::SizeF(1.f, 1.f), &images);
+                                              1.f, &images);
     EXPECT_EQ(1u, images.size());
     EXPECT_TRUE(images[0].image() == discardable_image[1][1]);
   }
   // Ensure there's no discardable images in the empty cell
   {
     std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 256, 256, 256),
-                                              gfx::SizeF(1.f, 1.f), &images);
+    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 256, 256, 256), 1.f,
+                                              &images);
     EXPECT_TRUE(images.empty());
   }
   // Layer sized iterators. These should find three images.
   {
     std::vector<DrawImage> images;
-    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 512, 512),
-                                              gfx::SizeF(1.f, 1.f), &images);
+    raster_source->GetDiscardableImagesInRect(gfx::Rect(0, 0, 512, 512), 1.f,
+                                              &images);
     EXPECT_EQ(3u, images.size());
     EXPECT_TRUE(images[0].image() == discardable_image[0][0]);
     EXPECT_TRUE(images[1].image() == discardable_image[0][1]);
     EXPECT_TRUE(images[2].image() == discardable_image[1][1]);
   }
 }
 
 }  // namespace
 }  // namespace cc