[4/5] Add translated rasterization support for PictureLayerTilingSet & below

cc/tiles/tile_manager_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 338 matching lines @@
   EXPECT_NE(new_content_tiles, required_for_draw_tiles);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest,
        RasterTilePriorityQueueHighNonIdealTilings) {
   const gfx::Size layer_bounds(1000, 1000);
   const gfx::Size viewport(800, 800);
   host_impl()->SetViewportSize(viewport);
   SetupDefaultTrees(layer_bounds);
 
-  pending_layer()->tilings()->AddTiling(1.5f, pending_layer()->raster_source());
-  active_layer()->tilings()->AddTiling(1.5f, active_layer()->raster_source());
-  pending_layer()->tilings()->AddTiling(1.7f, pending_layer()->raster_source());
-  active_layer()->tilings()->AddTiling(1.7f, active_layer()->raster_source());
+  pending_layer()->tilings()->AddTiling(
+      gfx::AxisTransform2d(1.5f, gfx::Vector2dF()),
+      pending_layer()->raster_source());
+  active_layer()->tilings()->AddTiling(
+      gfx::AxisTransform2d(1.5f, gfx::Vector2dF()),
+      active_layer()->raster_source());
+  pending_layer()->tilings()->AddTiling(
+      gfx::AxisTransform2d(1.7f, gfx::Vector2dF()),
+      pending_layer()->raster_source());
+  active_layer()->tilings()->AddTiling(
+      gfx::AxisTransform2d(1.7f, gfx::Vector2dF()),
+      active_layer()->raster_source());
 
   pending_layer()->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f,
                                                    5.0, Occlusion(), true);
   active_layer()->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f, 5.0,
                                                   Occlusion(), true);
 
   std::set<Tile*> all_expected_tiles;
   for (size_t i = 0; i < pending_layer()->num_tilings(); ++i) {
     PictureLayerTiling* tiling = pending_layer()->tilings()->tiling_at(i);
-    if (tiling->contents_scale() == 1.f) {
+    if (tiling->contents_scale_key() == 1.f) {
       tiling->set_resolution(HIGH_RESOLUTION);
       const auto& all_tiles = tiling->AllTilesForTesting();
       all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
     } else {
       tiling->set_resolution(NON_IDEAL_RESOLUTION);
     }
   }
 
   for (size_t i = 0; i < active_layer()->num_tilings(); ++i) {
     PictureLayerTiling* tiling = active_layer()->tilings()->tiling_at(i);
-    if (tiling->contents_scale() == 1.5f) {
+    if (tiling->contents_scale_key() == 1.5f) {
       tiling->set_resolution(HIGH_RESOLUTION);
       const auto& all_tiles = tiling->AllTilesForTesting();
       all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
     } else {
       tiling->set_resolution(NON_IDEAL_RESOLUTION);
       // Non ideal tilings with a high res pending twin have to be processed
       // because of possible activation tiles.
-      if (tiling->contents_scale() == 1.f) {
+      if (tiling->contents_scale_key() == 1.f) {
         tiling->UpdateAndGetAllPrioritizedTilesForTesting();
         const auto& all_tiles = tiling->AllTilesForTesting();
         for (auto* tile : all_tiles)
           EXPECT_TRUE(tile->required_for_activation());
         all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
       }
     }
   }
 
   std::unique_ptr<RasterTilePriorityQueue> queue(host_impl()->BuildRasterQueue(
@@ skipping 14 matching lines @@
   EXPECT_EQ(all_expected_tiles, all_actual_tiles);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest,
        RasterTilePriorityQueueHighLowTilings) {
   const gfx::Size layer_bounds(1000, 1000);
   const gfx::Size viewport(800, 800);
   host_impl()->SetViewportSize(viewport);
   SetupDefaultTrees(layer_bounds);
 
-  pending_layer()->tilings()->AddTiling(1.5f, pending_layer()->raster_source());
-  active_layer()->tilings()->AddTiling(1.5f, active_layer()->raster_source());
-  pending_layer()->tilings()->AddTiling(1.7f, pending_layer()->raster_source());
-  active_layer()->tilings()->AddTiling(1.7f, active_layer()->raster_source());
+  pending_layer()->tilings()->AddTiling(
+      gfx::AxisTransform2d(1.5f, gfx::Vector2dF()),
+      pending_layer()->raster_source());
+  active_layer()->tilings()->AddTiling(
+      gfx::AxisTransform2d(1.5f, gfx::Vector2dF()),
+      active_layer()->raster_source());
+  pending_layer()->tilings()->AddTiling(
+      gfx::AxisTransform2d(1.7f, gfx::Vector2dF()),
+      pending_layer()->raster_source());
+  active_layer()->tilings()->AddTiling(
+      gfx::AxisTransform2d(1.7f, gfx::Vector2dF()),
+      active_layer()->raster_source());
 
   pending_layer()->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f,
                                                    5.0, Occlusion(), true);
   active_layer()->tilings()->UpdateTilePriorities(gfx::Rect(viewport), 1.f, 5.0,
                                                   Occlusion(), true);
 
   std::set<Tile*> all_expected_tiles;
   for (size_t i = 0; i < pending_layer()->num_tilings(); ++i) {
     PictureLayerTiling* tiling = pending_layer()->tilings()->tiling_at(i);
-    if (tiling->contents_scale() == 1.f) {
+    if (tiling->contents_scale_key() == 1.f) {
       tiling->set_resolution(HIGH_RESOLUTION);
       const auto& all_tiles = tiling->AllTilesForTesting();
       all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
     } else {
       tiling->set_resolution(NON_IDEAL_RESOLUTION);
     }
   }
 
   for (size_t i = 0; i < active_layer()->num_tilings(); ++i) {
     PictureLayerTiling* tiling = active_layer()->tilings()->tiling_at(i);
-    if (tiling->contents_scale() == 1.5f) {
+    if (tiling->contents_scale_key() == 1.5f) {
       tiling->set_resolution(HIGH_RESOLUTION);
       const auto& all_tiles = tiling->AllTilesForTesting();
       all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
     } else {
       tiling->set_resolution(LOW_RESOLUTION);
       // Low res tilings with a high res pending twin have to be processed
       // because of possible activation tiles.
-      if (tiling->contents_scale() == 1.f) {
+      if (tiling->contents_scale_key() == 1.f) {
         tiling->UpdateAndGetAllPrioritizedTilesForTesting();
         const auto& all_tiles = tiling->AllTilesForTesting();
         for (auto* tile : all_tiles)
           EXPECT_TRUE(tile->required_for_activation());
         all_expected_tiles.insert(all_tiles.begin(), all_tiles.end());
       }
     }
   }
 
   std::unique_ptr<RasterTilePriorityQueue> queue(host_impl()->BuildRasterQueue(
@@ skipping 437 matching lines @@
 
       bool last_tile_is_occluded = last_tile.is_occluded();
       if (!last_tile_is_occluded) {
         TilePriority::PriorityBin tile_priority_bin =
             prioritized_tile.priority().priority_bin;
         TilePriority::PriorityBin last_tile_priority_bin =
             last_tile.priority().priority_bin;
 
         EXPECT_TRUE((tile_priority_bin < last_tile_priority_bin) ||
                     prioritized_tile.tile()->required_for_activation() ||
-                    (prioritized_tile.tile()->contents_scale() !=
-                     last_tile.tile()->contents_scale()));
+                    (prioritized_tile.tile()->raster_transform() !=
+                     last_tile.tile()->raster_transform()));
       }
     }
     last_tile = prioritized_tile;
     queue->Pop();
   }
   size_t expected_occluded_count = pending_child_high_res_tiles.size();
   EXPECT_EQ(expected_occluded_count, occluded_count);
 }
 
 TEST_F(TileManagerTilePriorityQueueTest,
@@ skipping 200 matching lines @@
 
   std::unique_ptr<PictureLayerTilingSet> tiling_set =
       PictureLayerTilingSet::Create(
           ACTIVE_TREE, &client, settings.tiling_interest_area_padding,
           settings.skewport_target_time_in_seconds,
           settings.skewport_extrapolation_limit_in_screen_pixels,
           settings.max_preraster_distance_in_screen_pixels);
 
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
-  PictureLayerTiling* tiling = tiling_set->AddTiling(1.0f, raster_source);
+  PictureLayerTiling* tiling =
+      tiling_set->AddTiling(gfx::AxisTransform2d(), raster_source);
   tiling->set_resolution(HIGH_RESOLUTION);
 
   tiling_set->UpdateTilePriorities(viewport, 1.0f, 1.0, Occlusion(), true);
   std::vector<Tile*> all_tiles = tiling->AllTilesForTesting();
   // Sanity check.
   EXPECT_EQ(3364u, all_tiles.size());
 
   // The explanation of each iteration is as follows:
   // 1. First iteration tests that we can get all of the tiles correctly.
   // 2. Second iteration ensures that we can get all of the tiles again (first
@@ skipping 90 matching lines @@
 
   std::unique_ptr<PictureLayerTilingSet> tiling_set =
       PictureLayerTilingSet::Create(
           ACTIVE_TREE, &client, settings.tiling_interest_area_padding,
           settings.skewport_target_time_in_seconds,
           settings.skewport_extrapolation_limit_in_screen_pixels,
           settings.max_preraster_distance_in_screen_pixels);
 
   scoped_refptr<FakeRasterSource> raster_source =
       FakeRasterSource::CreateFilled(layer_bounds);
-  PictureLayerTiling* tiling = tiling_set->AddTiling(1.0f, raster_source);
+  PictureLayerTiling* tiling =
+      tiling_set->AddTiling(gfx::AxisTransform2d(), raster_source);
   tiling->set_resolution(HIGH_RESOLUTION);
 
   tiling_set->UpdateTilePriorities(viewport, 1.0f, 1.0, Occlusion(), true);
   tiling_set->UpdateTilePriorities(moved_viewport, 1.0f, 2.0, Occlusion(),
                                    true);
 
   const int soon_border_outset = 312;
   gfx::Rect soon_rect = moved_viewport;
   soon_rect.Inset(-soon_border_outset, -soon_border_outset);
 
@@ skipping 135 matching lines @@
       FakeRasterSource::CreateFilled(layer_bounds);
 
   FakePictureLayerTilingClient pending_client;
   pending_client.SetTileSize(gfx::Size(64, 64));
 
   std::unique_ptr<PictureLayerTilingSet> tiling_set =
       PictureLayerTilingSet::Create(WhichTree::ACTIVE_TREE, &pending_client,
                                     1.0f, 1.0f, 1000, 1000.f);
   pending_client.set_twin_tiling_set(tiling_set.get());
 
-  auto* tiling = tiling_set->AddTiling(1.0f, raster_source);
+  auto* tiling = tiling_set->AddTiling(gfx::AxisTransform2d(), raster_source);
 
   tiling->set_resolution(HIGH_RESOLUTION);
   tiling->CreateAllTilesForTesting();
 
   // The tile is (0, 0, 1, 1), create an intersecting and non-intersecting
   // rectangle to test the advance phase with. The tile size is (64, 64), so
   // both rectangles intersect the tile content size, but only one should
   // intersect the actual size.
   gfx::Rect non_intersecting_rect(2, 2, 10, 10);
   gfx::Rect intersecting_rect(0, 0, 10, 10);
@@ skipping 55 matching lines @@
       RasterSource::CreateFromRecordingSource(recording_source.get(), false);
 
   FakePictureLayerTilingClient tiling_client;
   tiling_client.SetTileSize(size);
 
   std::unique_ptr<PictureLayerImpl> layer_impl = PictureLayerImpl::Create(
       host_impl()->active_tree(), 1, Layer::LayerMaskType::NOT_MASK);
   layer_impl->set_is_drawn_render_surface_layer_list_member(true);
   PictureLayerTilingSet* tiling_set = layer_impl->picture_layer_tiling_set();
 
-  PictureLayerTiling* tiling = tiling_set->AddTiling(1.0f, raster_source);
+  PictureLayerTiling* tiling =
+      tiling_set->AddTiling(gfx::AxisTransform2d(), raster_source);
   tiling->set_resolution(HIGH_RESOLUTION);
   tiling->CreateAllTilesForTesting();
   tiling->SetTilePriorityRectsForTesting(
       gfx::Rect(layer_bounds),   // Visible rect.
       gfx::Rect(layer_bounds),   // Skewport rect.
       gfx::Rect(layer_bounds),   // Soon rect.
       gfx::Rect(layer_bounds));  // Eventually rect.
 
   host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
 
@@ skipping 182 matching lines @@
         RasterSource::CreateFromRecordingSource(recording_source.get(), false);
 
     FakePictureLayerTilingClient tiling_client;
     tiling_client.SetTileSize(size);
 
     std::unique_ptr<PictureLayerImpl> layer = PictureLayerImpl::Create(
         host_impl()->active_tree(), 1, Layer::LayerMaskType::NOT_MASK);
     PictureLayerTilingSet* tiling_set = layer->picture_layer_tiling_set();
     layer->set_is_drawn_render_surface_layer_list_member(true);
 
-    auto* tiling = tiling_set->AddTiling(1.0f, raster);
+    auto* tiling = tiling_set->AddTiling(gfx::AxisTransform2d(), raster);
     tiling->set_resolution(resolutions[i]);
     tiling->CreateAllTilesForTesting();
     tiling->SetTilePriorityRectsForTesting(
         gfx::Rect(size),   // Visible rect.
         gfx::Rect(size),   // Skewport rect.
         gfx::Rect(size),   // Soon rect.
         gfx::Rect(size));  // Eventually rect.
 
     // SMOOTHNESS_TAKES_PRIORITY ensures that we will actually raster
     // LOW_RESOLUTION tiles, otherwise they are skipped.
@@ skipping 661 matching lines @@
 
   recording_source->Rerecord();
   scoped_refptr<RasterSource> raster_source =
       RasterSource::CreateFromRecordingSource(recording_source.get(), false);
 
   std::unique_ptr<PictureLayerImpl> layer_impl = PictureLayerImpl::Create(
       host_impl()->active_tree(), 1, Layer::LayerMaskType::NOT_MASK);
   layer_impl->set_is_drawn_render_surface_layer_list_member(true);
   PictureLayerTilingSet* tiling_set = layer_impl->picture_layer_tiling_set();
 
-  PictureLayerTiling* tiling = tiling_set->AddTiling(1.0f, raster_source);
+  PictureLayerTiling* tiling =
+      tiling_set->AddTiling(gfx::AxisTransform2d(), raster_source);
   tiling->set_resolution(HIGH_RESOLUTION);
   tiling->CreateAllTilesForTesting();
   tiling->SetTilePriorityRectsForTesting(
       gfx::Rect(layer_bounds),   // Visible rect.
       gfx::Rect(layer_bounds),   // Skewport rect.
       gfx::Rect(layer_bounds),   // Soon rect.
       gfx::Rect(layer_bounds));  // Eventually rect.
 
   // PrepareTiles and synchronously run all tasks added to the TaskGraph. Since
   // we are using a strict mock for the SkImageGenerator, if the decode runs as
   // a part of raster tasks, the test should fail.
   host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
   EXPECT_TRUE(host_impl()->tile_manager()->HasScheduledTileTasksForTesting());
   static_cast<SynchronousTaskGraphRunner*>(task_graph_runner())->RunUntilIdle();
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(host_impl()->tile_manager()->HasScheduledTileTasksForTesting());
 }
 
 }  // namespace
 }  // namespace cc