cc: Drop an unused member variable from tiling data iterators

cc/base/tiling_data.cc

 // Copyright 2010 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/base/tiling_data.h"
 
 #include <algorithm>
 
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/vector2d.h"
@@ skipping 275 matching lines @@
   return gfx::Vector2d(left, top);
 }
 
 void TilingData::RecomputeNumTiles() {
   num_tiles_x_ = ComputeNumTiles(
       max_texture_size_.width(), tiling_size_.width(), border_texels_);
   num_tiles_y_ = ComputeNumTiles(
       max_texture_size_.height(), tiling_size_.height(), border_texels_);
 }
 
-TilingData::BaseIterator::BaseIterator(const TilingData* tiling_data)
-    : tiling_data_(tiling_data),
-      index_x_(-1),
-      index_y_(-1) {
+TilingData::BaseIterator::BaseIterator() : index_x_(-1), index_y_(-1) {
 }
 
-TilingData::Iterator::Iterator() : BaseIterator(nullptr) { done(); }
+TilingData::Iterator::Iterator() {
+  done();
+}
 
 TilingData::Iterator::Iterator(const TilingData* tiling_data,
                                const gfx::Rect& consider_rect,
                                bool include_borders)
-    : BaseIterator(tiling_data), left_(-1), right_(-1), bottom_(-1) {
-  if (tiling_data_->num_tiles_x() <= 0 || tiling_data_->num_tiles_y() <= 0) {
+    : left_(-1), right_(-1), bottom_(-1) {
+  if (tiling_data->num_tiles_x() <= 0 || tiling_data->num_tiles_y() <= 0) {
     done();
     return;
   }
 
-  gfx::Rect tiling_bounds_rect(tiling_data_->tiling_size());
+  gfx::Rect tiling_bounds_rect(tiling_data->tiling_size());
   gfx::Rect rect(consider_rect);
   rect.Intersect(tiling_bounds_rect);
 
   gfx::Rect top_left_tile;
   if (include_borders) {
-    index_x_ = tiling_data_->FirstBorderTileXIndexFromSrcCoord(rect.x());
-    index_y_ = tiling_data_->FirstBorderTileYIndexFromSrcCoord(rect.y());
-    right_ = tiling_data_->LastBorderTileXIndexFromSrcCoord(rect.right() - 1);
-    bottom_ = tiling_data_->LastBorderTileYIndexFromSrcCoord(rect.bottom() - 1);
-    top_left_tile = tiling_data_->TileBoundsWithBorder(index_x_, index_y_);
+    index_x_ = tiling_data->FirstBorderTileXIndexFromSrcCoord(rect.x());
+    index_y_ = tiling_data->FirstBorderTileYIndexFromSrcCoord(rect.y());
+    right_ = tiling_data->LastBorderTileXIndexFromSrcCoord(rect.right() - 1);
+    bottom_ = tiling_data->LastBorderTileYIndexFromSrcCoord(rect.bottom() - 1);
+    top_left_tile = tiling_data->TileBoundsWithBorder(index_x_, index_y_);
   } else {
-    index_x_ = tiling_data_->TileXIndexFromSrcCoord(rect.x());
-    index_y_ = tiling_data_->TileYIndexFromSrcCoord(rect.y());
-    right_ = tiling_data_->TileXIndexFromSrcCoord(rect.right() - 1);
-    bottom_ = tiling_data_->TileYIndexFromSrcCoord(rect.bottom() - 1);
-    top_left_tile = tiling_data_->TileBounds(index_x_, index_y_);
+    index_x_ = tiling_data->TileXIndexFromSrcCoord(rect.x());
+    index_y_ = tiling_data->TileYIndexFromSrcCoord(rect.y());
+    right_ = tiling_data->TileXIndexFromSrcCoord(rect.right() - 1);
+    bottom_ = tiling_data->TileYIndexFromSrcCoord(rect.bottom() - 1);
+    top_left_tile = tiling_data->TileBounds(index_x_, index_y_);
   }
   left_ = index_x_;
 
   // Index functions always return valid indices, so explicitly check
   // for non-intersecting rects.
   if (!top_left_tile.Intersects(rect))
     done();
 }
 
 TilingData::Iterator& TilingData::Iterator::operator++() {
   if (!*this)
     return *this;
 
   index_x_++;
   if (index_x_ > right_) {
     index_x_ = left_;
     index_y_++;
     if (index_y_ > bottom_)
       done();
   }
 
   return *this;
 }
 
 TilingData::DifferenceIterator::DifferenceIterator(
     const TilingData* tiling_data,
     const gfx::Rect& consider_rect,
     const gfx::Rect& ignore_rect)
-    : BaseIterator(tiling_data),
-      consider_left_(-1),
+    : consider_left_(-1),
       consider_top_(-1),
       consider_right_(-1),
       consider_bottom_(-1),
       ignore_left_(-1),
       ignore_top_(-1),
       ignore_right_(-1),
       ignore_bottom_(-1) {
-  if (tiling_data_->num_tiles_x() <= 0 || tiling_data_->num_tiles_y() <= 0) {
+  if (tiling_data->num_tiles_x() <= 0 || tiling_data->num_tiles_y() <= 0) {
     done();
     return;
   }
 
-  gfx::Rect tiling_bounds_rect(tiling_data_->tiling_size());
+  gfx::Rect tiling_bounds_rect(tiling_data->tiling_size());
   gfx::Rect consider(consider_rect);
   gfx::Rect ignore(ignore_rect);
   consider.Intersect(tiling_bounds_rect);
   ignore.Intersect(tiling_bounds_rect);
   if (consider.IsEmpty()) {
     done();
     return;
   }
 
-  consider_left_ = tiling_data_->TileXIndexFromSrcCoord(consider.x());
-  consider_top_ = tiling_data_->TileYIndexFromSrcCoord(consider.y());
-  consider_right_ = tiling_data_->TileXIndexFromSrcCoord(consider.right() - 1);
-  consider_bottom_ =
-      tiling_data_->TileYIndexFromSrcCoord(consider.bottom() - 1);
+  consider_left_ = tiling_data->TileXIndexFromSrcCoord(consider.x());
+  consider_top_ = tiling_data->TileYIndexFromSrcCoord(consider.y());
+  consider_right_ = tiling_data->TileXIndexFromSrcCoord(consider.right() - 1);
+  consider_bottom_ = tiling_data->TileYIndexFromSrcCoord(consider.bottom() - 1);
 
   if (!ignore.IsEmpty()) {
-    ignore_left_ = tiling_data_->TileXIndexFromSrcCoord(ignore.x());
-    ignore_top_ = tiling_data_->TileYIndexFromSrcCoord(ignore.y());
-    ignore_right_ = tiling_data_->TileXIndexFromSrcCoord(ignore.right() - 1);
-    ignore_bottom_ = tiling_data_->TileYIndexFromSrcCoord(ignore.bottom() - 1);
+    ignore_left_ = tiling_data->TileXIndexFromSrcCoord(ignore.x());
+    ignore_top_ = tiling_data->TileYIndexFromSrcCoord(ignore.y());
+    ignore_right_ = tiling_data->TileXIndexFromSrcCoord(ignore.right() - 1);
+    ignore_bottom_ = tiling_data->TileYIndexFromSrcCoord(ignore.bottom() - 1);
 
     // Clamp ignore indices to consider indices.
     ignore_left_ = std::max(ignore_left_, consider_left_);
     ignore_top_ = std::max(ignore_top_, consider_top_);
     ignore_right_ = std::min(ignore_right_, consider_right_);
     ignore_bottom_ = std::min(ignore_bottom_, consider_bottom_);
   }
 
   if (ignore_left_ == consider_left_ && ignore_right_ == consider_right_ &&
       ignore_top_ == consider_top_ && ignore_bottom_ == consider_bottom_) {
@@ skipping 30 matching lines @@
       }
     }
 
     if (index_y_ > consider_bottom_)
       done();
   }
 
   return *this;
 }
 
-TilingData::SpiralDifferenceIterator::SpiralDifferenceIterator()
-    : BaseIterator(nullptr) {
+TilingData::SpiralDifferenceIterator::SpiralDifferenceIterator() {
   done();
 }
 
 TilingData::SpiralDifferenceIterator::SpiralDifferenceIterator(
     const TilingData* tiling_data,
     const gfx::Rect& consider_rect,
     const gfx::Rect& ignore_rect,
     const gfx::Rect& center_rect)
-    : BaseIterator(tiling_data),
-      consider_left_(-1),
+    : consider_left_(-1),
       consider_top_(-1),
       consider_right_(-1),
       consider_bottom_(-1),
       ignore_left_(-1),
       ignore_top_(-1),
       ignore_right_(-1),
       ignore_bottom_(-1),
       direction_(RIGHT),
       delta_x_(1),
       delta_y_(0),
       current_step_(0),
       horizontal_step_count_(0),
       vertical_step_count_(0) {
-  if (tiling_data_->num_tiles_x() <= 0 || tiling_data_->num_tiles_y() <= 0) {
+  if (tiling_data->num_tiles_x() <= 0 || tiling_data->num_tiles_y() <= 0) {
     done();
     return;
   }
 
-  gfx::Rect tiling_bounds_rect(tiling_data_->tiling_size());
+  gfx::Rect tiling_bounds_rect(tiling_data->tiling_size());
   gfx::Rect consider(consider_rect);
   gfx::Rect ignore(ignore_rect);
   gfx::Rect center(center_rect);
   consider.Intersect(tiling_bounds_rect);
   ignore.Intersect(tiling_bounds_rect);
   if (consider.IsEmpty()) {
     done();
     return;
   }
 
-  consider_left_ = tiling_data_->TileXIndexFromSrcCoord(consider.x());
-  consider_top_ = tiling_data_->TileYIndexFromSrcCoord(consider.y());
-  consider_right_ = tiling_data_->TileXIndexFromSrcCoord(consider.right() - 1);
-  consider_bottom_ =
-      tiling_data_->TileYIndexFromSrcCoord(consider.bottom() - 1);
+  consider_left_ = tiling_data->TileXIndexFromSrcCoord(consider.x());
+  consider_top_ = tiling_data->TileYIndexFromSrcCoord(consider.y());
+  consider_right_ = tiling_data->TileXIndexFromSrcCoord(consider.right() - 1);
+  consider_bottom_ = tiling_data->TileYIndexFromSrcCoord(consider.bottom() - 1);
 
   if (!ignore.IsEmpty()) {
-    ignore_left_ = tiling_data_->TileXIndexFromSrcCoord(ignore.x());
-    ignore_top_ = tiling_data_->TileYIndexFromSrcCoord(ignore.y());
-    ignore_right_ = tiling_data_->TileXIndexFromSrcCoord(ignore.right() - 1);
-    ignore_bottom_ = tiling_data_->TileYIndexFromSrcCoord(ignore.bottom() - 1);
+    ignore_left_ = tiling_data->TileXIndexFromSrcCoord(ignore.x());
+    ignore_top_ = tiling_data->TileYIndexFromSrcCoord(ignore.y());
+    ignore_right_ = tiling_data->TileXIndexFromSrcCoord(ignore.right() - 1);
+    ignore_bottom_ = tiling_data->TileYIndexFromSrcCoord(ignore.bottom() - 1);
 
     // Clamp ignore indices to consider indices.
     ignore_left_ = std::max(ignore_left_, consider_left_);
     ignore_top_ = std::max(ignore_top_, consider_top_);
     ignore_right_ = std::min(ignore_right_, consider_right_);
     ignore_bottom_ = std::min(ignore_bottom_, consider_bottom_);
   }
 
   if (ignore_left_ == consider_left_ && ignore_right_ == consider_right_ &&
       ignore_top_ == consider_top_ && ignore_bottom_ == consider_bottom_) {
@@ skipping 154 matching lines @@
 
   current_step_ = 0;
   direction_ = static_cast<Direction>((direction_ + 1) % 4);
 
   if (direction_ == RIGHT || direction_ == LEFT) {
     ++vertical_step_count_;
     ++horizontal_step_count_;
   }
 }
 
-TilingData::ReverseSpiralDifferenceIterator::ReverseSpiralDifferenceIterator()
-    : BaseIterator(nullptr) {
+TilingData::ReverseSpiralDifferenceIterator::ReverseSpiralDifferenceIterator() {
   done();
 }
 
 TilingData::ReverseSpiralDifferenceIterator::ReverseSpiralDifferenceIterator(
     const TilingData* tiling_data,
     const gfx::Rect& consider_rect,
     const gfx::Rect& ignore_rect,
     const gfx::Rect& center_rect)
-    : BaseIterator(tiling_data),
-      consider_left_(-1),
+    : consider_left_(-1),
       consider_top_(-1),
       consider_right_(-1),
       consider_bottom_(-1),
       around_left_(-1),
       around_top_(-1),
       around_right_(-1),
       around_bottom_(-1),
       ignore_left_(-1),
       ignore_top_(-1),
       ignore_right_(-1),
       ignore_bottom_(-1),
       direction_(LEFT),
       delta_x_(-1),
       delta_y_(0),
       current_step_(0),
       horizontal_step_count_(0),
       vertical_step_count_(0) {
-  if (tiling_data_->num_tiles_x() <= 0 || tiling_data_->num_tiles_y() <= 0) {
+  if (tiling_data->num_tiles_x() <= 0 || tiling_data->num_tiles_y() <= 0) {
     done();
     return;
   }
 
-  gfx::Rect tiling_bounds_rect(tiling_data_->tiling_size());
+  gfx::Rect tiling_bounds_rect(tiling_data->tiling_size());
   gfx::Rect consider(consider_rect);
   gfx::Rect ignore(ignore_rect);
   gfx::Rect center(center_rect);
   consider.Intersect(tiling_bounds_rect);
   ignore.Intersect(tiling_bounds_rect);
   if (consider.IsEmpty()) {
     done();
     return;
   }
 
-  consider_left_ = tiling_data_->TileXIndexFromSrcCoord(consider.x());
-  consider_top_ = tiling_data_->TileYIndexFromSrcCoord(consider.y());
-  consider_right_ = tiling_data_->TileXIndexFromSrcCoord(consider.right() - 1);
-  consider_bottom_ =
-      tiling_data_->TileYIndexFromSrcCoord(consider.bottom() - 1);
+  consider_left_ = tiling_data->TileXIndexFromSrcCoord(consider.x());
+  consider_top_ = tiling_data->TileYIndexFromSrcCoord(consider.y());
+  consider_right_ = tiling_data->TileXIndexFromSrcCoord(consider.right() - 1);
+  consider_bottom_ = tiling_data->TileYIndexFromSrcCoord(consider.bottom() - 1);
 
   if (!ignore.IsEmpty()) {
-    ignore_left_ = tiling_data_->TileXIndexFromSrcCoord(ignore.x());
-    ignore_top_ = tiling_data_->TileYIndexFromSrcCoord(ignore.y());
-    ignore_right_ = tiling_data_->TileXIndexFromSrcCoord(ignore.right() - 1);
-    ignore_bottom_ = tiling_data_->TileYIndexFromSrcCoord(ignore.bottom() - 1);
+    ignore_left_ = tiling_data->TileXIndexFromSrcCoord(ignore.x());
+    ignore_top_ = tiling_data->TileYIndexFromSrcCoord(ignore.y());
+    ignore_right_ = tiling_data->TileXIndexFromSrcCoord(ignore.right() - 1);
+    ignore_bottom_ = tiling_data->TileYIndexFromSrcCoord(ignore.bottom() - 1);
 
     // Clamp ignore indices to consider indices.
     ignore_left_ = std::max(ignore_left_, consider_left_);
     ignore_top_ = std::max(ignore_top_, consider_top_);
     ignore_right_ = std::min(ignore_right_, consider_right_);
     ignore_bottom_ = std::min(ignore_bottom_, consider_bottom_);
   }
 
   if (ignore_left_ == consider_left_ && ignore_right_ == consider_right_ &&
       ignore_top_ == consider_top_ && ignore_bottom_ == consider_bottom_) {
@@ skipping 186 matching lines @@
 
     // We should always end up in an around rect at some point.
     // Since the direction is now vertical, we have to ensure that we will
     // advance.
     DCHECK_GE(horizontal_step_count_, 1);
     DCHECK_GE(vertical_step_count_, 1);
   }
 }
 
 }  // namespace cc