cc: Implement IndexRect for encapsulating tile indices.

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"
 
 namespace cc {
 
+namespace {
+const IndexRect kOutOfBoundsIndexRect(-1, -1, -1, -1);

[vmpstr, 2016/09/19 18:01:11]

This is technically a valid index rect, should we make it invalid?

[prashant.n, 2016/09/20 02:04:58]

As per current implementation of spiral iterator, this is invalid, but with
respect to pyramid sequence, as pointed out it is valid. But for tiling we
consider only positive quadrant, so I named it as out of bounds.

I was thinking to move this constant to index_rect.h and adding following
function, so that other files can also use it.

is_out_of_bounds() or may be we can have some other function name.
(is_in_positive_quadrant() meaning left, right, top and bottom all >= 0).

+}
+
 static int ComputeNumTiles(int max_texture_size,
                            int total_size,
                            int border_texels) {
   if (max_texture_size - 2 * border_texels <= 0)
     return total_size > 0 && max_texture_size >= total_size ? 1 : 0;
 
   int num_tiles = std::max(1,
                            1 + (total_size - 1 - 2 * border_texels) /
                            (max_texture_size - 2 * border_texels));
   return total_size > 0 ? num_tiles : 0;
@@ skipping 265 matching lines @@
 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() : index_x_(-1), index_y_(-1) {
 }
 
-TilingData::Iterator::Iterator() {
+TilingData::Iterator::Iterator() : index_rect_(kOutOfBoundsIndexRect) {
   done();
 }
 
 TilingData::Iterator::Iterator(const TilingData* tiling_data,
                                const gfx::Rect& consider_rect,
                                bool include_borders)
-    : left_(-1), right_(-1), bottom_(-1) {
+    : index_rect_(kOutOfBoundsIndexRect) {
   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 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);
+    index_rect_ = IndexRect(
+        index_x_,
+        tiling_data->LastBorderTileXIndexFromSrcCoord(rect.right() - 1),
+        index_y_,
+        tiling_data->LastBorderTileYIndexFromSrcCoord(rect.bottom() - 1));
+    DCHECK(index_rect_.is_valid());
     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);
+    index_rect_ = IndexRect(
+        index_x_, tiling_data->TileXIndexFromSrcCoord(rect.right() - 1),
+        index_y_, tiling_data->TileYIndexFromSrcCoord(rect.bottom() - 1));
+    DCHECK(index_rect_.is_valid());
     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_;
+  if (index_x_ > index_rect_.right()) {
+    index_x_ = index_rect_.left();
     index_y_++;
-    if (index_y_ > bottom_)
+    if (index_y_ > index_rect_.bottom())
       done();
   }
 
   return *this;
 }
 
-TilingData::BaseDifferenceIterator::BaseDifferenceIterator() {
+TilingData::BaseDifferenceIterator::BaseDifferenceIterator()
+    : consider_index_rect_(kOutOfBoundsIndexRect),
+      ignore_index_rect_(kOutOfBoundsIndexRect) {
   done();
 }
 
 TilingData::BaseDifferenceIterator::BaseDifferenceIterator(
     const TilingData* tiling_data,
     const gfx::Rect& consider_rect,
     const gfx::Rect& ignore_rect)
-    : consider_left_(-1),
-      consider_top_(-1),
-      consider_right_(-1),
-      consider_bottom_(-1),
-      ignore_left_(-1),
-      ignore_top_(-1),
-      ignore_right_(-1),
-      ignore_bottom_(-1) {
+    : consider_index_rect_(kOutOfBoundsIndexRect),
+      ignore_index_rect_(kOutOfBoundsIndexRect) {
   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 consider(consider_rect);
   consider.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_index_rect_ =
+      IndexRect(tiling_data->TileXIndexFromSrcCoord(consider.x()),
+                tiling_data->TileXIndexFromSrcCoord(consider.right() - 1),
+                tiling_data->TileYIndexFromSrcCoord(consider.y()),
+                tiling_data->TileYIndexFromSrcCoord(consider.bottom() - 1));
+  DCHECK(consider_index_rect_.is_valid());
 
   gfx::Rect ignore(ignore_rect);
   ignore.Intersect(tiling_bounds_rect);
 
   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_index_rect_ =
+        IndexRect(tiling_data->TileXIndexFromSrcCoord(ignore.x()),
+                  tiling_data->TileXIndexFromSrcCoord(ignore.right() - 1),
+                  tiling_data->TileYIndexFromSrcCoord(ignore.y()),
+                  tiling_data->TileYIndexFromSrcCoord(ignore.bottom() - 1));
+    DCHECK(ignore_index_rect_.is_valid());
 
     // 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_);
+    ignore_index_rect_.ClampTo(consider_index_rect_);
 
-    if (ignore_left_ == consider_left_ && ignore_right_ == consider_right_ &&
-        ignore_top_ == consider_top_ && ignore_bottom_ == consider_bottom_) {
-      consider_left_ = consider_top_ = consider_right_ = consider_bottom_ = -1;
+    // If ignore rect is invalid, reset.
+    if (!ignore_index_rect_.is_valid())
+      ignore_index_rect_ = kOutOfBoundsIndexRect;
+
+    if (ignore_index_rect_ == consider_index_rect_) {
+      consider_index_rect_ = kOutOfBoundsIndexRect;
       done();
       return;
     }
   }
 }
 
 bool TilingData::BaseDifferenceIterator::HasConsiderRect() const {
   // Consider indices are either all valid or all equal to -1.
-  DCHECK((0 <= consider_left_ && consider_left_ <= consider_right_ &&
-          0 <= consider_top_ && consider_top_ <= consider_bottom_) ||
-         (consider_left_ == -1 && consider_top_ == -1 &&
-          consider_right_ == -1 && consider_bottom_ == -1));
-  return consider_left_ != -1;
+  DCHECK(
+      (0 <= consider_index_rect_.left() && 0 <= consider_index_rect_.top()) ||

[vmpstr, 2016/09/19 18:01:11]

i think this has to be

consider_index_rect_.left >= 0 && top >= 0 && rect.is_valid() || rect ==
outofbounds

(ie you're missing is_valid check). Also, if out of bounds rect is invalid, then
this can just be is_valid check.

[prashant.n, 2016/09/20 02:04:58]

We use DCHECK(is_valid()) after the object is constructed, so we can skip
checking again here.

+      (consider_index_rect_ == kOutOfBoundsIndexRect));
+  return consider_index_rect_.left() != -1;
 }
 
 TilingData::DifferenceIterator::DifferenceIterator() {
 }
 
 TilingData::DifferenceIterator::DifferenceIterator(
     const TilingData* tiling_data,
     const gfx::Rect& consider_rect,
     const gfx::Rect& ignore_rect)
     : BaseDifferenceIterator(tiling_data, consider_rect, ignore_rect) {
   if (!HasConsiderRect()) {
     done();
     return;
   }
 
-  index_x_ = consider_left_;
-  index_y_ = consider_top_;
+  index_x_ = consider_index_rect_.left();
+  index_y_ = consider_index_rect_.top();
 
-  if (in_ignore_rect())
+  if (ignore_index_rect_.Contains(index_x_, index_y_))
     ++(*this);
 }
 
 TilingData::DifferenceIterator& TilingData::DifferenceIterator::operator++() {
   if (!*this)
     return *this;
 
   index_x_++;
-  if (in_ignore_rect())
-    index_x_ = ignore_right_ + 1;
+  if (ignore_index_rect_.Contains(index_x_, index_y_))
+    index_x_ = ignore_index_rect_.right() + 1;
 
-  if (index_x_ > consider_right_) {
-    index_x_ = consider_left_;
+  if (index_x_ > consider_index_rect_.right()) {
+    index_x_ = consider_index_rect_.left();
     index_y_++;
 
-    if (in_ignore_rect()) {
-      index_x_ = ignore_right_ + 1;
+    if (ignore_index_rect_.Contains(index_x_, index_y_)) {
+      index_x_ = ignore_index_rect_.right() + 1;
       // If the ignore rect spans the whole consider rect horizontally, then
       // ignore_right + 1 will be out of bounds.
-      if (in_ignore_rect() || index_x_ > consider_right_) {
-        index_y_ = ignore_bottom_ + 1;
-        index_x_ = consider_left_;
+      if (ignore_index_rect_.Contains(index_x_, index_y_) ||
+          index_x_ > consider_index_rect_.right()) {
+        index_y_ = ignore_index_rect_.bottom() + 1;
+        index_x_ = consider_index_rect_.left();
       }
     }
 
-    if (index_y_ > consider_bottom_)
+    if (index_y_ > consider_index_rect_.bottom())
       done();
   }
 
   return *this;
 }
 
 TilingData::SpiralDifferenceIterator::SpiralDifferenceIterator() {
   done();
 }
 
@@ skipping 70 matching lines @@
 operator++() {
   int cannot_hit_consider_count = 0;
   while (cannot_hit_consider_count < 4) {
     if (needs_direction_switch())
       switch_direction();
 
     index_x_ += delta_x_;
     index_y_ += delta_y_;
     ++current_step_;
 
-    if (in_consider_rect()) {
+    if (consider_index_rect_.Contains(index_x_, index_y_)) {
       cannot_hit_consider_count = 0;
 
-      if (!in_ignore_rect())
+      if (!ignore_index_rect_.Contains(index_x_, index_y_))
         break;
 
       // Steps needed to reach the very edge of the ignore rect, while remaining
       // inside (so that the continue would take us outside).
       int steps_to_edge = 0;
       switch (direction_) {
         case UP:
-          steps_to_edge = index_y_ - ignore_top_;
+          steps_to_edge = index_y_ - ignore_index_rect_.top();
           break;
         case LEFT:
-          steps_to_edge = index_x_ - ignore_left_;
+          steps_to_edge = index_x_ - ignore_index_rect_.left();
           break;
         case DOWN:
-          steps_to_edge = ignore_bottom_ - index_y_;
+          steps_to_edge = ignore_index_rect_.bottom() - index_y_;
           break;
         case RIGHT:
-          steps_to_edge = ignore_right_ - index_x_;
+          steps_to_edge = ignore_index_rect_.right() - index_x_;
           break;
       }
 
       // We need to switch directions in |max_steps|.
       int max_steps = current_step_count() - current_step_;
 
       int steps_to_take = std::min(steps_to_edge, max_steps);
       DCHECK_GE(steps_to_take, 0);
 
       index_x_ += steps_to_take * delta_x_;
       index_y_ += steps_to_take * delta_y_;
       current_step_ += steps_to_take;
     } else {
       int max_steps = current_step_count() - current_step_;
       int steps_to_take = max_steps;
       bool can_hit_consider_rect = false;
       switch (direction_) {
         case UP:
-          if (valid_column() && consider_bottom_ < index_y_)
-            steps_to_take = index_y_ - consider_bottom_ - 1;
-          can_hit_consider_rect |= consider_right_ >= index_x_;
+          if (consider_index_rect_.valid_column(index_x_) &&
+              consider_index_rect_.bottom() < index_y_)
+            steps_to_take = index_y_ - consider_index_rect_.bottom() - 1;
+          can_hit_consider_rect |= consider_index_rect_.right() >= index_x_;
           break;
         case LEFT:
-          if (valid_row() && consider_right_ < index_x_)
-            steps_to_take = index_x_ - consider_right_ - 1;
-          can_hit_consider_rect |= consider_top_ <= index_y_;
+          if (consider_index_rect_.valid_row(index_y_) &&
+              consider_index_rect_.right() < index_x_)
+            steps_to_take = index_x_ - consider_index_rect_.right() - 1;
+          can_hit_consider_rect |= consider_index_rect_.top() <= index_y_;
           break;
         case DOWN:
-          if (valid_column() && consider_top_ > index_y_)
-            steps_to_take = consider_top_ - index_y_ - 1;
-          can_hit_consider_rect |= consider_left_ <= index_x_;
+          if (consider_index_rect_.valid_column(index_x_) &&
+              consider_index_rect_.top() > index_y_)
+            steps_to_take = consider_index_rect_.top() - index_y_ - 1;
+          can_hit_consider_rect |= consider_index_rect_.left() <= index_x_;
           break;
         case RIGHT:
-          if (valid_row() && consider_left_ > index_x_)
-            steps_to_take = consider_left_ - index_x_ - 1;
-          can_hit_consider_rect |= consider_bottom_ >= index_y_;
+          if (consider_index_rect_.valid_row(index_y_) &&
+              consider_index_rect_.left() > index_x_)
+            steps_to_take = consider_index_rect_.left() - index_x_ - 1;
+          can_hit_consider_rect |= consider_index_rect_.bottom() >= index_y_;
           break;
       }
       steps_to_take = std::min(steps_to_take, max_steps);
       DCHECK_GE(steps_to_take, 0);
 
       index_x_ += steps_to_take * delta_x_;
       index_y_ += steps_to_take * delta_y_;
       current_step_ += steps_to_take;
 
       if (can_hit_consider_rect)
@@ skipping 20 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() {
+TilingData::ReverseSpiralDifferenceIterator::ReverseSpiralDifferenceIterator()
+    : around_index_rect_(kOutOfBoundsIndexRect) {
   done();
 }
 
 TilingData::ReverseSpiralDifferenceIterator::ReverseSpiralDifferenceIterator(
     const TilingData* tiling_data,
     const gfx::Rect& consider_rect,
     const gfx::Rect& ignore_rect,
     const gfx::Rect& center_rect)
     : BaseDifferenceIterator(tiling_data, consider_rect, ignore_rect),
-      around_left_(-1),
-      around_top_(-1),
-      around_right_(-1),
-      around_bottom_(-1),
+      around_index_rect_(kOutOfBoundsIndexRect),
       direction_(LEFT),
       delta_x_(-1),
       delta_y_(0),
       current_step_(0),
       horizontal_step_count_(0),
       vertical_step_count_(0) {
   if (!HasConsiderRect()) {
     done();
     return;
   }
 
+  int around_left = 0;
   // Determine around left, such that it is between -1 and num_tiles_x.
   if (center_rect.x() < 0 || center_rect.IsEmpty())
-    around_left_ = -1;
+    around_left = -1;
   else if (center_rect.x() >= tiling_data->tiling_size().width())
-    around_left_ = tiling_data->num_tiles_x();
+    around_left = tiling_data->num_tiles_x();
   else
-    around_left_ = tiling_data->TileXIndexFromSrcCoord(center_rect.x());
+    around_left = tiling_data->TileXIndexFromSrcCoord(center_rect.x());
 
   // Determine around top, such that it is between -1 and num_tiles_y.
+  int around_top = 0;
   if (center_rect.y() < 0 || center_rect.IsEmpty())
-    around_top_ = -1;
+    around_top = -1;
   else if (center_rect.y() >= tiling_data->tiling_size().height())
-    around_top_ = tiling_data->num_tiles_y();
+    around_top = tiling_data->num_tiles_y();
   else
-    around_top_ = tiling_data->TileYIndexFromSrcCoord(center_rect.y());
+    around_top = tiling_data->TileYIndexFromSrcCoord(center_rect.y());
 
   // Determine around right, such that it is between -1 and num_tiles_x.
+  int around_right = 0;
   int right_src_coord = center_rect.right() - 1;
   if (right_src_coord < 0 || center_rect.IsEmpty()) {
-    around_right_ = -1;
+    around_right = -1;
   } else if (right_src_coord >= tiling_data->tiling_size().width()) {
-    around_right_ = tiling_data->num_tiles_x();
+    around_right = tiling_data->num_tiles_x();
   } else {
-    around_right_ = tiling_data->TileXIndexFromSrcCoord(right_src_coord);
+    around_right = tiling_data->TileXIndexFromSrcCoord(right_src_coord);
   }
 
   // Determine around bottom, such that it is between -1 and num_tiles_y.
+  int around_bottom = 0;
   int bottom_src_coord = center_rect.bottom() - 1;
   if (bottom_src_coord < 0 || center_rect.IsEmpty()) {
-    around_bottom_ = -1;
+    around_bottom = -1;
   } else if (bottom_src_coord >= tiling_data->tiling_size().height()) {
-    around_bottom_ = tiling_data->num_tiles_y();
+    around_bottom = tiling_data->num_tiles_y();
   } else {
-    around_bottom_ = tiling_data->TileYIndexFromSrcCoord(bottom_src_coord);
+    around_bottom = tiling_data->TileYIndexFromSrcCoord(bottom_src_coord);
   }
 
+  around_index_rect_ =
+      IndexRect(around_left, around_right, around_top, around_bottom);
+  DCHECK(around_index_rect_.is_valid());
+
   // Figure out the maximum distance from the around edge to consider edge.
   int max_distance = 0;
-  max_distance = std::max(max_distance, around_top_ - consider_top_);
-  max_distance = std::max(max_distance, around_left_ - consider_left_);
-  max_distance = std::max(max_distance, consider_bottom_ - around_bottom_);
-  max_distance = std::max(max_distance, consider_right_ - around_right_);
+  max_distance = std::max(
+      max_distance, around_index_rect_.top() - consider_index_rect_.top());
+  max_distance = std::max(
+      max_distance, around_index_rect_.left() - consider_index_rect_.left());
+  max_distance = std::max(max_distance, consider_index_rect_.bottom() -
+                                            around_index_rect_.bottom());
+  max_distance = std::max(
+      max_distance, consider_index_rect_.right() - around_index_rect_.right());
 
-  // The step count is the length of the edge (around_right_ - around_left_ + 1)
+  // The step count is the length of the edge (around_index_rect_.width())
   // plus twice the max distance to pad (to the right and to the left). This way
   // the initial rect is the size proportional to the center, but big enough
   // to cover the consider rect.
   //
   // C = consider rect
   // A = around rect
   // . = area of the padded around rect
   // md = max distance (note in the picture below, there's md written vertically
   //      as well).
   // I = initial starting position
   //
   //       |md|  |md|
   //
   //     - ..........
   //     m ..........
   //     d ..........
   //     - CCCCCCC...
   //       CCCCAAC...
   //       CCCCAAC...
   //     - ..........
   //     m ..........
   //     d ..........
   //     - ..........I
-  vertical_step_count_ = around_bottom_ - around_top_ + 1 + 2 * max_distance;
-  horizontal_step_count_ = around_right_ - around_left_ + 1 + 2 * max_distance;
+  vertical_step_count_ = around_index_rect_.height() + 2 * max_distance;
+  horizontal_step_count_ = around_index_rect_.width() + 2 * max_distance;
 
   // Start with one to the right of the padded around rect.
-  index_x_ = around_right_ + max_distance + 1;
-  index_y_ = around_bottom_ + max_distance;
+  index_x_ = around_index_rect_.right() + max_distance + 1;
+  index_y_ = around_index_rect_.bottom() + max_distance;
 
   // The current index is outside a valid tile, so advance immediately.
   ++(*this);
 }
 
 TilingData::ReverseSpiralDifferenceIterator&
     TilingData::ReverseSpiralDifferenceIterator::
     operator++() {
-  while (!in_around_rect()) {
+  while (!around_index_rect_.Contains(index_x_, index_y_)) {
     if (needs_direction_switch())
       switch_direction();
 
     index_x_ += delta_x_;
     index_y_ += delta_y_;
     ++current_step_;
 
-    if (in_around_rect()) {
+    if (around_index_rect_.Contains(index_x_, index_y_)) {
       break;
-    } else if (in_consider_rect()) {
+    } else if (consider_index_rect_.Contains(index_x_, index_y_)) {
       // If the tile is in the consider rect but not in ignore rect, then it's a
       // valid tile to visit.
-      if (!in_ignore_rect())
+      if (!ignore_index_rect_.Contains(index_x_, index_y_))
         break;
 
       // Steps needed to reach the very edge of the ignore rect, while remaining
       // inside it (so that the continue would take us outside).
       int steps_to_edge = 0;
       switch (direction_) {
         case UP:
-          steps_to_edge = index_y_ - ignore_top_;
+          steps_to_edge = index_y_ - ignore_index_rect_.top();
           break;
         case LEFT:
-          steps_to_edge = index_x_ - ignore_left_;
+          steps_to_edge = index_x_ - ignore_index_rect_.left();
           break;
         case DOWN:
-          steps_to_edge = ignore_bottom_ - index_y_;
+          steps_to_edge = ignore_index_rect_.bottom() - index_y_;
           break;
         case RIGHT:
-          steps_to_edge = ignore_right_ - index_x_;
+          steps_to_edge = ignore_index_rect_.right() - index_x_;
           break;
       }
 
       // We need to switch directions in |max_steps|.
       int max_steps = current_step_count() - current_step_;
 
       int steps_to_take = std::min(steps_to_edge, max_steps);
       DCHECK_GE(steps_to_take, 0);
 
       index_x_ += steps_to_take * delta_x_;
       index_y_ += steps_to_take * delta_y_;
       current_step_ += steps_to_take;
     } else {
       // We're not in the consider rect.
 
       int max_steps = current_step_count() - current_step_;
       int steps_to_take = max_steps;
 
       // We might hit the consider rect before needing to switch directions:
       // update steps to take.
       switch (direction_) {
         case UP:
-          if (valid_column() && consider_bottom_ < index_y_)
-            steps_to_take = index_y_ - consider_bottom_ - 1;
+          if (consider_index_rect_.valid_column(index_x_) &&
+              consider_index_rect_.bottom() < index_y_)
+            steps_to_take = index_y_ - consider_index_rect_.bottom() - 1;
           break;
         case LEFT:
-          if (valid_row() && consider_right_ < index_x_)
-            steps_to_take = index_x_ - consider_right_ - 1;
+          if (consider_index_rect_.valid_row(index_y_) &&
+              consider_index_rect_.right() < index_x_)
+            steps_to_take = index_x_ - consider_index_rect_.right() - 1;
           break;
         case DOWN:
-          if (valid_column() && consider_top_ > index_y_)
-            steps_to_take = consider_top_ - index_y_ - 1;
+          if (consider_index_rect_.valid_column(index_x_) &&
+              consider_index_rect_.top() > index_y_)
+            steps_to_take = consider_index_rect_.top() - index_y_ - 1;
           break;
         case RIGHT:
-          if (valid_row() && consider_left_ > index_x_)
-            steps_to_take = consider_left_ - index_x_ - 1;
+          if (consider_index_rect_.valid_row(index_y_) &&
+              consider_index_rect_.left() > index_x_)
+            steps_to_take = consider_index_rect_.left() - index_x_ - 1;
           break;
       }
       steps_to_take = std::min(steps_to_take, max_steps);
       DCHECK_GE(steps_to_take, 0);
 
       index_x_ += steps_to_take * delta_x_;
       index_y_ += steps_to_take * delta_y_;
       current_step_ += steps_to_take;
     }
   }
 
   // Once we enter the around rect, we're done.
-  if (in_around_rect())
+  if (around_index_rect_.Contains(index_x_, index_y_))
     done();
   return *this;
 }
 
 bool TilingData::ReverseSpiralDifferenceIterator::needs_direction_switch()
     const {
   return current_step_ >= current_step_count();
 }
 
 void TilingData::ReverseSpiralDifferenceIterator::switch_direction() {
@@ skipping 11 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