cc: Separate the priority from the tile and put in new PrioritizedTile

cc/resources/tiling_set_raster_queue_all.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/resources/tiling_set_raster_queue_all.h"
 
 #include <utility>
 
 #include "cc/resources/picture_layer_tiling_set.h"
 #include "cc/resources/tile.h"
@@ skipping 100 matching lines @@
 
   // First advance the iterator.
   DCHECK(!iterators_[index].done());
   DCHECK(iterators_[index].type() == tile_type);
   ++iterators_[index];
 
   if (iterators_[index].done() || iterators_[index].type() != tile_type)
     AdvanceToNextStage();
 }
 
-Tile* TilingSetRasterQueueAll::Top() {
+const PrioritizedTile& TilingSetRasterQueueAll::Top() const {
   DCHECK(!IsEmpty());
 
   IteratorType index = stages_[current_stage_].iterator_type;
-  DCHECK(!iterators_[index].done());
-  DCHECK(iterators_[index].type() == stages_[current_stage_].tile_type);
-
-  return *iterators_[index];
-}
-
-const Tile* TilingSetRasterQueueAll::Top() const {
-  DCHECK(!IsEmpty());
-
-  IteratorType index = stages_[current_stage_].iterator_type;
   DCHECK(!iterators_[index].done());
   DCHECK(iterators_[index].type() == stages_[current_stage_].tile_type);
 
   return *iterators_[index];
 }
 
 void TilingSetRasterQueueAll::AdvanceToNextStage() {
   DCHECK_LT(current_stage_, stages_->size());
   ++current_stage_;
   while (current_stage_ < stages_->size()) {
     IteratorType index = stages_[current_stage_].iterator_type;
     TilePriority::PriorityBin tile_type = stages_[current_stage_].tile_type;
 
     if (!iterators_[index].done() && iterators_[index].type() == tile_type)
       break;
     ++current_stage_;
   }
 }
 
 // OnePriorityRectIterator
 TilingSetRasterQueueAll::OnePriorityRectIterator::OnePriorityRectIterator()
-    : tile_(nullptr), tiling_(nullptr), tiling_data_(nullptr) {
+    : tiling_(nullptr), tiling_data_(nullptr) {
 }
 
 TilingSetRasterQueueAll::OnePriorityRectIterator::OnePriorityRectIterator(
     PictureLayerTiling* tiling,
     TilingData* tiling_data)
-    : tile_(nullptr), tiling_(tiling), tiling_data_(tiling_data) {
+    : tiling_(tiling), tiling_data_(tiling_data) {
 }
 
 template <typename TilingIteratorType>
 void TilingSetRasterQueueAll::OnePriorityRectIterator::AdvanceToNextTile(
     TilingIteratorType* iterator) {
-  tile_ = nullptr;
-  while (!tile_ || !TileNeedsRaster(tile_)) {
+  current_tile_ = PrioritizedTile();
+  Tile* tile = nullptr;
+  while (!tile || !TileNeedsRaster(tile)) {
     ++(*iterator);
     if (!(*iterator)) {
-      tile_ = nullptr;
       return;
     }
-    tile_ = tiling_->TileAt(iterator->index_x(), iterator->index_y());
+    tile = tiling_->TileAt(iterator->index_x(), iterator->index_y());
   }
-  tiling_->UpdateTilePriority(tile_);
+  tiling_->UpdateRequiredStatesOnTile(tile);
+  current_tile_ = tiling_->MakePrioritizedTile(tile);
 }
 
 template <typename TilingIteratorType>
 bool TilingSetRasterQueueAll::OnePriorityRectIterator::
     GetFirstTileAndCheckIfValid(TilingIteratorType* iterator) {
-  tile_ = tiling_->TileAt(iterator->index_x(), iterator->index_y());
-  if (!tile_ || !TileNeedsRaster(tile_)) {
-    tile_ = nullptr;
+  Tile* tile = tiling_->TileAt(iterator->index_x(), iterator->index_y());
+  if (!tile || !TileNeedsRaster(tile)) {
+    current_tile_ = PrioritizedTile();
     return false;
   }
-  tiling_->UpdateTilePriority(tile_);
+  tiling_->UpdateRequiredStatesOnTile(tile);
+  current_tile_ = tiling_->MakePrioritizedTile(tile);
   return true;
 }
 
 // VisibleTilingIterator.
 TilingSetRasterQueueAll::VisibleTilingIterator::VisibleTilingIterator(
     PictureLayerTiling* tiling,
     TilingData* tiling_data)
     : OnePriorityRectIterator(tiling, tiling_data) {
   if (!tiling_->has_visible_rect_tiles())
     return;
@@ skipping 44 matching lines @@
     return;
   iterator_ = TilingData::SpiralDifferenceIterator(
       tiling_data_, tiling_->current_skewport_rect(),
       tiling_->current_visible_rect(), tiling_->current_visible_rect());
   if (!iterator_)
     return;
   if (!GetFirstTileAndCheckIfValid(&iterator_)) {
     ++(*this);
     return;
   }
-  if (tile_->content_rect().Intersects(pending_visible_rect_))
+  if (current_tile_.tile()->content_rect().Intersects(pending_visible_rect_))
     ++(*this);
 }
 
 TilingSetRasterQueueAll::SkewportTilingIterator&
     TilingSetRasterQueueAll::SkewportTilingIterator::
     operator++() {
   AdvanceToNextTile(&iterator_);
   while (!done()) {
-    if (!tile_->content_rect().Intersects(pending_visible_rect_))
+    if (!current_tile_.tile()->content_rect().Intersects(pending_visible_rect_))
       break;
     AdvanceToNextTile(&iterator_);
   }
   return *this;
 }
 
 // SoonBorderTilingIterator.
 TilingSetRasterQueueAll::SoonBorderTilingIterator::SoonBorderTilingIterator(
     PictureLayerTiling* tiling,
     TilingData* tiling_data)
     : OnePriorityRectIterator(tiling, tiling_data),
       pending_visible_rect_(tiling->pending_visible_rect()) {
   if (!tiling_->has_soon_border_rect_tiles())
     return;
   iterator_ = TilingData::SpiralDifferenceIterator(
       tiling_data_, tiling_->current_soon_border_rect(),
       tiling_->current_skewport_rect(), tiling_->current_visible_rect());
   if (!iterator_)
     return;
   if (!GetFirstTileAndCheckIfValid(&iterator_)) {
     ++(*this);
     return;
   }
-  if (tile_->content_rect().Intersects(pending_visible_rect_))
+  if (current_tile_.tile()->content_rect().Intersects(pending_visible_rect_))
     ++(*this);
 }
 
 TilingSetRasterQueueAll::SoonBorderTilingIterator&
     TilingSetRasterQueueAll::SoonBorderTilingIterator::
     operator++() {
   AdvanceToNextTile(&iterator_);
   while (!done()) {
-    if (!tile_->content_rect().Intersects(pending_visible_rect_))
+    if (!current_tile_.tile()->content_rect().Intersects(pending_visible_rect_))
       break;
     AdvanceToNextTile(&iterator_);
   }
   return *this;
 }
 
 // EventuallyTilingIterator.
 TilingSetRasterQueueAll::EventuallyTilingIterator::EventuallyTilingIterator(
     PictureLayerTiling* tiling,
     TilingData* tiling_data)
     : OnePriorityRectIterator(tiling, tiling_data),
       pending_visible_rect_(tiling->pending_visible_rect()) {
   if (!tiling_->has_eventually_rect_tiles())
     return;
   iterator_ = TilingData::SpiralDifferenceIterator(
       tiling_data_, tiling_->current_eventually_rect(),
       tiling_->current_skewport_rect(), tiling_->current_soon_border_rect());
   if (!iterator_)
     return;
   if (!GetFirstTileAndCheckIfValid(&iterator_)) {
     ++(*this);
     return;
   }
-  if (tile_->content_rect().Intersects(pending_visible_rect_))
+  if (current_tile_.tile()->content_rect().Intersects(pending_visible_rect_))
     ++(*this);
 }
 
 TilingSetRasterQueueAll::EventuallyTilingIterator&
     TilingSetRasterQueueAll::EventuallyTilingIterator::
     operator++() {
   AdvanceToNextTile(&iterator_);
   while (!done()) {
-    if (!tile_->content_rect().Intersects(pending_visible_rect_))
+    if (!current_tile_.tile()->content_rect().Intersects(pending_visible_rect_))
       break;
     AdvanceToNextTile(&iterator_);
   }
   return *this;
 }
 
 // TilingIterator
-TilingSetRasterQueueAll::TilingIterator::TilingIterator()
-    : tiling_(NULL), current_tile_(NULL) {
+TilingSetRasterQueueAll::TilingIterator::TilingIterator() : tiling_(nullptr) {
 }
 
 TilingSetRasterQueueAll::TilingIterator::TilingIterator(
     PictureLayerTiling* tiling,
     TilingData* tiling_data)
-    : tiling_(tiling),
-      tiling_data_(tiling_data),
-      phase_(VISIBLE_RECT),
-      current_tile_(NULL) {
+    : tiling_(tiling), tiling_data_(tiling_data), phase_(VISIBLE_RECT) {
   visible_iterator_ = VisibleTilingIterator(tiling_, tiling_data_);
   if (visible_iterator_.done()) {
     AdvancePhase();
     return;
   }
   current_tile_ = *visible_iterator_;
 }
 
 TilingSetRasterQueueAll::TilingIterator::~TilingIterator() {
 }
 
 void TilingSetRasterQueueAll::TilingIterator::AdvancePhase() {
   DCHECK_LT(phase_, EVENTUALLY_RECT);
 
-  current_tile_ = nullptr;
-  while (!current_tile_ && phase_ < EVENTUALLY_RECT) {
+  current_tile_ = PrioritizedTile();
+  while (!current_tile_.tile() && phase_ < EVENTUALLY_RECT) {
     phase_ = static_cast<Phase>(phase_ + 1);
     switch (phase_) {
       case VISIBLE_RECT:
         NOTREACHED();
         return;
       case PENDING_VISIBLE_RECT:
         pending_visible_iterator_ =
             PendingVisibleTilingIterator(tiling_, tiling_data_);
         if (!pending_visible_iterator_.done())
           current_tile_ = *pending_visible_iterator_;
@@ skipping 49 matching lines @@
       ++soon_border_iterator_;
       if (soon_border_iterator_.done()) {
         AdvancePhase();
         return *this;
       }
       current_tile_ = *soon_border_iterator_;
       break;
     case EVENTUALLY_RECT:
       ++eventually_iterator_;
       if (eventually_iterator_.done()) {
-        current_tile_ = nullptr;
+        current_tile_ = PrioritizedTile();
         return *this;
       }
       current_tile_ = *eventually_iterator_;
       break;
   }
   return *this;
 }
 
 }  // namespace cc