cc/priority_calculator.cc

   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/priority_calculator.h"
   6
   7 #include "ui/gfx/rect.h"
   8
   9 namespace cc {
  10
  11 static const int nothingPriorityCutoff = -3;
  12
  13 static const int mostHighPriority = -2;
  14
  15 static const int uiDrawsToRootSurfacePriority = -1;
  16 static const int visibleDrawsToRootSurfacePriority = 0;
  17 static const int renderSurfacesPriority = 1;
  18 static const int uiDoesNotDrawToRootSurfacePriority = 2;
  19 static const int visibleDoesNotDrawToRootSurfacePriority = 3;
  20
  21 static const int visibleOnlyPriorityCutoff = 4;
  22
  23 // The lower digits are how far from being visible the texture is,
  24 // in pixels.
  25 static const int notVisibleBasePriority = 1000000;
  26 static const int notVisibleLimitPriority = 1900000;
  27
  28 // Arbitrarily define "nearby" to be 2000 pixels. A better estimate
  29 // would be percent-of-viewport or percent-of-screen.
  30 static const int visibleAndNearbyPriorityCutoff = notVisibleBasePriority + 2000;
  31
  32 // Small animated layers are treated as though they are 512 pixels
  33 // from being visible.
  34 static const int smallAnimatedLayerPriority = notVisibleBasePriority + 512;
  35
  36 static const int lingeringBasePriority = 2000000;
  37 static const int lingeringLimitPriority = 2900000;
  38
  39 static const int mostLowPriority = 3000000;
  40
  41 static const int everythingPriorityCutoff = 3000001;
  42
  43 // static
  44 int PriorityCalculator::uiPriority(bool drawsToRootSurface)
  45 {
  46     return drawsToRootSurface ? uiDrawsToRootSurfacePriority : uiDoesNotDrawToRootSurfacePriority;
  47 }
  48
  49 // static
  50 int PriorityCalculator::visiblePriority(bool drawsToRootSurface)
  51 {
  52     return drawsToRootSurface ? visibleDrawsToRootSurfacePriority : visibleDoesNotDrawToRootSurfacePriority;
  53 }
  54
  55 // static
  56 int PriorityCalculator::renderSurfacePriority()
  57 {
  58     return renderSurfacesPriority;
  59 }
  60
  61 // static
  62 int PriorityCalculator::lingeringPriority(int previousPriority)
  63 {
  64     // FIXME: We should remove this once we have priorities for all
  65     //        textures (we can't currently calculate distances for
  66     //        off-screen textures).
  67     return std::min(lingeringLimitPriority,
  68                     std::max(lingeringBasePriority, previousPriority + 1));
  69 }
  70
  71 namespace {
  72 int manhattanDistance(const gfx::Rect& a, const gfx::Rect& b)
  73 {
  74     gfx::Rect c = gfx::UnionRects(a, b);
  75     int x = std::max(0, c.width() - a.width() - b.width() + 1);
  76     int y = std::max(0, c.height() - a.height() - b.height() + 1);
  77     return (x + y);
  78 }
  79 }
  80
  81 // static
  82 int PriorityCalculator::priorityFromDistance(const gfx::Rect& visibleRect, const gfx::Rect& textureRect, bool drawsToRootSurface)
  83 {
  84     int distance = manhattanDistance(visibleRect, textureRect);
  85     if (!distance)
  86         return visiblePriority(drawsToRootSurface);
  87     return std::min(notVisibleLimitPriority, notVisibleBasePriority + distance);
  88 }
  89
  90 // static
  91 int PriorityCalculator::smallAnimatedLayerMinPriority()
  92 {
  93     return smallAnimatedLayerPriority;
  94 }
  95
  96 // static
  97 int PriorityCalculator::highestPriority()
  98 {
  99     return mostHighPriority;
 100 }
 101
 102 // static
 103 int PriorityCalculator::lowestPriority()
 104 {
 105     return mostLowPriority;
 106 }
 107
 108 // static
 109 int PriorityCalculator::allowNothingCutoff()
 110 {
 111     return nothingPriorityCutoff;
 112 }
 113
 114 // static
 115 int PriorityCalculator::allowVisibleOnlyCutoff()
 116 {
 117     return visibleOnlyPriorityCutoff;
 118 }
 119
 120 // static
 121 int PriorityCalculator::allowVisibleAndNearbyCutoff()
 122 {
 123     return visibleAndNearbyPriorityCutoff;
 124 }
 125
 126 // static
 127 int PriorityCalculator::allowEverythingCutoff()
 128 {
 129     return everythingPriorityCutoff;
 130 }
 131
 132 }  // namespace cc