| // 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 |