Home | History | Annotate | Download | only in resources 
      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_
    177