cc: Start using raster/eviction iterators.

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 47 matching lines @@
 
 PictureLayerTiling::PictureLayerTiling(float contents_scale,
                                        const gfx::Size& layer_bounds,
                                        PictureLayerTilingClient* client)
     : contents_scale_(contents_scale),
       layer_bounds_(layer_bounds),
       resolution_(NON_IDEAL_RESOLUTION),
       client_(client),
       tiling_data_(gfx::Size(), gfx::Rect(), true),
       last_impl_frame_time_in_seconds_(0.0),
-      eviction_tiles_cache_valid_(false),
-      eviction_cache_tree_priority_(SAME_PRIORITY_FOR_BOTH_TREES) {
+      current_visible_rect_has_tiles_(false),
+      current_skewport_has_tiles_(false),
+      current_eventually_rect_has_tiles_(false),
+      current_soon_border_rect_has_tiles_(false) {
   gfx::Size content_bounds =
       gfx::ToCeiledSize(gfx::ScaleSize(layer_bounds, contents_scale));
   gfx::Size tile_size = client_->CalculateTileSize(content_bounds);
 
   DCHECK(!gfx::ToFlooredSize(
       gfx::ScaleSize(layer_bounds, contents_scale)).IsEmpty()) <<
       "Tiling created with scale too small as contents become empty." <<
       " Layer bounds: " << layer_bounds.ToString() <<
       " Contents scale: " << contents_scale;
 
@@ skipping 31 matching lines @@
           gfx::ScaleToEnclosingRect(paint_rect, 1.0f / contents_scale_);
       if (!client_->GetInvalidation()->Intersects(rect)) {
         tiles_[key] = candidate_tile;
         return candidate_tile;
       }
     }
   }
 
   // Create a new tile because our twin didn't have a valid one.
   scoped_refptr<Tile> tile = client_->CreateTile(this, tile_rect);
-  if (tile.get())
+  if (tile.get()) {
+    tile->set_tiling_index(i, j);
     tiles_[key] = tile;
+  }
   return tile.get();
 }
 
-void PictureLayerTiling::CreateMissingTilesInLiveTilesRect() {
-  const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
-  bool include_borders = true;
-  for (TilingData::Iterator iter(
-           &tiling_data_, live_tiles_rect_, include_borders);
-       iter;
-       ++iter) {
-    TileMapKey key = iter.index();
-    TileMap::iterator find = tiles_.find(key);
-    if (find != tiles_.end())
-      continue;
-    CreateTile(key.first, key.second, twin_tiling);
-  }
+Tile* PictureLayerTiling::GetOrCreateTileAt(int i, int j) {
+  Tile* existing_tile = TileAt(i, j);
+  if (existing_tile)
+    return existing_tile;
+  return CreateTile(i, j, client_->GetTwinTiling(this));
 }
 
 void PictureLayerTiling::SetLayerBounds(const gfx::Size& layer_bounds) {
   if (layer_bounds_ == layer_bounds)
     return;
 
   DCHECK(!layer_bounds.IsEmpty());
 
   gfx::Size old_layer_bounds = layer_bounds_;
   layer_bounds_ = layer_bounds;
@@ skipping 13 matching lines @@
   bounded_live_tiles_rect.Intersect(gfx::Rect(content_bounds));
   SetLiveTilesRect(bounded_live_tiles_rect);
   tiling_data_.SetTilingRect(gfx::Rect(content_bounds));
 
   // Create tiles for newly exposed areas.
   Region layer_region((gfx::Rect(layer_bounds_)));
   layer_region.Subtract(gfx::Rect(old_layer_bounds));
   Invalidate(layer_region);
 }
 
-void PictureLayerTiling::RemoveTilesInRegion(const Region& layer_region) {
-  DoInvalidate(layer_region, false /* recreate_tiles */);
-}
-
 void PictureLayerTiling::Invalidate(const Region& layer_region) {
-  DoInvalidate(layer_region, true /* recreate_tiles */);
-}
-
-void PictureLayerTiling::DoInvalidate(const Region& layer_region,
-                                      bool recreate_tiles) {
-  std::vector<TileMapKey> new_tile_keys;
   gfx::Rect expanded_live_tiles_rect(
       tiling_data_.ExpandRectToTileBoundsWithBorders(live_tiles_rect_));
   for (Region::Iterator iter(layer_region); iter.has_rect(); iter.next()) {
     gfx::Rect layer_rect = iter.rect();
     gfx::Rect content_rect =
         gfx::ScaleToEnclosingRect(layer_rect, contents_scale_);
     // Avoid needless work by not bothering to invalidate where there aren't
     // tiles.
     content_rect.Intersect(expanded_live_tiles_rect);
     if (content_rect.IsEmpty())
       continue;
     bool include_borders = true;
     for (TilingData::Iterator iter(
              &tiling_data_, content_rect, include_borders);
          iter;
          ++iter) {
       TileMapKey key(iter.index());
       TileMap::iterator find = tiles_.find(key);
       if (find == tiles_.end())
         continue;
       tiles_.erase(find);
-      if (recreate_tiles)
-        new_tile_keys.push_back(key);
     }
   }
-
-  if (recreate_tiles) {
-    const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
-    for (size_t i = 0; i < new_tile_keys.size(); ++i)
-      CreateTile(new_tile_keys[i].first, new_tile_keys[i].second, twin_tiling);
-  }
 }
 
+void PictureLayerTiling::UpdateTileOcclusion(Tile* tile) {
+  if (!tile)
+    return;
+
+  bool is_occluded = occlusion_set_.count(std::make_pair(
+                         tile->tiling_i_index(), tile->tiling_j_index())) != 0;
+  WhichTree tree = client_->GetTree();
+  tile->set_is_occluded(tree, is_occluded);
+}
+
+bool PictureLayerTiling::IsTileRequiredForActivation(Tile* tile) const {
+  if (resolution_ != HIGH_RESOLUTION)
+    return false;
+
+  WhichTree tree = client_->GetTree();
+  if (tree != PENDING_TREE)
+    return false;
+
+  if (tile->is_occluded(tree))
+    return false;
+
+  if (client_->RequiresHighResToDraw())
+    return true;
+
+  const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
+  if (twin_tiling) {
+    if (twin_tiling->layer_bounds() != layer_bounds())
+      return true;
+
+    if (twin_tiling->current_visible_rect_in_content_space_ !=
+        current_visible_rect_in_content_space_) {
+      return true;
+    }
+
+    Tile* twin_tile =
+        twin_tiling->TileAt(tile->tiling_i_index(), tile->tiling_j_index());
+    if (!twin_tile || twin_tile == tile)
+      return false;
+  }
+  return true;
+}
+
 PictureLayerTiling::CoverageIterator::CoverageIterator()
     : tiling_(NULL),
       current_tile_(NULL),
       tile_i_(0),
       tile_j_(0),
       left_(0),
       top_(0),
       right_(-1),
       bottom_(-1) {
 }
@@ skipping 229 matching lines @@
                                        TilingRect(),
                                        &expansion_cache_);
 
   DCHECK(eventually_rect.IsEmpty() || TilingRect().Contains(eventually_rect));
 
   SetLiveTilesRect(eventually_rect);
 
   last_impl_frame_time_in_seconds_ = current_frame_time_in_seconds;
   last_visible_rect_in_content_space_ = visible_rect_in_content_space;
 
+  const gfx::Rect& tiling_rect = TilingRect();
   current_visible_rect_in_content_space_ = visible_rect_in_content_space;
+  current_visible_rect_has_tiles_ =
+      tiling_rect.Intersects(current_visible_rect_in_content_space_);
   current_skewport_ = skewport;
+  current_skewport_has_tiles_ = tiling_rect.Intersects(current_skewport_);
   current_eventually_rect_ = eventually_rect;
-  eviction_tiles_cache_valid_ = false;
+  current_eventually_rect_has_tiles_ =
+      tiling_rect.Intersects(current_eventually_rect_);
+  content_to_screen_scale_ = 1.0f / (contents_scale_ * ideal_contents_scale);
 
-  TilePriority now_priority(resolution_, TilePriority::NOW, 0);
-  float content_to_screen_scale =
-      1.0f / (contents_scale_ * ideal_contents_scale);
+  current_soon_border_rect_ = visible_rect_in_content_space;
+  float border = kSoonBorderDistanceInScreenPixels / content_to_screen_scale_;
+  current_soon_border_rect_.Inset(-border, -border, -border, -border);
+  current_soon_border_rect_has_tiles_ =
+      tiling_rect.Intersects(current_soon_border_rect_);
 
-  // Assign now priority to all visible tiles.
-  bool include_borders = true;
-  for (TilingData::Iterator iter(
-           &tiling_data_, visible_rect_in_content_space, include_borders);
-       iter;
-       ++iter) {
-    TileMap::iterator find = tiles_.find(iter.index());
-    if (find == tiles_.end())
-      continue;
-    Tile* tile = find->second.get();
+  // Compute occluded indecies.
+  occlusion_set_.clear();
+  if (occlusion_tracker) {
+    bool include_borders = true;
+    for (TilingData::Iterator iter(
+             &tiling_data_, visible_rect_in_content_space, include_borders);
+         iter;
+         ++iter) {
+      gfx::Rect paint_rect =
+          tiling_data_.TileBoundsWithBorder(iter.index_x(), iter.index_y());
+      gfx::Rect tile_rect = paint_rect;
+      tile_rect.set_size(tiling_data_.max_texture_size());
+      gfx::Rect tile_query_rect = ScaleToEnclosingRect(
+          IntersectRects(tile_rect, visible_rect_in_content_space),
+          1.0f / contents_scale_);
+      bool is_occluded = occlusion_tracker->Occluded(
+          render_target, tile_query_rect, draw_transform);
+      if (!is_occluded)
+        continue;
 
-    tile->SetPriority(tree, now_priority);
-
-    // Set whether tile is occluded or not.
-    bool is_occluded = false;
-    if (occlusion_tracker) {
-      gfx::Rect tile_query_rect = ScaleToEnclosingRect(
-          IntersectRects(tile->content_rect(), visible_rect_in_content_space),
-          1.0f / contents_scale_);
-      // TODO(vmpstr): Remove render_target and draw_transform from the
-      // parameters so they can be hidden from the tiling.
-      is_occluded = occlusion_tracker->Occluded(
-          render_target, tile_query_rect, draw_transform);
+      occlusion_set_.insert(iter.index());
     }
-    tile->set_is_occluded(tree, is_occluded);
-  }
-
-  // Assign soon priority to skewport tiles.
-  for (TilingData::DifferenceIterator iter(
-           &tiling_data_, skewport, visible_rect_in_content_space);
-       iter;
-       ++iter) {
-    TileMap::iterator find = tiles_.find(iter.index());
-    if (find == tiles_.end())
-      continue;
-    Tile* tile = find->second.get();
-
-    gfx::Rect tile_bounds =
-        tiling_data_.TileBounds(iter.index_x(), iter.index_y());
-
-    float distance_to_visible =
-        visible_rect_in_content_space.ManhattanInternalDistance(tile_bounds) *
-        content_to_screen_scale;
-
-    TilePriority priority(resolution_, TilePriority::SOON, distance_to_visible);
-    tile->SetPriority(tree, priority);
-  }
-
-  // Assign eventually priority to interest rect tiles.
-  for (TilingData::DifferenceIterator iter(
-           &tiling_data_, eventually_rect, skewport);
-       iter;
-       ++iter) {
-    TileMap::iterator find = tiles_.find(iter.index());
-    if (find == tiles_.end())
-      continue;
-    Tile* tile = find->second.get();
-
-    gfx::Rect tile_bounds =
-        tiling_data_.TileBounds(iter.index_x(), iter.index_y());
-
-    float distance_to_visible =
-        visible_rect_in_content_space.ManhattanInternalDistance(tile_bounds) *
-        content_to_screen_scale;
-    TilePriority priority(
-        resolution_, TilePriority::EVENTUALLY, distance_to_visible);
-    tile->SetPriority(tree, priority);
-  }
-
-  // Upgrade the priority on border tiles to be SOON.
-  current_soon_border_rect_ = visible_rect_in_content_space;
-  float border = kSoonBorderDistanceInScreenPixels / content_to_screen_scale;
-  current_soon_border_rect_.Inset(-border, -border, -border, -border);
-  for (TilingData::DifferenceIterator iter(
-           &tiling_data_, current_soon_border_rect_, skewport);
-       iter;
-       ++iter) {
-    TileMap::iterator find = tiles_.find(iter.index());
-    if (find == tiles_.end())
-      continue;
-    Tile* tile = find->second.get();
-
-    TilePriority priority(resolution_,
-                          TilePriority::SOON,
-                          tile->priority(tree).distance_to_visible);
-    tile->SetPriority(tree, priority);
   }
 }
 
+void PictureLayerTiling::SetTileAndTwinPriority(Tile* tile) const {
+  // First update the twin if required.
+  const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
+  if (twin_tiling)
+    twin_tiling->SetTilePriority(tile);
+  SetTilePriority(tile);
+}
+
+void PictureLayerTiling::SetTilePriority(Tile* tile) const {
+  WhichTree tree = client_->GetTree();
+
+  // If we're on the pending tree, start by clearing out the required for
+  // activation flag.
+  if (tree == PENDING_TREE)
+    tile->set_required_for_activation(false);
+
+  // If this tiling doesn't have the given tile, then set default priority.
+  if (TileAt(tile->tiling_i_index(), tile->tiling_j_index()) != tile) {
+    tile->SetPriority(tree, TilePriority());
+    return;
+  }
+
+  gfx::Rect tile_bounds = tiling_data_.TileBoundsWithBorder(
+      tile->tiling_i_index(), tile->tiling_j_index());
+
+  // If we're in the now bin, set the priority and return.
+  if (current_visible_rect_in_content_space_.Intersects(tile_bounds)) {
+    tile->SetPriority(tree, TilePriority(resolution_, TilePriority::NOW, 0));
+
+    // If necessary, mark this visible tile as required for activation.
+    tile->set_required_for_activation(IsTileRequiredForActivation(tile));
+    return;
+  }
+
+  // For non-now bin, we'll need to know distance to visible.
+  float distance_to_visible =
+      current_visible_rect_in_content_space_.ManhattanInternalDistance(
+          tile_bounds) *
+      content_to_screen_scale_;
+
+  // Soon border and skewport tiles get SOON bin, otherwise they get EVENTUALLY
+  // bin.
+  if (current_soon_border_rect_.Intersects(tile_bounds) ||
+      current_skewport_.Intersects(tile_bounds)) {
+    tile->SetPriority(
+        tree,
+        TilePriority(resolution_, TilePriority::SOON, distance_to_visible));
+    return;
+  }
+
+  tile->SetPriority(
+      tree,
+      TilePriority(resolution_, TilePriority::EVENTUALLY, distance_to_visible));
+}
+
 void PictureLayerTiling::SetLiveTilesRect(
     const gfx::Rect& new_live_tiles_rect) {
   DCHECK(new_live_tiles_rect.IsEmpty() ||
          TilingRect().Contains(new_live_tiles_rect));
   if (live_tiles_rect_ == new_live_tiles_rect)
     return;
 
   // Iterate to delete all tiles outside of our new live_tiles rect.
   for (TilingData::DifferenceIterator iter(&tiling_data_,
                                            live_tiles_rect_,
                                            new_live_tiles_rect);
        iter;
        ++iter) {
     TileMapKey key(iter.index());
     TileMap::iterator found = tiles_.find(key);
     // If the tile was outside of the recorded region, it won't exist even
     // though it was in the live rect.
     if (found != tiles_.end())
       tiles_.erase(found);
   }
 
-  const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
-
-  // Iterate to allocate new tiles for all regions with newly exposed area.
-  for (TilingData::DifferenceIterator iter(&tiling_data_,
-                                           new_live_tiles_rect,
-                                           live_tiles_rect_);
-       iter;
-       ++iter) {
-    TileMapKey key(iter.index());
-    CreateTile(key.first, key.second, twin_tiling);
-  }
-
   live_tiles_rect_ = new_live_tiles_rect;
 }
 
-void PictureLayerTiling::DidBecomeRecycled() {
-  // DidBecomeActive below will set the active priority for tiles that are
-  // still in the tree. Calling this first on an active tiling that is becoming
-  // recycled takes care of tiles that are no longer in the active tree (eg.
-  // due to a pending invalidation).
-  for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
-    it->second->SetPriority(ACTIVE_TREE, TilePriority());
-  }
-}
-
 void PictureLayerTiling::DidBecomeActive() {
   PicturePileImpl* active_pile = client_->GetPile();
   for (TileMap::const_iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
-    it->second->SetPriority(ACTIVE_TREE, it->second->priority(PENDING_TREE));
-    it->second->SetPriority(PENDING_TREE, TilePriority());
+    it->second->set_required_for_activation(false);
 
     // Tile holds a ref onto a picture pile. If the tile never gets invalidated
     // and recreated, then that picture pile ref could exist indefinitely.  To
     // prevent this, ask the client to update the pile to its own ref.  This
     // will cause PicturePileImpls and their clones to get deleted once the
     // corresponding PictureLayerImpl and any in flight raster jobs go out of
     // scope.
     it->second->set_picture_pile(active_pile);
   }
 }
@@ skipping 166 matching lines @@
   }
 
   gfx::Rect result(origin_x, origin_y, width, height);
   if (cache)
     cache->previous_result = result;
   return result;
 }
 
 void PictureLayerTiling::UpdateEvictionCacheIfNeeded(
     TreePriority tree_priority) {
-  if (eviction_tiles_cache_valid_ &&
-      eviction_cache_tree_priority_ == tree_priority)
-    return;
 
   eviction_tiles_cache_.clear();
   eviction_tiles_cache_.reserve(tiles_.size());
   for (TileMap::iterator it = tiles_.begin(); it != tiles_.end(); ++it) {
-    // TODO(vmpstr): This should update the priority if UpdateTilePriorities
-    // changes not to do this.
+    UpdateTileOcclusion(it->second);
+    SetTileAndTwinPriority(it->second);
     eviction_tiles_cache_.push_back(it->second);
   }
 
   std::sort(eviction_tiles_cache_.begin(),
             eviction_tiles_cache_.end(),
             TileEvictionOrder(tree_priority));
-  eviction_tiles_cache_valid_ = true;
-  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),
-      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) {
+  if (tiling_->current_visible_rect_has_tiles_) {
+    visible_iterator_ =
+        TilingData::Iterator(&tiling_->tiling_data_,
+                             tiling_->current_visible_rect_in_content_space_,
+                             true /* include_borders */);
+  }
+
   if (!visible_iterator_) {
     AdvancePhase();
     return;
   }
 
-  current_tile_ =
-      tiling_->TileAt(visible_iterator_.index_x(), visible_iterator_.index_y());
-  if (!current_tile_ || !TileNeedsRaster(current_tile_))
+  current_tile_ = tiling_->GetOrCreateTileAt(visible_iterator_.index_x(),
+                                             visible_iterator_.index_y());
+  if (!current_tile_) {
     ++(*this);
+  } else {
+    tiling_->UpdateTileOcclusion(current_tile_);
+    if (!TileNeedsRaster(current_tile_))
+      ++(*this);
+    else
+      tiling_->SetTileAndTwinPriority(current_tile_);
+  }
 }
 
 PictureLayerTiling::TilingRasterTileIterator::~TilingRasterTileIterator() {}
 
 void PictureLayerTiling::TilingRasterTileIterator::AdvancePhase() {
   DCHECK_LT(type_, TilePriority::EVENTUALLY);
+  DCHECK(!spiral_iterator_);
 
   do {
-    type_ = static_cast<TilePriority::PriorityBin>(type_ + 1);
-    if (type_ == TilePriority::EVENTUALLY) {
+    if (type_ == TilePriority::SOON && !skewport_processed_)
+      skewport_processed_ = true;
+    else
+      type_ = static_cast<TilePriority::PriorityBin>(type_ + 1);
+
+    if (type_ == TilePriority::SOON && !skewport_processed_) {
+      if (!tiling_->current_soon_border_rect_has_tiles_)
+        continue;
+
       spiral_iterator_ = TilingData::SpiralDifferenceIterator(
           &tiling_->tiling_data_,
-          eventually_rect_in_content_space_,
-          skewport_in_content_space_,
-          visible_rect_in_content_space_);
+          tiling_->current_skewport_,
+          tiling_->current_visible_rect_in_content_space_,
+          tiling_->current_visible_rect_in_content_space_);
+    } else if (type_ == TilePriority::SOON && skewport_processed_) {
+      if (!tiling_->current_skewport_has_tiles_)
+        continue;
+
+      spiral_iterator_ = TilingData::SpiralDifferenceIterator(
+          &tiling_->tiling_data_,
+          tiling_->current_soon_border_rect_,
+          tiling_->current_skewport_,
+          tiling_->current_visible_rect_in_content_space_);
+    } else if (type_ == TilePriority::EVENTUALLY) {
+      if (!tiling_->current_eventually_rect_has_tiles_) {
+        current_tile_ = NULL;
+        break;
+      }
+
+      spiral_iterator_ = TilingData::SpiralDifferenceIterator(
+          &tiling_->tiling_data_,
+          tiling_->current_eventually_rect_,
+          tiling_->current_skewport_,
+          tiling_->current_soon_border_rect_);
     }
 
     while (spiral_iterator_) {
-      current_tile_ = tiling_->TileAt(spiral_iterator_.index_x(),
-                                      spiral_iterator_.index_y());
+      current_tile_ = tiling_->GetOrCreateTileAt(spiral_iterator_.index_x(),
+                                                 spiral_iterator_.index_y());
+      tiling_->UpdateTileOcclusion(current_tile_);
       if (current_tile_ && TileNeedsRaster(current_tile_))
         break;
       ++spiral_iterator_;
     }
 
     if (!spiral_iterator_ && type_ == TilePriority::EVENTUALLY) {
       current_tile_ = NULL;
       break;
     }
   } while (!spiral_iterator_);
+
+  if (current_tile_)
+    tiling_->SetTileAndTwinPriority(current_tile_);
 }
 
 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:
         ++visible_iterator_;
         if (!visible_iterator_) {
           AdvancePhase();
           return *this;
         }
         next_index = visible_iterator_.index();
         break;
       case TilePriority::SOON:
         ++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:
         ++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);
+    current_tile_ =
+        tiling_->GetOrCreateTileAt(next_index.first, next_index.second);
+    tiling_->UpdateTileOcclusion(current_tile_);
   }
+
+  if (current_tile_)
+    tiling_->SetTileAndTwinPriority(current_tile_);
   return *this;
 }
 
 PictureLayerTiling::TilingEvictionTileIterator::TilingEvictionTileIterator()
     : is_valid_(false), tiling_(NULL) {}
 
 PictureLayerTiling::TilingEvictionTileIterator::TilingEvictionTileIterator(
     PictureLayerTiling* tiling,
     TreePriority tree_priority)
     : is_valid_(false), tiling_(tiling), tree_priority_(tree_priority) {}
@@ skipping 34 matching lines @@
   tiling_->UpdateEvictionCacheIfNeeded(tree_priority_);
   tile_iterator_ = tiling_->eviction_tiles_cache_.begin();
   is_valid_ = true;
   if (tile_iterator_ != tiling_->eviction_tiles_cache_.end() &&
       !(*tile_iterator_)->HasResources()) {
     ++(*this);
   }
 }
 
 }  // namespace cc