cc: Implement tile iteration order based on pyramid sequence. [old]

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 <list>
 #include <utility>
+#include <vector>
 
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "cc/base/cc_export.h"
+#include "cc/base/pyramid_sequence.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace gfx {
 class Vector2d;
 }
 
 namespace cc {
 
 class CC_EXPORT TilingData {
@@ skipping 111 matching lines @@
   // with |consider| but which also do not intersect with |ignore|.
   class CC_EXPORT DifferenceIterator : public BaseDifferenceIterator {
    public:
     DifferenceIterator();
     DifferenceIterator(const TilingData* tiling_data,
                        const gfx::Rect& consider_rect,
                        const gfx::Rect& ignore_rect);
     DifferenceIterator& operator++();
   };
 
+  struct LevelDistance {
+    int level;
+    int distance;
+  };
+
+  class LDSequence {

[vmpstr, 2016/06/16 18:28:58]

I prefer to not abberviate here

[vmpstr, 2016/06/16 18:28:58]

Needs a comment

+   public:
+    typedef std::list<LDSequence> List;
+
+    LDSequence(PyramidSequence traversal_seq,

[vmpstr, 2016/06/16 18:28:58]

don't abbreviate seq

+               PyramidSequence level_seq,
+               bool swapped,
+               int distance);
+    LDSequence(const LDSequence& other);
+    ~LDSequence();
+
+    bool IsValid() const { return !level_distances_.empty(); }
+    int GetIndexX() const;
+    int GetIndexY() const;
+    int GetTopDistance();
+    bool Advance();
+
+   private:
+    void Reset();
+
+    PyramidSequence traversal_seq_;
+    bool swapped_;
+    int current_seq_index_;
+    int current_level_index_;
+    std::vector<LevelDistance> level_distances_;
+  };
+
   // 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);
+    ~SpiralDifferenceIterator();
     SpiralDifferenceIterator& operator++();
 
-   private:
-    bool valid_column() const {
-      return index_x_ >= consider_left_ && index_x_ <= consider_right_;
-    }
-    bool valid_row() const {
-      return index_y_ >= consider_top_ && index_y_ <= consider_bottom_;
+    bool valid_column(int column) const {
+      return column >= 0 && column <= num_tiles_x_;
     }
 
-    int current_step_count() const {
-      return (direction_ == UP || direction_ == DOWN) ? vertical_step_count_
-                                                      : horizontal_step_count_;
-    }
+    bool valid_row(int row) const { return row >= 0 && row <= num_tiles_y_; }
 
-    bool needs_direction_switch() const;
-    void switch_direction();
+   private:
+    LDSequence::List::iterator GetNextLDSequence();
 
-    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_;
+    int num_tiles_x_;
+    int num_tiles_y_;
+    LDSequence::List ld_sequences_;
+    LDSequence::List::iterator current_ld_seq;
   };
 
   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);
@@ skipping 50 matching lines @@
   gfx::Size borderless_max_texture_size_;
 
   // These are computed values.
   int num_tiles_x_;
   int num_tiles_y_;
 };
 
 }  // namespace cc
 
 #endif  // CC_BASE_TILING_DATA_H_