1 files changed, 124 insertions, 0 deletions
diff --git a/cc/resources/priority_calculator.cc b/cc/resources/priority_calculator.cc
new file mode 100644
index 0000000..aaeb6bb
--- /dev/null
+++ b/cc/resources/priority_calculator.cc
@@ -0,0 +1,124 @@
+// 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 "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) {
+  // FIXME: 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