Raster PictureLayerTiling with fractional translation

cc/tiles/picture_layer_tiling_set_unittest.cc

Index: cc/tiles/picture_layer_tiling_set_unittest.cc
diff --git a/cc/tiles/picture_layer_tiling_set_unittest.cc b/cc/tiles/picture_layer_tiling_set_unittest.cc
index 2bc927406d2f46a2de13443f8792f3e15c5dde1a..0e1b2e762abffb71441fa97571a5578b0859f23b 100644
--- a/cc/tiles/picture_layer_tiling_set_unittest.cc
+++ b/cc/tiles/picture_layer_tiling_set_unittest.cc
@@ -67,9 +67,9 @@ TEST(PictureLayerTilingSetTest, NoResources) {
   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(
@@ -106,13 +106,14 @@ TEST(PictureLayerTilingSetTest, TilingRange) {
       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);
@@ -139,11 +140,15 @@ TEST(PictureLayerTilingSetTest, TilingRange) {
 
   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);
@@ -170,11 +175,11 @@ TEST(PictureLayerTilingSetTest, TilingRange) {
 
   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(
@@ -204,7 +209,8 @@ TEST(PictureLayerTilingSetTest, TilingRange) {
 
   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(
@@ -256,7 +262,8 @@ class PictureLayerTilingSetTestWithResources : public testing::Test {
 
     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();
@@ -277,7 +284,7 @@ class PictureLayerTilingSetTestWithResources : public testing::Test {
       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)
@@ -341,7 +348,7 @@ TEST(PictureLayerTilingSetTest, TileSizeChange) {
   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());
 
@@ -366,7 +373,7 @@ TEST(PictureLayerTilingSetTest, TileSizeChange) {
   // 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(),
@@ -446,9 +453,11 @@ TEST(PictureLayerTilingSetTest, MaxContentScale) {
       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);
@@ -503,7 +512,7 @@ TEST(PictureLayerTilingSetTest, SkewportLimits) {
       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);
@@ -589,7 +598,7 @@ TEST(PictureLayerTilingSetTest, ComputeSkewportExtremeCases) {
       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);
@@ -606,7 +615,8 @@ TEST(PictureLayerTilingSetTest, ComputeSkewportExtremeCases) {
 
   // 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());
@@ -624,7 +634,7 @@ TEST(PictureLayerTilingSetTest, ComputeSkewport) {
       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);
 
@@ -686,7 +696,7 @@ TEST(PictureLayerTilingSetTest, SkewportThroughUpdateTilePriorities) {
       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);
 
@@ -760,7 +770,8 @@ TEST(PictureLayerTilingTest, ViewportDistanceWithScale) {
       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);
@@ -921,7 +932,8 @@ TEST(PictureLayerTilingTest, ViewportDistanceWithScale) {
   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();
@@ -956,7 +968,8 @@ TEST(PictureLayerTilingTest, InvalidateAfterComputeTilePriorityRects) {
       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
@@ -999,7 +1012,8 @@ TEST(PictureLayerTilingTest, InvalidateAfterUpdateRasterSourceForCommit) {
   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());
 
@@ -1038,5 +1052,64 @@ TEST(PictureLayerTilingTest, InvalidateAfterUpdateRasterSourceForCommit) {
       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