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

cc/base/spiral_iterator_unittest.cc

 // Copyright 2016 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 <stddef.h>
 
 #include <algorithm>
 #include <vector>
 
 #include "cc/base/tiling_data.h"
 #include "cc/test/geometry_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 namespace {
 
 void TestSpiralIterate(int source_line_number,
                        const TilingData& tiling_data,
                        const gfx::Rect& consider,
                        const gfx::Rect& ignore,
                        const gfx::Rect& center,
                        const std::vector<std::pair<int, int>>& expected) {
   std::vector<std::pair<int, int>> actual_forward;
   for (TilingData::SpiralDifferenceIterator it(&tiling_data, consider, ignore,
-                                               center);
+                                               center, false);
        it; ++it) {
     actual_forward.push_back(it.index());
   }
 
   EXPECT_EQ(expected.size(), actual_forward.size()) << "error from line "
                                                     << source_line_number;
   for (size_t i = 0; i < std::min(expected.size(), actual_forward.size());
        ++i) {
     EXPECT_EQ(expected[i].first, actual_forward[i].first)
         << "i: " << i << " error from line: " << source_line_number;
     EXPECT_EQ(expected[i].second, actual_forward[i].second)
         << "i: " << i << " error from line: " << source_line_number;
   }
 
   std::vector<std::pair<int, int>> actual_reverse;
   for (TilingData::ReverseSpiralDifferenceIterator it(&tiling_data, consider,
-                                                      ignore, center);
+                                                      ignore, center, false);
        it; ++it) {
     actual_reverse.push_back(it.index());
   }
 
   std::vector<std::pair<int, int>> reversed_expected = expected;
   std::reverse(reversed_expected.begin(), reversed_expected.end());
   EXPECT_EQ(reversed_expected.size(), actual_reverse.size())
       << "error from line " << source_line_number;
   for (size_t i = 0;
        i < std::min(reversed_expected.size(), actual_reverse.size()); ++i) {
@@ skipping 636 matching lines @@
   expected.clear();
   expected.push_back(std::make_pair(0, 0));
 
   TestSpiralIterate(__LINE__, smaller_tiling, consider, ignore, center,
                     expected);
 }
 
 }  // namespace
 
 }  // namespace cc