blob: 4e828207ff15d2862dcc9ddeba722f9db6aaca07 (
plain)
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
|
// 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.
#include "cc/resources/priority_calculator.h"
#include <algorithm>
#include "ui/gfx/rect.h"
namespace cc {
static const int kNothingPriorityCutoff = -3;
static const int kMostHighPriority = -2;
static const int kUIDrawsToRootSurfacePriority = -1;
static const int kVisibleDrawsToRootSurfacePriority = 0;
static const int kRenderSurfacesPriority = 1;
static const int kUIDoesNotDrawToRootSurfacePriority = 2;
static const int kVisibleDoesNotDrawToRootSurfacePriority = 3;
static const int kVisibleOnlyPriorityCutoff = 4;
// The lower digits are how far from being visible the texture is,
// in pixels.
static const int kNotVisibleBasePriority = 1000000;
static const int kNotVisibleLimitPriority = 1900000;
// Arbitrarily define "nearby" to be 2000 pixels. A better estimate
// would be percent-of-viewport or percent-of-screen.
static const int kVisibleAndNearbyPriorityCutoff =
kNotVisibleBasePriority + 2000;
// Small animated layers are treated as though they are 512 pixels
// from being visible.
static const int kSmallAnimatedLayerPriority = kNotVisibleBasePriority + 512;
static const int kLingeringBasePriority = 2000000;
static const int kLingeringLimitPriority = 2900000;
static const int kMostLowPriority = 3000000;
static const int kEverythingPriorityCutoff = 3000001;
// static
int PriorityCalculator::UIPriority(bool draws_to_root_surface) {
return draws_to_root_surface ? kUIDrawsToRootSurfacePriority
: kUIDoesNotDrawToRootSurfacePriority;
}
// static
int PriorityCalculator::VisiblePriority(bool draws_to_root_surface) {
return draws_to_root_surface ? kVisibleDrawsToRootSurfacePriority
: kVisibleDoesNotDrawToRootSurfacePriority;
}
// static
int PriorityCalculator::RenderSurfacePriority() {
return kRenderSurfacesPriority;
}
// static
int PriorityCalculator::LingeringPriority(int previous_priority) {
// TODO(reveman): We should remove this once we have priorities for all
// textures (we can't currently calculate distances for off-screen textures).
return std::min(kLingeringLimitPriority,
std::max(kLingeringBasePriority, previous_priority + 1));
}
namespace {
int ManhattanDistance(gfx::Rect a, gfx::Rect b) {
gfx::Rect c = gfx::UnionRects(a, b);
int x = std::max(0, c.width() - a.width() - b.width() + 1);
int y = std::max(0, c.height() - a.height() - b.height() + 1);
return (x + y);
}
}
// static
int PriorityCalculator::PriorityFromDistance(gfx::Rect visible_rect,
gfx::Rect texture_rect,
bool draws_to_root_surface) {
int distance = ManhattanDistance(visible_rect, texture_rect);
if (!distance)
return VisiblePriority(draws_to_root_surface);
return std::min(kNotVisibleLimitPriority, kNotVisibleBasePriority + distance);
}
// static
int PriorityCalculator::SmallAnimatedLayerMinPriority() {
return kSmallAnimatedLayerPriority;
}
// static
int PriorityCalculator::HighestPriority() {
return kMostHighPriority;
}
// static
int PriorityCalculator::LowestPriority() {
return kMostLowPriority;
}
// static
int PriorityCalculator::AllowNothingCutoff() {
return kNothingPriorityCutoff;
}
// static
int PriorityCalculator::AllowVisibleOnlyCutoff() {
return kVisibleOnlyPriorityCutoff;
}
// static
int PriorityCalculator::AllowVisibleAndNearbyCutoff() {
return kVisibleAndNearbyPriorityCutoff;
}
// static
int PriorityCalculator::AllowEverythingCutoff() {
return kEverythingPriorityCutoff;
}
} // namespace cc
|
