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