cc: Replace > > with >>

cc/base/tiling_data_unittest.cc

 // Copyright 2013 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 "cc/base/tiling_data.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "cc/test/geometry_test_utils.h"
@@ skipping 1020 matching lines @@
                  int expect_left,
                  int expect_top,
                  int expect_right,
                  int expect_bottom,
                  bool include_borders) {
   EXPECT_GE(expect_left, 0);
   EXPECT_GE(expect_top, 0);
   EXPECT_LT(expect_right, data.num_tiles_x());
   EXPECT_LT(expect_bottom, data.num_tiles_y());
 
-  std::vector<std::pair<int, int> > original_expected;
+  std::vector<std::pair<int, int>> original_expected;
   for (int x = 0; x < data.num_tiles_x(); ++x) {
     for (int y = 0; y < data.num_tiles_y(); ++y) {
       gfx::Rect bounds;
       if (include_borders)
         bounds = data.TileBoundsWithBorder(x, y);
       else
         bounds = data.TileBounds(x, y);
       if (x >= expect_left && x <= expect_right &&
           y >= expect_top && y <= expect_bottom) {
         EXPECT_TRUE(bounds.Intersects(rect));
         original_expected.push_back(std::make_pair(x, y));
       } else {
         EXPECT_FALSE(bounds.Intersects(rect));
       }
     }
   }
 
   // Verify with vanilla iterator.
   {
-    std::vector<std::pair<int, int> > expected = original_expected;
+    std::vector<std::pair<int, int>> expected = original_expected;
     for (TilingData::Iterator iter(&data, rect, include_borders); iter;
          ++iter) {
       bool found = false;
       for (size_t i = 0; i < expected.size(); ++i) {
         if (expected[i] == iter.index()) {
           expected[i] = expected.back();
           expected.pop_back();
           found = true;
           break;
         }
       }
       EXPECT_TRUE(found);
     }
     EXPECT_EQ(0u, expected.size());
   }
 
   // Make sure this also works with a difference iterator and an empty ignore.
   // The difference iterator never includes borders, so ignore it otherwise.
   if (!include_borders) {
-    std::vector<std::pair<int, int> > expected = original_expected;
+    std::vector<std::pair<int, int>> expected = original_expected;
     for (TilingData::DifferenceIterator iter(&data, rect, gfx::Rect()); iter;
          ++iter) {
       bool found = false;
       for (size_t i = 0; i < expected.size(); ++i) {
         if (expected[i] == iter.index()) {
           expected[i] = expected.back();
           expected.pop_back();
           found = true;
           break;
         }
@@ skipping 145 matching lines @@
 
 TEST(TilingDataTest, IteratorNoTiles) {
   TilingData data(gfx::Size(100, 100), gfx::Size(), false);
   TestIterateAll(data, gfx::Rect(100, 100), 0, 0, -1, -1);
 }
 
 void TestDiff(const TilingData& data,
               gfx::Rect consider,
               gfx::Rect ignore,
               size_t num_tiles) {
-  std::vector<std::pair<int, int> > expected;
+  std::vector<std::pair<int, int>> expected;
   for (int y = 0; y < data.num_tiles_y(); ++y) {
     for (int x = 0; x < data.num_tiles_x(); ++x) {
       gfx::Rect bounds = data.TileBounds(x, y);
       if (bounds.Intersects(consider) && !bounds.Intersects(ignore))
         expected.push_back(std::make_pair(x, y));
     }
   }
 
   // Sanity check the test.
   EXPECT_EQ(num_tiles, expected.size());
@@ skipping 108 matching lines @@
 TEST(TilingDataTest, DifferenceIteratorNoTiles) {
   TilingData data(gfx::Size(100, 100), gfx::Size(), false);
   TestDiff(data, gfx::Rect(100, 100), gfx::Rect(5, 5), 0);
 }
 
 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;
+                       const std::vector<std::pair<int, int>>& expected) {
+  std::vector<std::pair<int, int>> actual;
   for (TilingData::SpiralDifferenceIterator it(
            &tiling_data, consider, ignore, center);
        it;
        ++it) {
     actual.push_back(it.index());
   }
 
   EXPECT_EQ(expected.size(), actual.size()) << "error from line "
                                             << source_line_number;
   for (size_t i = 0; i < std::min(expected.size(), actual.size()); ++i) {
     EXPECT_EQ(expected[i].first, actual[i].first)
         << "i: " << i << " error from line: " << source_line_number;
     EXPECT_EQ(expected[i].second, actual[i].second)
         << "i: " << i << " error from line: " << source_line_number;
   }
 }
 
 TEST(TilingDataTest, SpiralDifferenceIteratorNoIgnoreFullConsider) {
   TilingData tiling_data(gfx::Size(10, 10), gfx::Size(30, 30), false);
   gfx::Rect consider(30, 30);
   gfx::Rect ignore;
-  std::vector<std::pair<int, int> > expected;
+  std::vector<std::pair<int, int>> expected;
 
   // Center is in the center of the tiling.
   gfx::Rect center(15, 15, 1, 1);
 
   // Layout of the tiling data, and expected return order:
   //   x 0 1 2
   //  y.------
   //  0| 4 3 2
   //  1| 5 * 1
   //  2| 6 7 8
@@ skipping 90 matching lines @@
   expected.push_back(std::make_pair(0, 0));
   expected.push_back(std::make_pair(0, 1));
   expected.push_back(std::make_pair(0, 2));
 
   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
 }
 
 TEST(TilingDataTest, SpiralDifferenceIteratorSmallConsider) {
   TilingData tiling_data(gfx::Size(10, 10), gfx::Size(50, 50), false);
   gfx::Rect ignore;
-  std::vector<std::pair<int, int> > expected;
+  std::vector<std::pair<int, int>> expected;
   gfx::Rect center(15, 15, 1, 1);
 
   // Consider is one cell.
   gfx::Rect consider(1, 1);
 
   // Layout of the tiling data, and expected return order:
   //   x 0 1 2 3 4
   //  y.----------
   //  0| 1
   //  1|   *
@@ skipping 39 matching lines @@
   expected.push_back(std::make_pair(1, 2));
   expected.push_back(std::make_pair(1, 3));
   expected.push_back(std::make_pair(1, 4));
 
   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
 }
 
 TEST(TilingDataTest, SpiralDifferenceIteratorHasIgnore) {
   TilingData tiling_data(gfx::Size(10, 10), gfx::Size(50, 50), false);
   gfx::Rect consider(50, 50);
-  std::vector<std::pair<int, int> > expected;
+  std::vector<std::pair<int, int>> expected;
   gfx::Rect center(15, 15, 1, 1);
 
   // Full ignore.
   gfx::Rect ignore(50, 50);
 
   // Layout of the tiling data, and expected return order:
   //   x 0 1 2 3 4
   //  y.----------
   //  0| . . . . .
   //  1| . * . . .
@@ skipping 53 matching lines @@
   expected.push_back(std::make_pair(2, 4));
   expected.push_back(std::make_pair(3, 4));
   expected.push_back(std::make_pair(4, 4));
 
   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
 }
 
 TEST(TilingDataTest, SpiralDifferenceIteratorRectangleCenter) {
   TilingData tiling_data(gfx::Size(10, 10), gfx::Size(50, 50), false);
   gfx::Rect consider(50, 50);
-  std::vector<std::pair<int, int> > expected;
+  std::vector<std::pair<int, int>> expected;
   gfx::Rect ignore;
 
   // Two cell center
   gfx::Rect center(25, 25, 1, 10);
 
   // Layout of the tiling data, and expected return order:
   //   x 0 1 2 3 4
   //  y.----------
   //  0| J I H G F
   //  1| K 5 4 3 E
@@ skipping 100 matching lines @@
   expected.push_back(std::make_pair(4, 3));
   expected.push_back(std::make_pair(4, 2));
   expected.push_back(std::make_pair(4, 1));
   expected.push_back(std::make_pair(4, 0));
 
   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
 }
 
 TEST(TilingDataTest, SpiralDifferenceIteratorEdgeCases) {
   TilingData tiling_data(gfx::Size(10, 10), gfx::Size(30, 30), false);
-  std::vector<std::pair<int, int> > expected;
+  std::vector<std::pair<int, int>> expected;
   gfx::Rect center;
   gfx::Rect consider;
   gfx::Rect ignore;
 
   // Ignore contains, but is not equal to, consider and center.
   ignore = gfx::Rect(15, 0, 20, 30);
   consider = gfx::Rect(20, 10, 10, 20);
   center = gfx::Rect(25, 0, 5, 5);
 
   // Layout of the tiling data, and expected return order:
@@ skipping 155 matching lines @@
   expected.push_back(std::make_pair(2, 2));
   expected.push_back(std::make_pair(2, 1));
   expected.push_back(std::make_pair(2, 0));
 
   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
 }
 
 }  // namespace
 
 }  // namespace cc