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