Raster PictureLayerTiling with fractional translation

cc/tiles/picture_layer_tiling_set_unittest.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/tiles/picture_layer_tiling_set.h"
 
 #include <map>
 #include <vector>
 
 #include "base/memory/ptr_util.h"
@@ skipping 49 matching lines @@
 
 TEST(PictureLayerTilingSetTest, NoResources) {
   FakePictureLayerTilingClient client;
   gfx::Size layer_bounds(1000, 800);
   std::unique_ptr<TestablePictureLayerTilingSet> set = CreateTilingSet(&client);
   client.SetTileSize(gfx::Size(256, 256));
 
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateEmpty(layer_bounds);
 
-  set->AddTiling(1.0, raster_source);
-  set->AddTiling(1.5, raster_source);
-  set->AddTiling(2.0, raster_source);
+  set->AddTiling(ScaleTranslate2d(), raster_source);
+  set->AddTiling(ScaleTranslate2d(1.5, gfx::Vector2dF()), raster_source);
+  set->AddTiling(ScaleTranslate2d(2.0, gfx::Vector2dF()), raster_source);
 
   float contents_scale = 2.0;
   gfx::Size content_bounds(
       gfx::ScaleToCeiledSize(layer_bounds, contents_scale));
   gfx::Rect content_rect(content_bounds);
 
   Region remaining(content_rect);
   PictureLayerTilingSet::CoverageIterator iter(set.get(), contents_scale,
                                                content_rect, contents_scale);
   for (; iter; ++iter) {
@@ skipping 16 matching lines @@
   PictureLayerTilingSet::TilingRange between_high_and_low_res_range(0, 0);
   PictureLayerTilingSet::TilingRange low_res_range(0, 0);
   PictureLayerTilingSet::TilingRange lower_than_low_res_range(0, 0);
   PictureLayerTiling* high_res_tiling;
   PictureLayerTiling* low_res_tiling;
 
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
 
   std::unique_ptr<TestablePictureLayerTilingSet> set = CreateTilingSet(&client);
-  set->AddTiling(2.0, raster_source);
-  high_res_tiling = set->AddTiling(1.0, raster_source);
+  set->AddTiling(ScaleTranslate2d(2.0, gfx::Vector2dF()), raster_source);
+  high_res_tiling = set->AddTiling(ScaleTranslate2d(), raster_source);
   high_res_tiling->set_resolution(HIGH_RESOLUTION);
-  set->AddTiling(0.5, raster_source);
-  low_res_tiling = set->AddTiling(0.25, raster_source);
+  set->AddTiling(ScaleTranslate2d(0.5, gfx::Vector2dF()), raster_source);
+  low_res_tiling =
+      set->AddTiling(ScaleTranslate2d(0.25, gfx::Vector2dF()), raster_source);
   low_res_tiling->set_resolution(LOW_RESOLUTION);
-  set->AddTiling(0.125, raster_source);
+  set->AddTiling(ScaleTranslate2d(0.125, gfx::Vector2dF()), raster_source);
 
   higher_than_high_res_range =
       set->GetTilingRange(PictureLayerTilingSet::HIGHER_THAN_HIGH_RES);
   EXPECT_EQ(0u, higher_than_high_res_range.start);
   EXPECT_EQ(1u, higher_than_high_res_range.end);
 
   high_res_range = set->GetTilingRange(PictureLayerTilingSet::HIGH_RES);
   EXPECT_EQ(1u, high_res_range.start);
   EXPECT_EQ(2u, high_res_range.end);
 
   between_high_and_low_res_range =
       set->GetTilingRange(PictureLayerTilingSet::BETWEEN_HIGH_AND_LOW_RES);
   EXPECT_EQ(2u, between_high_and_low_res_range.start);
   EXPECT_EQ(3u, between_high_and_low_res_range.end);
 
   low_res_range = set->GetTilingRange(PictureLayerTilingSet::LOW_RES);
   EXPECT_EQ(3u, low_res_range.start);
   EXPECT_EQ(4u, low_res_range.end);
 
   lower_than_low_res_range =
       set->GetTilingRange(PictureLayerTilingSet::LOWER_THAN_LOW_RES);
   EXPECT_EQ(4u, lower_than_low_res_range.start);
   EXPECT_EQ(5u, lower_than_low_res_range.end);
 
   std::unique_ptr<TestablePictureLayerTilingSet> set_without_low_res =
       CreateTilingSet(&client);
-  set_without_low_res->AddTiling(2.0, raster_source);
-  high_res_tiling = set_without_low_res->AddTiling(1.0, raster_source);
+  set_without_low_res->AddTiling(ScaleTranslate2d(2.0, gfx::Vector2dF()),
+                                 raster_source);
+  high_res_tiling =
+      set_without_low_res->AddTiling(ScaleTranslate2d(), raster_source);
   high_res_tiling->set_resolution(HIGH_RESOLUTION);
-  set_without_low_res->AddTiling(0.5, raster_source);
-  set_without_low_res->AddTiling(0.25, raster_source);
+  set_without_low_res->AddTiling(ScaleTranslate2d(0.5, gfx::Vector2dF()),
+                                 raster_source);
+  set_without_low_res->AddTiling(ScaleTranslate2d(0.25, gfx::Vector2dF()),
+                                 raster_source);
 
   higher_than_high_res_range = set_without_low_res->GetTilingRange(
       PictureLayerTilingSet::HIGHER_THAN_HIGH_RES);
   EXPECT_EQ(0u, higher_than_high_res_range.start);
   EXPECT_EQ(1u, higher_than_high_res_range.end);
 
   high_res_range =
       set_without_low_res->GetTilingRange(PictureLayerTilingSet::HIGH_RES);
   EXPECT_EQ(1u, high_res_range.start);
   EXPECT_EQ(2u, high_res_range.end);
 
   between_high_and_low_res_range = set_without_low_res->GetTilingRange(
       PictureLayerTilingSet::BETWEEN_HIGH_AND_LOW_RES);
   EXPECT_EQ(2u, between_high_and_low_res_range.start);
   EXPECT_EQ(4u, between_high_and_low_res_range.end);
 
   low_res_range =
       set_without_low_res->GetTilingRange(PictureLayerTilingSet::LOW_RES);
   EXPECT_EQ(0u, low_res_range.end - low_res_range.start);
 
   lower_than_low_res_range = set_without_low_res->GetTilingRange(
       PictureLayerTilingSet::LOWER_THAN_LOW_RES);
   EXPECT_EQ(0u, lower_than_low_res_range.end - lower_than_low_res_range.start);
 
   std::unique_ptr<TestablePictureLayerTilingSet>
       set_with_only_high_and_low_res = CreateTilingSet(&client);
-  high_res_tiling =
-      set_with_only_high_and_low_res->AddTiling(1.0, raster_source);
+  high_res_tiling = set_with_only_high_and_low_res->AddTiling(
+      ScaleTranslate2d(), raster_source);
   high_res_tiling->set_resolution(HIGH_RESOLUTION);
-  low_res_tiling =
-      set_with_only_high_and_low_res->AddTiling(0.5, raster_source);
+  low_res_tiling = set_with_only_high_and_low_res->AddTiling(
+      ScaleTranslate2d(0.5, gfx::Vector2dF()), raster_source);
   low_res_tiling->set_resolution(LOW_RESOLUTION);
 
   higher_than_high_res_range = set_with_only_high_and_low_res->GetTilingRange(
       PictureLayerTilingSet::HIGHER_THAN_HIGH_RES);
   EXPECT_EQ(0u,
             higher_than_high_res_range.end - higher_than_high_res_range.start);
 
   high_res_range = set_with_only_high_and_low_res->GetTilingRange(
       PictureLayerTilingSet::HIGH_RES);
   EXPECT_EQ(0u, high_res_range.start);
   EXPECT_EQ(1u, high_res_range.end);
 
   between_high_and_low_res_range =
       set_with_only_high_and_low_res->GetTilingRange(
           PictureLayerTilingSet::BETWEEN_HIGH_AND_LOW_RES);
   EXPECT_EQ(0u, between_high_and_low_res_range.end -
                     between_high_and_low_res_range.start);
 
   low_res_range = set_with_only_high_and_low_res->GetTilingRange(
       PictureLayerTilingSet::LOW_RES);
   EXPECT_EQ(1u, low_res_range.start);
   EXPECT_EQ(2u, low_res_range.end);
 
   lower_than_low_res_range = set_with_only_high_and_low_res->GetTilingRange(
       PictureLayerTilingSet::LOWER_THAN_LOW_RES);
   EXPECT_EQ(0u, lower_than_low_res_range.end - lower_than_low_res_range.start);
 
   std::unique_ptr<TestablePictureLayerTilingSet> set_with_only_high_res =
       CreateTilingSet(&client);
-  high_res_tiling = set_with_only_high_res->AddTiling(1.0, raster_source);
+  high_res_tiling =
+      set_with_only_high_res->AddTiling(ScaleTranslate2d(), raster_source);
   high_res_tiling->set_resolution(HIGH_RESOLUTION);
 
   higher_than_high_res_range = set_with_only_high_res->GetTilingRange(
       PictureLayerTilingSet::HIGHER_THAN_HIGH_RES);
   EXPECT_EQ(0u,
             higher_than_high_res_range.end - higher_than_high_res_range.start);
 
   high_res_range =
       set_with_only_high_res->GetTilingRange(PictureLayerTilingSet::HIGH_RES);
   EXPECT_EQ(0u, high_res_range.start);
@@ skipping 31 matching lines @@
     FakePictureLayerTilingClient client(resource_provider.get());
     client.SetTileSize(gfx::Size(256, 256));
     gfx::Size layer_bounds(1000, 800);
     std::unique_ptr<TestablePictureLayerTilingSet> set =
         CreateTilingSet(&client);
     scoped_refptr<FakeRasterSource> raster_source =
         FakeRasterSource::CreateFilled(layer_bounds);
 
     float scale = min_scale;
     for (int i = 0; i < num_tilings; ++i, scale += scale_increment) {
-      PictureLayerTiling* tiling = set->AddTiling(scale, raster_source);
+      PictureLayerTiling* tiling = set->AddTiling(
+          ScaleTranslate2d(scale, gfx::Vector2dF()), raster_source);
       tiling->set_resolution(HIGH_RESOLUTION);
       tiling->CreateAllTilesForTesting();
       std::vector<Tile*> tiles = tiling->AllTilesForTesting();
       client.tile_manager()->InitializeTilesWithResourcesForTesting(tiles);
     }
 
     float max_contents_scale = scale;
     gfx::Size content_bounds(
         gfx::ScaleToCeiledSize(layer_bounds, max_contents_scale));
     gfx::Rect content_rect(content_bounds);
 
     Region remaining(content_rect);
     PictureLayerTilingSet::CoverageIterator iter(
         set.get(), max_contents_scale, content_rect, ideal_contents_scale);
     for (; iter; ++iter) {
       gfx::Rect geometry_rect = iter.geometry_rect();
       EXPECT_TRUE(content_rect.Contains(geometry_rect));
       ASSERT_TRUE(remaining.Contains(geometry_rect));
       remaining.Subtract(geometry_rect);
 
-      float scale = iter.CurrentTiling()->contents_scale();
+      float scale = iter.CurrentTiling()->contents_scale_key();
       EXPECT_EQ(expected_scale, scale);
 
       if (num_tilings)
         EXPECT_TRUE(*iter);
       else
         EXPECT_FALSE(*iter);
     }
     EXPECT_TRUE(remaining.IsEmpty());
   }
 };
@@ skipping 43 matching lines @@
 
   gfx::Size layer_bounds(100, 100);
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
 
   gfx::Size tile_size1(10, 10);
   gfx::Size tile_size2(30, 30);
   gfx::Size tile_size3(20, 20);
 
   pending_client.SetTileSize(tile_size1);
-  pending_set->AddTiling(1.f, raster_source);
+  pending_set->AddTiling(ScaleTranslate2d(), raster_source);
   // New tilings get the correct tile size.
   EXPECT_EQ(tile_size1, pending_set->tiling_at(0)->tile_size());
 
   // Set some expected things for the tiling set to function.
   pending_set->tiling_at(0)->set_resolution(HIGH_RESOLUTION);
   active_client.set_twin_tiling_set(pending_set.get());
 
   // Set a priority rect so we get tiles.
   pending_set->UpdateTilePriorities(gfx::Rect(layer_bounds), 1.f, 1.0,
                                     Occlusion(), false);
   EXPECT_EQ(tile_size1, pending_set->tiling_at(0)->tile_size());
 
   // The tiles should get the correct size.
   std::vector<Tile*> pending_tiles =
       pending_set->tiling_at(0)->AllTilesForTesting();
   EXPECT_GT(pending_tiles.size(), 0u);
   for (auto* tile : pending_tiles)
     EXPECT_EQ(tile_size1, tile->content_rect().size());
 
   // Update to a new source frame with a new tile size.
   // Note that setting a new raster source can typically only happen after
   // activation, since we can't set the raster source twice on the pending tree
   // without activating. For test, just remove and add a new tiling instead.
   pending_set->RemoveAllTilings();
-  pending_set->AddTiling(1.f, raster_source);
+  pending_set->AddTiling(ScaleTranslate2d(), raster_source);
   pending_set->tiling_at(0)->set_resolution(HIGH_RESOLUTION);
   pending_client.SetTileSize(tile_size2);
   pending_set->UpdateTilingsToCurrentRasterSourceForCommit(raster_source.get(),
                                                            Region(), 1.f, 1.f);
   // The tiling should get the correct tile size.
   EXPECT_EQ(tile_size2, pending_set->tiling_at(0)->tile_size());
 
   // Set a priority rect so we get tiles.
   pending_set->UpdateTilePriorities(gfx::Rect(layer_bounds), 1.f, 2.0,
                                     Occlusion(), false);
@@ skipping 59 matching lines @@
                                     1000, 1000.f);
   std::unique_ptr<PictureLayerTilingSet> active_set =
       PictureLayerTilingSet::Create(ACTIVE_TREE, &active_client, 1000, 1.f,
                                     1000, 1000.f);
 
   gfx::Size layer_bounds(100, 105);
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateEmpty(layer_bounds);
 
   // Tilings can be added of any scale, the tiling client can controls this.
-  pending_set->AddTiling(1.f, raster_source);
-  pending_set->AddTiling(2.f, raster_source);
-  pending_set->AddTiling(3.f, raster_source);
+  pending_set->AddTiling(ScaleTranslate2d(), raster_source);
+  pending_set->AddTiling(ScaleTranslate2d(2.f, gfx::Vector2dF()),
+                         raster_source);
+  pending_set->AddTiling(ScaleTranslate2d(3.f, gfx::Vector2dF()),
+                         raster_source);
 
   // Set some expected things for the tiling set to function.
   pending_set->tiling_at(0)->set_resolution(HIGH_RESOLUTION);
   active_client.set_twin_tiling_set(pending_set.get());
 
   // Update to a new source frame with a max content scale that is larger than
   // everything.
   float max_content_scale = 3.f;
   pending_set->UpdateTilingsToCurrentRasterSourceForCommit(
       raster_source.get(), Region(), 1.f, max_content_scale);
@@ skipping 34 matching lines @@
   LayerTreeSettings settings;
   settings.skewport_extrapolation_limit_in_screen_pixels = 75;
   settings.tiling_interest_area_padding = 1000000;
 
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
   std::unique_ptr<TestablePictureLayerTilingSet> tiling_set =
       CreateTilingSetWithSettings(&client, settings);
 
   EXPECT_FALSE(tiling_set->TilingsNeedUpdate(viewport, 1.0));
-  tiling_set->AddTiling(1.f, raster_source);
+  tiling_set->AddTiling(ScaleTranslate2d(), raster_source);
   EXPECT_TRUE(tiling_set->TilingsNeedUpdate(viewport, 1.0));
 
   tiling_set->UpdateTilePriorities(viewport, 1.f, 1.0, Occlusion(), true);
 
   // Move viewport down 50 pixels in 0.5 seconds.
   gfx::Rect down_skewport =
       tiling_set->ComputeSkewport(gfx::Rect(0, 50, 100, 100), 1.5, 1.f);
 
   EXPECT_EQ(0, down_skewport.x());
   EXPECT_EQ(50, down_skewport.y());
@@ skipping 65 matching lines @@
   FakePictureLayerTilingClient client;
 
   gfx::Size layer_bounds(200, 200);
   client.SetTileSize(gfx::Size(100, 100));
   LayerTreeSettings settings;
   settings.tiling_interest_area_padding = 1000000000;
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
   std::unique_ptr<TestablePictureLayerTilingSet> tiling_set =
       CreateTilingSetWithSettings(&client, settings);
-  tiling_set->AddTiling(1.f, raster_source);
+  tiling_set->AddTiling(ScaleTranslate2d(), raster_source);
 
   gfx::Rect viewport1(-1918, 255860, 4010, 2356);
   gfx::Rect viewport2(-7088, -91738, 14212, 8350);
   gfx::Rect viewport3(-12730024, -158883296, 24607540, 14454512);
   double time = 1.0;
   tiling_set->UpdateTilePriorities(viewport1, 1.f, time, Occlusion(), true);
   time += 0.016;
   EXPECT_TRUE(
       tiling_set->ComputeSkewport(viewport2, time, 1.f).Contains(viewport2));
   tiling_set->UpdateTilePriorities(viewport2, 1.f, time, Occlusion(), true);
   time += 0.016;
   EXPECT_TRUE(
       tiling_set->ComputeSkewport(viewport3, time, 1.f).Contains(viewport3));
 
   // Use a tiling with a large scale, so the viewport times the scale no longer
   // fits into integers, and the viewport is not anywhere close to the tiling.
-  PictureLayerTiling* tiling = tiling_set->AddTiling(1000.f, raster_source);
+  PictureLayerTiling* tiling = tiling_set->AddTiling(
+      ScaleTranslate2d(1000.f, gfx::Vector2dF()), raster_source);
   EXPECT_TRUE(tiling_set->TilingsNeedUpdate(viewport3, time));
   tiling_set->UpdateTilePriorities(viewport3, 1.f, time, Occlusion(), true);
   EXPECT_TRUE(tiling->GetCurrentVisibleRectForTesting().IsEmpty());
 }
 
 TEST(PictureLayerTilingSetTest, ComputeSkewport) {
   FakePictureLayerTilingClient client;
 
   gfx::Rect viewport(0, 0, 100, 100);
   gfx::Size layer_bounds(200, 200);
 
   client.SetTileSize(gfx::Size(100, 100));
 
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
   std::unique_ptr<TestablePictureLayerTilingSet> tiling_set =
       CreateTilingSet(&client);
-  tiling_set->AddTiling(1.f, raster_source);
+  tiling_set->AddTiling(ScaleTranslate2d(), raster_source);
 
   tiling_set->UpdateTilePriorities(viewport, 1.f, 1.0, Occlusion(), true);
 
   // Move viewport down 50 pixels in 0.5 seconds.
   gfx::Rect down_skewport =
       tiling_set->ComputeSkewport(gfx::Rect(0, 50, 100, 100), 1.5, 1.f);
 
   EXPECT_EQ(0, down_skewport.x());
   EXPECT_EQ(50, down_skewport.y());
   EXPECT_EQ(100, down_skewport.width());
@@ skipping 41 matching lines @@
 
   gfx::Rect viewport(0, 0, 100, 100);
   gfx::Size layer_bounds(200, 200);
 
   client.SetTileSize(gfx::Size(100, 100));
 
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
   std::unique_ptr<TestablePictureLayerTilingSet> tiling_set =
       CreateTilingSet(&client);
-  tiling_set->AddTiling(1.f, raster_source);
+  tiling_set->AddTiling(ScaleTranslate2d(), raster_source);
 
   tiling_set->UpdateTilePriorities(viewport, 1.f, 1.0, Occlusion(), true);
 
   // Move viewport down 50 pixels in 0.5 seconds.
   gfx::Rect viewport_50 = gfx::Rect(0, 50, 100, 100);
   gfx::Rect skewport_50 = tiling_set->ComputeSkewport(viewport_50, 1.5, 1.f);
 
   EXPECT_EQ(gfx::Rect(0, 50, 100, 200), skewport_50);
   tiling_set->UpdateTilePriorities(viewport_50, 1.f, 1.5, Occlusion(), true);
 
@@ skipping 53 matching lines @@
 
   // Tiling at 0.25 scale: this should create 47x47 tiles of size 10x10.
   // The reason is that each tile has a one pixel border, so tile at (1, 2)
   // for instance begins at (8, 16) pixels. So tile at (46, 46) will begin at
   // (368, 368) and extend to the end of 1500 * 0.25 = 375 edge of the
   // tiling.
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
   std::unique_ptr<TestablePictureLayerTilingSet> tiling_set =
       CreateTilingSet(&client);
-  auto* tiling = tiling_set->AddTiling(0.25f, raster_source);
+  auto* tiling = tiling_set->AddTiling(
+      ScaleTranslate2d(0.25f, gfx::Vector2dF()), raster_source);
   tiling->set_resolution(HIGH_RESOLUTION);
   gfx::Rect viewport_in_content_space =
       gfx::ScaleToEnclosedRect(viewport, 0.25f);
 
   tiling_set->UpdateTilePriorities(viewport, 1.f, 1.0, Occlusion(), true);
   auto prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
 
   // Compute the soon border.
   gfx::Rect soon_border_rect_in_content_space =
       tiling_set->ComputeSoonBorderRect(viewport, 1.f);
@@ skipping 140 matching lines @@
   priority = prioritized_tiles[tiling->TileAt(5, 1)].priority();
   EXPECT_FLOAT_EQ(136.f, priority.distance_to_visible);
 
   priority = prioritized_tiles[tiling->TileAt(2, 5)].priority();
   EXPECT_FLOAT_EQ(56.f, priority.distance_to_visible);
 
   priority = prioritized_tiles[tiling->TileAt(3, 4)].priority();
   EXPECT_FLOAT_EQ(8.f, priority.distance_to_visible);
 
   // Test additional scales.
-  tiling = tiling_set->AddTiling(0.2f, raster_source);
+  tiling = tiling_set->AddTiling(ScaleTranslate2d(0.2f, gfx::Vector2dF()),
+                                 raster_source);
   tiling->set_resolution(HIGH_RESOLUTION);
   tiling_set->UpdateTilePriorities(viewport, 1.0f, 4.0, Occlusion(), true);
   prioritized_tiles = tiling->UpdateAndGetAllPrioritizedTilesForTesting();
 
   priority = prioritized_tiles[tiling->TileAt(5, 1)].priority();
   EXPECT_FLOAT_EQ(110.f, priority.distance_to_visible);
 
   priority = prioritized_tiles[tiling->TileAt(2, 5)].priority();
   EXPECT_FLOAT_EQ(70.f, priority.distance_to_visible);
 
@@ skipping 14 matching lines @@
 }
 
 TEST(PictureLayerTilingTest, InvalidateAfterComputeTilePriorityRects) {
   FakePictureLayerTilingClient pending_client;
   pending_client.SetTileSize(gfx::Size(100, 100));
 
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(gfx::Size(100, 100));
   std::unique_ptr<TestablePictureLayerTilingSet> tiling_set =
       CreateTilingSet(&pending_client);
-  auto* pending_tiling = tiling_set->AddTiling(1.f, raster_source);
+  auto* pending_tiling =
+      tiling_set->AddTiling(ScaleTranslate2d(), raster_source);
   pending_tiling->set_resolution(HIGH_RESOLUTION);
 
   // Ensure that we can compute tile priority rects, invalidate, and compute the
   // rects again. It is important that the second compute tile priority rects
   // return true, indicating that things have changed (since invalidation has
   // changed things). This causes PrepareTiles to be properly scheduled. If the
   // second ComputeTilePriorityRects returns false, then we assume that
   // PrepareTiles isn't needed and we signal that we're ready to draw
   // immediately, which can cause visual glitches.
   //
@@ skipping 22 matching lines @@
       PictureLayerTilingSet::Create(PENDING_TREE, &pending_client, 1000, 1.f,
                                     1000, 1000.f);
   std::unique_ptr<PictureLayerTilingSet> active_set =
       PictureLayerTilingSet::Create(ACTIVE_TREE, &active_client, 1000, 1.f,
                                     1000, 1000.f);
 
   gfx::Size layer_bounds(100, 100);
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
 
-  auto* pending_tiling = pending_set->AddTiling(1.f, raster_source);
+  auto* pending_tiling =
+      pending_set->AddTiling(ScaleTranslate2d(), raster_source);
   pending_tiling->set_resolution(HIGH_RESOLUTION);
   active_client.set_twin_tiling_set(pending_set.get());
 
   double time = 1.;
   gfx::Rect viewport(0, 0, 100, 100);
 
   // The first commit will update the raster source for pending tilings.
   pending_set->UpdateTilingsToCurrentRasterSourceForCommit(raster_source,
                                                            Region(), 1.f, 1.f);
   // UpdateTilePriorities for pending set gets called during UDP in commit.
@@ skipping 18 matching lines @@
   pending_set->UpdateTilingsToCurrentRasterSourceForCommit(raster_source,
                                                            Region(), 1.f, 1.f);
   // UpdateTilePriorities for pending set gets called during UDP in commit.
   EXPECT_TRUE(pending_set->UpdateTilePriorities(viewport, 1.f, time,
                                                 Occlusion(), true));
   // No changes for active set until activation.
   EXPECT_FALSE(
       active_set->UpdateTilePriorities(viewport, 1.f, time, Occlusion(), true));
 }
 
+TEST(PictureLayerTilingSetTest, TilingTranslationChanges) {
+  gfx::Size tile_size(64, 64);
+  FakePictureLayerTilingClient pending_client;
+  FakePictureLayerTilingClient active_client;
+  pending_client.SetTileSize(tile_size);
+  active_client.SetTileSize(tile_size);
+  std::unique_ptr<PictureLayerTilingSet> pending_set =
+      PictureLayerTilingSet::Create(PENDING_TREE, &pending_client, 0, 1.f, 0,
+                                    0.f);
+  std::unique_ptr<PictureLayerTilingSet> active_set =
+      PictureLayerTilingSet::Create(ACTIVE_TREE, &active_client, 0, 1.f, 0,
+                                    0.f);
+  active_client.set_twin_tiling_set(pending_set.get());
+
+  gfx::Size layer_bounds(100, 100);
+  scoped_refptr<FakeRasterSource> raster_source =
+      FakeRasterSource::CreateFilled(layer_bounds);
+
+  ScaleTranslate2d raster_transform1(1.f, gfx::Vector2dF(0.25f, 0.25f));
+  pending_set->AddTiling(raster_transform1, raster_source);
+  pending_set->tiling_at(0)->set_resolution(HIGH_RESOLUTION);
+
+  // Set a priority rect so we get tiles.
+  pending_set->UpdateTilePriorities(gfx::Rect(layer_bounds), 1.f, 1.0,
+                                    Occlusion(), false);
+
+  // Make sure all tiles are generated.
+  EXPECT_EQ(4u, pending_set->tiling_at(0)->AllTilesForTesting().size());
+
+  // Clone from the pending to the active tree.
+  active_set->UpdateTilingsToCurrentRasterSourceForActivation(
+      raster_source.get(), pending_set.get(), Region(), 1.f, 1.f);
+
+  // Verifies active tree cloned the tiling correctly.
+  ASSERT_EQ(1u, active_set->num_tilings());
+  EXPECT_EQ(active_set->tiling_at(0)->raster_transform(), raster_transform1);
+  EXPECT_EQ(4u, active_set->tiling_at(0)->AllTilesForTesting().size());
+
+  // Change raster translation on the pending set.
+  ScaleTranslate2d raster_transform2(1.f, gfx::Vector2dF(0.75f, 0.75f));
+  pending_set->RemoveAllTilings();
+  pending_set->AddTiling(raster_transform2, raster_source);
+  pending_set->tiling_at(0)->set_resolution(HIGH_RESOLUTION);
+
+  // Set a different priority rect to get one tile.
+  pending_set->UpdateTilePriorities(gfx::Rect(1, 1), 1.f, 1.0, Occlusion(),
+                                    false);
+  EXPECT_EQ(1u, pending_set->tiling_at(0)->AllTilesForTesting().size());
+
+  // Commit the pending to the active tree again.
+  active_set->UpdateTilingsToCurrentRasterSourceForActivation(
+      raster_source.get(), pending_set.get(), Region(), 1.f, 1.f);
+
+  // Verifies the old tiling with a different translation is dropped.
+  ASSERT_EQ(1u, active_set->num_tilings());
+  EXPECT_EQ(active_set->tiling_at(0)->raster_transform(), raster_transform2);
+  EXPECT_EQ(1u, active_set->tiling_at(0)->AllTilesForTesting().size());
+}
+
 }  // namespace
 }  // namespace cc