cc: Separate raster and decode prepaint regions.

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 80 matching lines @@
 
 // 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.
 class CC_EXPORT TileManager {
  public:
   TileManager(TileManagerClient* client,
               base::SequencedTaskRunner* task_runner,
               size_t scheduled_raster_task_limit,
-              bool use_partial_raster);
+              bool use_partial_raster,
+              int max_preraster_distance_in_screen_pixels);
   virtual ~TileManager();
 
   // Assigns tile memory and schedules work to prepare tiles for drawing.
   // - Runs client_->NotifyReadyToActivate() when all tiles required for
   // activation are prepared, or failed to prepare due to OOM.
   // - Runs client_->NotifyReadyToDraw() when all tiles required draw are
   // prepared, or failed to prepare due to OOM.
   bool PrepareTiles(const GlobalStateThatImpactsTilePriority& state);
 
   // Synchronously finish any in progress work, cancel the rest, and clean up as
@@ skipping 89 matching lines @@
 
  protected:
   void FreeResourcesForReleasedTiles();
   void CleanUpReleasedTiles();
 
   friend class Tile;
   // Virtual for testing.
   virtual void Release(Tile* tile);
   Tile::Id GetUniqueTileId() { return ++next_tile_id_; }
 
-  // Virtual for test
-  virtual void ScheduleTasks(
-      const std::vector<PrioritizedTile>& tiles_that_need_to_be_rasterized);
-
  private:
   class MemoryUsage {
    public:
     MemoryUsage();
     MemoryUsage(size_t memory_bytes, size_t resource_count);
 
     static MemoryUsage FromConfig(const gfx::Size& size, ResourceFormat format);
     static MemoryUsage FromTile(const Tile* tile);
 
     MemoryUsage& operator+=(const MemoryUsage& other);
     MemoryUsage& operator-=(const MemoryUsage& other);
     MemoryUsage operator-(const MemoryUsage& other);
 
     bool Exceeds(const MemoryUsage& limit) const;
     int64_t memory_bytes() const { return memory_bytes_; }
 
    private:
     int64_t memory_bytes_;
     int resource_count_;
   };
 
+  struct Signals {
+    Signals();
+
+    void reset();
+
+    bool ready_to_activate;
+    bool did_notify_ready_to_activate;
+    bool ready_to_draw;
+    bool did_notify_ready_to_draw;
+    bool all_tile_tasks_completed;
+    bool did_notify_all_tile_tasks_completed;
+  };
+
+  struct PrioritizedWorkToSchedule {
+    PrioritizedWorkToSchedule();
+    PrioritizedWorkToSchedule(PrioritizedWorkToSchedule&& other);
+    ~PrioritizedWorkToSchedule();
+
+    std::vector<PrioritizedTile> tiles_to_raster;
+    std::vector<PrioritizedTile> tiles_to_process_for_images;
+  };
+
   void FreeResourcesForTile(Tile* tile);
   void FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(Tile* tile);
   scoped_refptr<TileTask> CreateRasterTask(
       const PrioritizedTile& prioritized_tile);
 
   std::unique_ptr<EvictionTilePriorityQueue>
   FreeTileResourcesUntilUsageIsWithinLimit(
       std::unique_ptr<EvictionTilePriorityQueue> eviction_priority_queue,
       const MemoryUsage& limit,
       MemoryUsage* usage);
@@ skipping 12 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)());
-  std::vector<PrioritizedTile> AssignGpuMemoryToTiles();
+  PrioritizedWorkToSchedule AssignGpuMemoryToTiles();
+  void ScheduleTasks(const PrioritizedWorkToSchedule& work_to_schedule);
 
   std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
   ScheduledTasksStateAsValue() const;
 
   TileManagerClient* client_;
   base::SequencedTaskRunner* task_runner_;
   ResourcePool* resource_pool_;
   TileTaskManager* tile_task_manager_;
   GlobalStateThatImpactsTilePriority global_state_;
   size_t scheduled_raster_task_limit_;
@@ skipping 16 matching lines @@
 
   std::vector<scoped_refptr<TileTask>> orphan_tasks_;
 
   TaskGraph graph_;
   scoped_refptr<TileTask> required_for_activation_done_task_;
   scoped_refptr<TileTask> required_for_draw_done_task_;
   scoped_refptr<TileTask> all_done_task_;
 
   UniqueNotifier more_tiles_need_prepare_check_notifier_;
 
-  struct Signals {
-    Signals();
-
-    void reset();
-
-    bool ready_to_activate;
-    bool did_notify_ready_to_activate;
-    bool ready_to_draw;
-    bool did_notify_ready_to_draw;
-    bool all_tile_tasks_completed;
-    bool did_notify_all_tile_tasks_completed;
-  } signals_;
+  Signals signals_;
 
   UniqueNotifier signals_check_notifier_;
 
   bool has_scheduled_tile_tasks_;
 
   uint64_t prepare_tiles_count_;
   uint64_t next_tile_id_;
 
   std::unordered_map<Tile::Id, std::vector<DrawImage>> scheduled_draw_images_;
+  const int max_preraster_distance_in_screen_pixels_;
+  std::vector<std::pair<DrawImage, scoped_refptr<TileTask>>> locked_images_;
 
   base::WeakPtrFactory<TileManager> task_set_finished_weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TileManager);
 };
 
 }  // namespace cc
 
 #endif  // CC_TILES_TILE_MANAGER_H_