cc/resources/tile.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_H_
   6 #define CC_RESOURCES_TILE_H_
   7
   8 #include "base/memory/ref_counted.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/memory/scoped_vector.h"
  11 #include "cc/base/ref_counted_managed.h"
  12 #include "cc/resources/managed_tile_state.h"
  13 #include "cc/resources/picture_pile_impl.h"
  14 #include "cc/resources/raster_mode.h"
  15 #include "cc/resources/tile_priority.h"
  16 #include "ui/gfx/rect.h"
  17 #include "ui/gfx/size.h"
  18
  19 namespace cc {
  20
  21 class CC_EXPORT Tile : public RefCountedManaged<Tile> {
  22  public:
  23   enum TileRasterFlags { USE_PICTURE_ANALYSIS = 1 << 0 };
  24
  25   typedef uint64 Id;
  26
  27   Id id() const {
  28     return id_;
  29   }
  30
  31   PicturePileImpl* picture_pile() {
  32     return picture_pile_.get();
  33   }
  34
  35   const PicturePileImpl* picture_pile() const {
  36     return picture_pile_.get();
  37   }
  38
  39   const TilePriority& priority(WhichTree tree) const {
  40     return priority_[tree];
  41   }
  42
  43   TilePriority priority_for_tree_priority(TreePriority tree_priority) const {
  44     switch (tree_priority) {
  45       case SMOOTHNESS_TAKES_PRIORITY:
  46         return priority_[ACTIVE_TREE];
  47       case NEW_CONTENT_TAKES_PRIORITY:
  48         return priority_[PENDING_TREE];
  49       case SAME_PRIORITY_FOR_BOTH_TREES:
  50         return combined_priority();
  51       default:
  52         NOTREACHED();
  53         return TilePriority();
  54     }
  55   }
  56
  57   TilePriority combined_priority() const {
  58     return TilePriority(priority_[ACTIVE_TREE],
  59                         priority_[PENDING_TREE]);
  60   }
  61
  62   void SetPriority(WhichTree tree, const TilePriority& priority);
  63
  64   void set_is_occluded(WhichTree tree, bool is_occluded) {
  65     is_occluded_[tree] = is_occluded;
  66   }
  67
  68   bool is_occluded(WhichTree tree) const { return is_occluded_[tree]; }
  69
  70   void set_shared(bool is_shared) { is_shared_ = is_shared; }
  71   bool is_shared() const { return is_shared_; }
  72
  73   bool is_occluded_for_tree_priority(TreePriority tree_priority) const {
  74     switch (tree_priority) {
  75       case SMOOTHNESS_TAKES_PRIORITY:
  76         return is_occluded_[ACTIVE_TREE];
  77       case NEW_CONTENT_TAKES_PRIORITY:
  78         return is_occluded_[PENDING_TREE];
  79       case SAME_PRIORITY_FOR_BOTH_TREES:
  80         return is_occluded_[ACTIVE_TREE] && is_occluded_[PENDING_TREE];
  81       default:
  82         NOTREACHED();
  83         return false;
  84     }
  85   }
  86
  87   void MarkRequiredForActivation();
  88
  89   bool required_for_activation() const {
  90     return priority_[PENDING_TREE].required_for_activation;
  91   }
  92
  93   bool use_picture_analysis() const {
  94     return !!(flags_ & USE_PICTURE_ANALYSIS);
  95   }
  96
  97   bool NeedsRasterForMode(RasterMode mode) const {
  98     return !managed_state_.tile_versions[mode].IsReadyToDraw();
  99   }
 100
 101   bool HasResources() const {
 102     for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
 103       if (managed_state_.tile_versions[mode].has_resource())
 104         return true;
 105     }
 106     return false;
 107   }
 108
 109   void AsValueInto(base::debug::TracedValue* dict) const;
 110
 111   inline bool IsReadyToDraw() const {
 112     for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
 113       if (managed_state_.tile_versions[mode].IsReadyToDraw())
 114         return true;
 115     }
 116     return false;
 117   }
 118
 119   const ManagedTileState::TileVersion& GetTileVersionForDrawing() const {
 120     for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
 121       if (managed_state_.tile_versions[mode].IsReadyToDraw())
 122         return managed_state_.tile_versions[mode];
 123     }
 124     return managed_state_.tile_versions[HIGH_QUALITY_RASTER_MODE];
 125   }
 126
 127   gfx::Rect opaque_rect() const { return opaque_rect_; }
 128   float contents_scale() const { return contents_scale_; }
 129   gfx::Rect content_rect() const { return content_rect_; }
 130
 131   int layer_id() const { return layer_id_; }
 132
 133   int source_frame_number() const { return source_frame_number_; }
 134
 135   void set_picture_pile(scoped_refptr<PicturePileImpl> pile) {
 136     DCHECK(pile->CanRaster(contents_scale_, content_rect_))
 137         << gfx::ScaleToEnclosingRect(content_rect_, 1.f / contents_scale_)
 138                .ToString();
 139     picture_pile_ = pile;
 140   }
 141
 142   size_t GPUMemoryUsageInBytes() const;
 143
 144   gfx::Size size() const { return size_; }
 145
 146   RasterMode DetermineRasterModeForTree(WhichTree tree) const;
 147   RasterMode DetermineOverallRasterMode() const;
 148
 149   // Functionality used in tests.
 150   RasterMode GetRasterModeForTesting() const {
 151     return managed_state().raster_mode;
 152   }
 153   ManagedTileState::TileVersion& GetTileVersionForTesting(RasterMode mode) {
 154     return managed_state_.tile_versions[mode];
 155   }
 156
 157  private:
 158   friend class TileManager;
 159   friend class PrioritizedTileSet;
 160   friend class FakeTileManager;
 161   friend class BinComparator;
 162   friend class FakePictureLayerImpl;
 163
 164   // Methods called by by tile manager.
 165   Tile(TileManager* tile_manager,
 166        PicturePileImpl* picture_pile,
 167        const gfx::Size& tile_size,
 168        const gfx::Rect& content_rect,
 169        const gfx::Rect& opaque_rect,
 170        float contents_scale,
 171        int layer_id,
 172        int source_frame_number,
 173        int flags);
 174   ~Tile();
 175
 176   ManagedTileState& managed_state() { return managed_state_; }
 177   const ManagedTileState& managed_state() const { return managed_state_; }
 178   RasterMode DetermineRasterModeForResolution(TileResolution resolution) const;
 179
 180   bool HasRasterTask() const;
 181
 182   TileManager* tile_manager_;
 183   scoped_refptr<PicturePileImpl> picture_pile_;
 184   gfx::Size size_;
 185   gfx::Rect content_rect_;
 186   float contents_scale_;
 187   gfx::Rect opaque_rect_;
 188   bool is_occluded_[NUM_TREES];
 189
 190   TilePriority priority_[NUM_TREES];
 191   ManagedTileState managed_state_;
 192   int layer_id_;
 193   int source_frame_number_;
 194   int flags_;
 195   bool is_shared_;
 196
 197   Id id_;
 198   static Id s_next_id_;
 199
 200   DISALLOW_COPY_AND_ASSIGN(Tile);
 201 };
 202
 203 }  // namespace cc
 204
 205 #endif  // CC_RESOURCES_TILE_H_