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/resources/managed_tile_state.h"
  12 #include "cc/resources/raster_mode.h"
  13 #include "cc/resources/tile_priority.h"
  14 #include "ui/gfx/rect.h"
  15 #include "ui/gfx/size.h"
  16
  17 namespace cc {
  18
  19 class PicturePileImpl;
  20
  21 class CC_EXPORT Tile : public base::RefCounted<Tile> {
  22  public:
  23   typedef uint64 Id;
  24
  25   Tile(TileManager* tile_manager,
  26        PicturePileImpl* picture_pile,
  27        gfx::Size tile_size,
  28        gfx::Rect content_rect,
  29        gfx::Rect opaque_rect,
  30        float contents_scale,
  31        int layer_id,
  32        int source_frame_number,
  33        bool can_use_lcd_text);
  34
  35   Id id() const {
  36     return id_;
  37   }
  38
  39   PicturePileImpl* picture_pile() {
  40     return picture_pile_.get();
  41   }
  42
  43   const PicturePileImpl* picture_pile() const {
  44     return picture_pile_.get();
  45   }
  46
  47   const TilePriority& priority(WhichTree tree) const {
  48     return priority_[tree];
  49   }
  50
  51   TilePriority combined_priority() const {
  52     return TilePriority(priority_[ACTIVE_TREE],
  53                         priority_[PENDING_TREE]);
  54   }
  55
  56   void SetPriority(WhichTree tree, const TilePriority& priority);
  57
  58   void MarkRequiredForActivation();
  59
  60   bool required_for_activation() const {
  61     return priority_[PENDING_TREE].required_for_activation;
  62   }
  63
  64   void set_can_use_lcd_text(bool can_use_lcd_text) {
  65     can_use_lcd_text_ = can_use_lcd_text;
  66   }
  67
  68   bool can_use_lcd_text() const {
  69     return can_use_lcd_text_;
  70   }
  71
  72   scoped_ptr<base::Value> AsValue() const;
  73
  74   inline bool IsReadyToDraw() const {
  75     for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
  76       if (managed_state_.tile_versions[mode].IsReadyToDraw())
  77         return true;
  78     }
  79     return false;
  80   }
  81
  82   const ManagedTileState::TileVersion& GetTileVersionForDrawing() const {
  83     for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
  84       if (managed_state_.tile_versions[mode].IsReadyToDraw())
  85         return managed_state_.tile_versions[mode];
  86     }
  87     return managed_state_.tile_versions[HIGH_QUALITY_RASTER_MODE];
  88   }
  89
  90   gfx::Rect opaque_rect() const { return opaque_rect_; }
  91   bool has_text(RasterMode mode) const {
  92     return managed_state_.tile_versions[mode].has_text_;
  93   }
  94
  95   float contents_scale() const { return contents_scale_; }
  96   gfx::Rect content_rect() const { return content_rect_; }
  97
  98   int layer_id() const { return layer_id_; }
  99
 100   int source_frame_number() const { return source_frame_number_; }
 101
 102   void set_picture_pile(scoped_refptr<PicturePileImpl> pile) {
 103     DCHECK(pile->CanRaster(contents_scale_, content_rect_));
 104     picture_pile_ = pile;
 105   }
 106
 107   size_t GPUMemoryUsageInBytes() const;
 108
 109   RasterMode GetRasterModeForTesting() const {
 110     return managed_state().raster_mode;
 111   }
 112   ManagedTileState::TileVersion& GetTileVersionForTesting(RasterMode mode) {
 113     return managed_state_.tile_versions[mode];
 114   }
 115
 116  private:
 117   // Methods called by by tile manager.
 118   friend class TileManager;
 119   friend class PrioritizedTileSet;
 120   friend class FakeTileManager;
 121   friend class BinComparator;
 122   ManagedTileState& managed_state() { return managed_state_; }
 123   const ManagedTileState& managed_state() const { return managed_state_; }
 124
 125   inline size_t bytes_consumed_if_allocated() const {
 126     return 4 * tile_size_.width() * tile_size_.height();
 127   }
 128
 129   // Normal private methods.
 130   friend class base::RefCounted<Tile>;
 131   ~Tile();
 132
 133   TileManager* tile_manager_;
 134   scoped_refptr<PicturePileImpl> picture_pile_;
 135   gfx::Rect tile_size_;
 136   gfx::Rect content_rect_;
 137   float contents_scale_;
 138   gfx::Rect opaque_rect_;
 139
 140   TilePriority priority_[NUM_TREES];
 141   ManagedTileState managed_state_;
 142   int layer_id_;
 143   int source_frame_number_;
 144   bool can_use_lcd_text_;
 145
 146   Id id_;
 147   static Id s_next_id_;
 148
 149   DISALLOW_COPY_AND_ASSIGN(Tile);
 150 };
 151
 152 }  // namespace cc
 153
 154 #endif  // CC_RESOURCES_TILE_H_