tile_manager.h revision f2477e01787aa58f445919b809d89e252beef54f 
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
3// found in the LICENSE file.
4
5#ifndef CC_RESOURCES_TILE_MANAGER_H_
6#define CC_RESOURCES_TILE_MANAGER_H_
7
8#include <queue>
9#include <set>
10#include <vector>
11
12#include "base/containers/hash_tables.h"
13#include "base/memory/scoped_ptr.h"
14#include "base/values.h"
15#include "cc/base/ref_counted_managed.h"
16#include "cc/debug/rendering_stats_instrumentation.h"
17#include "cc/resources/managed_tile_state.h"
18#include "cc/resources/memory_history.h"
19#include "cc/resources/picture_pile_impl.h"
20#include "cc/resources/prioritized_tile_set.h"
21#include "cc/resources/raster_worker_pool.h"
22#include "cc/resources/resource_pool.h"
23#include "cc/resources/tile.h"
24
25namespace cc {
26class ResourceProvider;
27
28class CC_EXPORT TileManagerClient {
29 public:
30  virtual void NotifyReadyToActivate() = 0;
31
32 protected:
33  virtual ~TileManagerClient() {}
34};
35
36struct RasterTaskCompletionStats {
37  RasterTaskCompletionStats();
38
39  size_t completed_count;
40  size_t canceled_count;
41};
42scoped_ptr<base::Value> RasterTaskCompletionStatsAsValue(
43    const RasterTaskCompletionStats& stats);
44
45// This class manages tiles, deciding which should get rasterized and which
46// should no longer have any memory assigned to them. Tile objects are "owned"
47// by layers; they automatically register with the manager when they are
48// created, and unregister from the manager when they are deleted.
49class CC_EXPORT TileManager : public RasterWorkerPoolClient,
50                              public RefCountedManager<Tile> {
51 public:
52  static scoped_ptr<TileManager> Create(
53      TileManagerClient* client,
54      ResourceProvider* resource_provider,
55      size_t num_raster_threads,
56      RenderingStatsInstrumentation* rendering_stats_instrumentation,
57      bool use_map_image,
58      size_t max_transfer_buffer_usage_bytes,
59      size_t max_raster_usage_bytes,
60      GLenum map_image_texture_target);
61  virtual ~TileManager();
62
63  void ManageTiles(const GlobalStateThatImpactsTilePriority& state);
64
65  // Returns true when visible tiles have been initialized.
66  bool UpdateVisibleTiles();
67
68  scoped_refptr<Tile> CreateTile(PicturePileImpl* picture_pile,
69                                 gfx::Size tile_size,
70                                 gfx::Rect content_rect,
71                                 gfx::Rect opaque_rect,
72                                 float contents_scale,
73                                 int layer_id,
74                                 int source_frame_number,
75                                 bool can_use_lcd_text);
76
77  scoped_ptr<base::Value> BasicStateAsValue() const;
78  scoped_ptr<base::Value> AllTilesAsValue() const;
79  void GetMemoryStats(size_t* memory_required_bytes,
80                      size_t* memory_nice_to_have_bytes,
81                      size_t* memory_allocated_bytes,
82                      size_t* memory_used_bytes) const;
83
84  const MemoryHistory::Entry& memory_stats_from_last_assign() const {
85    return memory_stats_from_last_assign_;
86  }
87
88  void InitializeTilesWithResourcesForTesting(
89      const std::vector<Tile*>& tiles,
90      ResourceProvider* resource_provider) {
91    for (size_t i = 0; i < tiles.size(); ++i) {
92      ManagedTileState& mts = tiles[i]->managed_state();
93      ManagedTileState::TileVersion& tile_version =
94          mts.tile_versions[HIGH_QUALITY_NO_LCD_RASTER_MODE];
95
96      tile_version.resource_ = resource_pool_->AcquireResource(
97          gfx::Size(1, 1));
98
99      bytes_releasable_ += BytesConsumedIfAllocated(tiles[i]);
100      ++resources_releasable_;
101    }
102  }
103  RasterWorkerPool* RasterWorkerPoolForTesting() {
104    return raster_worker_pool_.get();
105  }
106
107  void SetGlobalStateForTesting(
108      const GlobalStateThatImpactsTilePriority& state) {
109    if (state != global_state_) {
110      global_state_ = state;
111      prioritized_tiles_dirty_ = true;
112      resource_pool_->SetResourceUsageLimits(
113          global_state_.memory_limit_in_bytes,
114          global_state_.unused_memory_limit_in_bytes,
115          global_state_.num_resources_limit);
116    }
117  }
118
119 protected:
120  TileManager(TileManagerClient* client,
121              ResourceProvider* resource_provider,
122              scoped_ptr<RasterWorkerPool> raster_worker_pool,
123              size_t num_raster_threads,
124              size_t max_raster_usage_bytes,
125              RenderingStatsInstrumentation* rendering_stats_instrumentation);
126
127  // Methods called by Tile
128  friend class Tile;
129  void DidChangeTilePriority(Tile* tile);
130
131  void CleanUpReleasedTiles();
132
133  // Overriden from RefCountedManager<Tile>:
134  virtual void Release(Tile* tile) OVERRIDE;
135
136  // Overriden from RasterWorkerPoolClient:
137  virtual bool ShouldForceTasksRequiredForActivationToComplete() const
138      OVERRIDE;
139  virtual void DidFinishRunningTasks() OVERRIDE;
140  virtual void DidFinishRunningTasksRequiredForActivation() OVERRIDE;
141
142  typedef std::vector<Tile*> TileVector;
143  typedef std::set<Tile*> TileSet;
144
145  // Virtual for test
146  virtual void ScheduleTasks(
147      const TileVector& tiles_that_need_to_be_rasterized);
148
149  void AssignGpuMemoryToTiles(
150      PrioritizedTileSet* tiles,
151      TileVector* tiles_that_need_to_be_rasterized);
152  void GetTilesWithAssignedBins(PrioritizedTileSet* tiles);
153
154 private:
155  void OnImageDecodeTaskCompleted(
156      int layer_id,
157      skia::LazyPixelRef* pixel_ref,
158      bool was_canceled);
159  void OnRasterTaskCompleted(
160      Tile::Id tile,
161      scoped_ptr<ResourcePool::Resource> resource,
162      RasterMode raster_mode,
163      const PicturePileImpl::Analysis& analysis,
164      bool was_canceled);
165
166  inline size_t BytesConsumedIfAllocated(const Tile* tile) const {
167    return Resource::MemorySizeBytes(tile->size(),
168                                     raster_worker_pool_->GetResourceFormat());
169  }
170
171  RasterMode DetermineRasterMode(const Tile* tile) const;
172  void FreeResourceForTile(Tile* tile, RasterMode mode);
173  void FreeResourcesForTile(Tile* tile);
174  void FreeUnusedResourcesForTile(Tile* tile);
175  RasterWorkerPool::Task CreateImageDecodeTask(
176      Tile* tile, skia::LazyPixelRef* pixel_ref);
177  RasterWorkerPool::RasterTask CreateRasterTask(Tile* tile);
178  scoped_ptr<base::Value> GetMemoryRequirementsAsValue() const;
179  void UpdatePrioritizedTileSetIfNeeded();
180
181  TileManagerClient* client_;
182  scoped_ptr<ResourcePool> resource_pool_;
183  scoped_ptr<RasterWorkerPool> raster_worker_pool_;
184  GlobalStateThatImpactsTilePriority global_state_;
185
186  typedef base::hash_map<Tile::Id, Tile*> TileMap;
187  TileMap tiles_;
188
189  PrioritizedTileSet prioritized_tiles_;
190  bool prioritized_tiles_dirty_;
191
192  bool all_tiles_that_need_to_be_rasterized_have_memory_;
193  bool all_tiles_required_for_activation_have_memory_;
194
195  size_t memory_required_bytes_;
196  size_t memory_nice_to_have_bytes_;
197
198  size_t bytes_releasable_;
199  size_t resources_releasable_;
200  size_t max_raster_usage_bytes_;
201
202  bool ever_exceeded_memory_budget_;
203  MemoryHistory::Entry memory_stats_from_last_assign_;
204
205  RenderingStatsInstrumentation* rendering_stats_instrumentation_;
206
207  bool did_initialize_visible_tile_;
208  bool did_check_for_completed_tasks_since_last_schedule_tasks_;
209
210  typedef base::hash_map<uint32_t, RasterWorkerPool::Task> PixelRefTaskMap;
211  typedef base::hash_map<int, PixelRefTaskMap> LayerPixelRefTaskMap;
212  LayerPixelRefTaskMap image_decode_tasks_;
213
214  typedef base::hash_map<int, int> LayerCountMap;
215  LayerCountMap used_layer_counts_;
216
217  RasterTaskCompletionStats update_visible_tiles_stats_;
218
219  std::vector<Tile*> released_tiles_;
220
221  DISALLOW_COPY_AND_ASSIGN(TileManager);
222};
223
224}  // namespace cc
225
226#endif  // CC_RESOURCES_TILE_MANAGER_H_
227