1// Copyright 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "cc/resources/priority_calculator.h"
6
7#include <algorithm>
8
9#include "ui/gfx/rect.h"
10
11namespace cc {
12
13static const int kNothingPriorityCutoff = -3;
14
15static const int kMostHighPriority = -2;
16
17static const int kUIDrawsToRootSurfacePriority = -1;
18static const int kVisibleDrawsToRootSurfacePriority = 0;
19static const int kRenderSurfacesPriority = 1;
20static const int kUIDoesNotDrawToRootSurfacePriority = 2;
21static const int kVisibleDoesNotDrawToRootSurfacePriority = 3;
22
23static const int kVisibleOnlyPriorityCutoff = 4;
24
25// The lower digits are how far from being visible the texture is,
26// in pixels.
27static const int kNotVisibleBasePriority = 1000000;
28static const int kNotVisibleLimitPriority = 1900000;
29
30// Arbitrarily define "nearby" to be 2000 pixels. A better estimate
31// would be percent-of-viewport or percent-of-screen.
32static const int kVisibleAndNearbyPriorityCutoff =
33    kNotVisibleBasePriority + 2000;
34
35// Small animated layers are treated as though they are 512 pixels
36// from being visible.
37static const int kSmallAnimatedLayerPriority = kNotVisibleBasePriority + 512;
38
39static const int kLingeringBasePriority = 2000000;
40static const int kLingeringLimitPriority = 2900000;
41
42static const int kMostLowPriority = 3000000;
43
44static const int kEverythingPriorityCutoff = 3000001;
45
46// static
47int PriorityCalculator::UIPriority(bool draws_to_root_surface) {
48  return draws_to_root_surface ? kUIDrawsToRootSurfacePriority
49                               : kUIDoesNotDrawToRootSurfacePriority;
50}
51
52// static
53int PriorityCalculator::VisiblePriority(bool draws_to_root_surface) {
54  return draws_to_root_surface ? kVisibleDrawsToRootSurfacePriority
55                               : kVisibleDoesNotDrawToRootSurfacePriority;
56}
57
58// static
59int PriorityCalculator::RenderSurfacePriority() {
60  return kRenderSurfacesPriority;
61}
62
63// static
64int PriorityCalculator::LingeringPriority(int previous_priority) {
65  // TODO(reveman): We should remove this once we have priorities for all
66  // textures (we can't currently calculate distances for off-screen textures).
67  return std::min(kLingeringLimitPriority,
68                  std::max(kLingeringBasePriority, previous_priority + 1));
69}
70
71// static
72int PriorityCalculator::PriorityFromDistance(const gfx::Rect& visible_rect,
73                                             const gfx::Rect& texture_rect,
74                                             bool draws_to_root_surface) {
75  int distance = visible_rect.ManhattanInternalDistance(texture_rect);
76  if (!distance)
77    return VisiblePriority(draws_to_root_surface);
78  return std::min(kNotVisibleLimitPriority, kNotVisibleBasePriority + distance);
79}
80
81// static
82int PriorityCalculator::SmallAnimatedLayerMinPriority() {
83  return kSmallAnimatedLayerPriority;
84}
85
86// static
87int PriorityCalculator::HighestPriority() {
88  return kMostHighPriority;
89}
90
91// static
92int PriorityCalculator::LowestPriority() {
93  return kMostLowPriority;
94}
95
96// static
97int PriorityCalculator::AllowNothingCutoff() {
98  return kNothingPriorityCutoff;
99}
100
101// static
102int PriorityCalculator::AllowVisibleOnlyCutoff() {
103  return kVisibleOnlyPriorityCutoff;
104}
105
106// static
107int PriorityCalculator::AllowVisibleAndNearbyCutoff() {
108  return kVisibleAndNearbyPriorityCutoff;
109}
110
111// static
112int PriorityCalculator::AllowEverythingCutoff() {
113  return kEverythingPriorityCutoff;
114}
115
116}  // namespace cc
117