cc: Add a tiling iterator that doesn't include borders

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 93 matching lines @@
   return opaque_region;
 }
 
 void PictureLayerTiling::SetCanUseLCDText(bool can_use_lcd_text) {
   for (TileMap::iterator it = tiles_.begin(); it != tiles_.end(); ++it)
     it->second->set_can_use_lcd_text(can_use_lcd_text);
 }
 
 void PictureLayerTiling::CreateMissingTilesInLiveTilesRect() {
   const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
-  for (TilingData::Iterator iter(&tiling_data_, live_tiles_rect_); iter;
+  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);
   }
 }
 
 void PictureLayerTiling::SetLayerBounds(const gfx::Size& layer_bounds) {
@@ skipping 30 matching lines @@
 
 void PictureLayerTiling::Invalidate(const Region& layer_region) {
   std::vector<TileMapKey> new_tile_keys;
   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_);
     content_rect.Intersect(live_tiles_rect_);
     if (content_rect.IsEmpty())
       continue;
-    for (TilingData::Iterator iter(&tiling_data_, content_rect); iter; ++iter) {
+    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);
       new_tile_keys.push_back(key);
     }
   }
 
   const PictureLayerTiling* twin_tiling = client_->GetTwinTiling(this);
@@ skipping 252 matching lines @@
 
   current_visible_rect_in_content_space_ = visible_rect_in_content_space;
   current_skewport_ = skewport;
   current_eventually_rect_ = eventually_rect;
 
   TilePriority now_priority(resolution_, TilePriority::NOW, 0);
   float content_to_screen_scale =
       1.0f / (contents_scale_ * layer_contents_scale);
 
   // Assign now priority to all visible tiles.
-  for (TilingData::Iterator iter(&tiling_data_, visible_rect_in_content_space);
+  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();
 
     tile->SetPriority(tree, now_priority);
   }
 
@@ skipping 281 matching lines @@
     PictureLayerTiling* tiling,
     WhichTree tree)
     : tiling_(tiling),
       type_(VISIBLE),
       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_),
       tree_(tree),
       current_tile_(NULL),
-      visible_iterator_(&tiling->tiling_data_, visible_rect_in_content_space_),
+      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_) {
   if (!visible_iterator_) {
     AdvancePhase();
     return;
   }
 
   current_tile_ =
@@ skipping 59 matching lines @@
           return *this;
         next_index = spiral_iterator_.index();
         break;
     }
     current_tile_ = tiling_->TileAt(next_index.first, next_index.second);
   }
   return *this;
 }
 
 }  // namespace cc