cc: Rename PictureLayerTiling(Set) Iterator to CoverageIterator

cc/layers/picture_layer_impl_unittest.cc

 // Copyright 2013 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/layers/picture_layer_impl.h"
 
 #include <utility>
 
 #include "cc/layers/picture_layer.h"
 #include "cc/test/fake_content_layer_client.h"
@@ skipping 171 matching lines @@
 
     scoped_ptr<TestablePictureLayerImpl> pending_layer =
         TestablePictureLayerImpl::Create(pending_tree, id_, pile);
     pending_layer->SetDrawsContent(true);
     pending_tree->SetRootLayer(pending_layer.PassAs<LayerImpl>());
   }
 
   static void VerifyAllTilesExistAndHavePile(
       const PictureLayerTiling* tiling,
       PicturePileImpl* pile) {
-    for (PictureLayerTiling::Iterator
+    for (PictureLayerTiling::CoverageIterator
              iter(tiling, tiling->contents_scale(), tiling->ContentRect());
          iter;
          ++iter) {
       EXPECT_TRUE(*iter);
       EXPECT_EQ(pile, iter->picture_pile());
     }
   }
 
   void SetContentsScaleOnBothLayers(float scale, bool animating_transform) {
     float result_scale_x, result_scale_y;
@@ skipping 121 matching lines @@
   Region invalidation(layer_invalidation);
   AddDefaultTilingsWithInvalidation(invalidation);
 
   const PictureLayerTilingSet& tilings = pending_layer_->tilings();
   EXPECT_GT(tilings.num_tilings(), 0u);
   for (size_t i = 0; i < tilings.num_tilings(); ++i) {
     const PictureLayerTiling* tiling = tilings.tiling_at(i);
     gfx::Rect content_invalidation = gfx::ToEnclosingRect(gfx::ScaleRect(
         layer_invalidation,
         tiling->contents_scale()));
-    for (PictureLayerTiling::Iterator
+    for (PictureLayerTiling::CoverageIterator
              iter(tiling,
                   tiling->contents_scale(),
                   tiling->ContentRect());
          iter;
          ++iter) {
       EXPECT_TRUE(*iter);
       EXPECT_FALSE(iter.geometry_rect().IsEmpty());
       if (iter.geometry_rect().Intersects(content_invalidation))
         EXPECT_EQ(pending_pile, iter->picture_pile());
       else
@@ skipping 41 matching lines @@
   Region invalidation;
   AddDefaultTilingsWithInvalidation(invalidation);
 
   const PictureLayerTilingSet& tilings = pending_layer_->tilings();
   EXPECT_GT(tilings.num_tilings(), 0u);
   for (size_t i = 0; i < tilings.num_tilings(); ++i) {
     const PictureLayerTiling* tiling = tilings.tiling_at(i);
     gfx::Rect active_content_bounds = gfx::ToEnclosingRect(gfx::ScaleRect(
         gfx::Rect(active_layer_bounds),
         tiling->contents_scale()));
-    for (PictureLayerTiling::Iterator
+    for (PictureLayerTiling::CoverageIterator
              iter(tiling,
                   tiling->contents_scale(),
                   tiling->ContentRect());
          iter;
          ++iter) {
       EXPECT_TRUE(*iter);
       EXPECT_FALSE(iter.geometry_rect().IsEmpty());
       if (iter.geometry_rect().right() >= active_content_bounds.width() ||
           iter.geometry_rect().bottom() >= active_content_bounds.height()) {
         EXPECT_EQ(pending_pile, iter->picture_pile());
@@ skipping 30 matching lines @@
 
   SetupTrees(pending_pile, active_pile);
   Region invalidation;
   AddDefaultTilingsWithInvalidation(invalidation);
 
   const PictureLayerTilingSet& tilings = pending_layer_->tilings();
   EXPECT_GT(tilings.num_tilings(), 0u);
   for (size_t i = 0; i < tilings.num_tilings(); ++i) {
     const PictureLayerTiling* tiling = tilings.tiling_at(i);
 
-    for (PictureLayerTiling::Iterator
+    for (PictureLayerTiling::CoverageIterator
              iter(tiling,
                   tiling->contents_scale(),
                   tiling->ContentRect());
          iter;
          ++iter) {
       EXPECT_FALSE(iter.full_tile_geometry_rect().IsEmpty());
       // Ensure there is a recording for this tile.
       gfx::Rect layer_rect = gfx::ToEnclosingRect(gfx::ScaleRect(
           iter.full_tile_geometry_rect(), 1.f / tiling->contents_scale()));
       layer_rect.Intersect(gfx::Rect(layer_bounds));
@@ skipping 229 matching lines @@
   used_tilings.push_back(active_layer_->tilings().tiling_at(1));
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(3u, active_layer_->tilings().num_tilings());
   used_tilings.clear();
   active_layer_->CleanUpTilingsOnActiveLayer(used_tilings);
   ASSERT_EQ(2u, active_layer_->tilings().num_tilings());
 }
 
 }  // namespace
 }  // namespace cc