cc: Fix tiling raster iterator to process all tiles correctly.

cc/resources/picture_layer_tiling.cc

 // Copyright 2012 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/picture_layer_tiling.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 
@@ skipping 819 matching lines @@
   eviction_cache_tree_priority_ = tree_priority;
 }
 
 PictureLayerTiling::TilingRasterTileIterator::TilingRasterTileIterator()
     : tiling_(NULL), current_tile_(NULL) {}
 
 PictureLayerTiling::TilingRasterTileIterator::TilingRasterTileIterator(
     PictureLayerTiling* tiling,
     WhichTree tree)
     : tiling_(tiling),
-      type_(TilePriority::NOW),
+      phase_(VISIBLE_RECT),
       visible_rect_in_content_space_(
           tiling_->current_visible_rect_in_content_space_),
       skewport_in_content_space_(tiling_->current_skewport_),
       eventually_rect_in_content_space_(tiling_->current_eventually_rect_),
       soon_border_rect_in_content_space_(tiling_->current_soon_border_rect_),
       tree_(tree),
       current_tile_(NULL),
       visible_iterator_(&tiling->tiling_data_,
                         visible_rect_in_content_space_,
                         true /* include_borders */),
       spiral_iterator_(&tiling->tiling_data_,
                        skewport_in_content_space_,
                        visible_rect_in_content_space_,
-                       visible_rect_in_content_space_),
-      skewport_processed_(false) {
+                       visible_rect_in_content_space_) {
   if (!visible_iterator_) {
     AdvancePhase();
     return;
   }
 
   current_tile_ =
       tiling_->TileAt(visible_iterator_.index_x(), visible_iterator_.index_y());
   if (!current_tile_ || !TileNeedsRaster(current_tile_))
     ++(*this);
 }
 
 PictureLayerTiling::TilingRasterTileIterator::~TilingRasterTileIterator() {}
 
 void PictureLayerTiling::TilingRasterTileIterator::AdvancePhase() {
-  DCHECK_LT(type_, TilePriority::EVENTUALLY);
+  DCHECK_LT(phase_, EVENTUALLY_RECT);
 
   do {
-    type_ = static_cast<TilePriority::PriorityBin>(type_ + 1);
-    if (type_ == TilePriority::EVENTUALLY) {
+    phase_ = static_cast<Phase>(phase_ + 1);
+
+    if (phase_ == SOON_BORDER_RECT) {

[reveman, 2014/07/24 16:38:49]

nit: I would prefer a switch statement with all phases explicitly listed.

[vmpstr, 2014/07/24 16:44:25]

Can I push this nit off into the optimization patch? I'm already doing it there.
I've uploaded it, so you can take a look.

[reveman, 2014/07/24 16:54:18]

sure, part of that patch is fine.

+      spiral_iterator_ = TilingData::SpiralDifferenceIterator(
+          &tiling_->tiling_data_,
+          soon_border_rect_in_content_space_,
+          skewport_in_content_space_,
+          visible_rect_in_content_space_);
+    } else if (phase_ == EVENTUALLY_RECT) {
       spiral_iterator_ = TilingData::SpiralDifferenceIterator(
           &tiling_->tiling_data_,
           eventually_rect_in_content_space_,
           skewport_in_content_space_,
-          visible_rect_in_content_space_);
+          soon_border_rect_in_content_space_);
     }
 
     while (spiral_iterator_) {
       current_tile_ = tiling_->TileAt(spiral_iterator_.index_x(),
                                       spiral_iterator_.index_y());
       if (current_tile_ && TileNeedsRaster(current_tile_))
         break;
       ++spiral_iterator_;
     }
 
-    if (!spiral_iterator_ && type_ == TilePriority::EVENTUALLY) {
+    if (!spiral_iterator_ && phase_ == EVENTUALLY_RECT) {
       current_tile_ = NULL;
       break;
     }
   } while (!spiral_iterator_);
 }
 
 PictureLayerTiling::TilingRasterTileIterator&
 PictureLayerTiling::TilingRasterTileIterator::
 operator++() {
   current_tile_ = NULL;
   while (!current_tile_ || !TileNeedsRaster(current_tile_)) {
     std::pair<int, int> next_index;
-    switch (type_) {
-      case TilePriority::NOW:
+    switch (phase_) {
+      case VISIBLE_RECT:
         ++visible_iterator_;
         if (!visible_iterator_) {
           AdvancePhase();
           return *this;
         }
         next_index = visible_iterator_.index();
         break;
-      case TilePriority::SOON:
+      case SKEWPORT_RECT:
+      case SOON_BORDER_RECT:
         ++spiral_iterator_;
         if (!spiral_iterator_) {
-          if (skewport_processed_) {
-            AdvancePhase();
-            return *this;
-          }
-          skewport_processed_ = true;
-          spiral_iterator_ = TilingData::SpiralDifferenceIterator(
-              &tiling_->tiling_data_,
-              soon_border_rect_in_content_space_,
-              skewport_in_content_space_,
-              visible_rect_in_content_space_);
-          if (!spiral_iterator_) {
-            AdvancePhase();
-            return *this;
-          }
+          AdvancePhase();
+          return *this;
         }
         next_index = spiral_iterator_.index();
         break;
-      case TilePriority::EVENTUALLY:
+      case EVENTUALLY_RECT:
         ++spiral_iterator_;
         if (!spiral_iterator_) {
           current_tile_ = NULL;
           return *this;
         }
         next_index = spiral_iterator_.index();
         break;
     }
     current_tile_ = tiling_->TileAt(next_index.first, next_index.second);
   }
@@ skipping 38 matching lines @@
   DCHECK(*this);
   do {
     ++tile_iterator_;
   } while (tile_iterator_ != tiling_->eviction_tiles_cache_.end() &&
            (!(*tile_iterator_)->HasResources()));
 
   return *this;
 }
 
 }  // namespace cc