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   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   // Calculate the time for the |current_bounds| to intersect with the
     82   // |target_bounds| given its previous location and time delta.
     83   // This function should work for both scaling and scrolling case.
     84   static float TimeForBoundsToIntersect(const gfx::RectF& previous_bounds,
     85                                         const gfx::RectF& current_bounds,
     86                                         float time_delta,
     87                                         const gfx::RectF& target_bounds);
     88 
     89   bool operator ==(const TilePriority& other) const {
     90     return resolution == other.resolution &&
     91         time_to_visible_in_seconds == other.time_to_visible_in_seconds &&
     92         distance_to_visible_in_pixels == other.distance_to_visible_in_pixels &&
     93         required_for_activation == other.required_for_activation;
     94   }
     95 
     96   bool operator !=(const TilePriority& other) const {
     97     return !(*this == other);
     98   }
     99 
    100   TileResolution resolution;
    101   bool required_for_activation;
    102   float time_to_visible_in_seconds;
    103   float distance_to_visible_in_pixels;
    104 };
    105 
    106 enum TileMemoryLimitPolicy {
    107   // Nothing.
    108   ALLOW_NOTHING = 0,
    109 
    110   // You might be made visible, but you're not being interacted with.
    111   ALLOW_ABSOLUTE_MINIMUM = 1,  // Tall.
    112 
    113   // You're being interacted with, but we're low on memory.
    114   ALLOW_PREPAINT_ONLY = 2,  // Grande.
    115 
    116   // You're the only thing in town. Go crazy.
    117   ALLOW_ANYTHING = 3,  // Venti.
    118 
    119   NUM_TILE_MEMORY_LIMIT_POLICIES = 4,
    120 
    121   // NOTE: Be sure to update TreePriorityAsValue and kBinPolicyMap when adding
    122   // or reordering fields.
    123 };
    124 scoped_ptr<base::Value> TileMemoryLimitPolicyAsValue(
    125     TileMemoryLimitPolicy policy);
    126 
    127 enum TreePriority {
    128   SAME_PRIORITY_FOR_BOTH_TREES,
    129   SMOOTHNESS_TAKES_PRIORITY,
    130   NEW_CONTENT_TAKES_PRIORITY
    131 
    132   // Be sure to update TreePriorityAsValue when adding new fields.
    133 };
    134 scoped_ptr<base::Value> TreePriorityAsValue(TreePriority prio);
    135 
    136 class GlobalStateThatImpactsTilePriority {
    137  public:
    138   GlobalStateThatImpactsTilePriority()
    139       : memory_limit_policy(ALLOW_NOTHING),
    140         memory_limit_in_bytes(0),
    141         unused_memory_limit_in_bytes(0),
    142         num_resources_limit(0),
    143         tree_priority(SAME_PRIORITY_FOR_BOTH_TREES) {}
    144 
    145   TileMemoryLimitPolicy memory_limit_policy;
    146 
    147   size_t memory_limit_in_bytes;
    148   size_t unused_memory_limit_in_bytes;
    149   size_t num_resources_limit;
    150 
    151   TreePriority tree_priority;
    152 
    153   bool operator==(const GlobalStateThatImpactsTilePriority& other) const {
    154     return memory_limit_policy == other.memory_limit_policy
    155         && memory_limit_in_bytes == other.memory_limit_in_bytes
    156         && unused_memory_limit_in_bytes == other.unused_memory_limit_in_bytes
    157         && num_resources_limit == other.num_resources_limit
    158         && tree_priority == other.tree_priority;
    159   }
    160   bool operator!=(const GlobalStateThatImpactsTilePriority& other) const {
    161     return !(*this == other);
    162   }
    163 
    164   scoped_ptr<base::Value> AsValue() const;
    165 };
    166 
    167 }  // namespace cc
    168 
    169 #endif  // CC_RESOURCES_TILE_PRIORITY_H_
    170