cc: Rename PictureLayerTiling(Set) Iterator to CoverageIterator

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 "base/debug/trace_event.h"
@@ skipping 119 matching lines @@
   std::vector<TileMapKey> new_tiles;
 
   for (Region::Iterator region_iter(layer_invalidation);
        region_iter.has_rect();
        region_iter.next()) {
     gfx::Rect layer_invalidation = region_iter.rect();
     layer_invalidation.Intersect(gfx::Rect(layer_bounds_));
     gfx::Rect rect =
         gfx::ToEnclosingRect(ScaleRect(layer_invalidation, contents_scale_));
 
-    for (PictureLayerTiling::Iterator tile_iter(this, contents_scale_, rect);
+    for (PictureLayerTiling::CoverageIterator tile_iter(this,
+                                                        contents_scale_,
+                                                        rect);
          tile_iter;
          ++tile_iter) {
       TileMapKey key(tile_iter.tile_i_, tile_iter.tile_j_);
       TileMap::iterator found = tiles_.find(key);
       if (found == tiles_.end())
         continue;
 
       tiles_.erase(found);
       new_tiles.push_back(key);
     }
@@ skipping 13 matching lines @@
   for (TilingData::Iterator iter(&tiling_data_, content_rect); iter; ++iter) {
     TileMap::iterator found =
         tiles_.find(TileMapKey(iter.index_x(), iter.index_y()));
     // Ignore any tiles that already exist.
     if (found != tiles_.end())
       continue;
     CreateTile(iter.index_x(), iter.index_y());
   }
 }
 
-PictureLayerTiling::Iterator::Iterator()
+PictureLayerTiling::CoverageIterator::CoverageIterator()
     : tiling_(NULL),
       current_tile_(NULL),
       tile_i_(0),
       tile_j_(0),
       left_(0),
       top_(0),
       right_(-1),
       bottom_(-1) {
 }
 
-PictureLayerTiling::Iterator::Iterator(const PictureLayerTiling* tiling,
-                                       float dest_scale,
-                                       gfx::Rect dest_rect)
+PictureLayerTiling::CoverageIterator::CoverageIterator(
+    const PictureLayerTiling* tiling,
+    float dest_scale,
+    gfx::Rect dest_rect)
     : tiling_(tiling),
       dest_rect_(dest_rect),
       dest_to_content_scale_(0),
       current_tile_(NULL),
       tile_i_(0),
       tile_j_(0),
       left_(0),
       top_(0),
       right_(-1),
       bottom_(-1) {
@@ skipping 23 matching lines @@
   right_ = tiling_->tiling_data_.TileXIndexFromSrcCoord(
       content_rect.right() - 1);
   bottom_ = tiling_->tiling_data_.TileYIndexFromSrcCoord(
       content_rect.bottom() - 1);
 
   tile_i_ = left_ - 1;
   tile_j_ = top_;
   ++(*this);
 }
 
-PictureLayerTiling::Iterator::~Iterator() {
+PictureLayerTiling::CoverageIterator::~CoverageIterator() {
 }
 
-PictureLayerTiling::Iterator& PictureLayerTiling::Iterator::operator++() {
+PictureLayerTiling::CoverageIterator&
+PictureLayerTiling::CoverageIterator::operator++() {
   if (tile_j_ > bottom_)
     return *this;
 
   bool first_time = tile_i_ < left_;
   bool new_row = false;
   tile_i_++;
   if (tile_i_ > right_) {
     tile_i_ = left_;
     tile_j_++;
     new_row = true;
@@ skipping 40 matching lines @@
 
   if (!new_row) {
     DCHECK_EQ(last_geometry_rect.right(), current_geometry_rect_.x());
     DCHECK_EQ(last_geometry_rect.bottom(), current_geometry_rect_.bottom());
     DCHECK_EQ(last_geometry_rect.y(), current_geometry_rect_.y());
   }
 
   return *this;
 }
 
-gfx::Rect PictureLayerTiling::Iterator::geometry_rect() const {
+gfx::Rect PictureLayerTiling::CoverageIterator::geometry_rect() const {
   return current_geometry_rect_;
 }
 
-gfx::Rect PictureLayerTiling::Iterator::full_tile_geometry_rect() const {
+gfx::Rect
+PictureLayerTiling::CoverageIterator::full_tile_geometry_rect() const {
   gfx::Rect rect = tiling_->tiling_data_.TileBoundsWithBorder(tile_i_, tile_j_);
   rect.set_size(tiling_->tiling_data_.max_texture_size());
   return rect;
 }
 
-gfx::RectF PictureLayerTiling::Iterator::texture_rect() const {
+gfx::RectF PictureLayerTiling::CoverageIterator::texture_rect() const {
   gfx::PointF tex_origin =
       tiling_->tiling_data_.TileBoundsWithBorder(tile_i_, tile_j_).origin();
 
   // Convert from dest space => content space => texture space.
   gfx::RectF texture_rect(current_geometry_rect_);
   texture_rect.Scale(dest_to_content_scale_,
                      dest_to_content_scale_);
   texture_rect.Offset(-tex_origin.OffsetFromOrigin());
   texture_rect.Intersect(tiling_->ContentRect());
 
   return texture_rect;
 }
 
-gfx::Size PictureLayerTiling::Iterator::texture_size() const {
+gfx::Size PictureLayerTiling::CoverageIterator::texture_size() const {
   return tiling_->tiling_data_.max_texture_size();
 }
 
 void PictureLayerTiling::UpdateTilePriorities(
     WhichTree tree,
     gfx::Size device_viewport,
     const gfx::RectF& viewport_in_layer_space,
     gfx::Size last_layer_bounds,
     gfx::Size current_layer_bounds,
     float last_layer_contents_scale,
@@ skipping 273 matching lines @@
 
     // If our delta is less then our event distance, we're done.
     if (delta < event.distance)
       break;
   }
 
   return gfx::Rect(origin_x, origin_y, width, height);
 }
 
 }  // namespace cc