cc: Move pre-decodes to background worker.

cc/tiles/tile_manager.h

 // 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.
 
 #ifndef CC_TILES_TILE_MANAGER_H_
 #define CC_TILES_TILE_MANAGER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 86 matching lines @@
   size_t completed_count;
   size_t canceled_count;
 };
 std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
 RasterTaskCompletionStatsAsValue(const RasterTaskCompletionStats& stats);
 
 // This class manages tiles, deciding which should get rasterized and which
 // should no longer have any memory assigned to them. Tile objects are "owned"
 // by layers; they automatically register with the manager when they are
 // created, and unregister from the manager when they are deleted.
+//
+// The TileManager coordinates scheduling of prioritized raster and decode work
+// across 2 different subsystems, namely the TaskGraphRunner used primarily for
+// raster work and images which must be decoded before rasterization of a tile
+// can proceed, and the CheckerImageTracker used for images decoded
+// asynchronously from raster using the |image_worker_task_runner|. The order in
+// which work is scheduled across these systems is as follows:
+//
+// 1) RequiredForActivation/Draw Tiles: These are the highest priority tiles
+// which block scheduling of any decode work for checkered-images.
+//
+// 2) Pre-paint Tiles: These are offscreen tiles which fall within the
+// pre-raster distance. The work for these tiles continues in parallel with the
+// decode work for checkered images from visible/pre-paint tiles.
+//
+// 3) Pre-decode Tiles: These are offscreen tiles which are outside the
+// pre-raster distance but have their images pre-decoded and locked. Finishing
+// work for these tiles on the TaskGraph blocks starting decode work for
+// checker-imaged pre-decode tiles.
+
 class CC_EXPORT TileManager : CheckerImageTrackerClient {
  public:
   TileManager(TileManagerClient* client,
               base::SequencedTaskRunner* origin_task_runner,
               scoped_refptr<base::SequencedTaskRunner> image_worker_task_runner,
               size_t scheduled_raster_task_limit,
               const TileManagerSettings& tile_manager_settings);
   ~TileManager() override;
 
   // Assigns tile memory and schedules work to prepare tiles for drawing.
@@ skipping 208 matching lines @@
   ResourceFormat DetermineResourceFormat(const Tile* tile) const;
   bool DetermineResourceRequiresSwizzle(const Tile* tile) const;
 
   void DidFinishRunningTileTasksRequiredForActivation();
   void DidFinishRunningTileTasksRequiredForDraw();
   void DidFinishRunningAllTileTasks();
 
   scoped_refptr<TileTask> CreateTaskSetFinishedTask(
       void (TileManager::*callback)());
   PrioritizedWorkToSchedule AssignGpuMemoryToTiles();
-  void ScheduleTasks(const PrioritizedWorkToSchedule& work_to_schedule);
+  void ScheduleTasks(PrioritizedWorkToSchedule work_to_schedule);
 
   void PartitionImagesForCheckering(const PrioritizedTile& prioritized_tile,
                                     const gfx::ColorSpace& raster_color_space,
                                     std::vector<DrawImage>* sync_decoded_images,
                                     std::vector<PaintImage>* checkered_images);
   void AddCheckeredImagesToDecodeQueue(
       const PrioritizedTile& prioritized_tile,
       const gfx::ColorSpace& raster_color_space,
+      CheckerImageTracker::DecodeType decode_type,
       CheckerImageTracker::ImageDecodeQueue* image_decode_queue);
 
   std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
   ScheduledTasksStateAsValue() const;
 
   bool UsePartialRaster() const;
 
   void CheckPendingGpuWorkTiles(bool issue_signals);
 
   TileManagerClient* client_;
@@ skipping 54 matching lines @@
   base::WeakPtrFactory<TileManager> task_set_finished_weak_ptr_factory_;
   // The |ready_to_draw_callback_weak_ptr_factory_| is never invalidated.
   base::WeakPtrFactory<TileManager> ready_to_draw_callback_weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TileManager);
 };
 
 }  // namespace cc
 
 #endif  // CC_TILES_TILE_MANAGER_H_