ps test.

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/pyramid_sequence.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 RectF;
 class Vector2d;
 }
 
@@ skipping 18 matching lines @@
   int border_texels() const { return border_texels_; }
   void SetHasBorderTexels(bool has_border_texels);
   void SetBorderTexels(int border_texels);
 
   bool has_empty_bounds() const { return !num_tiles_x_ || !num_tiles_y_; }
   int num_tiles_x() const { return num_tiles_x_; }
   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 absolute tile index, assuming tiling size to be infinite in all
+  // quadrants.
+  int TileAbsoluteXIndexFromSrcCoord(int src_position) const;
+  int TileAbsoluteYIndexFromSrcCoord(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;
+  // Return the absolute tile indices around the given rect.
+  IndexRect TileAroundAbsoluteIndexRect(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;
 
   gfx::RectF TexelExtent(int i, int j) const;
 
   // Difference between TileBound's and TileBoundWithBorder's origin().
   gfx::Vector2d TextureOffset(int x_index, int y_index) const;
 
+  // Returns true if tiling-iterator is specified as pyramid-sequence.
+  static bool IsPyramidSequenceEnabled();
+
   class CC_EXPORT BaseIterator {
    public:
     operator bool() const { return index_x_ != -1 && index_y_ != -1; }
 
     int index_x() const { return index_x_; }
     int index_y() const { return index_y_; }
     std::pair<int, int> index() const {
      return std::make_pair(index_x_, index_y_);
     }
 
@@ skipping 47 matching lines @@
 
   // 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 BaseDifferenceIterator {
    public:
     SpiralDifferenceIterator();
     SpiralDifferenceIterator(const TilingData* tiling_data,
                              const gfx::Rect& consider_rect,
                              const gfx::Rect& ignore_rect,
-                             const gfx::Rect& center_rect);
+                             const gfx::Rect& center_rect,
+                             const bool use_pyramid_sequence);
+    SpiralDifferenceIterator(const SpiralDifferenceIterator& other);
+    SpiralDifferenceIterator(SpiralDifferenceIterator&& other);
+    ~SpiralDifferenceIterator();
+
+    SpiralDifferenceIterator& operator=(const SpiralDifferenceIterator& other);
+    SpiralDifferenceIterator& operator=(SpiralDifferenceIterator&& other);
+
     SpiralDifferenceIterator& operator++();
 
    private:
     SpiralIterator spiral_iterator_;
+    bool use_pyramid_sequence_;
+    PyramidSequence pyramid_sequence_;
+    PyramidSequence::Iterator iterator_;
   };
 
   class CC_EXPORT ReverseSpiralDifferenceIterator
       : public BaseDifferenceIterator {
    public:
     ReverseSpiralDifferenceIterator();
     ReverseSpiralDifferenceIterator(const TilingData* tiling_data,
                                     const gfx::Rect& consider_rect,
                                     const gfx::Rect& ignore_rect,
-                                    const gfx::Rect& center_rect);
+                                    const gfx::Rect& center_rect,
+                                    const bool use_pyramid_sequence);
+    ReverseSpiralDifferenceIterator(
+        const ReverseSpiralDifferenceIterator& other);
+    ReverseSpiralDifferenceIterator(ReverseSpiralDifferenceIterator&& other);
+    ~ReverseSpiralDifferenceIterator();
+
+    ReverseSpiralDifferenceIterator& operator=(
+        const ReverseSpiralDifferenceIterator& other);
+    ReverseSpiralDifferenceIterator& operator=(
+        ReverseSpiralDifferenceIterator&& other);
+
     ReverseSpiralDifferenceIterator& operator++();
 
    private:
     ReverseSpiralIterator reverse_spiral_iterator_;
+    bool use_pyramid_sequence_;
+    PyramidSequence pyramid_sequence_;
+    PyramidSequence::ReverseIterator reverse_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_