| OLD | NEW |
| (Empty) |
| 1 // Copyright 2014 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_TILING_SET_RASTER_QUEUE_ALL_H_ | |
| 6 #define CC_RESOURCES_TILING_SET_RASTER_QUEUE_ALL_H_ | |
| 7 | |
| 8 #include "base/containers/stack_container.h" | |
| 9 #include "cc/base/cc_export.h" | |
| 10 #include "cc/resources/picture_layer_tiling_set.h" | |
| 11 #include "cc/resources/prioritized_tile.h" | |
| 12 #include "cc/resources/tile.h" | |
| 13 #include "cc/resources/tile_priority.h" | |
| 14 | |
| 15 namespace cc { | |
| 16 | |
| 17 // This queue returns all tiles required to be rasterized from HIGH_RESOLUTION | |
| 18 // and LOW_RESOLUTION tilings. | |
| 19 class CC_EXPORT TilingSetRasterQueueAll { | |
| 20 public: | |
| 21 TilingSetRasterQueueAll(PictureLayerTilingSet* tiling_set, | |
| 22 bool prioritize_low_res); | |
| 23 ~TilingSetRasterQueueAll(); | |
| 24 | |
| 25 const PrioritizedTile& Top() const; | |
| 26 void Pop(); | |
| 27 bool IsEmpty() const; | |
| 28 | |
| 29 private: | |
| 30 // Helper base class for individual region iterators. | |
| 31 class OnePriorityRectIterator { | |
| 32 public: | |
| 33 OnePriorityRectIterator(); | |
| 34 OnePriorityRectIterator( | |
| 35 PictureLayerTiling* tiling, | |
| 36 TilingData* tiling_data, | |
| 37 PictureLayerTiling::PriorityRectType priority_rect_type); | |
| 38 | |
| 39 bool done() const { return !current_tile_.tile(); } | |
| 40 const PrioritizedTile& operator*() const { return current_tile_; } | |
| 41 | |
| 42 protected: | |
| 43 ~OnePriorityRectIterator() = default; | |
| 44 bool TileNeedsRaster(Tile* tile) const { | |
| 45 return tile->draw_info().NeedsRaster() && !tiling_->IsTileOccluded(tile); | |
| 46 } | |
| 47 | |
| 48 template <typename TilingIteratorType> | |
| 49 void AdvanceToNextTile(TilingIteratorType* iterator); | |
| 50 template <typename TilingIteratorType> | |
| 51 bool GetFirstTileAndCheckIfValid(TilingIteratorType* iterator); | |
| 52 | |
| 53 PrioritizedTile current_tile_; | |
| 54 PictureLayerTiling* tiling_; | |
| 55 TilingData* tiling_data_; | |
| 56 PictureLayerTiling::PriorityRectType priority_rect_type_; | |
| 57 }; | |
| 58 | |
| 59 // Iterates over visible rect only, left to right top to bottom order. | |
| 60 class VisibleTilingIterator : public OnePriorityRectIterator { | |
| 61 public: | |
| 62 VisibleTilingIterator() = default; | |
| 63 VisibleTilingIterator(PictureLayerTiling* tiling, TilingData* tiling_data); | |
| 64 | |
| 65 VisibleTilingIterator& operator++(); | |
| 66 | |
| 67 private: | |
| 68 TilingData::Iterator iterator_; | |
| 69 }; | |
| 70 | |
| 71 class PendingVisibleTilingIterator : public OnePriorityRectIterator { | |
| 72 public: | |
| 73 PendingVisibleTilingIterator() = default; | |
| 74 PendingVisibleTilingIterator(PictureLayerTiling* tiling, | |
| 75 TilingData* tiling_data); | |
| 76 | |
| 77 PendingVisibleTilingIterator& operator++(); | |
| 78 | |
| 79 private: | |
| 80 TilingData::DifferenceIterator iterator_; | |
| 81 }; | |
| 82 | |
| 83 // Iterates over skewport only, spiral around the visible rect. | |
| 84 class SkewportTilingIterator : public OnePriorityRectIterator { | |
| 85 public: | |
| 86 SkewportTilingIterator() = default; | |
| 87 SkewportTilingIterator(PictureLayerTiling* tiling, TilingData* tiling_data); | |
| 88 | |
| 89 SkewportTilingIterator& operator++(); | |
| 90 | |
| 91 private: | |
| 92 TilingData::SpiralDifferenceIterator iterator_; | |
| 93 gfx::Rect pending_visible_rect_; | |
| 94 }; | |
| 95 | |
| 96 // Iterates over soon border only, spiral around the visible rect. | |
| 97 class SoonBorderTilingIterator : public OnePriorityRectIterator { | |
| 98 public: | |
| 99 SoonBorderTilingIterator() = default; | |
| 100 SoonBorderTilingIterator(PictureLayerTiling* tiling, | |
| 101 TilingData* tiling_data); | |
| 102 | |
| 103 SoonBorderTilingIterator& operator++(); | |
| 104 | |
| 105 private: | |
| 106 TilingData::SpiralDifferenceIterator iterator_; | |
| 107 gfx::Rect pending_visible_rect_; | |
| 108 }; | |
| 109 | |
| 110 // Iterates over eventually rect only, spiral around the soon rect. | |
| 111 class EventuallyTilingIterator : public OnePriorityRectIterator { | |
| 112 public: | |
| 113 EventuallyTilingIterator() = default; | |
| 114 EventuallyTilingIterator(PictureLayerTiling* tiling, | |
| 115 TilingData* tiling_data); | |
| 116 | |
| 117 EventuallyTilingIterator& operator++(); | |
| 118 | |
| 119 private: | |
| 120 TilingData::SpiralDifferenceIterator iterator_; | |
| 121 gfx::Rect pending_visible_rect_; | |
| 122 }; | |
| 123 | |
| 124 // Iterates over all of the above phases in the following order: visible, | |
| 125 // skewport, soon border, eventually. | |
| 126 class TilingIterator { | |
| 127 public: | |
| 128 TilingIterator(); | |
| 129 explicit TilingIterator(PictureLayerTiling* tiling, | |
| 130 TilingData* tiling_data); | |
| 131 ~TilingIterator(); | |
| 132 | |
| 133 bool done() const { return !current_tile_.tile(); } | |
| 134 const PrioritizedTile& operator*() const { return current_tile_; } | |
| 135 TilePriority::PriorityBin type() const { | |
| 136 switch (phase_) { | |
| 137 case Phase::VISIBLE_RECT: | |
| 138 return TilePriority::NOW; | |
| 139 case Phase::PENDING_VISIBLE_RECT: | |
| 140 case Phase::SKEWPORT_RECT: | |
| 141 case Phase::SOON_BORDER_RECT: | |
| 142 return TilePriority::SOON; | |
| 143 case Phase::EVENTUALLY_RECT: | |
| 144 return TilePriority::EVENTUALLY; | |
| 145 } | |
| 146 NOTREACHED(); | |
| 147 return TilePriority::EVENTUALLY; | |
| 148 } | |
| 149 | |
| 150 TilingIterator& operator++(); | |
| 151 | |
| 152 private: | |
| 153 using Phase = PictureLayerTiling::PriorityRectType; | |
| 154 | |
| 155 void AdvancePhase(); | |
| 156 | |
| 157 PictureLayerTiling* tiling_; | |
| 158 TilingData* tiling_data_; | |
| 159 | |
| 160 Phase phase_; | |
| 161 | |
| 162 PrioritizedTile current_tile_; | |
| 163 VisibleTilingIterator visible_iterator_; | |
| 164 PendingVisibleTilingIterator pending_visible_iterator_; | |
| 165 SkewportTilingIterator skewport_iterator_; | |
| 166 SoonBorderTilingIterator soon_border_iterator_; | |
| 167 EventuallyTilingIterator eventually_iterator_; | |
| 168 }; | |
| 169 | |
| 170 enum IteratorType { | |
| 171 LOW_RES, | |
| 172 HIGH_RES, | |
| 173 ACTIVE_NON_IDEAL_PENDING_HIGH_RES, | |
| 174 NUM_ITERATORS | |
| 175 }; | |
| 176 | |
| 177 void AdvanceToNextStage(); | |
| 178 | |
| 179 PictureLayerTilingSet* tiling_set_; | |
| 180 | |
| 181 struct IterationStage { | |
| 182 IterationStage(IteratorType type, TilePriority::PriorityBin bin); | |
| 183 IteratorType iterator_type; | |
| 184 TilePriority::PriorityBin tile_type; | |
| 185 }; | |
| 186 | |
| 187 size_t current_stage_; | |
| 188 | |
| 189 // The max number of stages is 6: 1 low res, 3 high res, and 2 active non | |
| 190 // ideal pending high res. | |
| 191 base::StackVector<IterationStage, 6> stages_; | |
| 192 TilingIterator iterators_[NUM_ITERATORS]; | |
| 193 | |
| 194 DISALLOW_COPY_AND_ASSIGN(TilingSetRasterQueueAll); | |
| 195 }; | |
| 196 | |
| 197 } // namespace cc | |
| 198 | |
| 199 #endif // CC_RESOURCES_TILING_SET_RASTER_QUEUE_ALL_H_ | |
| OLD | NEW |