1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
// 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_TILE_MANAGER_H_
#define CC_TILE_MANAGER_H_
#include <queue>
#include <vector>
#include "base/memory/scoped_ptr.h"
#include "base/values.h"
#include "cc/resource_pool.h"
#include "cc/tile_priority.h"
namespace cc {
class RasterThread;
class ResourceProvider;
class Tile;
class TileVersion;
struct RenderingStats;
class CC_EXPORT TileManagerClient {
public:
virtual void ScheduleManageTiles() = 0;
virtual void ScheduleCheckForCompletedSetPixels() = 0;
protected:
virtual ~TileManagerClient() {}
};
// Tile manager classifying tiles into a few basic
// bins:
enum TileManagerBin {
NOW_BIN = 0, // Needed ASAP.
SOON_BIN = 1, // Impl-side version of prepainting.
EVENTUALLY_BIN = 2, // Nice to have, if we've got memory and time.
NEVER_BIN = 3, // Dont bother.
NUM_BINS = 4
};
// This is state that is specific to a tile that is
// managed by the TileManager.
class CC_EXPORT ManagedTileState {
public:
ManagedTileState();
~ManagedTileState();
// Persisted state: valid all the time.
bool can_use_gpu_memory;
bool can_be_freed;
scoped_ptr<ResourcePool::Resource> resource;
bool resource_is_being_initialized;
bool contents_swizzled;
// Ephemeral state, valid only during Manage.
TileManagerBin bin;
TileResolution resolution;
float time_to_needed_in_seconds;
};
// This class manages tiles, deciding which should get rasterized and which
// should no longer have any memory assigned to them. Tile objects are "owned"
// by layers; they automatically register with the manager when they are
// created, and unregister from the manager when they are deleted.
class CC_EXPORT TileManager {
public:
TileManager(TileManagerClient* client,
ResourceProvider *resource_provider,
size_t num_raster_threads);
virtual ~TileManager();
const GlobalStateThatImpactsTilePriority& GlobalState() const { return global_state_; }
void SetGlobalState(const GlobalStateThatImpactsTilePriority& state);
void ManageTiles();
void CheckForCompletedSetPixels();
void renderingStats(RenderingStats* stats);
protected:
// Methods called by Tile
friend class Tile;
void RegisterTile(Tile*);
void UnregisterTile(Tile*);
void WillModifyTilePriority(Tile*, WhichTree, const TilePriority& new_priority);
private:
void AssignGpuMemoryToTiles();
void FreeResourcesForTile(Tile*);
void ScheduleManageTiles();
void ScheduleCheckForCompletedSetPixels();
void DispatchMoreRasterTasks();
void DispatchOneRasterTask(RasterThread*, scoped_refptr<Tile>);
void OnRasterTaskCompleted(
scoped_refptr<Tile>,
scoped_ptr<ResourcePool::Resource>,
scoped_refptr<PicturePileImpl>,
RenderingStats*);
void DidFinishTileInitialization(Tile*);
TileManagerClient* client_;
scoped_ptr<ResourcePool> resource_pool_;
bool manage_tiles_pending_;
bool check_for_completed_set_pixels_pending_;
GlobalStateThatImpactsTilePriority global_state_;
typedef std::vector<Tile*> TileVector;
TileVector tiles_;
TileVector tiles_that_need_to_be_rasterized_;
typedef std::queue<scoped_refptr<Tile> > TileQueue;
TileQueue tiles_with_pending_set_pixels_;
typedef ScopedPtrVector<RasterThread> RasterThreadVector;
RasterThreadVector raster_threads_;
RenderingStats rendering_stats_;
DISALLOW_COPY_AND_ASSIGN(TileManager);
};
} // namespace cc
#endif // CC_TILE_MANAGER_H_
|
