cc/tiles/tiling_set_raster_queue_required.cc

   1 // Copyright 2014 The Chromium Authors
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/tiles/tiling_set_raster_queue_required.h"
   6
   7 #include <stddef.h>
   8
   9 #include <utility>
  10
  11 #include "cc/tiles/picture_layer_tiling_set.h"
  12 #include "cc/tiles/tile.h"
  13 #include "cc/tiles/tile_priority.h"
  14
  15 namespace cc {
  16
  17 TilingSetRasterQueueRequired::TilingSetRasterQueueRequired(
  18     PictureLayerTilingSet* tiling_set,
  19     RasterTilePriorityQueue::Type type)
  20     : type_(type) {
  21   DCHECK_NE(static_cast<int>(type),
  22             static_cast<int>(RasterTilePriorityQueue::Type::ALL));
  23
  24   // Required tiles should only come from HIGH_RESOLUTION tilings. However, if
  25   // we want required for activation tiles on the active tree, then it will come
  26   // from tilings whose pending twin is high resolution.
  27   PictureLayerTiling* tiling = nullptr;
  28   if (type == RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION &&
  29       tiling_set->tree() == ACTIVE_TREE) {
  30     for (size_t i = 0; i < tiling_set->num_tilings(); ++i) {
  31       PictureLayerTiling* active_tiling = tiling_set->tiling_at(i);
  32       const PictureLayerTiling* pending_twin =
  33           tiling_set->client()->GetPendingOrActiveTwinTiling(active_tiling);
  34       if (pending_twin && pending_twin->resolution() == HIGH_RESOLUTION) {
  35         tiling = active_tiling;
  36         break;
  37       }
  38     }
  39   } else {
  40     tiling = tiling_set->FindTilingWithResolution(HIGH_RESOLUTION);
  41   }
  42
  43   // If we don't have a tiling, then this queue will yield no tiles. See
  44   // PictureLayerImpl::CanHaveTilings for examples of when a HIGH_RESOLUTION
  45   // tiling would not be generated.
  46   if (!tiling || tiling->all_tiles_done())
  47     return;
  48
  49   if (type == RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION) {
  50     iterator_ = TilingIterator(tiling, &tiling->tiling_data_,
  51                                tiling->pending_visible_rect());
  52   } else {
  53     iterator_ = TilingIterator(tiling, &tiling->tiling_data_,
  54                                tiling->current_visible_rect());
  55   }
  56
  57   while (!iterator_.done() && !IsTileRequired(*iterator_))
  58     ++iterator_;
  59 }
  60
  61 TilingSetRasterQueueRequired::~TilingSetRasterQueueRequired() = default;
  62
  63 bool TilingSetRasterQueueRequired::IsEmpty() const {
  64   return iterator_.done();
  65 }
  66
  67 void TilingSetRasterQueueRequired::Pop() {
  68   DCHECK(!IsEmpty());
  69   ++iterator_;
  70   while (!iterator_.done() && !IsTileRequired(*iterator_))
  71     ++iterator_;
  72 }
  73
  74 const PrioritizedTile& TilingSetRasterQueueRequired::Top() const {
  75   DCHECK(!IsEmpty());
  76   return *iterator_;
  77 }
  78
  79 bool TilingSetRasterQueueRequired::IsTileRequired(
  80     const PrioritizedTile& prioritized_tile) const {
  81   return (type_ == RasterTilePriorityQueue::Type::REQUIRED_FOR_ACTIVATION &&
  82           prioritized_tile.tile()->required_for_activation()) ||
  83          (type_ == RasterTilePriorityQueue::Type::REQUIRED_FOR_DRAW &&
  84           prioritized_tile.tile()->required_for_draw());
  85 }
  86
  87 TilingSetRasterQueueRequired::TilingIterator::TilingIterator()
  88     : tiling_(nullptr) {
  89 }
  90
  91 TilingSetRasterQueueRequired::TilingIterator::TilingIterator(
  92     PictureLayerTiling* tiling,
  93     TilingData* tiling_data,
  94     const gfx::Rect& rect)
  95     : tiling_(tiling), tiling_data_(tiling_data) {
  96   visible_iterator_ =
  97       TilingData::Iterator(tiling_data_, rect, false /* include_borders */);
  98   if (!visible_iterator_)
  99     return;
 100
 101   Tile* tile =
 102       tiling_->TileAt(visible_iterator_.index_x(), visible_iterator_.index_y());
 103   // If this is a valid tile, return it. Note that we have to use a tiling check
 104   // for occlusion, since the tile's internal state has not yet been updated.
 105   if (tile && tile->draw_info().NeedsRaster() &&
 106       !tiling_->IsTileOccluded(tile)) {
 107     current_tile_ = tiling_->MakePrioritizedTile(
 108         tile, tiling_->ComputePriorityRectTypeForTile(tile), false);
 109     return;
 110   }
 111   ++(*this);
 112 }
 113
 114 TilingSetRasterQueueRequired::TilingIterator::~TilingIterator() = default;
 115
 116 TilingSetRasterQueueRequired::TilingIterator&
 117     TilingSetRasterQueueRequired::TilingIterator::
 118     operator++() {
 119   Tile* tile = nullptr;
 120   while (true) {
 121     ++visible_iterator_;
 122     if (!visible_iterator_) {
 123       current_tile_ = PrioritizedTile();
 124       return *this;
 125     }
 126     std::pair<int, int> next_index = visible_iterator_.index();
 127     tile = tiling_->TileAt(next_index.first, next_index.second);
 128     // If the tile doesn't exist or if it exists but doesn't need raster work,
 129     // we can move on to the next tile.
 130     if (!tile || !tile->draw_info().NeedsRaster())
 131       continue;
 132
 133     // If the tile is occluded, we also can skip it. Note that we use the tiling
 134     // check for occlusion, since tile's internal state has not yet been updated
 135     // (by UpdateTilePriority). The tiling check does not rely on tile's
 136     // internal state (it is, in fact, used to determine the tile's state).
 137     if (tiling_->IsTileOccluded(tile))
 138       continue;
 139
 140     // If we get here, that means we have a valid tile that needs raster and is
 141     // in the NOW bin, which means that it can be required.
 142     break;
 143   }
 144
 145   current_tile_ = tiling_->MakePrioritizedTile(
 146       tile, tiling_->ComputePriorityRectTypeForTile(tile), false);
 147   return *this;
 148 }
 149
 150 }  // namespace cc