cc/resources/tile_priority.h

   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 #ifndef CC_RESOURCES_TILE_PRIORITY_H_
   6 #define CC_RESOURCES_TILE_PRIORITY_H_
   7
   8 #include <algorithm>
   9 #include <limits>
  10
  11 #include "base/memory/ref_counted.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "cc/resources/picture_pile.h"
  14 #include "ui/gfx/quad_f.h"
  15 #include "ui/gfx/rect.h"
  16 #include "ui/gfx/size.h"
  17
  18 namespace base {
  19 class Value;
  20 }
  21
  22 namespace cc {
  23
  24 enum WhichTree {
  25   // Note: these must be 0 and 1 because we index with them in various places,
  26   // e.g. in Tile::priority_.
  27   ACTIVE_TREE = 0,
  28   PENDING_TREE = 1,
  29   NUM_TREES = 2
  30   // Be sure to update WhichTreeAsValue when adding new fields.
  31 };
  32 scoped_ptr<base::Value> WhichTreeAsValue(
  33     WhichTree tree);
  34
  35 enum TileResolution {
  36   LOW_RESOLUTION = 0 ,
  37   HIGH_RESOLUTION = 1,
  38   NON_IDEAL_RESOLUTION = 2,
  39 };
  40 scoped_ptr<base::Value> TileResolutionAsValue(
  41     TileResolution resolution);
  42
  43 struct CC_EXPORT TilePriority {
  44   TilePriority()
  45       : resolution(NON_IDEAL_RESOLUTION),
  46         required_for_activation(false),
  47         time_to_visible_in_seconds(std::numeric_limits<float>::infinity()),
  48         distance_to_visible_in_pixels(std::numeric_limits<float>::infinity()) {}
  49
  50   TilePriority(TileResolution resolution,
  51                float time_to_visible_in_seconds,
  52                float distance_to_visible_in_pixels)
  53       : resolution(resolution),
  54         required_for_activation(false),
  55         time_to_visible_in_seconds(time_to_visible_in_seconds),
  56         distance_to_visible_in_pixels(distance_to_visible_in_pixels) {}
  57
  58   TilePriority(const TilePriority& active, const TilePriority& pending) {
  59     if (active.resolution == HIGH_RESOLUTION ||
  60         pending.resolution == HIGH_RESOLUTION)
  61       resolution = HIGH_RESOLUTION;
  62     else if (active.resolution == LOW_RESOLUTION ||
  63              pending.resolution == LOW_RESOLUTION)
  64       resolution = LOW_RESOLUTION;
  65     else
  66       resolution = NON_IDEAL_RESOLUTION;
  67
  68     required_for_activation =
  69         active.required_for_activation || pending.required_for_activation;
  70
  71     time_to_visible_in_seconds =
  72       std::min(active.time_to_visible_in_seconds,
  73                pending.time_to_visible_in_seconds);
  74     distance_to_visible_in_pixels =
  75       std::min(active.distance_to_visible_in_pixels,
  76                pending.distance_to_visible_in_pixels);
  77   }
  78
  79   scoped_ptr<base::Value> AsValue() const;
  80
  81   static inline float manhattanDistance(const gfx::RectF& a,
  82                                         const gfx::RectF& b) {
  83     // Compute the union explicitly.
  84     gfx::RectF c = gfx::RectF(
  85         std::min(a.x(), b.x()),
  86         std::min(a.y(), b.y()),
  87         std::max(a.right(), b.right()) - std::min(a.x(), b.x()),
  88         std::max(a.bottom(), b.bottom()) - std::min(a.y(), b.y()));
  89
  90     // Rects touching the edge of the screen should not be considered visible.
  91     // So we add 1 pixel here to avoid that situation.
  92     float x = std::max(0.0f, c.width() - a.width() - b.width() + 1.0f);
  93     float y = std::max(0.0f, c.height() - a.height() - b.height() + 1.0f);
  94     return (x + y);
  95   }
  96
  97   // Calculate the time for the |current_bounds| to intersect with the
  98   // |target_bounds| given its previous location and time delta.
  99   // This function should work for both scaling and scrolling case.
 100   static float TimeForBoundsToIntersect(const gfx::RectF& previous_bounds,
 101                                         const gfx::RectF& current_bounds,
 102                                         float time_delta,
 103                                         const gfx::RectF& target_bounds);
 104
 105   bool operator ==(const TilePriority& other) const {
 106     return resolution == other.resolution &&
 107         time_to_visible_in_seconds == other.time_to_visible_in_seconds &&
 108         distance_to_visible_in_pixels == other.distance_to_visible_in_pixels &&
 109         required_for_activation == other.required_for_activation;
 110   }
 111
 112   bool operator !=(const TilePriority& other) const {
 113     return !(*this == other);
 114   }
 115
 116   TileResolution resolution;
 117   bool required_for_activation;
 118   float time_to_visible_in_seconds;
 119   float distance_to_visible_in_pixels;
 120 };
 121
 122 enum TileMemoryLimitPolicy {
 123   // Nothing.
 124   ALLOW_NOTHING = 0,
 125
 126   // You might be made visible, but you're not being interacted with.
 127   ALLOW_ABSOLUTE_MINIMUM = 1,  // Tall.
 128
 129   // You're being interacted with, but we're low on memory.
 130   ALLOW_PREPAINT_ONLY = 2,  // Grande.
 131
 132   // You're the only thing in town. Go crazy.
 133   ALLOW_ANYTHING = 3,  // Venti.
 134
 135   NUM_TILE_MEMORY_LIMIT_POLICIES = 4,
 136
 137   // NOTE: Be sure to update TreePriorityAsValue and kBinPolicyMap when adding
 138   // or reordering fields.
 139 };
 140 scoped_ptr<base::Value> TileMemoryLimitPolicyAsValue(
 141     TileMemoryLimitPolicy policy);
 142
 143 enum TreePriority {
 144   SAME_PRIORITY_FOR_BOTH_TREES,
 145   SMOOTHNESS_TAKES_PRIORITY,
 146   NEW_CONTENT_TAKES_PRIORITY
 147
 148   // Be sure to update TreePriorityAsValue when adding new fields.
 149 };
 150 scoped_ptr<base::Value> TreePriorityAsValue(TreePriority prio);
 151
 152 class GlobalStateThatImpactsTilePriority {
 153  public:
 154   GlobalStateThatImpactsTilePriority()
 155       : memory_limit_policy(ALLOW_NOTHING),
 156         memory_limit_in_bytes(0),
 157         unused_memory_limit_in_bytes(0),
 158         num_resources_limit(0),
 159         tree_priority(SAME_PRIORITY_FOR_BOTH_TREES) {}
 160
 161   TileMemoryLimitPolicy memory_limit_policy;
 162
 163   size_t memory_limit_in_bytes;
 164   size_t unused_memory_limit_in_bytes;
 165   size_t num_resources_limit;
 166
 167   TreePriority tree_priority;
 168
 169   bool operator==(const GlobalStateThatImpactsTilePriority& other) const {
 170     return memory_limit_policy == other.memory_limit_policy
 171         && memory_limit_in_bytes == other.memory_limit_in_bytes
 172         && unused_memory_limit_in_bytes == other.unused_memory_limit_in_bytes
 173         && num_resources_limit == other.num_resources_limit
 174         && tree_priority == other.tree_priority;
 175   }
 176   bool operator!=(const GlobalStateThatImpactsTilePriority& other) const {
 177     return !(*this == other);
 178   }
 179
 180   scoped_ptr<base::Value> AsValue() const;
 181 };
 182
 183 }  // namespace cc
 184
 185 #endif  // CC_RESOURCES_TILE_PRIORITY_H_