cc: Rename PictureLayerTiling(Set) Iterator to CoverageIterator

cc/resources/picture_layer_tiling_set.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_set.h"
 
 namespace cc {
 
 namespace {
 
@@ skipping 93 matching lines @@
 void PictureLayerTilingSet::RemoveAllTiles() {
   for (size_t i = 0; i < tilings_.size(); ++i)
     tilings_[i]->Reset();
 }
 
 void PictureLayerTilingSet::CreateTilesFromLayerRect(gfx::Rect layer_rect) {
   for (size_t i = 0; i < tilings_.size(); ++i)
     tilings_[i]->CreateTilesFromLayerRect(layer_rect);
 }
 
-PictureLayerTilingSet::Iterator::Iterator(
+PictureLayerTilingSet::CoverageIterator::CoverageIterator(
     const PictureLayerTilingSet* set,
     float contents_scale,
     gfx::Rect content_rect,
     float ideal_contents_scale)
     : set_(set),
       contents_scale_(contents_scale),
       ideal_contents_scale_(ideal_contents_scale),
       current_tiling_(-1) {
   missing_region_.Union(content_rect);
 
   for (ideal_tiling_ = 0;
        static_cast<size_t>(ideal_tiling_) < set_->tilings_.size();
        ++ideal_tiling_) {
     PictureLayerTiling* tiling = set_->tilings_[ideal_tiling_];
     if (tiling->contents_scale() < ideal_contents_scale_) {
       if (ideal_tiling_ > 0)
         ideal_tiling_--;
       break;
     }
   }
 
   if (ideal_tiling_ == set_->tilings_.size() && ideal_tiling_ > 0)
     ideal_tiling_--;
 
   ++(*this);
 }
 
-PictureLayerTilingSet::Iterator::~Iterator() {
+PictureLayerTilingSet::CoverageIterator::~CoverageIterator() {
 }
 
-gfx::Rect PictureLayerTilingSet::Iterator::geometry_rect() const {
+gfx::Rect PictureLayerTilingSet::CoverageIterator::geometry_rect() const {
   if (!tiling_iter_) {
     if (!region_iter_.has_rect())
       return gfx::Rect();
     return region_iter_.rect();
   }
   return tiling_iter_.geometry_rect();
 }
 
-gfx::RectF PictureLayerTilingSet::Iterator::texture_rect() const {
+gfx::RectF PictureLayerTilingSet::CoverageIterator::texture_rect() const {
   if (!tiling_iter_)
     return gfx::RectF();
   return tiling_iter_.texture_rect();
 }
 
-gfx::Size PictureLayerTilingSet::Iterator::texture_size() const {
+gfx::Size PictureLayerTilingSet::CoverageIterator::texture_size() const {
   if (!tiling_iter_)
     return gfx::Size();
   return tiling_iter_.texture_size();
 }
 
-Tile* PictureLayerTilingSet::Iterator::operator->() const {
+Tile* PictureLayerTilingSet::CoverageIterator::operator->() const {
   if (!tiling_iter_)
     return NULL;
   return *tiling_iter_;
 }
 
-Tile* PictureLayerTilingSet::Iterator::operator*() const {
+Tile* PictureLayerTilingSet::CoverageIterator::operator*() const {
   if (!tiling_iter_)
     return NULL;
   return *tiling_iter_;
 }
 
-PictureLayerTiling* PictureLayerTilingSet::Iterator::CurrentTiling() {
+PictureLayerTiling* PictureLayerTilingSet::CoverageIterator::CurrentTiling() {
   if (current_tiling_ < 0)
     return NULL;
   if (static_cast<size_t>(current_tiling_) >= set_->tilings_.size())
     return NULL;
   return set_->tilings_[current_tiling_];
 }
 
-int PictureLayerTilingSet::Iterator::NextTiling() const {
+int PictureLayerTilingSet::CoverageIterator::NextTiling() const {
   // Order returned by this method is:
   // 1. Ideal tiling index
   // 2. Tiling index < Ideal in decreasing order (higher res than ideal)
   // 3. Tiling index > Ideal in increasing order (lower res than ideal)
   // 4. Tiling index > tilings.size() (invalid index)
   if (current_tiling_ < 0)
     return ideal_tiling_;
   else if (current_tiling_ > ideal_tiling_)
     return current_tiling_ + 1;
   else if (current_tiling_)
     return current_tiling_ - 1;
   else
     return ideal_tiling_ + 1;
 }
 
-PictureLayerTilingSet::Iterator& PictureLayerTilingSet::Iterator::operator++() {
+PictureLayerTilingSet::CoverageIterator&
+PictureLayerTilingSet::CoverageIterator::operator++() {
   bool first_time = current_tiling_ < 0;
 
   if (!*this && !first_time)
     return *this;
 
   if (tiling_iter_)
     ++tiling_iter_;
 
   // Loop until we find a valid place to stop.
   while (true) {
@@ skipping 29 matching lines @@
     // treated as geometry with null tiles that the caller can checkerboard.
     gfx::Rect last_rect = region_iter_.rect();
     region_iter_.next();
 
     // Done, found next checkerboard rect to return.
     if (current_tiling_ >= static_cast<int>(set_->tilings_.size()))
       return *this;
 
     // Construct a new iterator for the next tiling, but we need to loop
     // again until we get to a valid one.
-    tiling_iter_ = PictureLayerTiling::Iterator(
+    tiling_iter_ = PictureLayerTiling::CoverageIterator(
         set_->tilings_[current_tiling_],
         contents_scale_,
         last_rect);
   }
 
   return *this;
 }
 
-PictureLayerTilingSet::Iterator::operator bool() const {
+PictureLayerTilingSet::CoverageIterator::operator bool() const {
   return current_tiling_ < static_cast<int>(set_->tilings_.size()) ||
       region_iter_.has_rect();
 }
 
 void PictureLayerTilingSet::UpdateTilePriorities(
     WhichTree tree,
     gfx::Size device_viewport,
     gfx::Rect viewport_in_content_space,
     gfx::Size last_layer_bounds,
     gfx::Size current_layer_bounds,
@@ skipping 34 matching lines @@
 }
 
 scoped_ptr<base::Value> PictureLayerTilingSet::AsValue() const {
   scoped_ptr<base::ListValue> state(new base::ListValue());
   for (size_t i = 0; i < tilings_.size(); ++i)
     state->Append(tilings_[i]->AsValue().release());
   return state.PassAs<base::Value>();
 }
 
 }  // namespace cc