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 #include <string>
  11
  12 #include "base/memory/ref_counted.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "cc/resources/picture_pile.h"
  15 #include "ui/gfx/quad_f.h"
  16 #include "ui/gfx/rect.h"
  17 #include "ui/gfx/size.h"
  18
  19 namespace base {
  20 class Value;
  21 }
  22
  23 namespace cc {
  24
  25 enum WhichTree {
  26   // Note: these must be 0 and 1 because we index with them in various places,
  27   // e.g. in Tile::priority_.
  28   ACTIVE_TREE = 0,
  29   PENDING_TREE = 1,
  30   NUM_TREES = 2
  31   // Be sure to update WhichTreeAsValue when adding new fields.
  32 };
  33 scoped_ptr<base::Value> WhichTreeAsValue(WhichTree tree);
  34
  35 enum TileResolution {
  36   LOW_RESOLUTION = 0 ,
  37   HIGH_RESOLUTION = 1,
  38   NON_IDEAL_RESOLUTION = 2,
  39 };
  40 std::string TileResolutionToString(TileResolution resolution);
  41
  42 struct CC_EXPORT TilePriority {
  43   enum PriorityBin { NOW, SOON, EVENTUALLY };
  44
  45   TilePriority()
  46       : resolution(NON_IDEAL_RESOLUTION),
  47         required_for_activation(false),
  48         priority_bin(EVENTUALLY),
  49         distance_to_visible(std::numeric_limits<float>::infinity()) {}
  50
  51   TilePriority(TileResolution resolution,
  52                PriorityBin bin,
  53                float distance_to_visible)
  54       : resolution(resolution),
  55         required_for_activation(false),
  56         priority_bin(bin),
  57         distance_to_visible(distance_to_visible) {}
  58
  59   TilePriority(const TilePriority& active, const TilePriority& pending) {
  60     if (active.resolution == HIGH_RESOLUTION ||
  61         pending.resolution == HIGH_RESOLUTION)
  62       resolution = HIGH_RESOLUTION;
  63     else if (active.resolution == LOW_RESOLUTION ||
  64              pending.resolution == LOW_RESOLUTION)
  65       resolution = LOW_RESOLUTION;
  66     else
  67       resolution = NON_IDEAL_RESOLUTION;
  68
  69     required_for_activation =
  70         active.required_for_activation || pending.required_for_activation;
  71
  72     if (active.priority_bin < pending.priority_bin) {
  73       priority_bin = active.priority_bin;
  74       distance_to_visible = active.distance_to_visible;
  75     } else if (active.priority_bin > pending.priority_bin) {
  76       priority_bin = pending.priority_bin;
  77       distance_to_visible = pending.distance_to_visible;
  78     } else {
  79       priority_bin = active.priority_bin;
  80       distance_to_visible =
  81           std::min(active.distance_to_visible, pending.distance_to_visible);
  82     }
  83   }
  84
  85   void AsValueInto(base::debug::TracedValue* dict) const;
  86
  87   bool operator ==(const TilePriority& other) const {
  88     return resolution == other.resolution &&
  89            priority_bin == other.priority_bin &&
  90            distance_to_visible == other.distance_to_visible &&
  91            required_for_activation == other.required_for_activation;
  92   }
  93
  94   bool operator !=(const TilePriority& other) const {
  95     return !(*this == other);
  96   }
  97
  98   bool IsHigherPriorityThan(const TilePriority& other) const {
  99     return priority_bin < other.priority_bin ||
 100            (priority_bin == other.priority_bin &&
 101             distance_to_visible < other.distance_to_visible);
 102   }
 103
 104   TileResolution resolution;
 105   bool required_for_activation;
 106   PriorityBin priority_bin;
 107   float distance_to_visible;
 108 };
 109
 110 std::string TilePriorityBinToString(TilePriority::PriorityBin bin);
 111
 112 enum TileMemoryLimitPolicy {
 113   // Nothing.
 114   ALLOW_NOTHING = 0,
 115
 116   // You might be made visible, but you're not being interacted with.
 117   ALLOW_ABSOLUTE_MINIMUM = 1,  // Tall.
 118
 119   // You're being interacted with, but we're low on memory.
 120   ALLOW_PREPAINT_ONLY = 2,  // Grande.
 121
 122   // You're the only thing in town. Go crazy.
 123   ALLOW_ANYTHING = 3,  // Venti.
 124
 125   NUM_TILE_MEMORY_LIMIT_POLICIES = 4,
 126
 127   // NOTE: Be sure to update TreePriorityAsValue and kBinPolicyMap when adding
 128   // or reordering fields.
 129 };
 130 std::string TileMemoryLimitPolicyToString(TileMemoryLimitPolicy policy);
 131
 132 enum TreePriority {
 133   SAME_PRIORITY_FOR_BOTH_TREES,
 134   SMOOTHNESS_TAKES_PRIORITY,
 135   NEW_CONTENT_TAKES_PRIORITY,
 136   NUM_TREE_PRIORITIES
 137   // Be sure to update TreePriorityAsValue when adding new fields.
 138 };
 139 std::string TreePriorityToString(TreePriority prio);
 140
 141 class GlobalStateThatImpactsTilePriority {
 142  public:
 143   GlobalStateThatImpactsTilePriority()
 144       : memory_limit_policy(ALLOW_NOTHING),
 145         soft_memory_limit_in_bytes(0),
 146         hard_memory_limit_in_bytes(0),
 147         num_resources_limit(0),
 148         tree_priority(SAME_PRIORITY_FOR_BOTH_TREES) {}
 149
 150   TileMemoryLimitPolicy memory_limit_policy;
 151
 152   size_t soft_memory_limit_in_bytes;
 153   size_t hard_memory_limit_in_bytes;
 154   size_t num_resources_limit;
 155
 156   TreePriority tree_priority;
 157
 158   bool operator==(const GlobalStateThatImpactsTilePriority& other) const {
 159     return memory_limit_policy == other.memory_limit_policy &&
 160            soft_memory_limit_in_bytes == other.soft_memory_limit_in_bytes &&
 161            hard_memory_limit_in_bytes == other.hard_memory_limit_in_bytes &&
 162            num_resources_limit == other.num_resources_limit &&
 163            tree_priority == other.tree_priority;
 164   }
 165   bool operator!=(const GlobalStateThatImpactsTilePriority& other) const {
 166     return !(*this == other);
 167   }
 168
 169   void AsValueInto(base::debug::TracedValue* dict) const;
 170 };
 171
 172 }  // namespace cc
 173
 174 #endif  // CC_RESOURCES_TILE_PRIORITY_H_