Delay activation/draw on GPU tile work completion

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 274 matching lines @@
   void CheckAndIssueSignals();
   bool MarkTilesOutOfMemory(
       std::unique_ptr<RasterTilePriorityQueue> queue) const;
 
   ResourceFormat DetermineResourceFormat(const Tile* tile) const;
   bool DetermineResourceRequiresSwizzle(const Tile* tile) const;
 
   void DidFinishRunningTileTasksRequiredForActivation();
   void DidFinishRunningTileTasksRequiredForDraw();
   void DidFinishRunningAllTileTasks();
+  void RequiredForActivationTilesAreReadyToDraw(uint64_t callback_id);
 
   scoped_refptr<TileTask> CreateTaskSetFinishedTask(
       void (TileManager::*callback)());
   PrioritizedWorkToSchedule AssignGpuMemoryToTiles();
   void ScheduleTasks(const PrioritizedWorkToSchedule& work_to_schedule);
 
   std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
   ScheduledTasksStateAsValue() const;
 
   bool UsePartialRaster() const;
 
-  TileManagerClient* client_;
-  base::SequencedTaskRunner* task_runner_;
-  ResourcePool* resource_pool_;
+  TileManagerClient* client_ = nullptr;
+  base::SequencedTaskRunner* task_runner_ = nullptr;
+  ResourcePool* resource_pool_ = nullptr;
   std::unique_ptr<TileTaskManager> tile_task_manager_;
-  RasterBufferProvider* raster_buffer_provider_;
+  RasterBufferProvider* raster_buffer_provider_ = nullptr;
   GlobalStateThatImpactsTilePriority global_state_;
-  size_t scheduled_raster_task_limit_;
-  const bool use_partial_raster_;
-  bool use_gpu_rasterization_;
+  size_t scheduled_raster_task_limit_ = 0;
+  const bool use_partial_raster_ = false;
+  bool use_gpu_rasterization_ = false;
 
   std::unordered_map<Tile::Id, Tile*> tiles_;
 
-  bool all_tiles_that_need_to_be_rasterized_are_scheduled_;
+  bool all_tiles_that_need_to_be_rasterized_are_scheduled_ = true;
   MemoryHistory::Entry memory_stats_from_last_assign_;
 
-  bool did_check_for_completed_tasks_since_last_schedule_tasks_;
-  bool did_oom_on_last_assign_;
+  bool did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
+  bool did_oom_on_last_assign_ = false;
 
   ImageManager image_manager_;
 
   RasterTaskCompletionStats flush_stats_;
 
   std::vector<Tile*> released_tiles_;
 
   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_;
 
   Signals signals_;
 
   UniqueNotifier signals_check_notifier_;
 
-  bool has_scheduled_tile_tasks_;
+  bool has_scheduled_tile_tasks_ = false;
 
-  uint64_t prepare_tiles_count_;
-  uint64_t next_tile_id_;
+  uint64_t prepare_tiles_count_ = 0u;
+  uint64_t next_tile_id_ = 0u;
 
   std::unordered_map<Tile::Id, std::vector<DrawImage>> scheduled_draw_images_;
   std::vector<scoped_refptr<TileTask>> locked_image_tasks_;
 
+  uint64_t pending_activation_callback_id_ = 0;
+
   base::WeakPtrFactory<TileManager> task_set_finished_weak_ptr_factory_;
+  base::WeakPtrFactory<TileManager> weak_ptr_factory_;

[vmpstr, 2016/12/07 21:00:25]

I'm assuming the two weakptrfactories here have different invalidation times?

If we do another schedule, we should invalidate the task set finished one.
However, should we still check if we can activate if we receive the sync token
callback?

I'm wondering whether we should also invalidate this one on new schedule,
because we're going to get another ready to activate signal. If so, then we only
really need one WeakPtrFactory

 
   DISALLOW_COPY_AND_ASSIGN(TileManager);
 };
 
 }  // namespace cc
 
 #endif  // CC_TILES_TILE_MANAGER_H_