cc: Rename PictureLayerTiling(Set) Iterator to CoverageIterator

cc/resources/picture_layer_tiling_unittest.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 "cc/test/fake_picture_layer_tiling_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/size_conversions.h"
@@ skipping 22 matching lines @@
     EXPECT_TRUE(request_rect.Contains(expect_rect));
 
     // Iterators are not valid if this ratio is too large (i.e. the
     // tiling is too high-res for a low-res destination rect.)  This is an
     // artifact of snapping geometry to integer coordinates and then mapping
     // back to floating point texture coordinates.
     float dest_to_contents_scale = tiling_->contents_scale() / rect_scale;
     ASSERT_LE(dest_to_contents_scale, 2.0);
 
     Region remaining = expect_rect;
-    for (PictureLayerTiling::Iterator iter(tiling_.get(),
-                                           rect_scale,
-                                           request_rect);
+    for (PictureLayerTiling::CoverageIterator
+             iter(tiling_.get(), rect_scale, request_rect);
          iter;
          ++iter) {
       // Geometry cannot overlap previous geometry at all
       gfx::Rect geometry = iter.geometry_rect();
       EXPECT_TRUE(expect_rect.Contains(geometry));
       EXPECT_TRUE(remaining.Contains(geometry));
       remaining.Subtract(geometry);
 
       // Sanity check that texture coords are within the texture rect.
       gfx::RectF texture_rect = iter.texture_rect();
@@ skipping 79 matching lines @@
   gfx::Rect full_rect(gfx::ToCeiledSize(gfx::ScaleSize(bounds, scale)));
   Initialize(gfx::Size(256, 512), 5.2f, bounds);
   VerifyTilesExactlyCoverRect(scale, full_rect);
   VerifyTilesExactlyCoverRect(scale, gfx::Rect(2014, 1579, 867, 1033));
 }
 
 TEST_F(PictureLayerTilingIteratorTest, IteratorEmptyRect) {
   Initialize(gfx::Size(100, 100), 1.0f, gfx::Size(800, 600));
 
   gfx::Rect empty;
-  PictureLayerTiling::Iterator iter(tiling_.get(), 1.0f, empty);
+  PictureLayerTiling::CoverageIterator iter(tiling_.get(), 1.0f, empty);
   EXPECT_FALSE(iter);
 }
 
 TEST_F(PictureLayerTilingIteratorTest, NonIntersectingRect) {
   Initialize(gfx::Size(100, 100), 1.0f, gfx::Size(800, 600));
   gfx::Rect non_intersecting(1000, 1000, 50, 50);
-  PictureLayerTiling::Iterator iter(tiling_.get(), 1, non_intersecting);
+  PictureLayerTiling::CoverageIterator iter(tiling_.get(), 1, non_intersecting);
   EXPECT_FALSE(iter);
 }
 
 TEST_F(PictureLayerTilingIteratorTest, LayerEdgeTextureCoordinates) {
   Initialize(gfx::Size(300, 300), 1.0f, gfx::Size(256, 256));
   // All of these sizes are 256x256, scaled and ceiled.
   VerifyTilesExactlyCoverRect(1.0f, gfx::Rect(0, 0, 256, 256));
   VerifyTilesExactlyCoverRect(0.8f, gfx::Rect(0, 0, 205, 205));
   VerifyTilesExactlyCoverRect(1.2f, gfx::Rect(0, 0, 308, 308));
 }
@@ skipping 191 matching lines @@
   gfx::Rect in(40, 50, 100, 200);
   gfx::Rect bounds(0, 0, 10, 10);
   int64 target_area = 400 * 400;
   gfx::Rect out = PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
       in, target_area, bounds);
   EXPECT_TRUE(out.IsEmpty());
 }
 
 }  // namespace
 }  // namespace cc