src/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   enum PriorityBin { NOW, SOON, EVENTUALLY };
  45
  46   TilePriority()
  47       : resolution(NON_IDEAL_RESOLUTION),
  48         required_for_activation(false),
  49         priority_bin(EVENTUALLY),
  50         distance_to_visible(std::numeric_limits<float>::infinity()) {}
  51
  52   TilePriority(TileResolution resolution,
  53                PriorityBin bin,
  54                float distance_to_visible)
  55       : resolution(resolution),
  56         required_for_activation(false),
  57         priority_bin(bin),
  58         distance_to_visible(distance_to_visible) {}
  59
  60   TilePriority(const TilePriority& active, const TilePriority& pending) {
  61     if (active.resolution == HIGH_RESOLUTION ||
  62         pending.resolution == HIGH_RESOLUTION)
  63       resolution = HIGH_RESOLUTION;
  64     else if (active.resolution == LOW_RESOLUTION ||
  65              pending.resolution == LOW_RESOLUTION)
  66       resolution = LOW_RESOLUTION;
  67     else
  68       resolution = NON_IDEAL_RESOLUTION;
  69
  70     required_for_activation =
  71         active.required_for_activation || pending.required_for_activation;
  72
  73     if (active.priority_bin < pending.priority_bin) {
  74       priority_bin = active.priority_bin;
  75       distance_to_visible = active.distance_to_visible;
  76     } else if (active.priority_bin > pending.priority_bin) {
  77       priority_bin = pending.priority_bin;
  78       distance_to_visible = pending.distance_to_visible;
  79     } else {
  80       priority_bin = active.priority_bin;
  81       distance_to_visible =
  82           std::min(active.distance_to_visible, pending.distance_to_visible);
  83     }
  84   }
  85
  86   scoped_ptr<base::Value> AsValue() const;
  87
  88   bool operator ==(const TilePriority& other) const {
  89     return resolution == other.resolution &&
  90            priority_bin == other.priority_bin &&
  91            distance_to_visible == other.distance_to_visible &&
  92            required_for_activation == other.required_for_activation;
  93   }
  94
  95   bool operator !=(const TilePriority& other) const {
  96     return !(*this == other);
  97   }
  98
  99   bool IsHigherPriorityThan(const TilePriority& other) const {
 100     return priority_bin < other.priority_bin ||
 101            (priority_bin == other.priority_bin &&
 102             distance_to_visible < other.distance_to_visible);
 103   }
 104
 105   TileResolution resolution;
 106   bool required_for_activation;
 107   PriorityBin priority_bin;
 108   float distance_to_visible;
 109 };
 110
 111 scoped_ptr<base::Value> TilePriorityBinAsValue(TilePriority::PriorityBin bin);
 112
 113 enum TileMemoryLimitPolicy {
 114   // Nothing.
 115   ALLOW_NOTHING = 0,
 116
 117   // You might be made visible, but you're not being interacted with.
 118   ALLOW_ABSOLUTE_MINIMUM = 1,  // Tall.
 119
 120   // You're being interacted with, but we're low on memory.
 121   ALLOW_PREPAINT_ONLY = 2,  // Grande.
 122
 123   // You're the only thing in town. Go crazy.
 124   ALLOW_ANYTHING = 3,  // Venti.
 125
 126   NUM_TILE_MEMORY_LIMIT_POLICIES = 4,
 127
 128   // NOTE: Be sure to update TreePriorityAsValue and kBinPolicyMap when adding
 129   // or reordering fields.
 130 };
 131 scoped_ptr<base::Value> TileMemoryLimitPolicyAsValue(
 132     TileMemoryLimitPolicy policy);
 133
 134 enum TreePriority {
 135   SAME_PRIORITY_FOR_BOTH_TREES,
 136   SMOOTHNESS_TAKES_PRIORITY,
 137   NEW_CONTENT_TAKES_PRIORITY
 138
 139   // Be sure to update TreePriorityAsValue when adding new fields.
 140 };
 141 scoped_ptr<base::Value> TreePriorityAsValue(TreePriority prio);
 142
 143 class GlobalStateThatImpactsTilePriority {
 144  public:
 145   GlobalStateThatImpactsTilePriority()
 146       : memory_limit_policy(ALLOW_NOTHING),
 147         soft_memory_limit_in_bytes(0),
 148         hard_memory_limit_in_bytes(0),
 149         num_resources_limit(0),
 150         tree_priority(SAME_PRIORITY_FOR_BOTH_TREES) {}
 151
 152   TileMemoryLimitPolicy memory_limit_policy;
 153
 154   size_t soft_memory_limit_in_bytes;
 155   size_t hard_memory_limit_in_bytes;
 156   size_t num_resources_limit;
 157
 158   TreePriority tree_priority;
 159
 160   bool operator==(const GlobalStateThatImpactsTilePriority& other) const {
 161     return memory_limit_policy == other.memory_limit_policy &&
 162            soft_memory_limit_in_bytes == other.soft_memory_limit_in_bytes &&
 163            hard_memory_limit_in_bytes == other.hard_memory_limit_in_bytes &&
 164            num_resources_limit == other.num_resources_limit &&
 165            tree_priority == other.tree_priority;
 166   }
 167   bool operator!=(const GlobalStateThatImpactsTilePriority& other) const {
 168     return !(*this == other);
 169   }
 170
 171   scoped_ptr<base::Value> AsValue() const;
 172 };
 173
 174 }  // namespace cc
 175
 176 #endif  // CC_RESOURCES_TILE_PRIORITY_H_