blob: 0895ef370e6788d715d79c27b08a6f0048d1b41f (
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
126
127
128
129
130
131
132
133
|
// 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/priority_calculator.h"
#include "ui/gfx/rect.h"
using namespace std;
namespace cc {
static const int nothingPriorityCutoff = -3;
static const int mostHighPriority = -2;
static const int uiDrawsToRootSurfacePriority = -1;
static const int visibleDrawsToRootSurfacePriority = 0;
static const int renderSurfacesPriority = 1;
static const int uiDoesNotDrawToRootSurfacePriority = 2;
static const int visibleDoesNotDrawToRootSurfacePriority = 3;
static const int visibleOnlyPriorityCutoff = 4;
// The lower digits are how far from being visible the texture is,
// in pixels.
static const int notVisibleBasePriority = 1000000;
static const int notVisibleLimitPriority = 1900000;
// Arbitrarily define "nearby" to be 2000 pixels. A better estimate
// would be percent-of-viewport or percent-of-screen.
static const int visibleAndNearbyPriorityCutoff = notVisibleBasePriority + 2000;
// Small animated layers are treated as though they are 512 pixels
// from being visible.
static const int smallAnimatedLayerPriority = notVisibleBasePriority + 512;
static const int lingeringBasePriority = 2000000;
static const int lingeringLimitPriority = 2900000;
static const int mostLowPriority = 3000000;
static const int everythingPriorityCutoff = 3000001;
// static
int PriorityCalculator::uiPriority(bool drawsToRootSurface)
{
return drawsToRootSurface ? uiDrawsToRootSurfacePriority : uiDoesNotDrawToRootSurfacePriority;
}
// static
int PriorityCalculator::visiblePriority(bool drawsToRootSurface)
{
return drawsToRootSurface ? visibleDrawsToRootSurfacePriority : visibleDoesNotDrawToRootSurfacePriority;
}
// static
int PriorityCalculator::renderSurfacePriority()
{
return renderSurfacesPriority;
}
// static
int PriorityCalculator::lingeringPriority(int previousPriority)
{
// FIXME: We should remove this once we have priorities for all
// textures (we can't currently calculate distances for
// off-screen textures).
return min(lingeringLimitPriority,
max(lingeringBasePriority, previousPriority + 1));
}
namespace {
int manhattanDistance(const gfx::Rect& a, const gfx::Rect& b)
{
gfx::Rect c = gfx::UnionRects(a, b);
int x = max(0, c.width() - a.width() - b.width() + 1);
int y = max(0, c.height() - a.height() - b.height() + 1);
return (x + y);
}
}
// static
int PriorityCalculator::priorityFromDistance(const gfx::Rect& visibleRect, const gfx::Rect& textureRect, bool drawsToRootSurface)
{
int distance = manhattanDistance(visibleRect, textureRect);
if (!distance)
return visiblePriority(drawsToRootSurface);
return min(notVisibleLimitPriority, notVisibleBasePriority + distance);
}
// static
int PriorityCalculator::smallAnimatedLayerMinPriority()
{
return smallAnimatedLayerPriority;
}
// static
int PriorityCalculator::highestPriority()
{
return mostHighPriority;
}
// static
int PriorityCalculator::lowestPriority()
{
return mostLowPriority;
}
// static
int PriorityCalculator::allowNothingCutoff()
{
return nothingPriorityCutoff;
}
// static
int PriorityCalculator::allowVisibleOnlyCutoff()
{
return visibleOnlyPriorityCutoff;
}
// static
int PriorityCalculator::allowVisibleAndNearbyCutoff()
{
return visibleAndNearbyPriorityCutoff;
}
// static
int PriorityCalculator::allowEverythingCutoff()
{
return everythingPriorityCutoff;
}
} // namespace cc
|
