cc: Remove separate x/y raster scales.

cc/tiles/tile_manager_unittest.cc

 // Copyright 2013 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 <stddef.h>
 #include <stdint.h>
 
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 312 matching lines @@
   active_layer()->tilings()->AddTiling(1.7f, active_layer()->raster_source());
 
   pending_layer()->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f,
                                                    5.0, Occlusion(), true);
   active_layer()->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f, 5.0,
                                                   Occlusion(), true);
 
   std::set<Tile*> all_expected_tiles;
   for (size_t i = 0; i < pending_layer()->num_tilings(); ++i) {
     PictureLayerTiling* tiling = pending_layer()->tilings()->tiling_at(i);
-    if (tiling->contents_scale_key() == 1.f) {
+    if (tiling->contents_scale() == 1.f) {
       tiling->set_resolution(HIGH_RESOLUTION);
       const auto& all_tiles = tiling->AllTilesForTesting();
       all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
     } else {
       tiling->set_resolution(NON_IDEAL_RESOLUTION);
     }
   }
 
   for (size_t i = 0; i < active_layer()->num_tilings(); ++i) {
     PictureLayerTiling* tiling = active_layer()->tilings()->tiling_at(i);
-    if (tiling->contents_scale_key() == 1.5f) {
+    if (tiling->contents_scale() == 1.5f) {
       tiling->set_resolution(HIGH_RESOLUTION);
       const auto& all_tiles = tiling->AllTilesForTesting();
       all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
     } else {
       tiling->set_resolution(NON_IDEAL_RESOLUTION);
       // Non ideal tilings with a high res pending twin have to be processed
       // because of possible activation tiles.
-      if (tiling->contents_scale_key() == 1.f) {
+      if (tiling->contents_scale() == 1.f) {
         tiling->UpdateAndGetAllPrioritizedTilesForTesting();
         const auto& all_tiles = tiling->AllTilesForTesting();
         for (auto* tile : all_tiles)
           EXPECT_TRUE(tile->required_for_activation());
         all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
       }
     }
   }
 
   std::unique_ptr<RasterTilePriorityQueue> queue(host_impl()->BuildRasterQueue(
@@ skipping 27 matching lines @@
   active_layer()->tilings()->AddTiling(1.7f, active_layer()->raster_source());
 
   pending_layer()->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f,
                                                    5.0, Occlusion(), true);
   active_layer()->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f, 5.0,
                                                   Occlusion(), true);
 
   std::set<Tile*> all_expected_tiles;
   for (size_t i = 0; i < pending_layer()->num_tilings(); ++i) {
     PictureLayerTiling* tiling = pending_layer()->tilings()->tiling_at(i);
-    if (tiling->contents_scale_key() == 1.f) {
+    if (tiling->contents_scale() == 1.f) {
       tiling->set_resolution(HIGH_RESOLUTION);
       const auto& all_tiles = tiling->AllTilesForTesting();
       all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
     } else {
       tiling->set_resolution(NON_IDEAL_RESOLUTION);
     }
   }
 
   for (size_t i = 0; i < active_layer()->num_tilings(); ++i) {
     PictureLayerTiling* tiling = active_layer()->tilings()->tiling_at(i);
-    if (tiling->contents_scale_key() == 1.5f) {
+    if (tiling->contents_scale() == 1.5f) {
       tiling->set_resolution(HIGH_RESOLUTION);
       const auto& all_tiles = tiling->AllTilesForTesting();
       all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
     } else {
       tiling->set_resolution(LOW_RESOLUTION);
       // Low res tilings with a high res pending twin have to be processed
       // because of possible activation tiles.
-      if (tiling->contents_scale_key() == 1.f) {
+      if (tiling->contents_scale() == 1.f) {
         tiling->UpdateAndGetAllPrioritizedTilesForTesting();
         const auto& all_tiles = tiling->AllTilesForTesting();
         for (auto* tile : all_tiles)
           EXPECT_TRUE(tile->required_for_activation());
         all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
       }
     }
   }
 
   std::unique_ptr<RasterTilePriorityQueue> queue(host_impl()->BuildRasterQueue(
@@ skipping 437 matching lines @@
 
       bool last_tile_is_occluded = last_tile.is_occluded();
       if (!last_tile_is_occluded) {
         TilePriority::PriorityBin tile_priority_bin =
             prioritized_tile.priority().priority_bin;
         TilePriority::PriorityBin last_tile_priority_bin =
             last_tile.priority().priority_bin;
 
         EXPECT_TRUE((tile_priority_bin < last_tile_priority_bin) ||
                     prioritized_tile.tile()->required_for_activation() ||
-                    (prioritized_tile.tile()->contents_scale_key() !=
-                     last_tile.tile()->contents_scale_key()));
+                    (prioritized_tile.tile()->contents_scale() !=
+                     last_tile.tile()->contents_scale()));
       }
     }
     last_tile = prioritized_tile;
     queue->Pop();
   }
   size_t expected_occluded_count = pending_child_high_res_tiles.size();
   EXPECT_EQ(expected_occluded_count, occluded_count);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest,
@@ skipping 990 matching lines @@
 }
 
 // Ensures that the tile manager does not attempt to reuse tiles when partial
 // raster is disabled.
 TEST_F(TileManagerTest, PartialRasterSuccessfullyDisabled) {
   RunPartialRasterCheck(TakeHostImpl(), false /* partial_raster_enabled */);
 }
 
 }  // namespace
 }  // namespace cc