cc: Remove separate x/y raster scales.

cc/tiles/picture_layer_tiling_unittest.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/tiles/picture_layer_tiling.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <set>
@@ skipping 58 matching lines @@
   TestablePictureLayerTiling(WhichTree tree,
                              float contents_scale,
                              scoped_refptr<RasterSource> raster_source,
                              PictureLayerTilingClient* client,
                              size_t tiling_interest_area_padding,
                              float skewport_target_time,
                              int skewport_extrapolation_limit,
                              float min_preraster_distance,
                              float max_preraster_distance)
       : PictureLayerTiling(tree,
-                           gfx::SizeF(contents_scale, contents_scale),
+                           contents_scale,
                            raster_source,
                            client,
                            min_preraster_distance,
                            max_preraster_distance) {}
 };
 
 class PictureLayerTilingIteratorTest : public testing::Test {
  public:
   PictureLayerTilingIteratorTest() {}
   ~PictureLayerTilingIteratorTest() override {}
@@ skipping 36 matching lines @@
   void VerifyTilesExactlyCoverRect(
       float rect_scale,
       const gfx::Rect& request_rect,
       const gfx::Rect& expect_rect) {
     EXPECT_TRUE(request_rect.Contains(expect_rect));
 
     // Iterators are not valid if the destination scale is smaller than the
     // tiling scale. This is because coverage computation is done in integer
     // grids in the dest space, and the overlap between tiles may not guarantee
     // to enclose an integer grid line to round to if scaled down.
-    ASSERT_GE(rect_scale, tiling_->contents_scale_key());
+    ASSERT_GE(rect_scale, tiling_->contents_scale());
 
     Region remaining = expect_rect;
     for (PictureLayerTiling::CoverageIterator
              iter(tiling_.get(), rect_scale, request_rect);
          iter;
          ++iter) {
       // Geometry cannot overlap previous geometry at all
       gfx::Rect geometry = iter.geometry_rect();
       EXPECT_TRUE(expect_rect.Contains(geometry));
       EXPECT_TRUE(remaining.Contains(geometry));
@@ skipping 47 matching lines @@
          iter;
          ++iter) {
       remaining.Subtract(iter.geometry_rect());
       callback.Run(*iter, iter.geometry_rect());
     }
     EXPECT_TRUE(remaining.IsEmpty());
   }
 
   void VerifyTilesCoverNonContainedRect(float rect_scale,
                                         const gfx::Rect& dest_rect) {
-    float dest_to_contents_scale = tiling_->contents_scale_key() / rect_scale;
+    float dest_to_contents_scale = tiling_->contents_scale() / rect_scale;
     gfx::Rect clamped_rect = gfx::ScaleToEnclosingRect(
         gfx::Rect(tiling_->tiling_size()), 1.f / dest_to_contents_scale);
     clamped_rect.Intersect(dest_rect);
     VerifyTilesExactlyCoverRect(rect_scale, dest_rect, clamped_rect);
   }
 
  protected:
   FakePictureLayerTilingClient client_;
   std::unique_ptr<TestablePictureLayerTiling> tiling_;
   bool loose_texel_extent_check_ = false;
@@ skipping 869 matching lines @@
 
   active_tiling->TakeTilesAndPropertiesFrom(tiling_.get(),
                                             Region(gfx::Rect(bounds)));
   for (const auto* tile : tiles) {
     EXPECT_EQ(tile->tiling(), active_tiling.get());
   }
 }
 
 }  // namespace
 }  // namespace cc