cc: Reduce duplicated tiling data difference iterator code

This adds a new BaseDifferenceIterator as a common base class for all
tiling data difference iterators and moves duplicated code from
different tiling data difference iterators to that common base class.
This reduces code duplication.

Review URL: https://codereview.chromium.org/1017713003

Cr-Commit-Position: refs/heads/master@{#321540}

cc/base/tiling_data.cc

@@ -350,7 +350,11 @@ TilingData::Iterator& TilingData::Iterator::operator++() {
   return *this;
 }
 
-TilingData::DifferenceIterator::DifferenceIterator(
+TilingData::BaseDifferenceIterator::BaseDifferenceIterator() {
+  done();
+}
+
+TilingData::BaseDifferenceIterator::BaseDifferenceIterator(
     const TilingData* tiling_data,
     const gfx::Rect& consider_rect,
     const gfx::Rect& ignore_rect)
@@ -369,9 +373,8 @@ TilingData::DifferenceIterator::DifferenceIterator(
 
   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;
@@ -382,6 +385,9 @@ TilingData::DifferenceIterator::DifferenceIterator(
   consider_right_ = tiling_data->TileXIndexFromSrcCoord(consider.right() - 1);
   consider_bottom_ = tiling_data->TileYIndexFromSrcCoord(consider.bottom() - 1);
 
+  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());
@@ -393,10 +399,31 @@ TilingData::DifferenceIterator::DifferenceIterator(
     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_) {
+      consider_left_ = consider_top_ = consider_right_ = consider_bottom_ = -1;
+      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;
+}
+
+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;
   }
@@ -446,82 +473,40 @@ TilingData::SpiralDifferenceIterator::SpiralDifferenceIterator(
     const gfx::Rect& consider_rect,
     const gfx::Rect& ignore_rect,
     const gfx::Rect& center_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),
+    : BaseDifferenceIterator(tiling_data, consider_rect, ignore_rect),
       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) {
-    done();
-    return;
-  }
-
-  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);
-
-  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);
-
-    // 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_) {
+  if (!HasConsiderRect()) {
     done();
     return;
   }
 
   // Determine around left, such that it is between -1 and num_tiles_x.
   int around_left = 0;
-  if (center.x() < 0 || center.IsEmpty())
+  if (center_rect.x() < 0 || center_rect.IsEmpty())
     around_left = -1;
-  else if (center.x() >= tiling_data->tiling_size().width())
+  else if (center_rect.x() >= tiling_data->tiling_size().width())
     around_left = tiling_data->num_tiles_x();
   else
-    around_left = tiling_data->TileXIndexFromSrcCoord(center.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.y() < 0 || center.IsEmpty())
+  if (center_rect.y() < 0 || center_rect.IsEmpty())
     around_top = -1;
-  else if (center.y() >= tiling_data->tiling_size().height())
+  else if (center_rect.y() >= tiling_data->tiling_size().height())
     around_top = tiling_data->num_tiles_y();
   else
-    around_top = tiling_data->TileYIndexFromSrcCoord(center.y());
+    around_top = tiling_data->TileYIndexFromSrcCoord(center_rect.y());
 
   // Determine around right, such that it is between -1 and num_tiles_x.
-  int right_src_coord = center.right() - 1;
+  int right_src_coord = center_rect.right() - 1;
   int around_right = 0;
-  if (right_src_coord < 0 || center.IsEmpty()) {
+  if (right_src_coord < 0 || center_rect.IsEmpty()) {
     around_right = -1;
   } else if (right_src_coord >= tiling_data->tiling_size().width()) {
     around_right = tiling_data->num_tiles_x();
@@ -530,9 +515,9 @@ TilingData::SpiralDifferenceIterator::SpiralDifferenceIterator(
   }
 
   // Determine around bottom, such that it is between -1 and num_tiles_y.
-  int bottom_src_coord = center.bottom() - 1;
+  int bottom_src_coord = center_rect.bottom() - 1;
   int around_bottom = 0;
-  if (bottom_src_coord < 0 || center.IsEmpty()) {
+  if (bottom_src_coord < 0 || center_rect.IsEmpty()) {
     around_bottom = -1;
   } else if (bottom_src_coord >= tiling_data->tiling_size().height()) {
     around_bottom = tiling_data->num_tiles_y();
@@ -669,83 +654,41 @@ TilingData::ReverseSpiralDifferenceIterator::ReverseSpiralDifferenceIterator(
     const gfx::Rect& consider_rect,
     const gfx::Rect& ignore_rect,
     const gfx::Rect& center_rect)
-    : consider_left_(-1),
-      consider_top_(-1),
-      consider_right_(-1),
-      consider_bottom_(-1),
+    : BaseDifferenceIterator(tiling_data, consider_rect, ignore_rect),
       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) {
-    done();
-    return;
-  }
-
-  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);
-
-  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);
-
-    // 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_) {
+  if (!HasConsiderRect()) {
     done();
     return;
   }
 
   // Determine around left, such that it is between -1 and num_tiles_x.
-  if (center.x() < 0 || center.IsEmpty())
+  if (center_rect.x() < 0 || center_rect.IsEmpty())
     around_left_ = -1;
-  else if (center.x() >= tiling_data->tiling_size().width())
+  else if (center_rect.x() >= tiling_data->tiling_size().width())
     around_left_ = tiling_data->num_tiles_x();
   else
-    around_left_ = tiling_data->TileXIndexFromSrcCoord(center.x());
+    around_left_ = tiling_data->TileXIndexFromSrcCoord(center_rect.x());
 
   // Determine around top, such that it is between -1 and num_tiles_y.
-  if (center.y() < 0 || center.IsEmpty())
+  if (center_rect.y() < 0 || center_rect.IsEmpty())
     around_top_ = -1;
-  else if (center.y() >= tiling_data->tiling_size().height())
+  else if (center_rect.y() >= tiling_data->tiling_size().height())
     around_top_ = tiling_data->num_tiles_y();
   else
-    around_top_ = tiling_data->TileYIndexFromSrcCoord(center.y());
+    around_top_ = tiling_data->TileYIndexFromSrcCoord(center_rect.y());
 
   // Determine around right, such that it is between -1 and num_tiles_x.
-  int right_src_coord = center.right() - 1;
-  if (right_src_coord < 0 || center.IsEmpty()) {
+  int right_src_coord = center_rect.right() - 1;
+  if (right_src_coord < 0 || center_rect.IsEmpty()) {
     around_right_ = -1;
   } else if (right_src_coord >= tiling_data->tiling_size().width()) {
     around_right_ = tiling_data->num_tiles_x();
@@ -754,8 +697,8 @@ TilingData::ReverseSpiralDifferenceIterator::ReverseSpiralDifferenceIterator(
   }
 
   // Determine around bottom, such that it is between -1 and num_tiles_y.
-  int bottom_src_coord = center.bottom() - 1;
-  if (bottom_src_coord < 0 || center.IsEmpty()) {
+  int bottom_src_coord = center_rect.bottom() - 1;
+  if (bottom_src_coord < 0 || center_rect.IsEmpty()) {
     around_bottom_ = -1;
   } else if (bottom_src_coord >= tiling_data->tiling_size().height()) {
     around_bottom_ = tiling_data->num_tiles_y();

cc/base/tiling_data.h

@@ -101,16 +101,18 @@ class CC_EXPORT TilingData {
     int bottom_;
   };
 
-  // Iterate through all indices whose bounds (not including borders) intersect
-  // with |consider| but which also do not intersect with |ignore|.
-  class CC_EXPORT DifferenceIterator : public BaseIterator {
-   public:
-    DifferenceIterator(const TilingData* tiling_data,
+  class CC_EXPORT BaseDifferenceIterator : public BaseIterator {
+   protected:
+    BaseDifferenceIterator();
+    BaseDifferenceIterator(const TilingData* tiling_data,
                            const gfx::Rect& consider_rect,
                            const gfx::Rect& ignore_rect);
-    DifferenceIterator& operator++();
 
-   private:
+    bool HasConsiderRect() const;
+    bool in_consider_rect() const {
+      return index_x_ >= consider_left_ && index_x_ <= consider_right_ &&
+             index_y_ >= consider_top_ && index_y_ <= consider_bottom_;
+    }
     bool in_ignore_rect() const {
       return index_x_ >= ignore_left_ && index_x_ <= ignore_right_ &&
              index_y_ >= ignore_top_ && index_y_ <= ignore_bottom_;
@@ -126,10 +128,20 @@ class CC_EXPORT TilingData {
     int ignore_bottom_;
   };
 
+  // Iterate through all indices whose bounds (not including borders) intersect
+  // with |consider| but which also do not intersect with |ignore|.
+  class CC_EXPORT DifferenceIterator : public BaseDifferenceIterator {
+   public:
+    DifferenceIterator(const TilingData* tiling_data,
+                       const gfx::Rect& consider_rect,
+                       const gfx::Rect& ignore_rect);
+    DifferenceIterator& operator++();
+  };
+
   // Iterate through all indices whose bounds + border intersect with
   // |consider| but which also do not intersect with |ignore|. The iterator
   // order is a counterclockwise spiral around the given center.
-  class CC_EXPORT SpiralDifferenceIterator : public BaseIterator {
+  class CC_EXPORT SpiralDifferenceIterator : public BaseDifferenceIterator {
    public:
     SpiralDifferenceIterator();
     SpiralDifferenceIterator(const TilingData* tiling_data,
@@ -139,14 +151,6 @@ class CC_EXPORT TilingData {
     SpiralDifferenceIterator& operator++();
 
    private:
-    bool in_consider_rect() const {
-      return index_x_ >= consider_left_ && index_x_ <= consider_right_ &&
-             index_y_ >= consider_top_ && index_y_ <= consider_bottom_;
-    }
-    bool in_ignore_rect() const {
-      return index_x_ >= ignore_left_ && index_x_ <= ignore_right_ &&
-             index_y_ >= ignore_top_ && index_y_ <= ignore_bottom_;
-    }
     bool valid_column() const {
       return index_x_ >= consider_left_ && index_x_ <= consider_right_;
     }
@@ -162,15 +166,6 @@ class CC_EXPORT TilingData {
     bool needs_direction_switch() const;
     void switch_direction();
 
-    int consider_left_;
-    int consider_top_;
-    int consider_right_;
-    int consider_bottom_;
-    int ignore_left_;
-    int ignore_top_;
-    int ignore_right_;
-    int ignore_bottom_;
-
     enum Direction { UP, LEFT, DOWN, RIGHT };
 
     Direction direction_;
@@ -181,7 +176,8 @@ class CC_EXPORT TilingData {
     int vertical_step_count_;
   };
 
-  class CC_EXPORT ReverseSpiralDifferenceIterator : public BaseIterator {
+  class CC_EXPORT ReverseSpiralDifferenceIterator
+      : public BaseDifferenceIterator {
    public:
     ReverseSpiralDifferenceIterator();
     ReverseSpiralDifferenceIterator(const TilingData* tiling_data,
@@ -191,18 +187,10 @@ class CC_EXPORT TilingData {
     ReverseSpiralDifferenceIterator& operator++();
 
    private:
-    bool in_consider_rect() const {
-      return index_x_ >= consider_left_ && index_x_ <= consider_right_ &&
-             index_y_ >= consider_top_ && index_y_ <= consider_bottom_;
-    }
     bool in_around_rect() const {
       return index_x_ >= around_left_ && index_x_ <= around_right_ &&
              index_y_ >= around_top_ && index_y_ <= around_bottom_;
     }
-    bool in_ignore_rect() const {
-      return index_x_ >= ignore_left_ && index_x_ <= ignore_right_ &&
-             index_y_ >= ignore_top_ && index_y_ <= ignore_bottom_;
-    }
     bool valid_column() const {
       return index_x_ >= consider_left_ && index_x_ <= consider_right_;
     }
@@ -218,18 +206,10 @@ class CC_EXPORT TilingData {
     bool needs_direction_switch() const;
     void switch_direction();
 
-    int consider_left_;
-    int consider_top_;
-    int consider_right_;
-    int consider_bottom_;
     int around_left_;
     int around_top_;
     int around_right_;
     int around_bottom_;
-    int ignore_left_;
-    int ignore_top_;
-    int ignore_right_;
-    int ignore_bottom_;
 
     enum Direction { LEFT, UP, RIGHT, DOWN };