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 #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. This mode is used when visible is set to false.
    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   NUM_TILE_MEMORY_LIMIT_POLICIES = 4,
    125 
    126   // NOTE: Be sure to update TreePriorityAsValue and kBinPolicyMap when adding
    127   // or reordering fields.
    128 };
    129 std::string TileMemoryLimitPolicyToString(TileMemoryLimitPolicy policy);
    130 
    131 enum TreePriority {
    132   SAME_PRIORITY_FOR_BOTH_TREES,
    133   SMOOTHNESS_TAKES_PRIORITY,
    134   NEW_CONTENT_TAKES_PRIORITY,
    135   NUM_TREE_PRIORITIES
    136   // Be sure to update TreePriorityAsValue when adding new fields.
    137 };
    138 std::string TreePriorityToString(TreePriority prio);
    139 
    140 class GlobalStateThatImpactsTilePriority {
    141  public:
    142   GlobalStateThatImpactsTilePriority()
    143       : memory_limit_policy(ALLOW_NOTHING),
    144         soft_memory_limit_in_bytes(0),
    145         hard_memory_limit_in_bytes(0),
    146         num_resources_limit(0),
    147         tree_priority(SAME_PRIORITY_FOR_BOTH_TREES) {}
    148 
    149   TileMemoryLimitPolicy memory_limit_policy;
    150 
    151   size_t soft_memory_limit_in_bytes;
    152   size_t hard_memory_limit_in_bytes;
    153   size_t num_resources_limit;
    154 
    155   TreePriority tree_priority;
    156 
    157   bool operator==(const GlobalStateThatImpactsTilePriority& other) const {
    158     return memory_limit_policy == other.memory_limit_policy &&
    159            soft_memory_limit_in_bytes == other.soft_memory_limit_in_bytes &&
    160            hard_memory_limit_in_bytes == other.hard_memory_limit_in_bytes &&
    161            num_resources_limit == other.num_resources_limit &&
    162            tree_priority == other.tree_priority;
    163   }
    164   bool operator!=(const GlobalStateThatImpactsTilePriority& other) const {
    165     return !(*this == other);
    166   }
    167 
    168   void AsValueInto(base::debug::TracedValue* dict) const;
    169 };
    170 
    171 }  // namespace cc
    172 
    173 #endif  // CC_RESOURCES_TILE_PRIORITY_H_
    174