tile_manager.h revision ca12bfac764ba476d6cd062bf1dde12cc64c3f40 
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/debug/rendering_stats_instrumentation.h"
16#include "cc/resources/managed_tile_state.h"
17#include "cc/resources/memory_history.h"
18#include "cc/resources/picture_pile_impl.h"
19#include "cc/resources/raster_worker_pool.h"
20#include "cc/resources/resource_pool.h"
21#include "cc/resources/tile.h"
22
23namespace cc {
24class ResourceProvider;
25
26class CC_EXPORT TileManagerClient {
27 public:
28  virtual void NotifyReadyToActivate() = 0;
29
30 protected:
31  virtual ~TileManagerClient() {}
32};
33
34struct RasterTaskCompletionStats {
35  RasterTaskCompletionStats();
36
37  size_t completed_count;
38  size_t canceled_count;
39};
40scoped_ptr<base::Value> RasterTaskCompletionStatsAsValue(
41    const RasterTaskCompletionStats& stats);
42
43// This class manages tiles, deciding which should get rasterized and which
44// should no longer have any memory assigned to them. Tile objects are "owned"
45// by layers; they automatically register with the manager when they are
46// created, and unregister from the manager when they are deleted.
47class CC_EXPORT TileManager : public RasterWorkerPoolClient {
48 public:
49  static scoped_ptr<TileManager> Create(
50      TileManagerClient* client,
51      ResourceProvider* resource_provider,
52      size_t num_raster_threads,
53      RenderingStatsInstrumentation* rendering_stats_instrumentation,
54      bool use_map_image);
55  virtual ~TileManager();
56
57  const GlobalStateThatImpactsTilePriority& GlobalState() const {
58      return global_state_;
59  }
60  void SetGlobalState(const GlobalStateThatImpactsTilePriority& state);
61
62  void ManageTiles();
63
64  // Returns true when visible tiles have been initialized.
65  bool UpdateVisibleTiles();
66
67  scoped_ptr<base::Value> BasicStateAsValue() const;
68  scoped_ptr<base::Value> AllTilesAsValue() const;
69  void GetMemoryStats(size_t* memory_required_bytes,
70                      size_t* memory_nice_to_have_bytes,
71                      size_t* memory_used_bytes) const;
72
73  const MemoryHistory::Entry& memory_stats_from_last_assign() const {
74    return memory_stats_from_last_assign_;
75  }
76
77  bool AreTilesRequiredForActivationReady() const {
78    return all_tiles_required_for_activation_have_been_initialized_;
79  }
80
81 protected:
82  TileManager(TileManagerClient* client,
83              ResourceProvider* resource_provider,
84              scoped_ptr<RasterWorkerPool> raster_worker_pool,
85              size_t num_raster_threads,
86              RenderingStatsInstrumentation* rendering_stats_instrumentation,
87              GLenum texture_format);
88
89  // Methods called by Tile
90  friend class Tile;
91  void RegisterTile(Tile* tile);
92  void UnregisterTile(Tile* tile);
93
94  // Overriden from RasterWorkerPoolClient:
95  virtual bool ShouldForceTasksRequiredForActivationToComplete() const
96      OVERRIDE;
97  virtual void DidFinishRunningTasks() OVERRIDE;
98  virtual void DidFinishRunningTasksRequiredForActivation() OVERRIDE;
99
100  typedef std::vector<Tile*> TileVector;
101  typedef std::vector<scoped_refptr<Tile> > TileRefVector;
102  typedef std::set<Tile*> TileSet;
103
104  // Virtual for test
105  virtual void ScheduleTasks(
106      const TileVector& tiles_that_need_to_be_rasterized);
107
108  void AssignGpuMemoryToTiles(
109      const TileRefVector& sorted_tiles,
110      TileVector* tiles_that_need_to_be_rasterized);
111  void AssignBinsToTiles(TileRefVector* tiles);
112  void SortTiles(TileRefVector* tiles);
113  void GetSortedTiles(TileRefVector* tiles);
114
115 private:
116  void OnImageDecodeTaskCompleted(
117      int layer_id,
118      skia::LazyPixelRef* pixel_ref,
119      bool was_canceled);
120  void OnRasterTaskCompleted(
121      Tile::Id tile,
122      scoped_ptr<ResourcePool::Resource> resource,
123      RasterMode raster_mode,
124      const PicturePileImpl::Analysis& analysis,
125      bool was_canceled);
126
127  RasterMode DetermineRasterMode(const Tile* tile) const;
128  void CleanUpUnusedImageDecodeTasks();
129  void FreeResourceForTile(Tile* tile, RasterMode mode);
130  void FreeResourcesForTile(Tile* tile);
131  void FreeUnusedResourcesForTile(Tile* tile);
132  RasterWorkerPool::Task CreateImageDecodeTask(
133      Tile* tile, skia::LazyPixelRef* pixel_ref);
134  RasterWorkerPool::RasterTask CreateRasterTask(Tile* tile);
135  scoped_ptr<base::Value> GetMemoryRequirementsAsValue() const;
136
137  TileManagerClient* client_;
138  scoped_ptr<ResourcePool> resource_pool_;
139  scoped_ptr<RasterWorkerPool> raster_worker_pool_;
140  GlobalStateThatImpactsTilePriority global_state_;
141
142  typedef base::hash_map<Tile::Id, Tile*> TileMap;
143  TileMap tiles_;
144
145  TileRefVector sorted_tiles_;
146
147  bool all_tiles_that_need_to_be_rasterized_have_memory_;
148  bool all_tiles_required_for_activation_have_memory_;
149  bool all_tiles_required_for_activation_have_been_initialized_;
150
151  bool ever_exceeded_memory_budget_;
152  MemoryHistory::Entry memory_stats_from_last_assign_;
153
154  RenderingStatsInstrumentation* rendering_stats_instrumentation_;
155
156  bool did_initialize_visible_tile_;
157
158  GLenum texture_format_;
159
160  typedef base::hash_map<uint32_t, RasterWorkerPool::Task> PixelRefTaskMap;
161  typedef base::hash_map<int, PixelRefTaskMap> LayerPixelRefTaskMap;
162  LayerPixelRefTaskMap image_decode_tasks_;
163
164  RasterTaskCompletionStats update_visible_tiles_stats_;
165
166  DISALLOW_COPY_AND_ASSIGN(TileManager);
167};
168
169}  // namespace cc
170
171#endif  // CC_RESOURCES_TILE_MANAGER_H_
172