cc: Optimize OnePriorityRectIterator a little bit.

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 140 matching lines @@
     TilingData* tiling_data,
     PictureLayerTiling::PriorityRectType priority_rect_type)
     : tiling_(tiling),
       tiling_data_(tiling_data),
       priority_rect_type_(priority_rect_type) {
 }
 
 template <typename TilingIteratorType>
 void TilingSetRasterQueueAll::OnePriorityRectIterator::AdvanceToNextTile(
     TilingIteratorType* iterator) {
-  bool found_tile = false;
-  while (!found_tile) {
+  for (;;) {
     ++(*iterator);
     if (!(*iterator)) {
       current_tile_ = PrioritizedTile();
       break;
     }
-    found_tile = GetFirstTileAndCheckIfValid(iterator);
+    Tile* tile = tiling_->TileAt(iterator->index_x(), iterator->index_y());
+    if (IsTileValid(tile)) {
+      tiling_->UpdateRequiredStatesOnTile(tile);
+      current_tile_ = tiling_->MakePrioritizedTile(tile, priority_rect_type_);
+      break;
+    }
   }
 }
 
 template <typename TilingIteratorType>
 bool TilingSetRasterQueueAll::OnePriorityRectIterator::
     GetFirstTileAndCheckIfValid(TilingIteratorType* iterator) {
   Tile* tile = tiling_->TileAt(iterator->index_x(), iterator->index_y());
-  if (!tile || !TileNeedsRaster(tile)) {
-    current_tile_ = PrioritizedTile();
-    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())) {
+  if (!IsTileValid(tile)) {
     current_tile_ = PrioritizedTile();
     return false;
   }
   tiling_->UpdateRequiredStatesOnTile(tile);
   current_tile_ = tiling_->MakePrioritizedTile(tile, priority_rect_type_);
   return true;
 }
 
+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())) {
+    return false;
+  }
+  return true;
+}
+
 // VisibleTilingIterator.
 TilingSetRasterQueueAll::VisibleTilingIterator::VisibleTilingIterator(
     PictureLayerTiling* tiling,
     TilingData* tiling_data)
     : OnePriorityRectIterator(tiling,
                               tiling_data,
                               PictureLayerTiling::VISIBLE_RECT) {
   if (!tiling_->has_visible_rect_tiles())
     return;
   iterator_ =
@@ skipping 248 matching lines @@
         current_tile_ = PrioritizedTile();
         return *this;
       }
       current_tile_ = *eventually_iterator_;
       break;
   }
   return *this;
 }
 
 }  // namespace cc