cc: TilingSetRasterQueue clean-ups and optimizations.

cc/tiles/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/tiles/tiling_set_raster_queue_all.h"
 
 #include <utility>
 
 #include "cc/tiles/picture_layer_tiling_set.h"
 #include "cc/tiles/tile.h"
@@ skipping 134 matching lines @@
 TilingSetRasterQueueAll::OnePriorityRectIterator::OnePriorityRectIterator()
     : tiling_(nullptr), tiling_data_(nullptr) {
 }
 
 TilingSetRasterQueueAll::OnePriorityRectIterator::OnePriorityRectIterator(
     PictureLayerTiling* tiling,
     TilingData* tiling_data,
     PictureLayerTiling::PriorityRectType priority_rect_type)
     : tiling_(tiling),
       tiling_data_(tiling_data),
-      priority_rect_type_(priority_rect_type) {
+      priority_rect_type_(priority_rect_type),
+      pending_visible_rect_(tiling->pending_visible_rect()) {
 }
 
 template <typename TilingIteratorType>
 void TilingSetRasterQueueAll::OnePriorityRectIterator::AdvanceToNextTile(
     TilingIteratorType* iterator) {
   for (;;) {
     ++(*iterator);
     if (!(*iterator)) {
       current_tile_ = PrioritizedTile();
       break;
@@ skipping 21 matching lines @@
 }
 
 bool TilingSetRasterQueueAll::OnePriorityRectIterator::IsTileValid(
     const Tile* tile) const {
   if (!tile || !TileNeedsRaster(tile))
     return false;
   // After the pending visible rect has been processed, we must return false
   // for pending visible rect tiles as tiling iterators do not ignore those
   // tiles.
   if (priority_rect_type_ > PictureLayerTiling::PENDING_VISIBLE_RECT &&
-      tiling_->pending_visible_rect().Intersects(tile->content_rect())) {
+      pending_visible_rect_.Intersects(tile->content_rect())) {
     return false;
   }
   return true;
 }
 
 // VisibleTilingIterator.
 TilingSetRasterQueueAll::VisibleTilingIterator::VisibleTilingIterator(
     PictureLayerTiling* tiling,
     TilingData* tiling_data)
     : OnePriorityRectIterator(tiling,
@@ skipping 17 matching lines @@
   return *this;
 }
 
 // PendingVisibleTilingIterator.
 TilingSetRasterQueueAll::PendingVisibleTilingIterator::
     PendingVisibleTilingIterator(PictureLayerTiling* tiling,
                                  TilingData* tiling_data)
     : OnePriorityRectIterator(tiling,
                               tiling_data,
                               PictureLayerTiling::PENDING_VISIBLE_RECT) {
-  iterator_ = TilingData::DifferenceIterator(tiling_data_,
-                                             tiling_->pending_visible_rect(),
-                                             tiling_->current_visible_rect());
+  iterator_ = TilingData::DifferenceIterator(
+      tiling_data_, pending_visible_rect_, tiling_->current_visible_rect());
   if (!iterator_)
     return;
   if (!GetFirstTileAndCheckIfValid(&iterator_))
     ++(*this);
 }
 
 TilingSetRasterQueueAll::PendingVisibleTilingIterator&
     TilingSetRasterQueueAll::PendingVisibleTilingIterator::
     operator++() {
   AdvanceToNextTile(&iterator_);
   return *this;
 }
 
 // SkewportTilingIterator.
 TilingSetRasterQueueAll::SkewportTilingIterator::SkewportTilingIterator(
     PictureLayerTiling* tiling,
     TilingData* tiling_data)
     : OnePriorityRectIterator(tiling,
                               tiling_data,
-                              PictureLayerTiling::SKEWPORT_RECT),
-      pending_visible_rect_(tiling->pending_visible_rect()) {
+                              PictureLayerTiling::SKEWPORT_RECT) {
   if (!tiling_->has_skewport_rect_tiles())
     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;
   }
-  // TODO(e_hakkinen): This is not needed as GetFirstTileAndCheckIfValid
-  // does the same checking.
-  if (current_tile_.tile()->content_rect().Intersects(pending_visible_rect_))
-    ++(*this);
 }
 
 TilingSetRasterQueueAll::SkewportTilingIterator&
     TilingSetRasterQueueAll::SkewportTilingIterator::
     operator++() {
   AdvanceToNextTile(&iterator_);
-  // TODO(e_hakkinen): This is not needed as GetFirstTileAndCheckIfValid called
-  // by AdvanceToNextTile does the same checking.
-  while (!done()) {
-    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,
-                              PictureLayerTiling::SOON_BORDER_RECT),
-      pending_visible_rect_(tiling->pending_visible_rect()) {
+                              PictureLayerTiling::SOON_BORDER_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;
   }
-  // TODO(e_hakkinen): This is not needed as GetFirstTileAndCheckIfValid
-  // does the same checking.
-  if (current_tile_.tile()->content_rect().Intersects(pending_visible_rect_))
-    ++(*this);
 }
 
 TilingSetRasterQueueAll::SoonBorderTilingIterator&
     TilingSetRasterQueueAll::SoonBorderTilingIterator::
     operator++() {
   AdvanceToNextTile(&iterator_);
-  // TODO(e_hakkinen): This is not needed as GetFirstTileAndCheckIfValid called
-  // by AdvanceToNextTile does the same checking.
-  while (!done()) {
-    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,
-                              PictureLayerTiling::EVENTUALLY_RECT),
-      pending_visible_rect_(tiling->pending_visible_rect()) {
+                              PictureLayerTiling::EVENTUALLY_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;
   }
-  // TODO(e_hakkinen): This is not needed as GetFirstTileAndCheckIfValid
-  // does the same checking.
-  if (current_tile_.tile()->content_rect().Intersects(pending_visible_rect_))
-    ++(*this);
 }
 
 TilingSetRasterQueueAll::EventuallyTilingIterator&
     TilingSetRasterQueueAll::EventuallyTilingIterator::
     operator++() {
   AdvanceToNextTile(&iterator_);
-  // TODO(e_hakkinen): This is not needed as GetFirstTileAndCheckIfValid called
-  // by AdvanceToNextTile does the same checking.
-  while (!done()) {
-    if (!current_tile_.tile()->content_rect().Intersects(pending_visible_rect_))
-      break;
-    AdvanceToNextTile(&iterator_);
-  }
   return *this;
 }
 
 // TilingIterator
 TilingSetRasterQueueAll::TilingIterator::TilingIterator() : tiling_(nullptr) {
 }
 
 TilingSetRasterQueueAll::TilingIterator::TilingIterator(
     PictureLayerTiling* tiling,
     TilingData* tiling_data)
@@ skipping 86 matching lines @@
         current_tile_ = PrioritizedTile();
         return *this;
       }
       current_tile_ = *eventually_iterator_;
       break;
   }
   return *this;
 }
 
 }  // namespace cc