Raster PictureLayerTiling with fractional translation

cc/layers/picture_layer_impl_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 "cc/layers/picture_layer_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 173 matching lines @@
                         animating_transform_to_screen);
     layer->UpdateTiles();
   }
 
   static void VerifyAllPrioritizedTilesExistAndHaveRasterSource(
       const PictureLayerTiling* tiling,
       RasterSource* raster_source) {
     auto prioritized_tiles =
         tiling->UpdateAndGetAllPrioritizedTilesForTesting();
     for (PictureLayerTiling::CoverageIterator iter(
-             tiling, tiling->contents_scale(),
+             tiling, tiling->contents_scale_key(),
              gfx::Rect(tiling->tiling_size()));
          iter; ++iter) {
       EXPECT_TRUE(*iter);
       EXPECT_EQ(raster_source, prioritized_tiles[*iter].raster_source());
     }
   }
 
   void SetContentsScaleOnBothLayers(float contents_scale,
                                     float device_scale_factor,
                                     float page_scale_factor,
@@ skipping 111 matching lines @@
 
   // Verify the viewport rect for tile priority is used in picture layer tiling.
   EXPECT_EQ(viewport_rect_for_tile_priority_in_view_space,
             active_layer()->viewport_rect_for_tile_priority_in_content_space());
   PictureLayerTilingSet* tilings = active_layer()->tilings();
   for (size_t i = 0; i < tilings->num_tilings(); i++) {
     PictureLayerTiling* tiling = tilings->tiling_at(i);
     EXPECT_EQ(
         tiling->GetCurrentVisibleRectForTesting(),
         gfx::ScaleToEnclosingRect(viewport_rect_for_tile_priority_in_view_space,
-                                  tiling->contents_scale()));
+                                  tiling->contents_scale_key()));
   }
 
   // Update tiles with viewport for tile priority as (200, 200, 100, 100) in
   // screen space and the transform for tile priority is translated and
   // rotated. The actual viewport for tile priority used by PictureLayerImpl
   // should be (200, 200, 100, 100) applied with the said transform.
   host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(200));
 
   viewport_rect_for_tile_priority = gfx::Rect(200, 200, 100, 100);
   transform_for_tile_priority.Translate(100, 100);
@@ skipping 15 matching lines @@
                                             viewport_rect_for_tile_priority);
 
   EXPECT_EQ(viewport_rect_for_tile_priority_in_view_space,
             active_layer()->viewport_rect_for_tile_priority_in_content_space());
   tilings = active_layer()->tilings();
   for (size_t i = 0; i < tilings->num_tilings(); i++) {
     PictureLayerTiling* tiling = tilings->tiling_at(i);
     EXPECT_EQ(
         tiling->GetCurrentVisibleRectForTesting(),
         gfx::ScaleToEnclosingRect(viewport_rect_for_tile_priority_in_view_space,
-                                  tiling->contents_scale()));
+                                  tiling->contents_scale_key()));
   }
 }
 
 TEST_F(PictureLayerImplTest, ViewportRectForTilePriorityIsCached) {
   host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
   gfx::Size layer_bounds(400, 400);
   SetupDefaultTrees(layer_bounds);
 
   SetupDrawPropertiesAndUpdateTiles(active_layer(), 1.f, 1.f, 1.f, 1.f, 0.f,
                                     false);
@@ skipping 37 matching lines @@
       FakeRasterSource::CreateFilled(layer_bounds);
   scoped_refptr<FakeRasterSource> active_raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
   scoped_refptr<FakeRasterSource> lost_raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
 
   SetupPendingTreeWithFixedTileSize(lost_raster_source, gfx::Size(50, 50),
                                     Region());
   ActivateTree();
   // Add a unique tiling on the active tree.
-  PictureLayerTiling* tiling = active_layer()->AddTiling(3.f);
+  PictureLayerTiling* tiling =
+      active_layer()->AddTiling(ScaleTranslate2d(3.f, gfx::Vector2dF()));
   tiling->set_resolution(HIGH_RESOLUTION);
   tiling->CreateAllTilesForTesting();
 
   // Ensure UpdateTiles won't remove any tilings.
   active_layer()->MarkAllTilingsUsed();
 
   // Then setup a new pending tree and activate it.
   SetupTreesWithFixedTileSize(pending_raster_source, active_raster_source,
                               gfx::Size(50, 50), layer_invalidation);
 
   EXPECT_EQ(1u, pending_layer()->num_tilings());
   EXPECT_EQ(3u, active_layer()->num_tilings());
 
   const PictureLayerTilingSet* tilings = pending_layer()->tilings();
   EXPECT_GT(tilings->num_tilings(), 0u);
   for (size_t i = 0; i < tilings->num_tilings(); ++i) {
     const PictureLayerTiling* tiling = tilings->tiling_at(i);
-    gfx::Rect content_invalidation =
-        gfx::ScaleToEnclosingRect(layer_invalidation, tiling->contents_scale());
+    gfx::Rect content_invalidation = gfx::ScaleToEnclosingRect(
+        layer_invalidation, tiling->contents_scale_key());
     auto prioritized_tiles =
         tiling->UpdateAndGetAllPrioritizedTilesForTesting();
     for (PictureLayerTiling::CoverageIterator iter(
-             tiling, tiling->contents_scale(),
+             tiling, tiling->contents_scale_key(),
              gfx::Rect(tiling->tiling_size()));
          iter; ++iter) {
       // We don't always have a tile, but when we do it's because it was
       // invalidated and it has the latest raster source.
       if (*iter) {
         EXPECT_FALSE(iter.geometry_rect().IsEmpty());
         EXPECT_EQ(pending_raster_source.get(),
                   prioritized_tiles[*iter].raster_source());
         EXPECT_TRUE(iter.geometry_rect().Intersects(content_invalidation));
       } else {
         // We don't create tiles in non-invalidated regions.
         EXPECT_FALSE(iter.geometry_rect().Intersects(content_invalidation));
       }
     }
   }
 
   tilings = active_layer()->tilings();
   EXPECT_GT(tilings->num_tilings(), 0u);
   for (size_t i = 0; i < tilings->num_tilings(); ++i) {
     const PictureLayerTiling* tiling = tilings->tiling_at(i);
     auto prioritized_tiles =
         tiling->UpdateAndGetAllPrioritizedTilesForTesting();
     for (PictureLayerTiling::CoverageIterator iter(
-             tiling, tiling->contents_scale(),
+             tiling, tiling->contents_scale_key(),
              gfx::Rect(tiling->tiling_size()));
          iter; ++iter) {
       EXPECT_TRUE(*iter);
       EXPECT_FALSE(iter.geometry_rect().IsEmpty());
       // Raster source will be updated upon activation.
       EXPECT_EQ(active_raster_source.get(),
                 prioritized_tiles[*iter].raster_source());
     }
   }
 }
@@ skipping 33 matching lines @@
   EXPECT_EQ(0u, active_layer()->tilings()->num_tilings());
 
   SetupDrawPropertiesAndUpdateTiles(active_layer(),
                                     6.f,  // ideal contents scale
                                     3.f,  // device scale
                                     2.f,  // page scale
                                     1.f,  // maximum animation scale
                                     0.f,  // starting animation scale
                                     false);
   ASSERT_EQ(2u, active_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(6.f,
-                  active_layer()->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_FLOAT_EQ(6.f * low_res_factor,
-                  active_layer()->tilings()->tiling_at(1)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      6.f, active_layer()->tilings()->tiling_at(0)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      6.f * low_res_factor,
+      active_layer()->tilings()->tiling_at(1)->contents_scale_key());
 
   // If we change the page scale factor, then we should get new tilings.
   SetupDrawPropertiesAndUpdateTiles(active_layer(),
                                     6.6f,  // ideal contents scale
                                     3.f,   // device scale
                                     2.2f,  // page scale
                                     1.f,   // maximum animation scale
                                     0.f,   // starting animation scale
                                     false);
   ASSERT_EQ(4u, active_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(6.6f,
-                  active_layer()->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_FLOAT_EQ(6.6f * low_res_factor,
-                  active_layer()->tilings()->tiling_at(2)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      6.6f, active_layer()->tilings()->tiling_at(0)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      6.6f * low_res_factor,
+      active_layer()->tilings()->tiling_at(2)->contents_scale_key());
 
   // If we change the device scale factor, then we should get new tilings.
   SetupDrawPropertiesAndUpdateTiles(active_layer(),
                                     7.26f,  // ideal contents scale
                                     3.3f,   // device scale
                                     2.2f,   // page scale
                                     1.f,    // maximum animation scale
                                     0.f,    // starting animation scale
                                     false);
   ASSERT_EQ(6u, active_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(7.26f,
-                  active_layer()->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_FLOAT_EQ(7.26f * low_res_factor,
-                  active_layer()->tilings()->tiling_at(3)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      7.26f, active_layer()->tilings()->tiling_at(0)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      7.26f * low_res_factor,
+      active_layer()->tilings()->tiling_at(3)->contents_scale_key());
 
   // If we change the device scale factor, but end up at the same total scale
   // factor somehow, then we don't get new tilings.
   SetupDrawPropertiesAndUpdateTiles(active_layer(),
                                     7.26f,  // ideal contents scale
                                     2.2f,   // device scale
                                     3.3f,   // page scale
                                     1.f,    // maximum animation scale
                                     0.f,    // starting animation scale
                                     false);
   ASSERT_EQ(6u, active_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(7.26f,
-                  active_layer()->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_FLOAT_EQ(7.26f * low_res_factor,
-                  active_layer()->tilings()->tiling_at(3)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      7.26f, active_layer()->tilings()->tiling_at(0)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      7.26f * low_res_factor,
+      active_layer()->tilings()->tiling_at(3)->contents_scale_key());
 }
 
 TEST_F(PictureLayerImplTest, PendingLayerOnlyHasHighResTiling) {
   gfx::Size layer_bounds(1300, 1900);
   SetupDefaultTrees(layer_bounds);
 
   float low_res_factor = host_impl()->settings().low_res_contents_scale_factor;
   EXPECT_LT(low_res_factor, 1.f);
 
   pending_layer()->ReleaseTileResources();
   EXPECT_FALSE(pending_layer()->tilings());
   pending_layer()->RecreateTileResources();
   EXPECT_EQ(0u, pending_layer()->tilings()->num_tilings());
 
   SetupDrawPropertiesAndUpdateTiles(pending_layer(),
                                     6.f,  // ideal contents scale
                                     3.f,  // device scale
                                     2.f,  // page scale
                                     1.f,  // maximum animation scale
                                     0.f,  // starting animation scale
                                     false);
   ASSERT_EQ(1u, pending_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(6.f,
-                  pending_layer()->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      6.f, pending_layer()->tilings()->tiling_at(0)->contents_scale_key());
 
   // If we change the page scale factor, then we should get new tilings.
   SetupDrawPropertiesAndUpdateTiles(pending_layer(),
                                     6.6f,  // ideal contents scale
                                     3.f,   // device scale
                                     2.2f,  // page scale
                                     1.f,   // maximum animation scale
                                     0.f,   // starting animation scale
                                     false);
   ASSERT_EQ(1u, pending_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(6.6f,
-                  pending_layer()->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      6.6f, pending_layer()->tilings()->tiling_at(0)->contents_scale_key());
 
   // If we change the device scale factor, then we should get new tilings.
   SetupDrawPropertiesAndUpdateTiles(pending_layer(),
                                     7.26f,  // ideal contents scale
                                     3.3f,   // device scale
                                     2.2f,   // page scale
                                     1.f,    // maximum animation scale
                                     0.f,    // starting animation scale
                                     false);
   ASSERT_EQ(1u, pending_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(7.26f,
-                  pending_layer()->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      7.26f, pending_layer()->tilings()->tiling_at(0)->contents_scale_key());
 
   // If we change the device scale factor, but end up at the same total scale
   // factor somehow, then we don't get new tilings.
   SetupDrawPropertiesAndUpdateTiles(pending_layer(),
                                     7.26f,  // ideal contents scale
                                     2.2f,   // device scale
                                     3.3f,   // page scale
                                     1.f,    // maximum animation scale
                                     0.f,    // starting animation scale
                                     false);
   ASSERT_EQ(1u, pending_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(7.26f,
-                  pending_layer()->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      7.26f, pending_layer()->tilings()->tiling_at(0)->contents_scale_key());
 }
 
 TEST_F(PictureLayerImplTest, CreateTilingsEvenIfTwinHasNone) {
   // This test makes sure that if a layer can have tilings, then a commit makes
   // it not able to have tilings (empty size), and then a future commit that
   // makes it valid again should be able to create tilings.
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakeRasterSource> empty_raster_source =
       FakeRasterSource::CreateEmpty(layer_bounds);
@@ skipping 46 matching lines @@
 }
 
 TEST_F(PictureLayerImplTest, ZoomOutCrash) {
   gfx::Size layer_bounds(1300, 1900);
 
   // Set up the high and low res tilings before pinch zoom.
   SetupDefaultTrees(layer_bounds);
   ResetTilingsAndRasterScales();
   EXPECT_EQ(0u, active_layer()->tilings()->num_tilings());
   SetContentsScaleOnBothLayers(32.0f, 1.0f, 32.0f, 1.0f, 0.f, false);
-  EXPECT_EQ(32.f, active_layer()->HighResTiling()->contents_scale());
+  EXPECT_EQ(32.f, active_layer()->HighResTiling()->contents_scale_key());
   host_impl()->PinchGestureBegin();
   SetContentsScaleOnBothLayers(1.0f, 1.0f, 1.0f, 1.0f, 0.f, false);
   SetContentsScaleOnBothLayers(1.0f, 1.0f, 1.0f, 1.0f, 0.f, false);
   EXPECT_EQ(active_layer()->tilings()->NumHighResTilings(), 1);
 }
 
 TEST_F(PictureLayerImplTest, ScaledBoundsOverflowInt) {
   // Limit visible size.
   gfx::Size viewport_size(1, 1);
   host_impl()->SetViewportSize(viewport_size);
 
   gfx::Size layer_bounds(600000, 60);
 
   // Set up the high and low res tilings before pinch zoom.
   SetupDefaultTrees(layer_bounds);
   ResetTilingsAndRasterScales();
   EXPECT_EQ(0u, active_layer()->tilings()->num_tilings());
   float scale = 8000.f;
 
   // Verify this will overflow an int.
   EXPECT_GT(static_cast<float>(layer_bounds.width()) * scale,
             static_cast<float>(std::numeric_limits<int>::max()));
 
   SetContentsScaleOnBothLayers(scale, 1.0f, scale, 1.0f, 0.f, false);
-  float adjusted_scale = active_layer()->HighResTiling()->contents_scale();
+  float adjusted_scale = active_layer()->HighResTiling()->contents_scale_key();
   EXPECT_LT(adjusted_scale, scale);
 
   // PopulateSharedQuadState CHECKs for overflows.
   // See http://crbug.com/679035
   active_layer()->draw_properties().visible_layer_rect =
       gfx::Rect(layer_bounds);
   SharedQuadState state;
   active_layer()->PopulateScaledSharedQuadState(&state, adjusted_scale,
                                                 adjusted_scale);
 }
 
 TEST_F(PictureLayerImplTest, PinchGestureTilings) {
   gfx::Size layer_bounds(1300, 1900);
 
   float low_res_factor = host_impl()->settings().low_res_contents_scale_factor;
   // Set up the high and low res tilings before pinch zoom.
   SetupDefaultTrees(layer_bounds);
   ResetTilingsAndRasterScales();
 
   SetContentsScaleOnBothLayers(2.f, 1.0f, 2.f, 1.0f, 0.f, false);
   EXPECT_EQ(active_layer()->num_tilings(), 2u);
   EXPECT_EQ(pending_layer()->num_tilings(), 1u);
-  EXPECT_EQ(active_layer()->tilings()->tiling_at(0)->contents_scale(), 2.f);
-  EXPECT_EQ(active_layer()->tilings()->tiling_at(1)->contents_scale(),
+  EXPECT_EQ(active_layer()->tilings()->tiling_at(0)->contents_scale_key(), 2.f);
+  EXPECT_EQ(active_layer()->tilings()->tiling_at(1)->contents_scale_key(),
             2.f * low_res_factor);
   // One of the tilings has to be a low resolution one.
   EXPECT_EQ(LOW_RESOLUTION,
             active_layer()->tilings()->tiling_at(1)->resolution());
 
   // Ensure UpdateTiles won't remove any tilings.
   active_layer()->MarkAllTilingsUsed();
 
   // Start a pinch gesture.
   host_impl()->PinchGestureBegin();
 
   // Zoom out by a small amount. We should create a tiling at half
   // the scale (2/kMaxScaleRatioDuringPinch).
   SetContentsScaleOnBothLayers(1.8f, 1.0f, 1.8f, 1.0f, 0.f, false);
   EXPECT_EQ(3u, active_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(2.0f,
-                  active_layer()->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_FLOAT_EQ(1.0f,
-                  active_layer()->tilings()->tiling_at(1)->contents_scale());
-  EXPECT_FLOAT_EQ(2.0f * low_res_factor,
-                  active_layer()->tilings()->tiling_at(2)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      2.0f, active_layer()->tilings()->tiling_at(0)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      1.0f, active_layer()->tilings()->tiling_at(1)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      2.0f * low_res_factor,
+      active_layer()->tilings()->tiling_at(2)->contents_scale_key());
   // Since we're pinching, we shouldn't create a low resolution tiling.
   EXPECT_FALSE(
       active_layer()->tilings()->FindTilingWithResolution(LOW_RESOLUTION));
 
   // Ensure UpdateTiles won't remove any tilings.
   active_layer()->MarkAllTilingsUsed();
 
   // Zoom out further, close to our low-res scale factor. We should
   // use that tiling as high-res, and not create a new tiling.
   SetContentsScaleOnBothLayers(low_res_factor * 2.1f, 1.0f,
                                low_res_factor * 2.1f, 1.0f, 0.f, false);
   EXPECT_EQ(3u, active_layer()->tilings()->num_tilings());
   EXPECT_FALSE(
       active_layer()->tilings()->FindTilingWithResolution(LOW_RESOLUTION));
 
   // Zoom in a lot now. Since we increase by increments of
   // kMaxScaleRatioDuringPinch, this will create a new tiling at 4.0.
   SetContentsScaleOnBothLayers(3.8f, 1.0f, 3.8f, 1.f, 0.f, false);
   EXPECT_EQ(4u, active_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(4.0f,
-                  active_layer()->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      4.0f, active_layer()->tilings()->tiling_at(0)->contents_scale_key());
   // Although one of the tilings matches the low resolution scale, it still
   // shouldn't be marked as low resolution since we're pinching.
   auto* low_res_tiling =
       active_layer()->tilings()->FindTilingWithScaleKey(4.f * low_res_factor);
   EXPECT_TRUE(low_res_tiling);
   EXPECT_NE(LOW_RESOLUTION, low_res_tiling->resolution());
 
   // Stop a pinch gesture.
   host_impl()->PinchGestureEnd();
 
   // Ensure UpdateTiles won't remove any tilings.
   active_layer()->MarkAllTilingsUsed();
 
   // After pinch ends, set the scale to what the raster scale was updated to
   // (checked above).
   SetContentsScaleOnBothLayers(4.0f, 1.0f, 4.0f, 1.f, 0.f, false);
   EXPECT_EQ(4u, active_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(4.0f,
-                  active_layer()->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      4.0f, active_layer()->tilings()->tiling_at(0)->contents_scale_key());
   // Now that we stopped pinching, the low resolution tiling that existed should
   // now be marked as low resolution.
   low_res_tiling =
       active_layer()->tilings()->FindTilingWithScaleKey(4.f * low_res_factor);
   EXPECT_TRUE(low_res_tiling);
   EXPECT_EQ(LOW_RESOLUTION, low_res_tiling->resolution());
 }
 
 TEST_F(PictureLayerImplTest, SnappedTilingDuringZoom) {
   gfx::Size layer_bounds(2600, 3800);
   SetupDefaultTrees(layer_bounds);
 
   ResetTilingsAndRasterScales();
   EXPECT_EQ(0u, active_layer()->tilings()->num_tilings());
 
   // Set up the high and low res tilings before pinch zoom.
   SetContentsScaleOnBothLayers(0.24f, 1.0f, 0.24f, 1.0f, 0.f, false);
   EXPECT_EQ(2u, active_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(0.24f,
-                  active_layer()->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_FLOAT_EQ(0.0625f,
-                  active_layer()->tilings()->tiling_at(1)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      0.24f, active_layer()->tilings()->tiling_at(0)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      0.0625f, active_layer()->tilings()->tiling_at(1)->contents_scale_key());
 
   // Ensure UpdateTiles won't remove any tilings.
   active_layer()->MarkAllTilingsUsed();
 
   // Start a pinch gesture.
   host_impl()->PinchGestureBegin();
 
   // Zoom out by a small amount. We should create a tiling at half
   // the scale (1/kMaxScaleRatioDuringPinch).
   SetContentsScaleOnBothLayers(0.2f, 1.0f, 0.2f, 1.0f, 0.f, false);
   EXPECT_EQ(3u, active_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(0.24f,
-                  active_layer()->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_FLOAT_EQ(0.12f,
-                  active_layer()->tilings()->tiling_at(1)->contents_scale());
-  EXPECT_FLOAT_EQ(0.0625,
-                  active_layer()->tilings()->tiling_at(2)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      0.24f, active_layer()->tilings()->tiling_at(0)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      0.12f, active_layer()->tilings()->tiling_at(1)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      0.0625, active_layer()->tilings()->tiling_at(2)->contents_scale_key());
 
   // Ensure UpdateTiles won't remove any tilings.
   active_layer()->MarkAllTilingsUsed();
 
   // Zoom out further, close to our low-res scale factor. We should
   // use that tiling as high-res, and not create a new tiling.
   SetContentsScaleOnBothLayers(0.1f, 1.0f, 0.1f, 1.0f, 0.f, false);
   EXPECT_EQ(3u, active_layer()->tilings()->num_tilings());
 
   // Zoom in. 0.25(desired_scale) should be snapped to 0.24 during zoom-in
   // because 0.25(desired_scale) is within the ratio(1.2).
   SetContentsScaleOnBothLayers(0.25f, 1.0f, 0.25f, 1.0f, 0.f, false);
   EXPECT_EQ(3u, active_layer()->tilings()->num_tilings());
 
   // Zoom in a lot. Since we move in factors of two, we should get a scale that
   // is a power of 2 times 0.24.
   SetContentsScaleOnBothLayers(1.f, 1.0f, 1.f, 1.0f, 0.f, false);
   EXPECT_EQ(4u, active_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(1.92f,
-                  active_layer()->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      1.92f, active_layer()->tilings()->tiling_at(0)->contents_scale_key());
 }
 
 TEST_F(PictureLayerImplTest, CleanUpTilings) {
   gfx::Size layer_bounds(1300, 1900);
 
   std::vector<PictureLayerTiling*> used_tilings;
 
   float low_res_factor = host_impl()->settings().low_res_contents_scale_factor;
   EXPECT_LT(low_res_factor, 1.f);
 
   float scale = 1.f;
   float page_scale = 1.f;
 
   SetupDefaultTrees(layer_bounds);
   active_layer()->SetHasWillChangeTransformHint(true);
   EXPECT_FLOAT_EQ(2u, active_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(1.f,
-                  active_layer()->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_FLOAT_EQ(1.f * low_res_factor,
-                  active_layer()->tilings()->tiling_at(1)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      1.f, active_layer()->tilings()->tiling_at(0)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      1.f * low_res_factor,
+      active_layer()->tilings()->tiling_at(1)->contents_scale_key());
 
   // Ensure UpdateTiles won't remove any tilings. Note this is unrelated to
   // |used_tilings| variable, and it's here only to ensure that active_layer()
   // won't remove tilings before the test has a chance to verify behavior.
   active_layer()->MarkAllTilingsUsed();
 
   // We only have ideal tilings, so they aren't removed.
   used_tilings.clear();
   active_layer()->CleanUpTilingsOnActiveLayer(used_tilings);
   EXPECT_FLOAT_EQ(2u, active_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(1.f,
-                  active_layer()->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_FLOAT_EQ(1.f * low_res_factor,
-                  active_layer()->tilings()->tiling_at(1)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      1.f, active_layer()->tilings()->tiling_at(0)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      1.f * low_res_factor,
+      active_layer()->tilings()->tiling_at(1)->contents_scale_key());
 
   host_impl()->PinchGestureBegin();
 
   // Changing the ideal but not creating new tilings.
   scale = 1.5f;
   page_scale = 1.5f;
   SetContentsScaleOnBothLayers(scale, 1.f, page_scale, 1.f, 0.f, false);
   EXPECT_FLOAT_EQ(2u, active_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(1.f,
-                  active_layer()->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_FLOAT_EQ(1.f * low_res_factor,
-                  active_layer()->tilings()->tiling_at(1)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      1.f, active_layer()->tilings()->tiling_at(0)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      1.f * low_res_factor,
+      active_layer()->tilings()->tiling_at(1)->contents_scale_key());
 
   // The tilings are still our target scale, so they aren't removed.
   used_tilings.clear();
   active_layer()->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(2u, active_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(1.f,
-                  active_layer()->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_FLOAT_EQ(1.f * low_res_factor,
-                  active_layer()->tilings()->tiling_at(1)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      1.f, active_layer()->tilings()->tiling_at(0)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      1.f * low_res_factor,
+      active_layer()->tilings()->tiling_at(1)->contents_scale_key());
 
   host_impl()->PinchGestureEnd();
 
   // Create a 1.2 scale tiling. Now we have 1.0 and 1.2 tilings. Ideal = 1.2.
   scale = 1.2f;
   page_scale = 1.2f;
   SetContentsScaleOnBothLayers(1.2f, 1.f, page_scale, 1.f, 0.f, false);
   ASSERT_EQ(4u, active_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(1.2f,
-                  active_layer()->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_FLOAT_EQ(1.f,
-                  active_layer()->tilings()->tiling_at(1)->contents_scale());
-  EXPECT_FLOAT_EQ(1.2f * low_res_factor,
-                  active_layer()->tilings()->tiling_at(2)->contents_scale());
-  EXPECT_FLOAT_EQ(1.f * low_res_factor,
-                  active_layer()->tilings()->tiling_at(3)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      1.2f, active_layer()->tilings()->tiling_at(0)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      1.f, active_layer()->tilings()->tiling_at(1)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      1.2f * low_res_factor,
+      active_layer()->tilings()->tiling_at(2)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      1.f * low_res_factor,
+      active_layer()->tilings()->tiling_at(3)->contents_scale_key());
 
   // Ensure UpdateTiles won't remove any tilings.
   active_layer()->MarkAllTilingsUsed();
 
   // Mark the non-ideal tilings as used. They won't be removed.
   used_tilings.clear();
   used_tilings.push_back(active_layer()->tilings()->tiling_at(1));
   used_tilings.push_back(active_layer()->tilings()->tiling_at(3));
   active_layer()->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(4u, active_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(1.2f,
-                  active_layer()->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_FLOAT_EQ(1.f,
-                  active_layer()->tilings()->tiling_at(1)->contents_scale());
-  EXPECT_FLOAT_EQ(1.2f * low_res_factor,
-                  active_layer()->tilings()->tiling_at(2)->contents_scale());
-  EXPECT_FLOAT_EQ(1.f * low_res_factor,
-                  active_layer()->tilings()->tiling_at(3)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      1.2f, active_layer()->tilings()->tiling_at(0)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      1.f, active_layer()->tilings()->tiling_at(1)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      1.2f * low_res_factor,
+      active_layer()->tilings()->tiling_at(2)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      1.f * low_res_factor,
+      active_layer()->tilings()->tiling_at(3)->contents_scale_key());
 
   // Now move the ideal scale to 0.5. Our target stays 1.2.
   SetContentsScaleOnBothLayers(0.5f, 1.f, page_scale, 1.f, 0.f, false);
 
   // The high resolution tiling is between target and ideal, so is not
   // removed.  The low res tiling for the old ideal=1.0 scale is removed.
   used_tilings.clear();
   active_layer()->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(3u, active_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(1.2f,
-                  active_layer()->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_FLOAT_EQ(1.f,
-                  active_layer()->tilings()->tiling_at(1)->contents_scale());
-  EXPECT_FLOAT_EQ(1.2f * low_res_factor,
-                  active_layer()->tilings()->tiling_at(2)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      1.2f, active_layer()->tilings()->tiling_at(0)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      1.f, active_layer()->tilings()->tiling_at(1)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      1.2f * low_res_factor,
+      active_layer()->tilings()->tiling_at(2)->contents_scale_key());
 
   // Now move the ideal scale to 1.0. Our target stays 1.2.
   SetContentsScaleOnBothLayers(1.f, 1.f, page_scale, 1.f, 0.f, false);
 
   // All the tilings are between are target and the ideal, so they are not
   // removed.
   used_tilings.clear();
   active_layer()->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(3u, active_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(1.2f,
-                  active_layer()->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_FLOAT_EQ(1.f,
-                  active_layer()->tilings()->tiling_at(1)->contents_scale());
-  EXPECT_FLOAT_EQ(1.2f * low_res_factor,
-                  active_layer()->tilings()->tiling_at(2)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      1.2f, active_layer()->tilings()->tiling_at(0)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      1.f, active_layer()->tilings()->tiling_at(1)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      1.2f * low_res_factor,
+      active_layer()->tilings()->tiling_at(2)->contents_scale_key());
 
   // Now move the ideal scale to 1.1 on the active layer. Our target stays 1.2.
   SetupDrawPropertiesAndUpdateTiles(active_layer(), 1.1f, 1.f, page_scale, 1.f,
                                     0.f, false);
 
   // Because the pending layer's ideal scale is still 1.0, our tilings fall
   // in the range [1.0,1.2] and are kept.
   used_tilings.clear();
   active_layer()->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(3u, active_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(1.2f,
-                  active_layer()->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_FLOAT_EQ(1.f,
-                  active_layer()->tilings()->tiling_at(1)->contents_scale());
-  EXPECT_FLOAT_EQ(1.2f * low_res_factor,
-                  active_layer()->tilings()->tiling_at(2)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      1.2f, active_layer()->tilings()->tiling_at(0)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      1.f, active_layer()->tilings()->tiling_at(1)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      1.2f * low_res_factor,
+      active_layer()->tilings()->tiling_at(2)->contents_scale_key());
 
   // Move the ideal scale on the pending layer to 1.1 as well. Our target stays
   // 1.2 still.
   SetupDrawPropertiesAndUpdateTiles(pending_layer(), 1.1f, 1.f, page_scale, 1.f,
                                     0.f, false);
 
   // Our 1.0 tiling now falls outside the range between our ideal scale and our
   // target raster scale. But it is in our used tilings set, so nothing is
   // deleted.
   used_tilings.clear();
   used_tilings.push_back(active_layer()->tilings()->tiling_at(1));
   active_layer()->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(3u, active_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(1.2f,
-                  active_layer()->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_FLOAT_EQ(1.f,
-                  active_layer()->tilings()->tiling_at(1)->contents_scale());
-  EXPECT_FLOAT_EQ(1.2f * low_res_factor,
-                  active_layer()->tilings()->tiling_at(2)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      1.2f, active_layer()->tilings()->tiling_at(0)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      1.f, active_layer()->tilings()->tiling_at(1)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      1.2f * low_res_factor,
+      active_layer()->tilings()->tiling_at(2)->contents_scale_key());
 
   // If we remove it from our used tilings set, it is outside the range to keep
   // so it is deleted.
   used_tilings.clear();
   active_layer()->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(2u, active_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(1.2f,
-                  active_layer()->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_FLOAT_EQ(1.2 * low_res_factor,
-                  active_layer()->tilings()->tiling_at(1)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      1.2f, active_layer()->tilings()->tiling_at(0)->contents_scale_key());
+  EXPECT_FLOAT_EQ(
+      1.2 * low_res_factor,
+      active_layer()->tilings()->tiling_at(1)->contents_scale_key());
 }
 
 TEST_F(PictureLayerImplTest, DontAddLowResDuringAnimation) {
   // Make sure this layer covers multiple tiles, since otherwise low
   // res won't get created because it is too small.
   gfx::Size tile_size(host_impl()->settings().default_tile_size);
   // Avoid max untiled layer size heuristics via fixed tile size.
   gfx::Size layer_bounds(tile_size.width() + 1, tile_size.height() + 1);
   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
 
   float low_res_factor = host_impl()->settings().low_res_contents_scale_factor;
   float contents_scale = 1.f;
   float device_scale = 1.f;
   float page_scale = 1.f;
   float maximum_animation_scale = 1.f;
   float starting_animation_scale = 0.f;
   bool animating_transform = true;
 
   ResetTilingsAndRasterScales();
 
   // Animating, so don't create low res even if there isn't one already.
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 1.f);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(), 1.f);
   EXPECT_BOTH_EQ(num_tilings(), 1u);
 
   // Stop animating, low res gets created.
   animating_transform = false;
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 1.f);
-  EXPECT_EQ(active_layer()->LowResTiling()->contents_scale(), low_res_factor);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(), 1.f);
+  EXPECT_EQ(active_layer()->LowResTiling()->contents_scale_key(),
+            low_res_factor);
   EXPECT_EQ(active_layer()->num_tilings(), 2u);
   EXPECT_EQ(pending_layer()->num_tilings(), 1u);
 
   // Ensure UpdateTiles won't remove any tilings.
   active_layer()->MarkAllTilingsUsed();
 
   // Page scale animation, new high res, but no low res. We still have
   // a tiling at the previous scale, it's just not marked as low res on the
   // active layer. The pending layer drops non-ideal tilings.
   contents_scale = 2.f;
   page_scale = 2.f;
   maximum_animation_scale = 2.f;
   animating_transform = true;
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(), 2.f);
   EXPECT_FALSE(active_layer()->LowResTiling());
   EXPECT_FALSE(pending_layer()->LowResTiling());
   EXPECT_EQ(3u, active_layer()->num_tilings());
   EXPECT_EQ(1u, pending_layer()->num_tilings());
 
   // Stop animating, new low res gets created for final page scale.
   animating_transform = false;
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
-  EXPECT_EQ(active_layer()->LowResTiling()->contents_scale(),
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(), 2.f);
+  EXPECT_EQ(active_layer()->LowResTiling()->contents_scale_key(),
             2.f * low_res_factor);
   EXPECT_EQ(4u, active_layer()->num_tilings());
   EXPECT_EQ(1u, pending_layer()->num_tilings());
 }
 
 TEST_F(PictureLayerImplTest, DontAddLowResForSmallLayers) {
   gfx::Size layer_bounds(host_impl()->settings().default_tile_size);
 
   scoped_refptr<FakeRasterSource> pending_raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
   scoped_refptr<FakeRasterSource> active_raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
 
   SetupTrees(pending_raster_source, active_raster_source);
 
   float low_res_factor = host_impl()->settings().low_res_contents_scale_factor;
   float device_scale = 1.f;
   float page_scale = 1.f;
   float maximum_animation_scale = 1.f;
   float starting_animation_scale = 0.f;
   bool animating_transform = false;
 
   // Contents exactly fit on one tile at scale 1, no low res.
   float contents_scale = 1.f;
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(), contents_scale);
   EXPECT_BOTH_EQ(num_tilings(), 1u);
 
   ResetTilingsAndRasterScales();
 
   // Contents that are smaller than one tile, no low res.
   contents_scale = 0.123f;
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(), contents_scale);
   EXPECT_BOTH_EQ(num_tilings(), 1u);
 
   // TODO(danakj): Remove these when raster scale doesn't get fixed?
   ResetTilingsAndRasterScales();
 
   // Any content bounds that would create more than one tile will
   // generate a low res tiling.
   contents_scale = 2.5f;
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), contents_scale);
-  EXPECT_EQ(active_layer()->LowResTiling()->contents_scale(),
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(), contents_scale);
+  EXPECT_EQ(active_layer()->LowResTiling()->contents_scale_key(),
             contents_scale * low_res_factor);
   EXPECT_FALSE(pending_layer()->LowResTiling());
   EXPECT_EQ(active_layer()->num_tilings(), 2u);
   EXPECT_EQ(pending_layer()->num_tilings(), 1u);
 
   // Mask layers dont create low res since they always fit on one tile.
   std::unique_ptr<FakePictureLayerImpl> mask =
       FakePictureLayerImpl::CreateSingleTextureMaskWithRasterSource(
           host_impl()->pending_tree(), 3, pending_raster_source);
   mask->SetBounds(layer_bounds);
   mask->SetDrawsContent(true);
   pending_layer()->test_properties()->SetMaskLayer(std::move(mask));
   pending_layer()->test_properties()->force_render_surface = true;
   RebuildPropertyTreesOnPendingTree();
   host_impl()->pending_tree()->UpdateDrawProperties(false);
 
   FakePictureLayerImpl* mask_raw = static_cast<FakePictureLayerImpl*>(
       pending_layer()->test_properties()->mask_layer);
   // We did an UpdateDrawProperties above, which will set a contents scale on
   // the mask layer, so allow us to reset the contents scale.
   mask_raw->ReleaseTileResources();
   mask_raw->RecreateTileResources();
 
   SetupDrawPropertiesAndUpdateTiles(
       mask_raw, contents_scale, device_scale, page_scale,
       maximum_animation_scale, starting_animation_scale, animating_transform);
-  EXPECT_EQ(mask_raw->HighResTiling()->contents_scale(), contents_scale);
+  EXPECT_EQ(mask_raw->HighResTiling()->contents_scale_key(), contents_scale);
   EXPECT_EQ(mask_raw->num_tilings(), 1u);
 }
 
 TEST_F(PictureLayerImplTest, HugeMasksGetScaledDown) {
   host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   gfx::Size layer_bounds(1000, 1000);
 
   scoped_refptr<FakeRasterSource> valid_raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
   SetupPendingTree(valid_raster_source);
 
   std::unique_ptr<FakePictureLayerImpl> mask_ptr =
       FakePictureLayerImpl::CreateSingleTextureMaskWithRasterSource(
           host_impl()->pending_tree(), 3, valid_raster_source);
   mask_ptr->SetBounds(layer_bounds);
   mask_ptr->SetDrawsContent(true);
   pending_layer()->test_properties()->SetMaskLayer(std::move(mask_ptr));
   pending_layer()->test_properties()->force_render_surface = true;
 
   RebuildPropertyTreesOnPendingTree();
   host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
   bool update_lcd_text = false;
   host_impl()->pending_tree()->UpdateDrawProperties(update_lcd_text);
 
   FakePictureLayerImpl* pending_mask = static_cast<FakePictureLayerImpl*>(
       pending_layer()->test_properties()->mask_layer);
 
-  EXPECT_EQ(1.f, pending_mask->HighResTiling()->contents_scale());
+  EXPECT_EQ(1.f, pending_mask->HighResTiling()->contents_scale_key());
   EXPECT_EQ(1u, pending_mask->num_tilings());
 
   host_impl()->tile_manager()->InitializeTilesWithResourcesForTesting(
       pending_mask->HighResTiling()->AllTilesForTesting());
 
   ActivateTree();
 
   FakePictureLayerImpl* active_mask = static_cast<FakePictureLayerImpl*>(
       host_impl()->active_tree()->LayerById(pending_mask->id()));
 
@@ skipping 25 matching lines @@
       FakeRasterSource::CreateFilled(huge_bounds);
 
   SetupPendingTree(huge_raster_source);
   pending_mask->SetBounds(huge_bounds);
   pending_mask->SetRasterSourceOnPending(huge_raster_source, Region());
 
   host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
   host_impl()->pending_tree()->UpdateDrawProperties(update_lcd_text);
 
   // The mask tiling gets scaled down.
-  EXPECT_LT(pending_mask->HighResTiling()->contents_scale(), 1.f);
+  EXPECT_LT(pending_mask->HighResTiling()->contents_scale_key(), 1.f);
   EXPECT_EQ(1u, pending_mask->num_tilings());
 
   host_impl()->tile_manager()->InitializeTilesWithResourcesForTesting(
       pending_mask->HighResTiling()->AllTilesForTesting());
 
   ActivateTree();
 
   // Mask layers have a tiling with a single tile in it.
   EXPECT_EQ(1u, active_mask->HighResTiling()->AllTilesForTesting().size());
   // The mask resource exists.
@@ skipping 63 matching lines @@
 
   RebuildPropertyTreesOnPendingTree();
   host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
   bool update_lcd_text = false;
   host_impl()->pending_tree()->UpdateDrawProperties(update_lcd_text);
 
   FakePictureLayerImpl* pending_mask = static_cast<FakePictureLayerImpl*>(
       pending_layer()->test_properties()->mask_layer);
 
   // Masks are scaled, and do not have a low res tiling.
-  EXPECT_EQ(1.3f, pending_mask->HighResTiling()->contents_scale());
+  EXPECT_EQ(1.3f, pending_mask->HighResTiling()->contents_scale_key());
   EXPECT_EQ(1u, pending_mask->num_tilings());
 
   host_impl()->tile_manager()->InitializeTilesWithResourcesForTesting(
       pending_mask->HighResTiling()->AllTilesForTesting());
 
   ActivateTree();
 
   FakePictureLayerImpl* active_mask = static_cast<FakePictureLayerImpl*>(
       host_impl()->active_tree()->LayerById(pending_mask->id()));
 
@@ skipping 314 matching lines @@
   host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(400, 400);
   gfx::Rect external_viewport_for_tile_priority(400, 200);
   gfx::Rect visible_layer_rect(200, 400);
 
   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
 
   ASSERT_EQ(1u, pending_layer()->num_tilings());
-  ASSERT_EQ(1.f, pending_layer()->HighResTiling()->contents_scale());
+  ASSERT_EQ(1.f, pending_layer()->HighResTiling()->contents_scale_key());
 
   // Set external viewport for tile priority.
   gfx::Transform transform;
   gfx::Transform transform_for_tile_priority;
   host_impl()->SetExternalTilePriorityConstraints(
       external_viewport_for_tile_priority, transform_for_tile_priority);
   host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
   bool update_lcd_text = false;
   host_impl()->pending_tree()->UpdateDrawProperties(update_lcd_text);
 
@@ skipping 177 matching lines @@
   gfx::Size viewport_size(400, 400);
 
   host_impl()->SetViewportSize(viewport_size);
   SetInitialDeviceScaleFactor(2.f);
 
   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
   active_layer()->SetHasWillChangeTransformHint(true);
 
   // One ideal tile exists, this will get used when drawing.
   std::vector<Tile*> ideal_tiles;
-  EXPECT_EQ(2.f, active_layer()->HighResTiling()->contents_scale());
+  EXPECT_EQ(2.f, active_layer()->HighResTiling()->contents_scale_key());
   ideal_tiles.push_back(active_layer()->HighResTiling()->TileAt(0, 0));
   host_impl()->tile_manager()->InitializeTilesWithResourcesForTesting(
       ideal_tiles);
 
   // Due to layer scale throttling, the raster contents scale is changed to 1,
   // while the ideal is still 2.
   SetupDrawPropertiesAndUpdateTiles(active_layer(), 1.f, 1.f, 1.f, 1.f, 0.f,
                                     false);
   SetupDrawPropertiesAndUpdateTiles(active_layer(), 2.f, 1.f, 1.f, 1.f, 0.f,
                                     false);
 
-  EXPECT_EQ(1.f, active_layer()->HighResTiling()->contents_scale());
+  EXPECT_EQ(1.f, active_layer()->HighResTiling()->contents_scale_key());
   EXPECT_EQ(1.f, active_layer()->raster_contents_scale());
   EXPECT_EQ(2.f, active_layer()->ideal_contents_scale());
 
   // Both tilings still exist.
-  EXPECT_EQ(2.f, active_layer()->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_EQ(1.f, active_layer()->tilings()->tiling_at(1)->contents_scale());
+  EXPECT_EQ(2.f, active_layer()->tilings()->tiling_at(0)->contents_scale_key());
+  EXPECT_EQ(1.f, active_layer()->tilings()->tiling_at(1)->contents_scale_key());
 
   // All high res tiles have resources.
   std::vector<Tile*> high_tiles =
       active_layer()->HighResTiling()->AllTilesForTesting();
   host_impl()->tile_manager()->InitializeTilesWithResourcesForTesting(
       high_tiles);
 
   std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
   AppendQuadsData data;
   active_layer()->WillDraw(DRAW_MODE_SOFTWARE, nullptr);
@@ skipping 553 matching lines @@
 
   // No tilings should be pushed to active layer.
   pending_layer()->PushPropertiesTo(active_layer());
   EXPECT_EQ(0u, active_layer()->num_tilings());
 }
 
 TEST_F(PictureLayerImplTest, FirstTilingDuringPinch) {
   SetupDefaultTrees(gfx::Size(10, 10));
 
   // We start with a tiling at scale 1.
-  EXPECT_EQ(1.f, pending_layer()->HighResTiling()->contents_scale());
+  EXPECT_EQ(1.f, pending_layer()->HighResTiling()->contents_scale_key());
 
   // When we page scale up by 2.3, we get a new tiling that is a power of 2, in
   // this case 4.
   host_impl()->PinchGestureBegin();
   float high_res_scale = 2.3f;
   SetContentsScaleOnBothLayers(high_res_scale, 1.f, high_res_scale, 1.f, 0.f,
                                false);
-  EXPECT_EQ(4.f, pending_layer()->HighResTiling()->contents_scale());
+  EXPECT_EQ(4.f, pending_layer()->HighResTiling()->contents_scale_key());
 }
 
 TEST_F(PictureLayerImplTest, PinchingTooSmall) {
   SetupDefaultTrees(gfx::Size(10, 10));
 
   // We start with a tiling at scale 1.
-  EXPECT_EQ(1.f, pending_layer()->HighResTiling()->contents_scale());
+  EXPECT_EQ(1.f, pending_layer()->HighResTiling()->contents_scale_key());
 
   host_impl()->PinchGestureBegin();
   float high_res_scale = 0.0001f;
   EXPECT_LT(high_res_scale, pending_layer()->MinimumContentsScale());
 
   SetContentsScaleOnBothLayers(high_res_scale, 1.f, high_res_scale, 1.f, 0.f,
                                false);
   EXPECT_FLOAT_EQ(pending_layer()->MinimumContentsScale(),
-                  pending_layer()->HighResTiling()->contents_scale());
+                  pending_layer()->HighResTiling()->contents_scale_key());
 }
 
 TEST_F(PictureLayerImplTest, PinchingTooSmallWithContentsScale) {
   SetupDefaultTrees(gfx::Size(10, 10));
 
   ResetTilingsAndRasterScales();
 
   float contents_scale = 0.15f;
   SetContentsScaleOnBothLayers(contents_scale, 1.f, 1.f, 1.f, 0.f, false);
 
   ASSERT_GE(pending_layer()->num_tilings(), 0u);
   EXPECT_FLOAT_EQ(contents_scale,
-                  pending_layer()->HighResTiling()->contents_scale());
+                  pending_layer()->HighResTiling()->contents_scale_key());
 
   host_impl()->PinchGestureBegin();
 
   float page_scale = 0.0001f;
   EXPECT_LT(page_scale * contents_scale,
             pending_layer()->MinimumContentsScale());
 
   SetContentsScaleOnBothLayers(contents_scale * page_scale, 1.f, page_scale,
                                1.f, 0.f, false);
   ASSERT_GE(pending_layer()->num_tilings(), 0u);
   EXPECT_FLOAT_EQ(pending_layer()->MinimumContentsScale(),
-                  pending_layer()->HighResTiling()->contents_scale());
+                  pending_layer()->HighResTiling()->contents_scale_key());
 }
 
 TEST_F(PictureLayerImplTest, ConsiderAnimationStartScaleForRasterScale) {
   gfx::Size viewport_size(1000, 1000);
   host_impl()->SetViewportSize(viewport_size);
 
   gfx::Size layer_bounds(100, 100);
   SetupDefaultTrees(layer_bounds);
 
   float contents_scale = 2.f;
   float device_scale = 1.f;
   float page_scale = 1.f;
   float maximum_animation_scale = 3.f;
   float starting_animation_scale = 1.f;
   bool animating_transform = true;
 
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 1.f);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(), 1.f);
 
   // Maximum animation scale is greater than starting animation scale
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 3.f);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(), 3.f);
 
   animating_transform = false;
 
   // Once we stop animating, a new high-res tiling should be created.
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(), 2.f);
 
   // Starting animation scale greater than maximum animation scale
   // Bounds at starting scale within the viewport
   animating_transform = true;
   starting_animation_scale = 5.f;
 
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 5.f);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(), 5.f);
 
   // Once we stop animating, a new high-res tiling should be created.
   animating_transform = false;
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(), 2.f);
 
   // Starting Animation scale greater than maximum animation scale
   // Bounds at starting scale outisde the viewport
   animating_transform = true;
   starting_animation_scale = 11.f;
 
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 3.f);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(), 3.f);
 }
 
 TEST_F(PictureLayerImplTest, HighResTilingDuringAnimation) {
   gfx::Size viewport_size(1000, 1000);
   host_impl()->SetViewportSize(viewport_size);
 
   gfx::Size layer_bounds(100, 100);
   SetupDefaultTrees(layer_bounds);
 
   float contents_scale = 1.f;
   float device_scale = 1.f;
   float page_scale = 1.f;
   float maximum_animation_scale = 1.f;
   float starting_animation_scale = 0.f;
   bool animating_transform = false;
 
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 1.f);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(), 1.f);
 
   // Starting an animation should cause tiling resolution to get set to the
   // maximum animation scale factor.
   animating_transform = true;
   maximum_animation_scale = 3.f;
   contents_scale = 2.f;
 
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 3.f);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(), 3.f);
 
   // Further changes to scale during the animation should not cause a new
   // high-res tiling to get created.
   contents_scale = 4.f;
   maximum_animation_scale = 5.f;
 
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 3.f);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(), 3.f);
 
   // Once we stop animating, a new high-res tiling should be created.
   animating_transform = false;
 
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 4.f);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(), 4.f);
 
   // When animating with an unknown maximum animation scale factor, a new
   // high-res tiling should be created at a source scale of 1.
   animating_transform = true;
   contents_scale = 2.f;
   maximum_animation_scale = 0.f;
 
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), page_scale * device_scale);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(),
+                 page_scale * device_scale);
 
   // Further changes to scale during the animation should not cause a new
   // high-res tiling to get created.
   contents_scale = 3.f;
 
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), page_scale * device_scale);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(),
+                 page_scale * device_scale);
 
   // Once we stop animating, a new high-res tiling should be created.
   animating_transform = false;
   contents_scale = 4.f;
 
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 4.f);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(), 4.f);
 
   // When animating with a maxmium animation scale factor that is so large
   // that the layer grows larger than the viewport at this scale, a new
   // high-res tiling should get created at a source scale of 1, not at its
   // maximum scale.
   animating_transform = true;
   contents_scale = 2.f;
   maximum_animation_scale = 11.f;
 
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), page_scale * device_scale);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(),
+                 page_scale * device_scale);
 
   // Once we stop animating, a new high-res tiling should be created.
   animating_transform = false;
   contents_scale = 11.f;
 
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 11.f);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(), 11.f);
 
   // When animating with a maxmium animation scale factor that is so large
   // that the layer grows larger than the viewport at this scale, and where
   // the intial source scale is < 1, a new high-res tiling should get created
   // at source scale 1.
   animating_transform = true;
   contents_scale = 0.1f;
   maximum_animation_scale = 11.f;
 
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), device_scale * page_scale);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(),
+                 device_scale * page_scale);
 
   // Once we stop animating, a new high-res tiling should be created.
   animating_transform = false;
   contents_scale = 12.f;
 
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 12.f);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(), 12.f);
 
   // When animating toward a smaller scale, but that is still so large that the
   // layer grows larger than the viewport at this scale, a new high-res tiling
   // should get created at source scale 1.
   animating_transform = true;
   contents_scale = 11.f;
   maximum_animation_scale = 11.f;
 
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), device_scale * page_scale);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(),
+                 device_scale * page_scale);
 
   // Once we stop animating, a new high-res tiling should be created.
   animating_transform = false;
   contents_scale = 11.f;
 
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 11.f);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(), 11.f);
 }
 
 TEST_F(PictureLayerImplTest, TilingSetRasterQueue) {
   host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   host_impl()->SetViewportSize(gfx::Size(500, 500));
 
   gfx::Size layer_bounds(1000, 1000);
 
   scoped_refptr<FakeRasterSource> pending_raster_source =
@@ skipping 244 matching lines @@
     TilePriority priority = prioritized_tile.priority();
 
     if (priority.priority_bin == TilePriority::NOW) {
       reached_visible = true;
       last_tile = prioritized_tile;
       break;
     }
 
     EXPECT_FALSE(tile->required_for_activation());
 
-    while (std::abs(tile->contents_scale() - expected_scales[scale_index]) >
+    while (std::abs(tile->contents_scale_key() - expected_scales[scale_index]) >
            std::numeric_limits<float>::epsilon()) {
       ++scale_index;
       ASSERT_LT(scale_index, arraysize(expected_scales));
     }
 
-    EXPECT_FLOAT_EQ(tile->contents_scale(), expected_scales[scale_index]);
+    EXPECT_FLOAT_EQ(tile->contents_scale_key(), expected_scales[scale_index]);
     unique_tiles.insert(tile);
 
     if (tile->required_for_activation() ==
             last_tile.tile()->required_for_activation() &&
-        std::abs(tile->contents_scale() - last_tile.tile()->contents_scale()) <
+        std::abs(tile->contents_scale_key() -
+                 last_tile.tile()->contents_scale_key()) <
             std::numeric_limits<float>::epsilon()) {
       if (priority.distance_to_visible <=
           last_tile.priority().distance_to_visible)
         ++distance_decreasing;
       else
         ++distance_increasing;
     }
 
     last_tile = prioritized_tile;
     queue->Pop();
@@ skipping 15 matching lines @@
     TilePriority priority = prioritized_tile.priority();
     EXPECT_EQ(TilePriority::NOW, priority.priority_bin);
 
     if (reached_required) {
       EXPECT_TRUE(tile->required_for_activation());
     } else if (tile->required_for_activation()) {
       reached_required = true;
       scale_index = 0;
     }
 
-    while (std::abs(tile->contents_scale() - expected_scales[scale_index]) >
+    while (std::abs(tile->contents_scale_key() - expected_scales[scale_index]) >
            std::numeric_limits<float>::epsilon()) {
       ++scale_index;
       ASSERT_LT(scale_index, arraysize(expected_scales));
     }
 
-    EXPECT_FLOAT_EQ(tile->contents_scale(), expected_scales[scale_index]);
+    EXPECT_FLOAT_EQ(tile->contents_scale_key(), expected_scales[scale_index]);
     unique_tiles.insert(tile);
     queue->Pop();
   }
 
   EXPECT_TRUE(reached_required);
   EXPECT_EQ(all_tiles_set.size(), unique_tiles.size());
 }
 
 TEST_F(PictureLayerImplTest, Occlusion) {
   gfx::Size tile_size(102, 102);
@@ skipping 54 matching lines @@
   float contents_scale = 2.f;
   float device_scale = 1.f;
   float page_scale = 1.f;
   float maximum_animation_scale = 1.f;
   float starting_animation_scale = 0.f;
   bool animating_transform = false;
 
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 2.f);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(), 2.f);
 
   // Changing the source scale without being in an animation will cause
   // the layer to change scale.
   contents_scale = 3.f;
 
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 3.f);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(), 3.f);
 
   contents_scale = 0.5f;
 
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 0.5f);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(), 0.5f);
 
   // However, if the layer has a will-change property, then the raster scale
   // will get fixed at the last value.
   active_layer()->SetHasWillChangeTransformHint(true);
   pending_layer()->SetHasWillChangeTransformHint(true);
 
   contents_scale = 3.f;
 
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 0.5f);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(), 0.5f);
 
   // Further changes to the source scale will no longer be reflected in the
   // contents scale.
   contents_scale = 1.f;
 
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 0.5f);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(), 0.5f);
 
   // Disabling the will-change hint will once again make the raster scale update
   // with the ideal scale.
   active_layer()->SetHasWillChangeTransformHint(false);
   pending_layer()->SetHasWillChangeTransformHint(false);
 
   contents_scale = 3.f;
 
   SetContentsScaleOnBothLayers(contents_scale, device_scale, page_scale,
                                maximum_animation_scale,
                                starting_animation_scale, animating_transform);
-  EXPECT_BOTH_EQ(HighResTiling()->contents_scale(), 3.f);
+  EXPECT_BOTH_EQ(HighResTiling()->contents_scale_key(), 3.f);
 }
 
 TEST_F(PictureLayerImplTest, LowResReadyToDrawNotEnoughToActivate) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(1000, 1000);
 
   // Make sure pending tree has tiles.
   gfx::Rect invalidation(gfx::Point(50, 50), tile_size);
   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, invalidation);
 
@@ skipping 62 matching lines @@
   ResetTilingsAndRasterScales();
 
   SetupDrawPropertiesAndUpdateTiles(active_layer(),
                                     6.f,  // ideal contents scale
                                     3.f,  // device scale
                                     2.f,  // page scale
                                     1.f,  // maximum animation scale
                                     0.f,  // starting animation scale
                                     false);
   ASSERT_EQ(1u, active_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(6.f,
-                  active_layer()->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      6.f, active_layer()->tilings()->tiling_at(0)->contents_scale_key());
 
   // If we change the page scale factor, then we should get new tilings.
   SetupDrawPropertiesAndUpdateTiles(active_layer(),
                                     6.6f,  // ideal contents scale
                                     3.f,   // device scale
                                     2.2f,  // page scale
                                     1.f,   // maximum animation scale
                                     0.f,   // starting animation scale
                                     false);
   ASSERT_EQ(2u, active_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(6.6f,
-                  active_layer()->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      6.6f, active_layer()->tilings()->tiling_at(0)->contents_scale_key());
 
   // If we change the device scale factor, then we should get new tilings.
   SetupDrawPropertiesAndUpdateTiles(active_layer(),
                                     7.26f,  // ideal contents scale
                                     3.3f,   // device scale
                                     2.2f,   // page scale
                                     1.f,    // maximum animation scale
                                     0.f,    // starting animation scale
                                     false);
   ASSERT_EQ(3u, active_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(7.26f,
-                  active_layer()->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      7.26f, active_layer()->tilings()->tiling_at(0)->contents_scale_key());
 
   // If we change the device scale factor, but end up at the same total scale
   // factor somehow, then we don't get new tilings.
   SetupDrawPropertiesAndUpdateTiles(active_layer(),
                                     7.26f,  // ideal contents scale
                                     2.2f,   // device scale
                                     3.3f,   // page scale
                                     1.f,    // maximum animation scale
                                     0.f,    // starting animation scale
                                     false);
   ASSERT_EQ(3u, active_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(7.26f,
-                  active_layer()->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      7.26f, active_layer()->tilings()->tiling_at(0)->contents_scale_key());
 }
 
 TEST_F(NoLowResPictureLayerImplTest, PendingLayerOnlyHasHighResTiling) {
   gfx::Size layer_bounds(1300, 1900);
   SetupDefaultTrees(layer_bounds);
 
   float low_res_factor = host_impl()->settings().low_res_contents_scale_factor;
   EXPECT_LT(low_res_factor, 1.f);
 
   ResetTilingsAndRasterScales();
 
   SetupDrawPropertiesAndUpdateTiles(pending_layer(),
                                     6.f,  // ideal contents scale
                                     3.f,  // device scale
                                     2.f,  // page scale
                                     1.f,  // maximum animation scale
                                     0.f,  // starting animation scale
                                     false);
   ASSERT_EQ(1u, pending_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(6.f,
-                  pending_layer()->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      6.f, pending_layer()->tilings()->tiling_at(0)->contents_scale_key());
 
   // If we change the page scale factor, then we should get new tilings.
   SetupDrawPropertiesAndUpdateTiles(pending_layer(),
                                     6.6f,  // ideal contents scale
                                     3.f,   // device scale
                                     2.2f,  // page scale
                                     1.f,   // maximum animation scale
                                     0.f,   // starting animation scale
                                     false);
   ASSERT_EQ(1u, pending_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(6.6f,
-                  pending_layer()->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      6.6f, pending_layer()->tilings()->tiling_at(0)->contents_scale_key());
 
   // If we change the device scale factor, then we should get new tilings.
   SetupDrawPropertiesAndUpdateTiles(pending_layer(),
                                     7.26f,  // ideal contents scale
                                     3.3f,   // device scale
                                     2.2f,   // page scale
                                     1.f,    // maximum animation scale
                                     0.f,    // starting animation scale
                                     false);
   ASSERT_EQ(1u, pending_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(7.26f,
-                  pending_layer()->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      7.26f, pending_layer()->tilings()->tiling_at(0)->contents_scale_key());
 
   // If we change the device scale factor, but end up at the same total scale
   // factor somehow, then we don't get new tilings.
   SetupDrawPropertiesAndUpdateTiles(pending_layer(),
                                     7.26f,  // ideal contents scale
                                     2.2f,   // device scale
                                     3.3f,   // page scale
                                     1.f,    // maximum animation scale
                                     0.f,    // starting animation scale
                                     false);
   ASSERT_EQ(1u, pending_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(7.26f,
-                  pending_layer()->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      7.26f, pending_layer()->tilings()->tiling_at(0)->contents_scale_key());
 }
 
 TEST_F(NoLowResPictureLayerImplTest, AllHighResRequiredEvenIfNotChanged) {
   gfx::Size layer_bounds(400, 400);
   gfx::Size tile_size(100, 100);
 
   SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
 
   Tile* some_active_tile =
       active_layer()->HighResTiling()->AllTilesForTesting()[0];
@@ skipping 89 matching lines @@
   active_layer()->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(1u, active_layer()->tilings()->num_tilings());
 
   host_impl()->PinchGestureEnd();
 
   // Create a 1.2 scale tiling. Now we have 1.0 and 1.2 tilings. Ideal = 1.2.
   scale /= 4.f;
   page_scale /= 4.f;
   SetContentsScaleOnBothLayers(1.2f, device_scale, page_scale, 1.f, 0.f, false);
   ASSERT_EQ(2u, active_layer()->tilings()->num_tilings());
-  EXPECT_FLOAT_EQ(1.f,
-                  active_layer()->tilings()->tiling_at(1)->contents_scale());
+  EXPECT_FLOAT_EQ(
+      1.f, active_layer()->tilings()->tiling_at(1)->contents_scale_key());
 
   // Ensure UpdateTiles won't remove any tilings.
   active_layer()->MarkAllTilingsUsed();
 
   // Mark the non-ideal tilings as used. They won't be removed.
   used_tilings.clear();
   used_tilings.push_back(active_layer()->tilings()->tiling_at(1));
   active_layer()->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(2u, active_layer()->tilings()->num_tilings());
 
@@ skipping 200 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 ||
                       tile->required_for_activation() ||
-                      tile->contents_scale() !=
-                          last_tile.tile()->contents_scale())
+                      tile->contents_scale_key() !=
+                          last_tile.tile()->contents_scale_key())
               << "line: " << source_line;
         }
       }
       last_tile = prioritized_tile;
       queue->Pop();
     }
     EXPECT_EQ(expected_occluded_tile_count, occluded_tile_count)
         << "line: " << source_line;
   }
 };
@@ skipping 232 matching lines @@
   pending_layer()->test_properties()->AddChild(
       LayerImpl::Create(host_impl()->pending_tree(), 1));
   LayerImpl* layer1 = pending_layer()->test_properties()->children[0];
   layer1->SetBounds(layer_bounds);
   layer1->SetDrawsContent(true);
   layer1->SetContentsOpaque(true);
   layer1->SetPosition(occluding_layer_position);
 
   pending_layer()->tilings()->RemoveAllTilings();
   float low_res_factor = host_impl()->settings().low_res_contents_scale_factor;
-  pending_layer()->AddTiling(low_res_factor)->set_resolution(LOW_RESOLUTION);
-  pending_layer()->AddTiling(0.3f)->set_resolution(HIGH_RESOLUTION);
-  pending_layer()->AddTiling(0.7f)->set_resolution(HIGH_RESOLUTION);
-  pending_layer()->AddTiling(1.0f)->set_resolution(HIGH_RESOLUTION);
-  pending_layer()->AddTiling(2.0f)->set_resolution(HIGH_RESOLUTION);
+  pending_layer()
+      ->AddTiling(ScaleTranslate2d(low_res_factor, gfx::Vector2dF()))
+      ->set_resolution(LOW_RESOLUTION);
+  pending_layer()
+      ->AddTiling(ScaleTranslate2d(0.3f, gfx::Vector2dF()))
+      ->set_resolution(HIGH_RESOLUTION);
+  pending_layer()
+      ->AddTiling(ScaleTranslate2d(0.7f, gfx::Vector2dF()))
+      ->set_resolution(HIGH_RESOLUTION);
+  pending_layer()
+      ->AddTiling(ScaleTranslate2d(1.0f, gfx::Vector2dF()))
+      ->set_resolution(HIGH_RESOLUTION);
+  pending_layer()
+      ->AddTiling(ScaleTranslate2d(2.0f, gfx::Vector2dF()))
+      ->set_resolution(HIGH_RESOLUTION);
 
   RebuildPropertyTreesOnPendingTree();
   host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
   // UpdateDrawProperties with the occluding layer.
   bool update_lcd_text = false;
   host_impl()->pending_tree()->UpdateDrawProperties(update_lcd_text);
 
   EXPECT_EQ(5u, pending_layer()->num_tilings());
 
   int occluded_tile_count = 0;
   for (size_t i = 0; i < pending_layer()->num_tilings(); ++i) {
     PictureLayerTiling* tiling = pending_layer()->tilings()->tiling_at(i);
     auto prioritized_tiles =
         tiling->UpdateAndGetAllPrioritizedTilesForTesting();
     std::vector<Tile*> tiles = tiling->AllTilesForTesting();
 
     occluded_tile_count = 0;
     for (size_t j = 0; j < tiles.size(); ++j) {
       if (prioritized_tiles[tiles[j]].is_occluded()) {
         gfx::Rect scaled_content_rect = ScaleToEnclosingRect(
-            tiles[j]->content_rect(), 1.f / tiles[j]->contents_scale());
+            tiles[j]->content_rect(), 1.f / tiles[j]->contents_scale_key());
         EXPECT_GE(scaled_content_rect.x(), occluding_layer_position.x());
         occluded_tile_count++;
       }
     }
 
     switch (i) {
       case 0:
         EXPECT_EQ(occluded_tile_count, 30);
         break;
       case 1:
@@ skipping 43 matching lines @@
         tiling->UpdateAndGetAllPrioritizedTilesForTesting();
 
     for (PictureLayerTiling::CoverageIterator iter(tiling, 1.f,
                                                    gfx::Rect(layer_bounds));
          iter; ++iter) {
       if (!*iter)
         continue;
       const Tile* tile = *iter;
 
       gfx::Rect scaled_content_rect = ScaleToEnclosingRect(
-          tile->content_rect(), 1.f / tile->contents_scale());
+          tile->content_rect(), 1.f / tile->contents_scale_key());
       // Tiles are occluded on the active tree iff they lie beneath the
       // occluding layer.
       EXPECT_EQ(prioritized_tiles[tile].is_occluded(),
                 scaled_content_rect.x() >= occluding_layer_position.x());
     }
   }
 
   // Partially invalidate the pending layer.
   SetupPendingTreeWithInvalidation(pending_raster_source, invalidation_rect);
 
@@ skipping 15 matching lines @@
 
       if (tiling->resolution() == LOW_RESOLUTION) {
         EXPECT_FALSE(active_layer()->GetPendingOrActiveTwinTiling(tiling));
         continue;
       }
 
       Tile* twin_tile =
           active_layer()->GetPendingOrActiveTwinTiling(tiling)->TileAt(
               iter.i(), iter.j());
       gfx::Rect scaled_content_rect = ScaleToEnclosingRect(
-          tile->content_rect(), 1.f / tile->contents_scale());
+          tile->content_rect(), 1.f / tile->contents_scale_key());
 
       if (scaled_content_rect.Intersects(invalidation_rect)) {
         // Tiles inside the invalidation rect exist on both trees.
         EXPECT_TRUE(twin_tile);
         EXPECT_NE(tile, twin_tile);
       } else {
         // Tiles outside the invalidation rect only exist on the active tree.
         EXPECT_FALSE(twin_tile);
       }
     }
@@ skipping 87 matching lines @@
       else
         EXPECT_FALSE(tile);
 
       if (!tile)
         continue;
       if (prioritized_tiles[tile].is_occluded())
         occluded_tile_count_on_pending++;
     }
     EXPECT_EQ(expected_occluded_tile_count_on_pending[i],
               occluded_tile_count_on_pending)
-        << tiling->contents_scale();
+        << tiling->contents_scale_key();
   }
 
   // Verify number of occluded tiles on the active layer for each tiling.
   for (size_t i = 0; i < active_layer()->num_tilings(); ++i) {
     PictureLayerTiling* tiling = active_layer()->tilings()->tiling_at(i);
     auto prioritized_tiles =
         tiling->UpdateAndGetAllPrioritizedTilesForTesting();
 
     size_t occluded_tile_count_on_active = 0u;
     for (PictureLayerTiling::CoverageIterator iter(tiling, dest_scale,
@@ skipping 569 matching lines @@
 TEST_F(NoLowResPictureLayerImplTest, LowResWasHighResCollision) {
   gfx::Size layer_bounds(1300, 1900);
 
   float low_res_factor = host_impl()->settings().low_res_contents_scale_factor;
   SetupDefaultTrees(layer_bounds);
   ResetTilingsAndRasterScales();
 
   float page_scale = 2.f;
   SetContentsScaleOnBothLayers(page_scale, 1.0f, page_scale, 1.0f, 0.f, false);
   EXPECT_BOTH_EQ(num_tilings(), 1u);
-  EXPECT_BOTH_EQ(tilings()->tiling_at(0)->contents_scale(), page_scale);
+  EXPECT_BOTH_EQ(tilings()->tiling_at(0)->contents_scale_key(), page_scale);
 
   host_impl()->PinchGestureBegin();
 
   // Zoom out to exactly the low res factor so that the previous high res
   // would be equal to the current low res (if it were possible to have one).
   float zoomed = page_scale / low_res_factor;
   SetContentsScaleOnBothLayers(zoomed, 1.0f, zoomed, 1.0f, 0.f, false);
   EXPECT_EQ(1u, pending_layer()->num_tilings());
-  EXPECT_EQ(zoomed, pending_layer()->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_EQ(zoomed,
+            pending_layer()->tilings()->tiling_at(0)->contents_scale_key());
 }
 
 TEST_F(PictureLayerImplTest, HighResWasLowResCollision) {
   gfx::Size layer_bounds(1300, 1900);
 
   float low_res_factor = host_impl()->settings().low_res_contents_scale_factor;
 
   SetupDefaultTrees(layer_bounds);
   ResetTilingsAndRasterScales();
 
   float page_scale = 4.f;
   float low_res = page_scale * low_res_factor;
   float extra_low_res = low_res * low_res_factor;
   SetupDrawPropertiesAndUpdateTiles(active_layer(), page_scale, 1.0f,
                                     page_scale, 1.0f, 0.f, false);
   EXPECT_EQ(2u, active_layer()->tilings()->num_tilings());
   EXPECT_EQ(page_scale,
-            active_layer()->tilings()->tiling_at(0)->contents_scale());
-  EXPECT_EQ(low_res, active_layer()->tilings()->tiling_at(1)->contents_scale());
+            active_layer()->tilings()->tiling_at(0)->contents_scale_key());
+  EXPECT_EQ(low_res,
+            active_layer()->tilings()->tiling_at(1)->contents_scale_key());
 
   // Grab a current low res tile.
   PictureLayerTiling* old_low_res_tiling =
       active_layer()->tilings()->tiling_at(1);
   Tile::Id old_low_res_tile_id =
       active_layer()->tilings()->tiling_at(1)->TileAt(0, 0)->id();
 
   // The tiling knows it has low res content.
   EXPECT_TRUE(active_layer()
                   ->tilings()
                   ->tiling_at(1)
                   ->may_contain_low_resolution_tiles());
 
   host_impl()->AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(1));
 
   // Zoom in to exactly the low res factor so that the previous low res
   // would be equal to the current high res.
   SetupDrawPropertiesAndUpdateTiles(active_layer(), low_res, 1.0f, low_res,
                                     1.0f, 0.f, false);
   // 3 tilings. The old high res, the new high res (old low res) and the new low
   // res.
   EXPECT_EQ(3u, active_layer()->num_tilings());
 
   PictureLayerTilingSet* tilings = active_layer()->tilings();
-  EXPECT_EQ(page_scale, tilings->tiling_at(0)->contents_scale());
-  EXPECT_EQ(low_res, tilings->tiling_at(1)->contents_scale());
-  EXPECT_EQ(extra_low_res, tilings->tiling_at(2)->contents_scale());
+  EXPECT_EQ(page_scale, tilings->tiling_at(0)->contents_scale_key());
+  EXPECT_EQ(low_res, tilings->tiling_at(1)->contents_scale_key());
+  EXPECT_EQ(extra_low_res, tilings->tiling_at(2)->contents_scale_key());
 
   EXPECT_EQ(NON_IDEAL_RESOLUTION, tilings->tiling_at(0)->resolution());
   EXPECT_EQ(HIGH_RESOLUTION, tilings->tiling_at(1)->resolution());
   EXPECT_EQ(LOW_RESOLUTION, tilings->tiling_at(2)->resolution());
 
   // The old low res tile was destroyed and replaced.
   EXPECT_EQ(old_low_res_tiling, tilings->tiling_at(1));
   EXPECT_NE(old_low_res_tile_id, tilings->tiling_at(1)->TileAt(0, 0)->id());
   EXPECT_TRUE(tilings->tiling_at(1)->TileAt(0, 0));
 
@@ skipping 50 matching lines @@
   // Set PictureLayerImpl::ideal_contents_scale_ to 2.f.
   const float suggested_ideal_contents_scale = 2.f;
   const float device_scale_factor = 3.f;
   const float page_scale_factor = 4.f;
   const float animation_contents_scale = 1.f;
   const bool animating_transform_to_screen = false;
   SetupDrawPropertiesAndUpdateTiles(
       pending_layer_ptr, suggested_ideal_contents_scale, device_scale_factor,
       page_scale_factor, animation_contents_scale, animation_contents_scale,
       animating_transform_to_screen);
-  EXPECT_EQ(1.f, pending_layer_ptr->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_EQ(1.f,
+            pending_layer_ptr->tilings()->tiling_at(0)->contents_scale_key());
 
   // Push to active layer.
   host_impl()->ActivateSyncTree();
 
   FakePictureLayerImpl* active_layer = static_cast<FakePictureLayerImpl*>(
       host_impl()->active_tree()->root_layer_for_testing());
   SetupDrawPropertiesAndUpdateTiles(
       active_layer, suggested_ideal_contents_scale, device_scale_factor,
       page_scale_factor, animation_contents_scale, animation_contents_scale,
       animating_transform_to_screen);
-  EXPECT_EQ(1.f, active_layer->tilings()->tiling_at(0)->contents_scale());
+  EXPECT_EQ(1.f, active_layer->tilings()->tiling_at(0)->contents_scale_key());
   active_layer->set_visible_layer_rect(gfx::Rect(layer_bounds));
 
   // Create resources for the tiles.
   host_impl()->tile_manager()->InitializeTilesWithResourcesForTesting(
       active_layer->tilings()->tiling_at(0)->AllTilesForTesting());
 
   // Draw.
   std::unique_ptr<RenderPass> render_pass = RenderPass::Create();
   AppendQuadsData data;
   active_layer->WillDraw(DRAW_MODE_SOFTWARE, nullptr);
@@ skipping 35 matching lines @@
       // Scale 0.6.
       case 6:
         expected_contents_scale = 1.f;
         break;
     }
     SetupDrawPropertiesAndUpdateTiles(pending_layer_ptr, ideal_contents_scale,
                                       1.f, 1.f, 1.f, 1.f, false);
     EXPECT_FLOAT_EQ(expected_contents_scale,
                     pending_layer_ptr->picture_layer_tiling_set()
                         ->FindTilingWithResolution(HIGH_RESOLUTION)
-                        ->contents_scale())
+                        ->contents_scale_key())
         << "ideal_contents_scale: " << ideal_contents_scale;
   }
 
   expected_contents_scale = 1.f;
   for (int i = 30; i >= 1; --i) {
     float ideal_contents_scale = 0.1f * i - 1e-6;
     switch (i) {
       // Scale 0.2.
       case 2:
         expected_contents_scale = 0.5f;
         break;
       // Scale 0.1.
       case 1:
         expected_contents_scale = 0.25f;
         break;
     }
     SetupDrawPropertiesAndUpdateTiles(pending_layer_ptr, ideal_contents_scale,
                                       1.f, 1.f, 1.f, 1.f, false);
     EXPECT_FLOAT_EQ(expected_contents_scale,
                     pending_layer_ptr->picture_layer_tiling_set()
                         ->FindTilingWithResolution(HIGH_RESOLUTION)
-                        ->contents_scale())
+                        ->contents_scale_key())
         << "ideal_contents_scale: " << ideal_contents_scale;
   }
 }
 
+TEST_F(PictureLayerImplTest, ChangeRasterTranslationNukePendingLayerTiles) {
+  gfx::Size layer_bounds(200, 200);
+  gfx::Size tile_size(256, 256);
+  SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
+  pending_layer()->SetUseTransformedRasterization(true);
+
+  // Start with scale & translation of * 2.25 + (0.25, 0.5).
+  SetupDrawProperties(pending_layer(), 2.25f, 1.5f, 1.f, 2.25f, 2.25f, false);
+  gfx::Transform translate1;
+  translate1.Translate(0.25f, 0.5f);
+  pending_layer()->draw_properties().screen_space_transform.ConcatTransform(
+      translate1);
+  pending_layer()->draw_properties().target_space_transform =
+      pending_layer()->draw_properties().screen_space_transform;
+  pending_layer()->UpdateTiles();
+  ASSERT_EQ(1u, pending_layer()->tilings()->num_tilings());
+  {
+    PictureLayerTiling* tiling = pending_layer()->tilings()->tiling_at(0);
+    EXPECT_EQ(ScaleTranslate2d(2.25f, gfx::Vector2dF(0.25f, 0.5f)),
+              tiling->raster_transform());
+    EXPECT_EQ(4u, tiling->AllTilesForTesting().size());
+    // Mark some arbitrary flags on the tiles for later checking.
+    for (auto* tile : tiling->AllTilesForTesting())
+      tile->set_solid_color_analysis_performed(true);
+  }
+
+  // Change to scale & translation of * 2.25 + (0.75, 0.25).
+  // Verifies there is a hysteresis that simple layer movement doesn't update
+  // raster translation.
+  SetupDrawProperties(pending_layer(), 2.25f, 1.5f, 1.f, 2.25f, 2.25f, false);
+  gfx::Transform translate2;
+  translate2.Translate(0.75f, 0.25f);
+  pending_layer()->draw_properties().screen_space_transform.ConcatTransform(
+      translate2);
+  pending_layer()->draw_properties().target_space_transform =
+      pending_layer()->draw_properties().screen_space_transform;
+  pending_layer()->UpdateTiles();
+  ASSERT_EQ(1u, pending_layer()->tilings()->num_tilings());
+  {
+    PictureLayerTiling* tiling = pending_layer()->tilings()->tiling_at(0);
+    EXPECT_EQ(ScaleTranslate2d(2.25f, gfx::Vector2dF(0.25f, 0.5f)),
+              tiling->raster_transform());
+    EXPECT_EQ(4u, tiling->AllTilesForTesting().size());
+    for (auto* tile : tiling->AllTilesForTesting())
+      EXPECT_TRUE(tile->is_solid_color_analysis_performed());
+  }
+
+  // Now change the device scale factor but keep the same total scale.
+  // Verifies the old tiles get evicted due to slot conflict.
+  SetupDrawProperties(pending_layer(), 2.25f, 1.0f, 1.f, 2.25f, 2.25f, false);
+  pending_layer()->draw_properties().screen_space_transform.ConcatTransform(
+      translate2);
+  pending_layer()->draw_properties().target_space_transform =
+      pending_layer()->draw_properties().screen_space_transform;
+  pending_layer()->UpdateTiles();
+  ASSERT_EQ(1u, pending_layer()->tilings()->num_tilings());
+  {
+    PictureLayerTiling* tiling = pending_layer()->tilings()->tiling_at(0);
+    EXPECT_EQ(ScaleTranslate2d(2.25f, gfx::Vector2dF(0.75f, 0.25f)),
+              tiling->raster_transform());
+    EXPECT_EQ(4u, tiling->AllTilesForTesting().size());
+    for (auto* tile : tiling->AllTilesForTesting())
+      EXPECT_FALSE(tile->is_solid_color_analysis_performed());
+  }
+}
+
+TEST_F(PictureLayerImplTest, ChangeRasterTranslationNukeActiveLayerTiles) {
+  gfx::Size layer_bounds(200, 200);
+  gfx::Size tile_size(256, 256);
+  SetupDefaultTreesWithFixedTileSize(layer_bounds, tile_size, Region());
+  active_layer()->SetUseTransformedRasterization(true);
+  pending_layer()->SetUseTransformedRasterization(true);
+
+  // Start with scale & translation of * 2.25 + (0.25, 0.5) on the active layer.
+  SetupDrawProperties(active_layer(), 2.25f, 1.5f, 1.f, 2.25f, 2.25f, false);
+  gfx::Transform translate1;
+  translate1.Translate(0.25f, 0.5f);
+  active_layer()->draw_properties().screen_space_transform.ConcatTransform(
+      translate1);
+  active_layer()->draw_properties().target_space_transform =
+      active_layer()->draw_properties().screen_space_transform;
+  active_layer()->UpdateTiles();
+  ASSERT_EQ(3u, active_layer()->tilings()->num_tilings());
+  {
+    PictureLayerTiling* tiling =
+        active_layer()->tilings()->FindTilingWithScaleKey(2.25f);
+    EXPECT_EQ(ScaleTranslate2d(2.25f, gfx::Vector2dF(0.25f, 0.5f)),
+              tiling->raster_transform());
+    EXPECT_EQ(4u, tiling->AllTilesForTesting().size());
+    // Mark some arbitrary flags on the tiles for later checking.
+    for (auto* tile : tiling->AllTilesForTesting())
+      tile->set_solid_color_analysis_performed(true);
+  }
+
+  // Create a pending layer with the same scale but different translation.
+  SetupDrawProperties(pending_layer(), 2.25f, 1.5f, 1.f, 2.25f, 2.25f, false);
+  gfx::Transform translate2;
+  translate2.Translate(0.75f, 0.25f);
+  pending_layer()->draw_properties().screen_space_transform.ConcatTransform(
+      translate2);
+  pending_layer()->draw_properties().target_space_transform =
+      pending_layer()->draw_properties().screen_space_transform;
+  pending_layer()->UpdateTiles();
+  ASSERT_EQ(1u, pending_layer()->tilings()->num_tilings());
+  {
+    PictureLayerTiling* tiling = pending_layer()->tilings()->tiling_at(0);
+    EXPECT_EQ(ScaleTranslate2d(2.25f, gfx::Vector2dF(0.75f, 0.25f)),
+              tiling->raster_transform());
+    EXPECT_EQ(4u, tiling->AllTilesForTesting().size());
+  }
+
+  // Now push to the active layer.
+  // Verifies the active tiles get evicted due to slot conflict.
+  host_impl()->ActivateSyncTree();
+  ASSERT_EQ(3u, active_layer()->tilings()->num_tilings());
+  {
+    PictureLayerTiling* tiling =
+        active_layer()->tilings()->FindTilingWithScaleKey(2.25f);
+    EXPECT_EQ(ScaleTranslate2d(2.25f, gfx::Vector2dF(0.75f, 0.25f)),
+              tiling->raster_transform());
+    EXPECT_EQ(4u, tiling->AllTilesForTesting().size());
+    for (auto* tile : tiling->AllTilesForTesting())
+      EXPECT_FALSE(tile->is_solid_color_analysis_performed());
+  }
+}
+
 }  // namespace
 }  // namespace cc