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 2509 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 17 matching lines @@
       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()->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,
+       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);
+
+  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