cc: Detach spiral iterator implementation to separate file.

cc/base/tiling_data.h

 // 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.
 
 #ifndef CC_BASE_TILING_DATA_H_
 #define CC_BASE_TILING_DATA_H_
 
 #include <utility>
 
 #include "base/logging.h"
 #include "cc/base/cc_export.h"
 #include "cc/base/index_rect.h"
+#include "cc/base/reverse_spiral_iterator.h"
+#include "cc/base/spiral_iterator.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace gfx {
 class Vector2d;
 }
 
 namespace cc {
 
 class CC_EXPORT TilingData {
@@ skipping 21 matching lines @@
   int num_tiles_y() const { return num_tiles_y_; }
   // Return the tile index whose non-border texels include src_position.
   int TileXIndexFromSrcCoord(int src_position) const;
   int TileYIndexFromSrcCoord(int src_position) const;
   // Return the lowest tile index whose border texels include src_position.
   int FirstBorderTileXIndexFromSrcCoord(int src_position) const;
   int FirstBorderTileYIndexFromSrcCoord(int src_position) const;
   // Return the highest tile index whose border texels include src_position.
   int LastBorderTileXIndexFromSrcCoord(int src_position) const;
   int LastBorderTileYIndexFromSrcCoord(int src_position) const;
+  // Return the tile indices around the given rect.
+  IndexRect TileAroundIndexRect(const gfx::Rect& center_rect) const;
 
   gfx::Rect ExpandRectIgnoringBordersToTileBounds(const gfx::Rect& rect) const;
   gfx::Rect ExpandRectToTileBounds(const gfx::Rect& rect) const;
 
   gfx::Rect TileBounds(int i, int j) const;
   gfx::Rect TileBoundsWithBorder(int i, int j) const;
   int TilePositionX(int x_index) const;
   int TilePositionY(int y_index) const;
   int TileSizeX(int x_index) const;
   int TileSizeY(int y_index) const;
@@ skipping 65 matching lines @@
   class CC_EXPORT SpiralDifferenceIterator : public BaseDifferenceIterator {
    public:
     SpiralDifferenceIterator();
     SpiralDifferenceIterator(const TilingData* tiling_data,
                              const gfx::Rect& consider_rect,
                              const gfx::Rect& ignore_rect,
                              const gfx::Rect& center_rect);
     SpiralDifferenceIterator& operator++();
 
    private:
-    int current_step_count() const {
-      return (direction_ == UP || direction_ == DOWN) ? vertical_step_count_
-                                                      : horizontal_step_count_;
-    }
-
-    bool needs_direction_switch() const;
-    void switch_direction();
-
-    enum Direction { UP, LEFT, DOWN, RIGHT };
-
-    Direction direction_;
-    int delta_x_;
-    int delta_y_;
-    int current_step_;
-    int horizontal_step_count_;
-    int vertical_step_count_;
+    SpiralIterator spiral_iterator_;
   };
 
   class CC_EXPORT ReverseSpiralDifferenceIterator

[vmpstr, 2016/09/22 17:43:42]

Can we remove this class and have the SpiralIterator/ReverseSpiralIterator do
all of the things that this does?

[prashant.n, 2016/09/23 01:52:34]

1. Basically this class provides around_index_rect, consider_index_rect,
ignore_index_rect to the actual spiral iterator. For computation of these index
rects we need tiling data. We can pass tiling data to
SpiralIterator/ReverseSpiralIterator, but that will tightly couple them to
tiling data.
IMO, the mathematical SpiralIterator/ReverseSpiralIterator and tiling data
should be separate. WDYT?

2. The SpiralDifferenceIterator/ReverseSpiralDifferenceIterator will also serve
as a wrapper over switchable SpiralIteraor and PyramidSequence.

May be once we have new logic implemented, we can revisit this.

       : public BaseDifferenceIterator {
    public:
     ReverseSpiralDifferenceIterator();
     ReverseSpiralDifferenceIterator(const TilingData* tiling_data,
                                     const gfx::Rect& consider_rect,
                                     const gfx::Rect& ignore_rect,
                                     const gfx::Rect& center_rect);
     ReverseSpiralDifferenceIterator& operator++();
 
    private:
-    int current_step_count() const {
-      return (direction_ == UP || direction_ == DOWN) ? vertical_step_count_
-                                                      : horizontal_step_count_;
-    }
-
-    bool needs_direction_switch() const;
-    void switch_direction();
-
-    IndexRect around_index_rect_;
-
-    enum Direction { LEFT, UP, RIGHT, DOWN };
-
-    Direction direction_;
-    int delta_x_;
-    int delta_y_;
-    int current_step_;
-    int horizontal_step_count_;
-    int vertical_step_count_;
+    ReverseSpiralIterator reverse_spiral_iterator_;
   };
 
  private:
   void AssertTile(int i, int j) const {
     DCHECK_GE(i,  0);
     DCHECK_LT(i, num_tiles_x_);
     DCHECK_GE(j, 0);
     DCHECK_LT(j, num_tiles_y_);
   }
 
   void RecomputeNumTiles();
 
   gfx::Size max_texture_size_;
   gfx::Size tiling_size_;
   int border_texels_;
 
   // These are computed values.
   int num_tiles_x_;
   int num_tiles_y_;
 };
 
 }  // namespace cc
 
 #endif  // CC_BASE_TILING_DATA_H_