Move TaskGraph creation to TileManager

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 <deque>
 #include <queue>
 #include <set>
@@ skipping 72 matching lines @@
   size_t completed_count;
   size_t canceled_count;
 };
 scoped_refptr<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.
-class CC_EXPORT TileManager : public TileTaskRunnerClient {
+class CC_EXPORT TileManager {
  public:
-  enum NamedTaskSet {
+  enum TaskSet : int {
     REQUIRED_FOR_ACTIVATION,
     REQUIRED_FOR_DRAW,
     // PixelBufferTileTaskWorkerPool depends on ALL being last.

[reveman, 2015/12/02 05:22:55]

not sure we need this enum still but we should at least remove this comment.

[ericrk, 2015/12/02 21:28:09]

removed.

     ALL
     // Adding additional values requires increasing kNumberOfTaskSets in
     // tile_task_runner.h

[reveman, 2015/12/02 05:22:55]

and this one

[ericrk, 2015/12/02 21:28:09]

Done.

   };
 
-  static_assert(NamedTaskSet::ALL == (kNumberOfTaskSets - 1),
-                "NamedTaskSet::ALL should be equal to kNumberOfTaskSets"
-                "minus 1");
+  enum : int { kNumberOfTaskSets = TaskSet::ALL + 1 };
 
   static scoped_ptr<TileManager> Create(TileManagerClient* client,
                                         base::SequencedTaskRunner* task_runner,
                                         size_t scheduled_raster_task_limit,
                                         bool use_partial_raster);
-  ~TileManager() override;
+  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
   // much resources as possible. Also, prevents any future work until a
@@ skipping 87 matching lines @@
               bool use_partial_raster);
 
   void FreeResourcesForReleasedTiles();
   void CleanUpReleasedTiles();
 
   friend class Tile;
   // Virtual for testing.
   virtual void Release(Tile* tile);
   Tile::Id GetUniqueTileId() { return ++next_tile_id_; }
 
-  // Overriden from TileTaskRunnerClient:
-  void DidFinishRunningTileTasks(TaskSet task_set) override;
-
   typedef std::vector<PrioritizedTile> PrioritizedTileVector;
   typedef std::set<Tile*> TileSet;
 
   // Virtual for test
   virtual void ScheduleTasks(
       const PrioritizedTileVector& tiles_that_need_to_be_rasterized);
 
   void AssignGpuMemoryToTiles(
       RasterTilePriorityQueue* raster_priority_queue,
       size_t scheduled_raser_task_limit,
@@ skipping 48 matching lines @@
       MemoryUsage* usage);
   bool TilePriorityViolatesMemoryPolicy(const TilePriority& priority);
   bool AreRequiredTilesReadyToDraw(RasterTilePriorityQueue::Type type) const;
   void CheckIfMoreTilesNeedToBePrepared();
   void CheckAndIssueSignals();
   bool MarkTilesOutOfMemory(scoped_ptr<RasterTilePriorityQueue> queue) const;
 
   ResourceFormat DetermineResourceFormat(const Tile* tile) const;
   bool DetermineResourceRequiresSwizzle(const Tile* tile) const;
 
+  void DidFinishRunningTileTasks(TaskSet task_set);
+
+  void BuildTaskGraph(
+      const PrioritizedTileVector& tiles_that_need_to_be_rasterized,
+      TaskGraph* graph,
+      std::array<scoped_refptr<TileTask>, kNumberOfTaskSets>*

[reveman, 2015/12/02 05:22:55]

The code that had to deal with task sets in the past was not aware of the exact
meaning of them but that's not the case now that this is implemented here. Can
we just pass 3 raw pointers to Tasks instead of this array and all the use of
kNumberOfTaskSets?

Task* required_for_activation_finished_task,
Task* required_for_draw_finished_task,
Task* finished_task
....

btw, are we allowed to use std::array in chromium now?

[ericrk, 2015/12/02 21:28:09]

std::array is now allowed.

Re structured this - the tasks are now member vars.

+          new_task_set_finished_tasks);
+
+  scoped_refptr<base::trace_event::ConvertableToTraceFormat>
+  ScheduledTasksStateAsValue() const;
+
   TileManagerClient* client_;
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
   ResourcePool* resource_pool_;
   TileTaskRunner* tile_task_runner_;
   GlobalStateThatImpactsTilePriority global_state_;
   size_t scheduled_raster_task_limit_;
   const bool use_partial_raster_;
 
   typedef base::hash_map<Tile::Id, Tile*> TileMap;
   TileMap tiles_;
 
   bool all_tiles_that_need_to_be_rasterized_are_scheduled_;
   MemoryHistory::Entry memory_stats_from_last_assign_;
 
   bool did_check_for_completed_tasks_since_last_schedule_tasks_;
   bool did_oom_on_last_assign_;
 
   ImageDecodeController image_decode_controller_;
 
   RasterTaskCompletionStats flush_stats_;
 
   std::vector<Tile*> released_tiles_;
 
-  // Queue used when scheduling raster tasks.
-  TileTaskQueue raster_queue_;

[reveman, 2015/12/02 05:22:55]

Keep this as "TaskGraph task_graph_"? See my other comment about avoiding heap
allocations.

+  std::vector<scoped_refptr<TileTask>> orphan_tasks_;
 
-  std::vector<scoped_refptr<RasterTask>> orphan_raster_tasks_;
+  using TaskSetCollection = std::bitset<kNumberOfTaskSets>;
+  TaskSetCollection tasks_pending_;
 
   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_;
 
   UniqueNotifier signals_check_notifier_;
 
   bool has_scheduled_tile_tasks_;
 
   uint64_t prepare_tiles_count_;
   uint64_t next_tile_id_;
 
+  base::WeakPtrFactory<TileManager> task_set_finished_weak_ptr_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(TileManager);
 };
 
 }  // namespace cc
 
 #endif  // CC_TILES_TILE_MANAGER_H_