cc: Move pre-decodes to background worker.

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 2515 matching lines @@
   // Set the tile priority rects such that only the tile with the second image
   // is scheduled for decodes, since it is checker-imaged.
   gfx::Rect rect_to_raster(600, 0, 300, 900);
   active_tiling->SetTilePriorityRectsForTesting(
       gfx::Rect(rect_to_raster),   // Visible rect.
       gfx::Rect(rect_to_raster),   // Skewport rect.
       gfx::Rect(rect_to_raster),   // Soon rect.
       gfx::Rect(rect_to_raster));  // Eventually rect.
   host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
 
+  // Finish all raster and dispatch completion callback so that the decode work
+  // for checkered images can be scheduled.
+  static_cast<SynchronousTaskGraphRunner*>(task_graph_runner())->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
+
   // Run decode tasks to trigger completion of any pending decodes.
   FlushDecodeTasks();
 
   // Create a new pending tree to invalidate tiles for decoded images and verify
   // that only tiles for |image2| are invalidated.
   EXPECT_TRUE(host_impl()->client()->did_request_impl_side_invalidation());
   PerformImplSideInvalidation();
   for (int i = 0; i < 2; i++) {
     for (int j = 0; j < 2; j++) {
       const Tile* tile = pending_tiling->TileAt(i, j);
@@ skipping 20 matching lines @@
       gfx::Rect(layer_bounds));  // Eventually rect.
   host_impl()->SetVisible(false);
   host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
   FlushDecodeTasks();
   EXPECT_FALSE(host_impl()->client()->did_request_impl_side_invalidation());
 }
 
 TEST_F(CheckerImagingTileManagerTest,
        TileManagerCleanupClearsCheckerImagedDecodes) {
   const gfx::Size layer_bounds(512, 512);
-  SetupDefaultTrees(layer_bounds);
 
   std::unique_ptr<FakeRecordingSource> recording_source =
       FakeRecordingSource::CreateFilledRecordingSource(layer_bounds);
   recording_source->set_fill_with_nonsolid_color(true);
   sk_sp<SkImage> image = CreateDiscardableImage(gfx::Size(512, 512));
   recording_source->add_draw_image(image, gfx::Point(0, 0));
   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_contributes_to_drawn_render_surface(true);
-  PictureLayerTilingSet* tiling_set = layer_impl->picture_layer_tiling_set();
-
-  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.
+  SetupPendingTree(raster_source, gfx::Size(100, 100),
+                   Region(gfx::Rect(0, 0, 500, 500)));
 
   host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
+  // Finish all raster and dispatch completion callback so that the decode work
+  // for checkered images can be scheduled.
+  static_cast<SynchronousTaskGraphRunner*>(task_graph_runner())->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   FlushDecodeTasks();
+
   EXPECT_TRUE(host_impl()
                   ->tile_manager()
                   ->checker_image_tracker()
                   .has_locked_decodes_for_testing());
+
+  host_impl()->pending_tree()->ReleaseTileResources();
   CleanUpTileManager();
+
   EXPECT_FALSE(host_impl()
                    ->tile_manager()
                    ->checker_image_tracker()
                    .has_locked_decodes_for_testing());
   EXPECT_TRUE(
       host_impl()->tile_manager()->TakeImagesToInvalidateOnSyncTree().empty());
 }
 
+TEST_F(CheckerImagingTileManagerTest,
+       TileManagerCorrectlyPrioritizesCheckerImagedDecodes) {
+  gfx::Size layer_bounds(500, 500);
+
+  std::unique_ptr<FakeRecordingSource> recording_source =
+      FakeRecordingSource::CreateFilledRecordingSource(layer_bounds);
+  recording_source->set_fill_with_nonsolid_color(true);
+  sk_sp<SkImage> image = CreateDiscardableImage(gfx::Size(512, 512));
+  recording_source->add_draw_image(image, gfx::Point(0, 0));
+  recording_source->Rerecord();
+  scoped_refptr<RasterSource> raster_source =
+      RasterSource::CreateFromRecordingSource(recording_source.get(), false);
+
+  // Required for activation tiles block checker-imaged decodes.
+  SetupPendingTree(raster_source, gfx::Size(100, 100),
+                   Region(gfx::Rect(0, 0, 500, 500)));
+  host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
+  EXPECT_TRUE(host_impl()->tile_manager()->HasScheduledTileTasksForTesting());
+  EXPECT_TRUE(host_impl()
+                  ->tile_manager()
+                  ->checker_image_tracker()
+                  .no_decodes_allowed_for_testing());
+  while (!host_impl()->client()->ready_to_activate()) {
+    static_cast<SynchronousTaskGraphRunner*>(task_graph_runner())
+        ->RunSingleTaskForTesting();
+    base::RunLoop().RunUntilIdle();
+  }
+  EXPECT_EQ(host_impl()
+                ->tile_manager()
+                ->checker_image_tracker()
+                .decode_priority_allowed_for_testing(),
+            CheckerImageTracker::DecodeType::kRaster);
+
+  // Finishing all tasks allows pre-decodes.
+  static_cast<SynchronousTaskGraphRunner*>(task_graph_runner())->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(host_impl()
+                ->tile_manager()
+                ->checker_image_tracker()
+                .decode_priority_allowed_for_testing(),
+            CheckerImageTracker::DecodeType::kPreDecode);
+
+  // Required for draw tiles block checker-imaged decodes.
+  // Free all tile resources and perform another PrepareTiles.
+  ActivateTree();
+  EXPECT_TRUE(host_impl()->tile_manager()->IsReadyToDraw());
+  host_impl()->tile_manager()->PrepareTiles(
+      GlobalStateThatImpactsTilePriority());
+  EXPECT_FALSE(host_impl()->tile_manager()->IsReadyToDraw());
+
+  host_impl()->client()->reset_ready_to_draw();
+  host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
+  EXPECT_TRUE(host_impl()->tile_manager()->HasScheduledTileTasksForTesting());
+  EXPECT_TRUE(host_impl()
+                  ->tile_manager()
+                  ->checker_image_tracker()
+                  .no_decodes_allowed_for_testing());
+  while (!host_impl()->client()->ready_to_draw()) {
+    static_cast<SynchronousTaskGraphRunner*>(task_graph_runner())
+        ->RunSingleTaskForTesting();
+    base::RunLoop().RunUntilIdle();
+  }
+  EXPECT_EQ(host_impl()
+                ->tile_manager()
+                ->checker_image_tracker()
+                .decode_priority_allowed_for_testing(),
+            CheckerImageTracker::DecodeType::kRaster);
+}
+
 class CheckerImagingTileManagerMemoryTest
     : public CheckerImagingTileManagerTest {
  public:
   std::unique_ptr<FakeLayerTreeHostImpl> CreateHostImpl(
       const LayerTreeSettings& settings,
       TaskRunnerProvider* task_runner_provider,
       TaskGraphRunner* task_graph_runner) override {
     LayerTreeSettings new_settings = settings;
     new_settings.gpu_memory_policy.num_resources_limit = 4;
     return CheckerImagingTileManagerTest::CreateHostImpl(
@@ skipping 52 matching lines @@
   gfx::Rect complete_tiling_rect(layer_bounds);
   PictureLayerTiling* active_tiling =
       active_layer()->picture_layer_tiling_set()->tiling_at(0);
   active_tiling->SetTilePriorityRectsForTesting(
       complete_tiling_rect,   // Visible rect.
       complete_tiling_rect,   // Skewport rect.
       complete_tiling_rect,   // Soon rect.
       complete_tiling_rect);  // Eventually rect.
   host_impl()->tile_manager()->PrepareTiles(host_impl()->global_tile_state());
 
+  // Finish all raster work so the decode work for checkered images can be
+  // scheduled.
+  static_cast<SynchronousTaskGraphRunner*>(task_graph_runner())->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
+
   // Flush all decode tasks. The tiles with checkered images should be
   // invalidated.
   FlushDecodeTasks();
   EXPECT_TRUE(host_impl()->client()->did_request_impl_side_invalidation());
   PerformImplSideInvalidation();
   for (int i = 0; i < 2; i++) {
     for (int j = 0; j < 3; j++) {
       const Tile* tile = pending_tiling->TileAt(i, j);
       if (j == 1)
         EXPECT_TRUE(tile);
       else
         EXPECT_FALSE(tile);
     }
   }
   host_impl()->client()->reset_did_request_impl_side_invalidation();
 }
 
 }  // namespace
 }  // namespace cc