Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(447)

Side by Side Diff: cc/resources/tile_manager.h

Issue 1063493002: cc: Remove all traces of synchronous GPU rasterization (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: more deleted code Created 5 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright 2012 The Chromium Authors. All rights reserved. 1 // Copyright 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #ifndef CC_RESOURCES_TILE_MANAGER_H_ 5 #ifndef CC_RESOURCES_TILE_MANAGER_H_
6 #define CC_RESOURCES_TILE_MANAGER_H_ 6 #define CC_RESOURCES_TILE_MANAGER_H_
7 7
8 #include <deque> 8 #include <deque>
9 #include <queue> 9 #include <queue>
10 #include <set> 10 #include <set>
(...skipping 16 matching lines...) Expand all
27 27
28 namespace base { 28 namespace base {
29 namespace trace_event { 29 namespace trace_event {
30 class ConvertableToTraceFormat; 30 class ConvertableToTraceFormat;
31 class TracedValue; 31 class TracedValue;
32 } 32 }
33 } 33 }
34 34
35 namespace cc { 35 namespace cc {
36 class PictureLayerImpl; 36 class PictureLayerImpl;
37 class Rasterizer;
38 class ResourceProvider; 37 class ResourceProvider;
39 38
40 class CC_EXPORT TileManagerClient { 39 class CC_EXPORT TileManagerClient {
41 public: 40 public:
42 // Called when all tiles marked as required for activation are ready to draw. 41 // Called when all tiles marked as required for activation are ready to draw.
43 virtual void NotifyReadyToActivate() = 0; 42 virtual void NotifyReadyToActivate() = 0;
44 43
45 // Called when all tiles marked as required for draw are ready to draw. 44 // Called when all tiles marked as required for draw are ready to draw.
46 virtual void NotifyReadyToDraw() = 0; 45 virtual void NotifyReadyToDraw() = 0;
47 46
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after
88 // by layers; they automatically register with the manager when they are 87 // by layers; they automatically register with the manager when they are
89 // created, and unregister from the manager when they are deleted. 88 // created, and unregister from the manager when they are deleted.
90 class CC_EXPORT TileManager : public TileTaskRunnerClient, 89 class CC_EXPORT TileManager : public TileTaskRunnerClient,
91 public RefCountedManager<Tile> { 90 public RefCountedManager<Tile> {
92 public: 91 public:
93 enum NamedTaskSet { 92 enum NamedTaskSet {
94 REQUIRED_FOR_ACTIVATION, 93 REQUIRED_FOR_ACTIVATION,
95 REQUIRED_FOR_DRAW, 94 REQUIRED_FOR_DRAW,
96 // PixelBufferTileTaskWorkerPool depends on ALL being last. 95 // PixelBufferTileTaskWorkerPool depends on ALL being last.
97 ALL 96 ALL
98 // Adding additional values requires increasing kNumberOfTaskSets in
99 // rasterizer.h
vmiura 2015/04/03 22:22:41 nit: Should keep this comment and change rasterize
100 }; 97 };
101 98
102 static_assert(NamedTaskSet::ALL == (kNumberOfTaskSets - 1), 99 static_assert(NamedTaskSet::ALL == (kNumberOfTaskSets - 1),
103 "NamedTaskSet::ALL should be equal to kNumberOfTaskSets" 100 "NamedTaskSet::ALL should be equal to kNumberOfTaskSets"
104 "minus 1"); 101 "minus 1");
105 102
106 static scoped_ptr<TileManager> Create(TileManagerClient* client, 103 static scoped_ptr<TileManager> Create(TileManagerClient* client,
107 base::SequencedTaskRunner* task_runner, 104 base::SequencedTaskRunner* task_runner,
108 ResourcePool* resource_pool, 105 ResourcePool* resource_pool,
109 TileTaskRunner* tile_task_runner, 106 TileTaskRunner* tile_task_runner,
110 Rasterizer* rasterizer,
111 size_t scheduled_raster_task_limit); 107 size_t scheduled_raster_task_limit);
112 ~TileManager() override; 108 ~TileManager() override;
113 109
114 // Assigns tile memory and schedules work to prepare tiles for drawing. 110 // Assigns tile memory and schedules work to prepare tiles for drawing.
115 // - Runs client_->NotifyReadyToActivate() when all tiles required for 111 // - Runs client_->NotifyReadyToActivate() when all tiles required for
116 // activation are prepared, or failed to prepare due to OOM. 112 // activation are prepared, or failed to prepare due to OOM.
117 // - Runs client_->NotifyReadyToDraw() when all tiles required draw are 113 // - Runs client_->NotifyReadyToDraw() when all tiles required draw are
118 // prepared, or failed to prepare due to OOM. 114 // prepared, or failed to prepare due to OOM.
119 void PrepareTiles(const GlobalStateThatImpactsTilePriority& state); 115 void PrepareTiles(const GlobalStateThatImpactsTilePriority& state);
120 116
(...skipping 61 matching lines...) Expand 10 before | Expand all | Expand 10 after
182 178
183 void CheckIfMoreTilesNeedToBePreparedForTesting() { 179 void CheckIfMoreTilesNeedToBePreparedForTesting() {
184 CheckIfMoreTilesNeedToBePrepared(); 180 CheckIfMoreTilesNeedToBePrepared();
185 } 181 }
186 182
187 protected: 183 protected:
188 TileManager(TileManagerClient* client, 184 TileManager(TileManagerClient* client,
189 const scoped_refptr<base::SequencedTaskRunner>& task_runner, 185 const scoped_refptr<base::SequencedTaskRunner>& task_runner,
190 ResourcePool* resource_pool, 186 ResourcePool* resource_pool,
191 TileTaskRunner* tile_task_runner, 187 TileTaskRunner* tile_task_runner,
192 Rasterizer* rasterizer,
193 size_t scheduled_raster_task_limit); 188 size_t scheduled_raster_task_limit);
194 189
195 void FreeResourcesForReleasedTiles(); 190 void FreeResourcesForReleasedTiles();
196 void CleanUpReleasedTiles(); 191 void CleanUpReleasedTiles();
197 192
198 // Overriden from RefCountedManager<Tile>: 193 // Overriden from RefCountedManager<Tile>:
199 friend class Tile; 194 friend class Tile;
200 void Release(Tile* tile) override; 195 void Release(Tile* tile) override;
201 196
202 // Overriden from TileTaskRunnerClient: 197 // Overriden from TileTaskRunnerClient:
203 void DidFinishRunningTileTasks(TaskSet task_set) override; 198 void DidFinishRunningTileTasks(TaskSet task_set) override;
204 TaskSetCollection TasksThatShouldBeForcedToComplete() const override; 199 TaskSetCollection TasksThatShouldBeForcedToComplete() const override;
205 200
206 typedef std::vector<Tile*> TileVector; 201 typedef std::vector<Tile*> TileVector;
207 typedef std::set<Tile*> TileSet; 202 typedef std::set<Tile*> TileSet;
208 203
209 // Virtual for test 204 // Virtual for test
210 virtual void ScheduleTasks( 205 virtual void ScheduleTasks(
211 const TileVector& tiles_that_need_to_be_rasterized); 206 const TileVector& tiles_that_need_to_be_rasterized);
212 207
213 void AssignGpuMemoryToTiles(RasterTilePriorityQueue* raster_priority_queue, 208 void AssignGpuMemoryToTiles(RasterTilePriorityQueue* raster_priority_queue,
214 size_t scheduled_raser_task_limit, 209 size_t scheduled_raser_task_limit,
215 TileVector* tiles_that_need_to_be_rasterized); 210 TileVector* tiles_that_need_to_be_rasterized);
216 211
217 void SynchronouslyRasterizeTiles(
218 const GlobalStateThatImpactsTilePriority& state);
219
220 private: 212 private:
221 class MemoryUsage { 213 class MemoryUsage {
222 public: 214 public:
223 MemoryUsage(); 215 MemoryUsage();
224 MemoryUsage(int64 memory_bytes, int resource_count); 216 MemoryUsage(int64 memory_bytes, int resource_count);
225 217
226 static MemoryUsage FromConfig(const gfx::Size& size, ResourceFormat format); 218 static MemoryUsage FromConfig(const gfx::Size& size, ResourceFormat format);
227 static MemoryUsage FromTile(const Tile* tile); 219 static MemoryUsage FromTile(const Tile* tile);
228 220
229 MemoryUsage& operator+=(const MemoryUsage& other); 221 MemoryUsage& operator+=(const MemoryUsage& other);
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after
271 void NotifyReadyToActivate(); 263 void NotifyReadyToActivate();
272 void NotifyReadyToDraw(); 264 void NotifyReadyToDraw();
273 void CheckIfReadyToActivate(); 265 void CheckIfReadyToActivate();
274 void CheckIfReadyToDraw(); 266 void CheckIfReadyToDraw();
275 void CheckIfMoreTilesNeedToBePrepared(); 267 void CheckIfMoreTilesNeedToBePrepared();
276 268
277 TileManagerClient* client_; 269 TileManagerClient* client_;
278 scoped_refptr<base::SequencedTaskRunner> task_runner_; 270 scoped_refptr<base::SequencedTaskRunner> task_runner_;
279 ResourcePool* resource_pool_; 271 ResourcePool* resource_pool_;
280 TileTaskRunner* tile_task_runner_; 272 TileTaskRunner* tile_task_runner_;
281 Rasterizer* rasterizer_;
282 GlobalStateThatImpactsTilePriority global_state_; 273 GlobalStateThatImpactsTilePriority global_state_;
283 size_t scheduled_raster_task_limit_; 274 size_t scheduled_raster_task_limit_;
284 275
285 typedef base::hash_map<Tile::Id, Tile*> TileMap; 276 typedef base::hash_map<Tile::Id, Tile*> TileMap;
286 TileMap tiles_; 277 TileMap tiles_;
287 278
288 bool all_tiles_that_need_to_be_rasterized_are_scheduled_; 279 bool all_tiles_that_need_to_be_rasterized_are_scheduled_;
289 MemoryHistory::Entry memory_stats_from_last_assign_; 280 MemoryHistory::Entry memory_stats_from_last_assign_;
290 281
291 bool did_check_for_completed_tasks_since_last_schedule_tasks_; 282 bool did_check_for_completed_tasks_since_last_schedule_tasks_;
292 bool did_oom_on_last_assign_; 283 bool did_oom_on_last_assign_;
293 284
294 typedef base::hash_map<uint32_t, scoped_refptr<ImageDecodeTask>> 285 typedef base::hash_map<uint32_t, scoped_refptr<ImageDecodeTask>>
295 PixelRefTaskMap; 286 PixelRefTaskMap;
296 typedef base::hash_map<int, PixelRefTaskMap> LayerPixelRefTaskMap; 287 typedef base::hash_map<int, PixelRefTaskMap> LayerPixelRefTaskMap;
297 LayerPixelRefTaskMap image_decode_tasks_; 288 LayerPixelRefTaskMap image_decode_tasks_;
298 289
299 typedef base::hash_map<int, int> LayerCountMap; 290 typedef base::hash_map<int, int> LayerCountMap;
300 LayerCountMap used_layer_counts_; 291 LayerCountMap used_layer_counts_;
301 292
302 RasterTaskCompletionStats update_visible_tiles_stats_; 293 RasterTaskCompletionStats update_visible_tiles_stats_;
303 294
304 std::vector<Tile*> released_tiles_; 295 std::vector<Tile*> released_tiles_;
305 296
306 // Queue used when scheduling raster tasks. 297 // Queue used when scheduling raster tasks.
307 TileTaskQueue raster_queue_; 298 TileTaskQueue raster_queue_;
308 299
309 std::vector<scoped_refptr<RasterTask>> orphan_raster_tasks_; 300 std::vector<scoped_refptr<RasterTask>> orphan_raster_tasks_;
310 301
311 UniqueNotifier ready_to_activate_notifier_;
312 UniqueNotifier ready_to_draw_notifier_;
313 UniqueNotifier ready_to_activate_check_notifier_; 302 UniqueNotifier ready_to_activate_check_notifier_;
314 UniqueNotifier ready_to_draw_check_notifier_; 303 UniqueNotifier ready_to_draw_check_notifier_;
315 UniqueNotifier more_tiles_need_prepare_check_notifier_; 304 UniqueNotifier more_tiles_need_prepare_check_notifier_;
316 305
317 bool did_notify_ready_to_activate_; 306 bool did_notify_ready_to_activate_;
318 bool did_notify_ready_to_draw_; 307 bool did_notify_ready_to_draw_;
319 308
320 DISALLOW_COPY_AND_ASSIGN(TileManager); 309 DISALLOW_COPY_AND_ASSIGN(TileManager);
321 }; 310 };
322 311
323 } // namespace cc 312 } // namespace cc
324 313
325 #endif // CC_RESOURCES_TILE_MANAGER_H_ 314 #endif // CC_RESOURCES_TILE_MANAGER_H_
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698