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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
|
// 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_PRIORITY_H_
#define CC_TILE_PRIORITY_H_
#include <limits>
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "cc/picture_pile.h"
#include "ui/gfx/quad_f.h"
#include "ui/gfx/rect.h"
#include "ui/gfx/size.h"
namespace base {
class Value;
}
namespace cc {
enum WhichTree {
// Note: these must be 0 and 1 because we index with them in various places,
// e.g. in Tile::priority_.
ACTIVE_TREE = 0,
PENDING_TREE = 1,
NUM_TREES = 2
// Be sure to update WhichTreeAsValue when adding new fields.
};
scoped_ptr<base::Value> WhichTreeAsValue(
WhichTree tree);
enum TileResolution {
LOW_RESOLUTION = 0 ,
HIGH_RESOLUTION = 1,
NON_IDEAL_RESOLUTION = 2,
};
scoped_ptr<base::Value> TileResolutionAsValue(
TileResolution resolution);
struct CC_EXPORT TilePriority {
TilePriority()
: is_live(false),
resolution(NON_IDEAL_RESOLUTION),
time_to_visible_in_seconds(std::numeric_limits<float>::infinity()),
distance_to_visible_in_pixels(std::numeric_limits<float>::infinity()) {}
TilePriority(
TileResolution resolution,
float time_to_visible_in_seconds,
float distance_to_visible_in_pixels)
: is_live(true),
resolution(resolution),
time_to_visible_in_seconds(time_to_visible_in_seconds),
distance_to_visible_in_pixels(distance_to_visible_in_pixels) {}
TilePriority(const TilePriority& active, const TilePriority& pending) {
if (!pending.is_live) {
if (!active.is_live) {
is_live = false;
return;
}
is_live = true;
resolution = active.resolution;
time_to_visible_in_seconds = active.time_to_visible_in_seconds;
distance_to_visible_in_pixels = active.distance_to_visible_in_pixels;
return;
} else if (!active.is_live) {
is_live = true;
resolution = pending.resolution;
time_to_visible_in_seconds = pending.time_to_visible_in_seconds;
distance_to_visible_in_pixels = pending.distance_to_visible_in_pixels;
return;
}
is_live = true;
if (active.resolution == HIGH_RESOLUTION ||
pending.resolution == HIGH_RESOLUTION)
resolution = HIGH_RESOLUTION;
else if (active.resolution == LOW_RESOLUTION ||
pending.resolution == LOW_RESOLUTION)
resolution = LOW_RESOLUTION;
else
resolution = NON_IDEAL_RESOLUTION;
time_to_visible_in_seconds =
std::min(active.time_to_visible_in_seconds,
pending.time_to_visible_in_seconds);
distance_to_visible_in_pixels =
std::min(active.distance_to_visible_in_pixels,
pending.distance_to_visible_in_pixels);
}
void set_current_screen_quad(const gfx::QuadF& q) { current_screen_quad = q; }
scoped_ptr<base::Value> AsValue() const;
static const float kMaxDistanceInContentSpace;
static const int64 kNumTilesToCoverWithInflatedViewportRectForPrioritization;
static inline float manhattanDistance(const gfx::RectF& a, const gfx::RectF& b) {
// Compute the union explicitly.
gfx::RectF c = gfx::RectF(
std::min(a.x(), b.x()),
std::min(a.y(), b.y()),
std::max(a.right(), b.right()) - std::min(a.x(), b.x()),
std::max(a.bottom(), b.bottom()) - std::min(a.y(), b.y()));
// Rects touching the edge of the screen should not be considered visible.
// So we add 1 pixel here to avoid that situation.
float x = std::max(0.0f, c.width() - a.width() - b.width() + 1.0f);
float y = std::max(0.0f, c.height() - a.height() - b.height() + 1.0f);
return (x + y);
}
// Calculate the time for the |current_bounds| to intersect with the
// |target_bounds| given its previous location and time delta.
// This function should work for both scaling and scrolling case.
static float TimeForBoundsToIntersect(const gfx::RectF& previous_bounds,
const gfx::RectF& current_bounds,
float time_delta,
const gfx::RectF& target_bounds);
// If a tile is not live, then all other fields are invalid.
bool is_live;
TileResolution resolution;
float time_to_visible_in_seconds;
float distance_to_visible_in_pixels;
private:
gfx::QuadF current_screen_quad;
};
enum TileMemoryLimitPolicy {
// Nothing.
ALLOW_NOTHING,
// You might be made visible, but you're not being interacted with.
ALLOW_ABSOLUTE_MINIMUM, // Tall.
// You're being interacted with, but we're low on memory.
ALLOW_PREPAINT_ONLY, // Grande.
// You're the only thing in town. Go crazy.
ALLOW_ANYTHING, // Venti.
// Be sure to update TreePriorityAsValue when adding new fields.
};
scoped_ptr<base::Value> TileMemoryLimitPolicyAsValue(
TileMemoryLimitPolicy policy);
enum TreePriority {
SAME_PRIORITY_FOR_BOTH_TREES,
SMOOTHNESS_TAKES_PRIORITY,
NEW_CONTENT_TAKES_PRIORITY
// Be sure to update TreePriorityAsValue when adding new fields.
};
scoped_ptr<base::Value> TreePriorityAsValue(TreePriority prio);
class GlobalStateThatImpactsTilePriority {
public:
GlobalStateThatImpactsTilePriority()
: memory_limit_policy(ALLOW_NOTHING)
, memory_limit_in_bytes(0)
, tree_priority(SAME_PRIORITY_FOR_BOTH_TREES) {
}
TileMemoryLimitPolicy memory_limit_policy;
size_t memory_limit_in_bytes;
TreePriority tree_priority;
scoped_ptr<base::Value> AsValue() const;
};
} // namespace cc
#endif // CC_TILE_PRIORITY_H_
|
