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
|
// 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/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,
};
struct CC_EXPORT TilePriority {
TilePriority()
: is_live(false),
resolution(NON_IDEAL_RESOLUTION),
time_to_visible_in_seconds(std::numeric_limits<float>::max()),
distance_to_visible_in_pixels(std::numeric_limits<float>::max()) {}
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);
}
static const double kMaxTimeToVisibleInSeconds;
static const double kMaxDistanceInContentSpace;
static int manhattanDistance(const gfx::RectF& a, const gfx::RectF& b);
// 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 double TimeForBoundsToIntersect(gfx::RectF previous_bounds,
gfx::RectF current_bounds,
double time_delta,
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;
};
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_
|
