cc: Rename PictureLayerTiling(Set) Iterator to CoverageIterator

cc/layers/picture_layer_impl.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/layers/picture_layer_impl.h"
 
 #include <algorithm>
 
 #include "base/time.h"
 #include "cc/base/math_util.h"
@@ skipping 88 matching lines @@
   SharedQuadState* shared_quad_state =
       quad_sink->UseSharedQuadState(CreateSharedQuadState());
   AppendDebugBorderQuad(quad_sink, shared_quad_state, append_quads_data);
 
   bool clipped = false;
   gfx::QuadF target_quad = MathUtil::MapQuad(
       draw_transform(),
       gfx::QuadF(rect),
       &clipped);
   if (ShowDebugBorders()) {
-    for (PictureLayerTilingSet::Iterator iter(tilings_.get(),
-                                              contents_scale_x(),
-                                              rect,
-                                              ideal_contents_scale_);
+    for (PictureLayerTilingSet::CoverageIterator iter(
+        tilings_.get(), contents_scale_x(), rect, ideal_contents_scale_);
          iter;
          ++iter) {
       SkColor color;
       float width;
       if (*iter && iter->drawing_info().IsReadyToDraw()) {
         ManagedTileState::DrawingInfo::Mode mode = iter->drawing_info().mode();
         if (mode == ManagedTileState::DrawingInfo::SOLID_COLOR_MODE ||
             mode == ManagedTileState::DrawingInfo::TRANSPARENT_MODE) {
           color = DebugColors::SolidColorTileBorderColor();
           width = DebugColors::SolidColorTileBorderWidth(layer_tree_impl());
@@ skipping 24 matching lines @@
       debug_border_quad->SetNew(shared_quad_state, geometry_rect, color, width);
       quad_sink->Append(debug_border_quad.PassAs<DrawQuad>(),
                         append_quads_data);
     }
   }
 
   // Keep track of the tilings that were used so that tilings that are
   // unused can be considered for removal.
   std::vector<PictureLayerTiling*> seen_tilings;
 
-  for (PictureLayerTilingSet::Iterator iter(tilings_.get(),
-                                            contents_scale_x(),
-                                            rect,
-                                            ideal_contents_scale_);
+  for (PictureLayerTilingSet::CoverageIterator iter(
+      tilings_.get(), contents_scale_x(), rect, ideal_contents_scale_);
        iter;
        ++iter) {
     gfx::Rect geometry_rect = iter.geometry_rect();
     if (!*iter || !iter->drawing_info().IsReadyToDraw()) {
       if (DrawCheckerboardForMissingTiles()) {
         // TODO(enne): Figure out how to show debug "invalidated checker" color
         scoped_ptr<CheckerboardDrawQuad> quad = CheckerboardDrawQuad::Create();
         SkColor color = DebugColors::DefaultCheckerboardColor();
         quad->SetNew(shared_quad_state, geometry_rect, color);
         if (quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data))
@@ skipping 324 matching lines @@
   if (is_mask_ == is_mask)
     return;
   is_mask_ = is_mask;
   if (tilings_)
     tilings_->RemoveAllTiles();
 }
 
 ResourceProvider::ResourceId PictureLayerImpl::ContentsResourceId() const {
   gfx::Rect content_rect(content_bounds());
   float scale = contents_scale_x();
-  for (PictureLayerTilingSet::Iterator
+  for (PictureLayerTilingSet::CoverageIterator
            iter(tilings_.get(), scale, content_rect, ideal_contents_scale_);
        iter;
        ++iter) {
     // Mask resource not ready yet.
     if (!*iter ||
         iter->drawing_info().mode() !=
             ManagedTileState::DrawingInfo::RESOURCE_MODE ||
         !iter->drawing_info().IsReadyToDraw())
       return 0;
     // Masks only supported if they fit on exactly one tile.
@@ skipping 26 matching lines @@
         std::min(twin->ideal_contents_scale_, twin->raster_contents_scale_));
   }
 
   Region missing_region = rect;
   for (size_t i = 0; i < tilings_->num_tilings(); ++i) {
     PictureLayerTiling* tiling = tilings_->tiling_at(i);
 
     if (tiling->contents_scale() < min_acceptable_scale)
       continue;
 
-    for (PictureLayerTiling::Iterator iter(tiling, contents_scale_x(), rect);
+    for (PictureLayerTiling::CoverageIterator iter(tiling,
+                                                   contents_scale_x(),
+                                                   rect);
          iter;
          ++iter) {
       if (should_force_uploads && *iter)
         layer_tree_impl()->tile_manager()->ForceTileUploadToComplete(*iter);
       // A null tile (i.e. no recording) is considered "ready".
       if (!*iter || iter->drawing_info().IsReadyToDraw())
         missing_region.Subtract(iter.geometry_rect());
     }
   }
 
@@ skipping 301 matching lines @@
 scoped_ptr<base::Value> PictureLayerImpl::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   LayerImpl::AsValueInto(state.get());
 
   state->SetDouble("ideal_contents_scale", ideal_contents_scale_);
   state->Set("tilings", tilings_->AsValue().release());
   return state.PassAs<base::Value>();
 }
 
 }  // namespace cc