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_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     priority_[tree] = priority;
     58   }
     59 
     60   void mark_required_for_activation() {
     61     priority_[PENDING_TREE].required_for_activation = true;
     62   }
     63 
     64   bool required_for_activation() const {
     65     return priority_[PENDING_TREE].required_for_activation;
     66   }
     67 
     68   void set_can_use_lcd_text(bool can_use_lcd_text) {
     69     can_use_lcd_text_ = can_use_lcd_text;
     70   }
     71 
     72   bool can_use_lcd_text() const {
     73     return can_use_lcd_text_;
     74   }
     75 
     76   scoped_ptr<base::Value> AsValue() const;
     77 
     78   bool IsReadyToDraw() const {
     79     for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
     80       if (managed_state_.tile_versions[mode].IsReadyToDraw())
     81         return true;
     82     }
     83     return false;
     84   }
     85 
     86   const ManagedTileState::TileVersion& GetTileVersionForDrawing() const {
     87     for (int mode = 0; mode < NUM_RASTER_MODES; ++mode) {
     88       if (managed_state_.tile_versions[mode].IsReadyToDraw())
     89         return managed_state_.tile_versions[mode];
     90     }
     91     return managed_state_.tile_versions[HIGH_QUALITY_RASTER_MODE];
     92   }
     93 
     94   gfx::Rect opaque_rect() const { return opaque_rect_; }
     95   bool has_text(RasterMode mode) const {
     96     return managed_state_.tile_versions[mode].has_text_;
     97   }
     98 
     99   float contents_scale() const { return contents_scale_; }
    100   gfx::Rect content_rect() const { return content_rect_; }
    101 
    102   int layer_id() const { return layer_id_; }
    103 
    104   int source_frame_number() const { return source_frame_number_; }
    105 
    106   void set_picture_pile(scoped_refptr<PicturePileImpl> pile) {
    107     DCHECK(pile->CanRaster(contents_scale_, content_rect_));
    108     picture_pile_ = pile;
    109   }
    110 
    111   size_t GPUMemoryUsageInBytes() const;
    112 
    113   RasterMode GetRasterModeForTesting() const {
    114     return managed_state().raster_mode;
    115   }
    116   ManagedTileState::TileVersion& GetTileVersionForTesting(RasterMode mode) {
    117     return managed_state_.tile_versions[mode];
    118   }
    119 
    120  private:
    121   // Methods called by by tile manager.
    122   friend class TileManager;
    123   friend class PrioritizedTileSet;
    124   friend class FakeTileManager;
    125   friend class BinComparator;
    126   ManagedTileState& managed_state() { return managed_state_; }
    127   const ManagedTileState& managed_state() const { return managed_state_; }
    128 
    129   inline size_t bytes_consumed_if_allocated() const {
    130     return 4 * tile_size_.width() * tile_size_.height();
    131   }
    132 
    133   // Normal private methods.
    134   friend class base::RefCounted<Tile>;
    135   ~Tile();
    136 
    137   TileManager* tile_manager_;
    138   scoped_refptr<PicturePileImpl> picture_pile_;
    139   gfx::Rect tile_size_;
    140   gfx::Rect content_rect_;
    141   float contents_scale_;
    142   gfx::Rect opaque_rect_;
    143 
    144   TilePriority priority_[NUM_BIN_PRIORITIES];
    145   ManagedTileState managed_state_;
    146   int layer_id_;
    147   int source_frame_number_;
    148   bool can_use_lcd_text_;
    149 
    150   Id id_;
    151   static Id s_next_id_;
    152 
    153   DISALLOW_COPY_AND_ASSIGN(Tile);
    154 };
    155 
    156 }  // namespace cc
    157 
    158 #endif  // CC_RESOURCES_TILE_H_
    159