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                                 int flags);
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(Tile::Id tile,
160                             scoped_ptr<ScopedResource> resource,
161                             RasterMode raster_mode,
162                             const PicturePileImpl::Analysis& analysis,
163                             bool was_canceled);
164
165  inline size_t BytesConsumedIfAllocated(const Tile* tile) const {
166    return Resource::MemorySizeBytes(tile->size(),
167                                     raster_worker_pool_->GetResourceFormat());
168  }
169
170  RasterMode DetermineRasterMode(const Tile* tile) const;
171  void FreeResourceForTile(Tile* tile, RasterMode mode);
172  void FreeResourcesForTile(Tile* tile);
173  void FreeUnusedResourcesForTile(Tile* tile);
174  RasterWorkerPool::Task CreateImageDecodeTask(
175      Tile* tile, skia::LazyPixelRef* pixel_ref);
176  RasterWorkerPool::RasterTask CreateRasterTask(Tile* tile);
177  scoped_ptr<base::Value> GetMemoryRequirementsAsValue() const;
178  void UpdatePrioritizedTileSetIfNeeded();
179
180  TileManagerClient* client_;
181  scoped_ptr<ResourcePool> resource_pool_;
182  scoped_ptr<RasterWorkerPool> raster_worker_pool_;
183  GlobalStateThatImpactsTilePriority global_state_;
184
185  typedef base::hash_map<Tile::Id, Tile*> TileMap;
186  TileMap tiles_;
187
188  PrioritizedTileSet prioritized_tiles_;
189  bool prioritized_tiles_dirty_;
190
191  bool all_tiles_that_need_to_be_rasterized_have_memory_;
192  bool all_tiles_required_for_activation_have_memory_;
193
194  size_t memory_required_bytes_;
195  size_t memory_nice_to_have_bytes_;
196
197  size_t bytes_releasable_;
198  size_t resources_releasable_;
199  size_t max_raster_usage_bytes_;
200
201  bool ever_exceeded_memory_budget_;
202  MemoryHistory::Entry memory_stats_from_last_assign_;
203
204  RenderingStatsInstrumentation* rendering_stats_instrumentation_;
205
206  bool did_initialize_visible_tile_;
207  bool did_check_for_completed_tasks_since_last_schedule_tasks_;
208
209  typedef base::hash_map<uint32_t, RasterWorkerPool::Task> PixelRefTaskMap;
210  typedef base::hash_map<int, PixelRefTaskMap> LayerPixelRefTaskMap;
211  LayerPixelRefTaskMap image_decode_tasks_;
212
213  typedef base::hash_map<int, int> LayerCountMap;
214  LayerCountMap used_layer_counts_;
215
216  RasterTaskCompletionStats update_visible_tiles_stats_;
217
218  std::vector<Tile*> released_tiles_;
219
220  DISALLOW_COPY_AND_ASSIGN(TileManager);
221};
222
223}  // namespace cc
224
225#endif  // CC_RESOURCES_TILE_MANAGER_H_
226