src/cc/layers/picture_layer_impl.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_LAYERS_PICTURE_LAYER_IMPL_H_
   6 #define CC_LAYERS_PICTURE_LAYER_IMPL_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "cc/base/cc_export.h"
  12 #include "cc/base/scoped_ptr_vector.h"
  13 #include "cc/layers/layer_impl.h"
  14 #include "cc/resources/picture_layer_tiling.h"
  15 #include "cc/resources/picture_layer_tiling_set.h"
  16 #include "cc/resources/picture_pile_impl.h"
  17 #include "skia/ext/refptr.h"
  18 #include "third_party/skia/include/core/SkPicture.h"
  19
  20 namespace cc {
  21
  22 struct AppendQuadsData;
  23 class MicroBenchmarkImpl;
  24 class Tile;
  25
  26 class CC_EXPORT PictureLayerImpl
  27     : public LayerImpl,
  28       NON_EXPORTED_BASE(public PictureLayerTilingClient) {
  29  public:
  30   struct CC_EXPORT Pair {
  31     Pair();
  32     Pair(PictureLayerImpl* active_layer, PictureLayerImpl* pending_layer);
  33     ~Pair();
  34
  35     PictureLayerImpl* active;
  36     PictureLayerImpl* pending;
  37   };
  38
  39   class CC_EXPORT LayerRasterTileIterator {
  40    public:
  41     LayerRasterTileIterator();
  42     LayerRasterTileIterator(PictureLayerImpl* layer, bool prioritize_low_res);
  43     ~LayerRasterTileIterator();
  44
  45     Tile* operator*();
  46     const Tile* operator*() const;
  47     LayerRasterTileIterator& operator++();
  48     operator bool() const;
  49
  50    private:
  51     enum IteratorType { LOW_RES, HIGH_RES, NUM_ITERATORS };
  52
  53     PictureLayerImpl* layer_;
  54
  55     struct IterationStage {
  56       IteratorType iterator_type;
  57       TilePriority::PriorityBin tile_type;
  58     };
  59
  60     size_t current_stage_;
  61
  62     // One low res stage, and three high res stages.
  63     IterationStage stages_[4];
  64     PictureLayerTiling::TilingRasterTileIterator iterators_[NUM_ITERATORS];
  65   };
  66
  67   class CC_EXPORT LayerEvictionTileIterator {
  68    public:
  69     LayerEvictionTileIterator();
  70     LayerEvictionTileIterator(PictureLayerImpl* layer,
  71                               TreePriority tree_priority);
  72     ~LayerEvictionTileIterator();
  73
  74     Tile* operator*();
  75     const Tile* operator*() const;
  76     LayerEvictionTileIterator& operator++();
  77     operator bool() const;
  78
  79    private:
  80     bool AdvanceToNextCategory();
  81     bool AdvanceToNextTilingRangeType();
  82     bool AdvanceToNextTiling();
  83
  84     PictureLayerTilingSet::TilingRange CurrentTilingRange() const;
  85     size_t CurrentTilingIndex() const;
  86
  87     PictureLayerImpl* layer_;
  88     TreePriority tree_priority_;
  89
  90     PictureLayerTiling::EvictionCategory current_category_;
  91     PictureLayerTilingSet::TilingRangeType current_tiling_range_type_;
  92     size_t current_tiling_;
  93     PictureLayerTiling::TilingEvictionTileIterator current_iterator_;
  94   };
  95
  96   static scoped_ptr<PictureLayerImpl> Create(LayerTreeImpl* tree_impl, int id) {
  97     return make_scoped_ptr(new PictureLayerImpl(tree_impl, id));
  98   }
  99   virtual ~PictureLayerImpl();
 100
 101   // LayerImpl overrides.
 102   virtual const char* LayerTypeAsString() const OVERRIDE;
 103   virtual scoped_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl)
 104       OVERRIDE;
 105   virtual void PushPropertiesTo(LayerImpl* layer) OVERRIDE;
 106   virtual void AppendQuads(RenderPass* render_pass,
 107                            const OcclusionTracker<LayerImpl>& occlusion_tracker,
 108                            AppendQuadsData* append_quads_data) OVERRIDE;
 109   virtual void UpdateTiles(
 110       const OcclusionTracker<LayerImpl>* occlusion_tracker) OVERRIDE;
 111   virtual void NotifyTileStateChanged(const Tile* tile) OVERRIDE;
 112   virtual void DidBecomeActive() OVERRIDE;
 113   virtual void DidBeginTracing() OVERRIDE;
 114   virtual void ReleaseResources() OVERRIDE;
 115   virtual skia::RefPtr<SkPicture> GetPicture() OVERRIDE;
 116
 117   // PictureLayerTilingClient overrides.
 118   virtual scoped_refptr<Tile> CreateTile(
 119     PictureLayerTiling* tiling,
 120     const gfx::Rect& content_rect) OVERRIDE;
 121   virtual PicturePileImpl* GetPile() OVERRIDE;
 122   virtual gfx::Size CalculateTileSize(
 123       const gfx::Size& content_bounds) const OVERRIDE;
 124   virtual const Region* GetInvalidation() OVERRIDE;
 125   virtual const PictureLayerTiling* GetTwinTiling(
 126       const PictureLayerTiling* tiling) const OVERRIDE;
 127   virtual size_t GetMaxTilesForInterestArea() const OVERRIDE;
 128   virtual float GetSkewportTargetTimeInSeconds() const OVERRIDE;
 129   virtual int GetSkewportExtrapolationLimitInContentPixels() const OVERRIDE;
 130   virtual WhichTree GetTree() const OVERRIDE;
 131
 132   // PushPropertiesTo active tree => pending tree.
 133   void SyncTiling(const PictureLayerTiling* tiling);
 134
 135   // Mask-related functions
 136   void SetIsMask(bool is_mask);
 137   virtual ResourceProvider::ResourceId ContentsResourceId() const OVERRIDE;
 138
 139   virtual size_t GPUMemoryUsageInBytes() const OVERRIDE;
 140
 141   virtual void RunMicroBenchmark(MicroBenchmarkImpl* benchmark) OVERRIDE;
 142
 143   // Functions used by tile manager.
 144   PictureLayerImpl* GetTwinLayer() { return twin_layer_; }
 145   bool IsOnActiveOrPendingTree() const;
 146   // Virtual for testing.
 147   virtual bool HasValidTilePriorities() const;
 148   bool AllTilesRequiredForActivationAreReadyToDraw() const;
 149
 150  protected:
 151   friend class LayerRasterTileIterator;
 152
 153   PictureLayerImpl(LayerTreeImpl* tree_impl, int id);
 154   PictureLayerTiling* AddTiling(float contents_scale);
 155   void RemoveTiling(float contents_scale);
 156   void RemoveAllTilings();
 157   void SyncFromActiveLayer(const PictureLayerImpl* other);
 158   void AddTilingsForRasterScale();
 159   void UpdateTilePriorities(
 160       const OcclusionTracker<LayerImpl>* occlusion_tracker);
 161   virtual bool ShouldAdjustRasterScale() const;
 162   virtual void RecalculateRasterScales();
 163   void CleanUpTilingsOnActiveLayer(
 164       std::vector<PictureLayerTiling*> used_tilings);
 165   float MinimumContentsScale() const;
 166   float SnappedContentsScale(float new_contents_scale);
 167   void ResetRasterScale();
 168   void MarkVisibleResourcesAsRequired() const;
 169   bool MarkVisibleTilesAsRequired(
 170       PictureLayerTiling* tiling,
 171       const PictureLayerTiling* optional_twin_tiling,
 172       float contents_scale,
 173       const gfx::Rect& rect,
 174       const Region& missing_region) const;
 175
 176   void DoPostCommitInitializationIfNeeded() {
 177     if (needs_post_commit_initialization_)
 178       DoPostCommitInitialization();
 179   }
 180   void DoPostCommitInitialization();
 181
 182   bool CanHaveTilings() const;
 183   bool CanHaveTilingWithScale(float contents_scale) const;
 184   void SanityCheckTilingState() const;
 185
 186   virtual void GetDebugBorderProperties(
 187       SkColor* color, float* width) const OVERRIDE;
 188   virtual void AsValueInto(base::debug::TracedValue* dict) const OVERRIDE;
 189
 190   virtual void UpdateIdealScales();
 191   float MaximumTilingContentsScale() const;
 192
 193   PictureLayerImpl* twin_layer_;
 194
 195   scoped_ptr<PictureLayerTilingSet> tilings_;
 196   scoped_refptr<PicturePileImpl> pile_;
 197   Region invalidation_;
 198
 199   bool is_mask_;
 200
 201   float ideal_page_scale_;
 202   float ideal_device_scale_;
 203   float ideal_source_scale_;
 204   float ideal_contents_scale_;
 205
 206   float raster_page_scale_;
 207   float raster_device_scale_;
 208   float raster_source_scale_;
 209   float raster_contents_scale_;
 210   float low_res_raster_contents_scale_;
 211
 212   bool raster_source_scale_is_fixed_;
 213   bool was_screen_space_transform_animating_;
 214   bool needs_post_commit_initialization_;
 215   // A sanity state check to make sure UpdateTilePriorities only gets called
 216   // after a CalculateContentsScale/ManageTilings.
 217   bool should_update_tile_priorities_;
 218
 219   // Save a copy of the visible rect and viewport size of the last frame that
 220   // has a valid viewport for prioritizing tiles.
 221   gfx::Rect visible_rect_for_tile_priority_;
 222   gfx::Rect viewport_rect_for_tile_priority_;
 223   gfx::Transform screen_space_transform_for_tile_priority_;
 224
 225   friend class PictureLayer;
 226   DISALLOW_COPY_AND_ASSIGN(PictureLayerImpl);
 227 };
 228
 229 }  // namespace cc
 230
 231 #endif  // CC_LAYERS_PICTURE_LAYER_IMPL_H_