cc: Chromify TilingData unittest

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 "cc/test/geometry_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
@@ skipping 97 matching lines @@
 
 int SizeY(
     gfx::Size max_texture_size,
     gfx::Size total_size,
     bool has_border_texels,
     int y_index) {
   TilingData tiling(max_texture_size, total_size, has_border_texels);
   return tiling.TileSizeY(y_index);
 }
 
-TEST(TilingDataTest, numTiles_NoTiling)
-{
+TEST(TilingDataTest, NumTiles_NoTiling) {
   EXPECT_EQ(1, NumTiles(gfx::Size(16, 16), gfx::Size(16, 16), false));
   EXPECT_EQ(1, NumTiles(gfx::Size(16, 16), gfx::Size(15, 15), true));
   EXPECT_EQ(1, NumTiles(gfx::Size(16, 16), gfx::Size(16, 16), true));
   EXPECT_EQ(1, NumTiles(gfx::Size(16, 16), gfx::Size(1, 16), false));
   EXPECT_EQ(1, NumTiles(gfx::Size(15, 15), gfx::Size(15, 15), true));
   EXPECT_EQ(1, NumTiles(gfx::Size(32, 16), gfx::Size(32, 16), false));
   EXPECT_EQ(1, NumTiles(gfx::Size(32, 16), gfx::Size(32, 16), true));
 }
 
-TEST(TilingDataTest, numTiles_TilingNoBorders)
-{
+TEST(TilingDataTest, NumTiles_TilingNoBorders) {
   EXPECT_EQ(0, NumTiles(gfx::Size(0, 0), gfx::Size(0, 0), false));
   EXPECT_EQ(0, NumTiles(gfx::Size(0, 0), gfx::Size(4, 0), false));
   EXPECT_EQ(0, NumTiles(gfx::Size(0, 0), gfx::Size(0, 4), false));
   EXPECT_EQ(0, NumTiles(gfx::Size(4, 4), gfx::Size(4, 0), false));
   EXPECT_EQ(0, NumTiles(gfx::Size(4, 4), gfx::Size(0, 4), false));
   EXPECT_EQ(0, NumTiles(gfx::Size(0, 0), gfx::Size(1, 1), false));
 
   EXPECT_EQ(1, NumTiles(gfx::Size(1, 1), gfx::Size(1, 1), false));
   EXPECT_EQ(2, NumTiles(gfx::Size(1, 1), gfx::Size(1, 2), false));
   EXPECT_EQ(2, NumTiles(gfx::Size(1, 1), gfx::Size(2, 1), false));
@@ skipping 29 matching lines @@
 
   EXPECT_EQ(1, NumTiles(gfx::Size(16, 16), gfx::Size(16, 16), false));
   EXPECT_EQ(1, NumTiles(gfx::Size(17, 17), gfx::Size(16, 16), false));
   EXPECT_EQ(4, NumTiles(gfx::Size(15, 15), gfx::Size(16, 16), false));
   EXPECT_EQ(4, NumTiles(gfx::Size(8, 8), gfx::Size(16, 16), false));
   EXPECT_EQ(6, NumTiles(gfx::Size(8, 8), gfx::Size(17, 16), false));
 
   EXPECT_EQ(8, NumTiles(gfx::Size(5, 8), gfx::Size(17, 16), false));
 }
 
-TEST(TilingDataTest, numTiles_TilingWithBorders)
-{
+TEST(TilingDataTest, NumTiles_TilingWithBorders) {
   EXPECT_EQ(0, NumTiles(gfx::Size(0, 0), gfx::Size(0, 0), true));
   EXPECT_EQ(0, NumTiles(gfx::Size(0, 0), gfx::Size(4, 0), true));
   EXPECT_EQ(0, NumTiles(gfx::Size(0, 0), gfx::Size(0, 4), true));
   EXPECT_EQ(0, NumTiles(gfx::Size(4, 4), gfx::Size(4, 0), true));
   EXPECT_EQ(0, NumTiles(gfx::Size(4, 4), gfx::Size(0, 4), true));
   EXPECT_EQ(0, NumTiles(gfx::Size(0, 0), gfx::Size(1, 1), true));
 
   EXPECT_EQ(1, NumTiles(gfx::Size(1, 1), gfx::Size(1, 1), true));
   EXPECT_EQ(0, NumTiles(gfx::Size(1, 1), gfx::Size(1, 2), true));
   EXPECT_EQ(0, NumTiles(gfx::Size(1, 1), gfx::Size(2, 1), true));
@@ skipping 30 matching lines @@
   EXPECT_EQ(2, NumTiles(gfx::Size(5, 5), gfx::Size(6, 5), true));
   EXPECT_EQ(2, NumTiles(gfx::Size(5, 5), gfx::Size(7, 5), true));
   EXPECT_EQ(2, NumTiles(gfx::Size(5, 5), gfx::Size(8, 5), true));
   EXPECT_EQ(3, NumTiles(gfx::Size(5, 5), gfx::Size(9, 5), true));
   EXPECT_EQ(3, NumTiles(gfx::Size(5, 5), gfx::Size(10, 5), true));
   EXPECT_EQ(3, NumTiles(gfx::Size(5, 5), gfx::Size(11, 5), true));
 
   EXPECT_EQ(30, NumTiles(gfx::Size(8, 5), gfx::Size(16, 32), true));
 }
 
-TEST(TilingDataTest, tileXIndexFromSrcCoord)
-{
+TEST(TilingDataTest, TileXIndexFromSrcCoord) {
   EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 0));
   EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 1));
   EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 2));
   EXPECT_EQ(1, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 3));
   EXPECT_EQ(1, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 4));
   EXPECT_EQ(1, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 5));
   EXPECT_EQ(2, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 6));
   EXPECT_EQ(2, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 7));
   EXPECT_EQ(2, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 8));
   EXPECT_EQ(3, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 9));
@@ skipping 31 matching lines @@
   EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 0));
   EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 1));
   EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 2));
 
   EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 0));
   EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 1));
   EXPECT_EQ(1, XIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 2));
   EXPECT_EQ(1, XIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 3));
 }
 
-TEST(TilingDataTest, firstBorderTileXIndexFromSrcCoord)
-{
+TEST(TilingDataTest, FirstBorderTileXIndexFromSrcCoord) {
   EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 0));
   EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 1));
   EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 2));
   EXPECT_EQ(1, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 3));
   EXPECT_EQ(1, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 4));
   EXPECT_EQ(1, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 5));
   EXPECT_EQ(2, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 6));
   EXPECT_EQ(2, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 7));
   EXPECT_EQ(2, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 8));
   EXPECT_EQ(3, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 9));
@@ skipping 31 matching lines @@
   EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 0));
   EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 1));
   EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 2));
 
   EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 0));
   EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 1));
   EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 2));
   EXPECT_EQ(1, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 3));
 }
 
-TEST(TilingDataTest, lastBorderTileXIndexFromSrcCoord)
-{
+TEST(TilingDataTest, LastBorderTileXIndexFromSrcCoord) {
   EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 0));
   EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 1));
   EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 2));
   EXPECT_EQ(1, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 3));
   EXPECT_EQ(1, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 4));
   EXPECT_EQ(1, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 5));
   EXPECT_EQ(2, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 6));
   EXPECT_EQ(2, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 7));
   EXPECT_EQ(2, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 8));
   EXPECT_EQ(3, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 9));
@@ skipping 31 matching lines @@
   EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 0));
   EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 1));
   EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 2));
 
   EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 0));
   EXPECT_EQ(1, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 1));
   EXPECT_EQ(1, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 2));
   EXPECT_EQ(1, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 3));
 }
 
-TEST(TilingDataTest, tileYIndexFromSrcCoord)
-{
+TEST(TilingDataTest, TileYIndexFromSrcCoord) {
   EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 0));
   EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 1));
   EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 2));
   EXPECT_EQ(1, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 3));
   EXPECT_EQ(1, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 4));
   EXPECT_EQ(1, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 5));
   EXPECT_EQ(2, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 6));
   EXPECT_EQ(2, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 7));
   EXPECT_EQ(2, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 8));
   EXPECT_EQ(3, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 9));
@@ skipping 31 matching lines @@
   EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 0));
   EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 1));
   EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 2));
 
   EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 0));
   EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 1));
   EXPECT_EQ(1, YIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 2));
   EXPECT_EQ(1, YIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 3));
 }
 
-TEST(TilingDataTest, firstBorderTileYIndexFromSrcCoord)
-{
+TEST(TilingDataTest, FirstBorderTileYIndexFromSrcCoord) {
   EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 0));
   EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 1));
   EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 2));
   EXPECT_EQ(1, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 3));
   EXPECT_EQ(1, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 4));
   EXPECT_EQ(1, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 5));
   EXPECT_EQ(2, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 6));
   EXPECT_EQ(2, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 7));
   EXPECT_EQ(2, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 8));
   EXPECT_EQ(3, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 9));
@@ skipping 31 matching lines @@
   EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 0));
   EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 1));
   EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 2));
 
   EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 0));
   EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 1));
   EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 2));
   EXPECT_EQ(1, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 3));
 }
 
-TEST(TilingDataTest, lastBorderTileYIndexFromSrcCoord)
-{
+TEST(TilingDataTest, LastBorderTileYIndexFromSrcCoord) {
   EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 0));
   EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 1));
   EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 2));
   EXPECT_EQ(1, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 3));
   EXPECT_EQ(1, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 4));
   EXPECT_EQ(1, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 5));
   EXPECT_EQ(2, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 6));
   EXPECT_EQ(2, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 7));
   EXPECT_EQ(2, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 8));
   EXPECT_EQ(3, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 9));
@@ skipping 31 matching lines @@
   EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 0));
   EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 1));
   EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 2));
 
   EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 0));
   EXPECT_EQ(1, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 1));
   EXPECT_EQ(1, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 2));
   EXPECT_EQ(1, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 3));
 }
 
-TEST(TilingDataTest, tileSizeX)
-{
+TEST(TilingDataTest, TileSizeX) {
   EXPECT_EQ(5, SizeX(gfx::Size(5, 5), gfx::Size(5, 5), false, 0));
   EXPECT_EQ(5, SizeX(gfx::Size(5, 5), gfx::Size(5, 5), true, 0));
 
   EXPECT_EQ(5, SizeX(gfx::Size(5, 5), gfx::Size(6, 6), false, 0));
   EXPECT_EQ(1, SizeX(gfx::Size(5, 5), gfx::Size(6, 6), false, 1));
   EXPECT_EQ(4, SizeX(gfx::Size(5, 5), gfx::Size(6, 6), true, 0));
   EXPECT_EQ(2, SizeX(gfx::Size(5, 5), gfx::Size(6, 6), true, 1));
 
   EXPECT_EQ(5, SizeX(gfx::Size(5, 5), gfx::Size(8, 8), false, 0));
   EXPECT_EQ(3, SizeX(gfx::Size(5, 5), gfx::Size(8, 8), false, 1));
   EXPECT_EQ(4, SizeX(gfx::Size(5, 5), gfx::Size(8, 8), true, 0));
   EXPECT_EQ(4, SizeX(gfx::Size(5, 5), gfx::Size(8, 8), true, 1));
 
   EXPECT_EQ(5, SizeX(gfx::Size(5, 5), gfx::Size(10, 10), false, 0));
   EXPECT_EQ(5, SizeX(gfx::Size(5, 5), gfx::Size(10, 10), false, 1));
   EXPECT_EQ(4, SizeX(gfx::Size(5, 5), gfx::Size(10, 10), true, 0));
   EXPECT_EQ(3, SizeX(gfx::Size(5, 5), gfx::Size(10, 10), true, 1));
   EXPECT_EQ(3, SizeX(gfx::Size(5, 5), gfx::Size(10, 10), true, 2));
 
   EXPECT_EQ(4, SizeX(gfx::Size(5, 5), gfx::Size(11, 11), true, 2));
   EXPECT_EQ(3, SizeX(gfx::Size(5, 5), gfx::Size(12, 12), true, 2));
 
   EXPECT_EQ(3, SizeX(gfx::Size(5, 9), gfx::Size(12, 17), true, 2));
 }
 
-TEST(TilingDataTest, TileSizeY)
-{
+TEST(TilingDataTest, TileSizeY) {
   EXPECT_EQ(5, SizeY(gfx::Size(5, 5), gfx::Size(5, 5), false, 0));
   EXPECT_EQ(5, SizeY(gfx::Size(5, 5), gfx::Size(5, 5), true, 0));
 
   EXPECT_EQ(5, SizeY(gfx::Size(5, 5), gfx::Size(6, 6), false, 0));
   EXPECT_EQ(1, SizeY(gfx::Size(5, 5), gfx::Size(6, 6), false, 1));
   EXPECT_EQ(4, SizeY(gfx::Size(5, 5), gfx::Size(6, 6), true, 0));
   EXPECT_EQ(2, SizeY(gfx::Size(5, 5), gfx::Size(6, 6), true, 1));
 
   EXPECT_EQ(5, SizeY(gfx::Size(5, 5), gfx::Size(8, 8), false, 0));
   EXPECT_EQ(3, SizeY(gfx::Size(5, 5), gfx::Size(8, 8), false, 1));
   EXPECT_EQ(4, SizeY(gfx::Size(5, 5), gfx::Size(8, 8), true, 0));
   EXPECT_EQ(4, SizeY(gfx::Size(5, 5), gfx::Size(8, 8), true, 1));
 
   EXPECT_EQ(5, SizeY(gfx::Size(5, 5), gfx::Size(10, 10), false, 0));
   EXPECT_EQ(5, SizeY(gfx::Size(5, 5), gfx::Size(10, 10), false, 1));
   EXPECT_EQ(4, SizeY(gfx::Size(5, 5), gfx::Size(10, 10), true, 0));
   EXPECT_EQ(3, SizeY(gfx::Size(5, 5), gfx::Size(10, 10), true, 1));
   EXPECT_EQ(3, SizeY(gfx::Size(5, 5), gfx::Size(10, 10), true, 2));
 
   EXPECT_EQ(4, SizeY(gfx::Size(5, 5), gfx::Size(11, 11), true, 2));
   EXPECT_EQ(3, SizeY(gfx::Size(5, 5), gfx::Size(12, 12), true, 2));
 
   EXPECT_EQ(3, SizeY(gfx::Size(9, 5), gfx::Size(17, 12), true, 2));
 }
 
-TEST(TilingDataTest, TileSizeX_and_TilePositionX)
-{
+TEST(TilingDataTest, TileSizeX_and_TilePositionX) {
   // Single tile cases:
   EXPECT_EQ(1, SizeX(gfx::Size(3, 3), gfx::Size(1, 1), false, 0));
   EXPECT_EQ(0, PosX(gfx::Size(3, 3), gfx::Size(1, 1), false, 0));
   EXPECT_EQ(1, SizeX(gfx::Size(3, 3), gfx::Size(1, 100), false, 0));
   EXPECT_EQ(0, PosX(gfx::Size(3, 3), gfx::Size(1, 100), false, 0));
   EXPECT_EQ(3, SizeX(gfx::Size(3, 3), gfx::Size(3, 1), false, 0));
   EXPECT_EQ(0, PosX(gfx::Size(3, 3), gfx::Size(3, 1), false, 0));
   EXPECT_EQ(3, SizeX(gfx::Size(3, 3), gfx::Size(3, 100), false, 0));
   EXPECT_EQ(0, PosX(gfx::Size(3, 3), gfx::Size(3, 100), false, 0));
   EXPECT_EQ(1, SizeX(gfx::Size(3, 3), gfx::Size(1, 1), true, 0));
@@ skipping 33 matching lines @@
   EXPECT_EQ(2, SizeX(gfx::Size(3, 7), gfx::Size(6, 100), true, 0));
   EXPECT_EQ(1, SizeX(gfx::Size(3, 7), gfx::Size(6, 100), true, 1));
   EXPECT_EQ(1, SizeX(gfx::Size(3, 7), gfx::Size(6, 100), true, 2));
   EXPECT_EQ(2, SizeX(gfx::Size(3, 7), gfx::Size(6, 100), true, 3));
   EXPECT_EQ(0, PosX(gfx::Size(3, 7), gfx::Size(6, 100), true, 0));
   EXPECT_EQ(2, PosX(gfx::Size(3, 7), gfx::Size(6, 100), true, 1));
   EXPECT_EQ(3, PosX(gfx::Size(3, 7), gfx::Size(6, 100), true, 2));
   EXPECT_EQ(4, PosX(gfx::Size(3, 7), gfx::Size(6, 100), true, 3));
 }
 
-TEST(TilingDataTest, TileSizeY_and_TilePositionY)
-{
+TEST(TilingDataTest, TileSizeY_and_TilePositionY) {
   // Single tile cases:
   EXPECT_EQ(1, SizeY(gfx::Size(3, 3), gfx::Size(1, 1), false, 0));
   EXPECT_EQ(0, PosY(gfx::Size(3, 3), gfx::Size(1, 1), false, 0));
   EXPECT_EQ(1, SizeY(gfx::Size(3, 3), gfx::Size(100, 1), false, 0));
   EXPECT_EQ(0, PosY(gfx::Size(3, 3), gfx::Size(100, 1), false, 0));
   EXPECT_EQ(3, SizeY(gfx::Size(3, 3), gfx::Size(1, 3), false, 0));
   EXPECT_EQ(0, PosY(gfx::Size(3, 3), gfx::Size(1, 3), false, 0));
   EXPECT_EQ(3, SizeY(gfx::Size(3, 3), gfx::Size(100, 3), false, 0));
   EXPECT_EQ(0, PosY(gfx::Size(3, 3), gfx::Size(100, 3), false, 0));
   EXPECT_EQ(1, SizeY(gfx::Size(3, 3), gfx::Size(1, 1), true, 0));
@@ skipping 33 matching lines @@
   EXPECT_EQ(2, SizeY(gfx::Size(7, 3), gfx::Size(100, 6), true, 0));
   EXPECT_EQ(1, SizeY(gfx::Size(7, 3), gfx::Size(100, 6), true, 1));
   EXPECT_EQ(1, SizeY(gfx::Size(7, 3), gfx::Size(100, 6), true, 2));
   EXPECT_EQ(2, SizeY(gfx::Size(7, 3), gfx::Size(100, 6), true, 3));
   EXPECT_EQ(0, PosY(gfx::Size(7, 3), gfx::Size(100, 6), true, 0));
   EXPECT_EQ(2, PosY(gfx::Size(7, 3), gfx::Size(100, 6), true, 1));
   EXPECT_EQ(3, PosY(gfx::Size(7, 3), gfx::Size(100, 6), true, 2));
   EXPECT_EQ(4, PosY(gfx::Size(7, 3), gfx::Size(100, 6), true, 3));
 }
 
-TEST(TilingDataTest, SetTotalSize)
-{
+TEST(TilingDataTest, SetTotalSize) {
   TilingData data(gfx::Size(5, 5), gfx::Size(5, 5), false);
   EXPECT_EQ(5, data.total_size().width());
   EXPECT_EQ(5, data.total_size().height());
   EXPECT_EQ(1, data.num_tiles_x());
   EXPECT_EQ(5, data.TileSizeX(0));
   EXPECT_EQ(1, data.num_tiles_y());
   EXPECT_EQ(5, data.TileSizeY(0));
 
   data.SetTotalSize(gfx::Size(6, 5));
   EXPECT_EQ(6, data.total_size().width());
   EXPECT_EQ(5, data.total_size().height());
   EXPECT_EQ(2, data.num_tiles_x());
   EXPECT_EQ(5, data.TileSizeX(0));
   EXPECT_EQ(1, data.TileSizeX(1));
   EXPECT_EQ(1, data.num_tiles_y());
   EXPECT_EQ(5, data.TileSizeY(0));
 
   data.SetTotalSize(gfx::Size(5, 12));
   EXPECT_EQ(5, data.total_size().width());
   EXPECT_EQ(12, data.total_size().height());
   EXPECT_EQ(1, data.num_tiles_x());
   EXPECT_EQ(5, data.TileSizeX(0));
   EXPECT_EQ(3, data.num_tiles_y());
   EXPECT_EQ(5, data.TileSizeY(0));
   EXPECT_EQ(5, data.TileSizeY(1));
   EXPECT_EQ(2, data.TileSizeY(2));
 }
 
-TEST(TilingDataTest, SetMaxTextureSizeNoBorders)
-{
+TEST(TilingDataTest, SetMaxTextureSizeNoBorders) {
   TilingData data(gfx::Size(8, 8), gfx::Size(16, 32), false);
   EXPECT_EQ(2, data.num_tiles_x());
   EXPECT_EQ(4, data.num_tiles_y());
 
   data.SetMaxTextureSize(gfx::Size(32, 32));
   EXPECT_EQ(gfx::Size(32, 32), data.max_texture_size());
   EXPECT_EQ(1, data.num_tiles_x());
   EXPECT_EQ(1, data.num_tiles_y());
 
   data.SetMaxTextureSize(gfx::Size(2, 2));
   EXPECT_EQ(gfx::Size(2, 2), data.max_texture_size());
   EXPECT_EQ(8, data.num_tiles_x());
   EXPECT_EQ(16, data.num_tiles_y());
 
   data.SetMaxTextureSize(gfx::Size(5, 5));
   EXPECT_EQ(gfx::Size(5, 5), data.max_texture_size());
   EXPECT_EQ(4, data.num_tiles_x());
   EXPECT_EQ(7, data.num_tiles_y());
 
   data.SetMaxTextureSize(gfx::Size(8, 5));
   EXPECT_EQ(gfx::Size(8, 5), data.max_texture_size());
   EXPECT_EQ(2, data.num_tiles_x());
   EXPECT_EQ(7, data.num_tiles_y());
 }
 
-TEST(TilingDataTest, SetMaxTextureSizeBorders)
-{
+TEST(TilingDataTest, SetMaxTextureSizeBorders) {
   TilingData data(gfx::Size(8, 8), gfx::Size(16, 32), true);
   EXPECT_EQ(3, data.num_tiles_x());
   EXPECT_EQ(5, data.num_tiles_y());
 
   data.SetMaxTextureSize(gfx::Size(32, 32));
   EXPECT_EQ(gfx::Size(32, 32), data.max_texture_size());
   EXPECT_EQ(1, data.num_tiles_x());
   EXPECT_EQ(1, data.num_tiles_y());
 
   data.SetMaxTextureSize(gfx::Size(2, 2));
   EXPECT_EQ(gfx::Size(2, 2), data.max_texture_size());
   EXPECT_EQ(0, data.num_tiles_x());
   EXPECT_EQ(0, data.num_tiles_y());
 
   data.SetMaxTextureSize(gfx::Size(5, 5));
   EXPECT_EQ(gfx::Size(5, 5), data.max_texture_size());
   EXPECT_EQ(5, data.num_tiles_x());
   EXPECT_EQ(10, data.num_tiles_y());
 
   data.SetMaxTextureSize(gfx::Size(8, 5));
   EXPECT_EQ(gfx::Size(8, 5), data.max_texture_size());
   EXPECT_EQ(3, data.num_tiles_x());
   EXPECT_EQ(10, data.num_tiles_y());
 }
 
-TEST(TilingDataTest, assignment)
-{
-  {
+TEST(TilingDataTest, Assignment) { {
     TilingData source(gfx::Size(8, 8), gfx::Size(16, 32), true);
     TilingData dest = source;
     EXPECT_EQ(source.border_texels(), dest.border_texels());
     EXPECT_EQ(source.max_texture_size(), dest.max_texture_size());
     EXPECT_EQ(source.num_tiles_x(), dest.num_tiles_x());
     EXPECT_EQ(source.num_tiles_y(), dest.num_tiles_y());
     EXPECT_EQ(source.total_size().width(), dest.total_size().width());
     EXPECT_EQ(source.total_size().height(), dest.total_size().height());
-  }
-  {
+  } {

[danakj, 2013/03/21 17:59:22]

I should fix this.

[enne (OOO), 2013/03/21 18:02:07]

Fixed.  Sorry for missing one.

     TilingData source(gfx::Size(7, 3), gfx::Size(6, 100), false);
     TilingData dest(source);
     EXPECT_EQ(source.border_texels(), dest.border_texels());
     EXPECT_EQ(source.max_texture_size(), dest.max_texture_size());
     EXPECT_EQ(source.num_tiles_x(), dest.num_tiles_x());
     EXPECT_EQ(source.num_tiles_y(), dest.num_tiles_y());
     EXPECT_EQ(source.total_size().width(), dest.total_size().width());
     EXPECT_EQ(source.total_size().height(), dest.total_size().height());
   }
 }
 
-TEST(TilingDataTest, setBorderTexels)
-{
+TEST(TilingDataTest, SetBorderTexels) {
   TilingData data(gfx::Size(8, 8), gfx::Size(16, 32), false);
   EXPECT_EQ(2, data.num_tiles_x());
   EXPECT_EQ(4, data.num_tiles_y());
 
   data.SetHasBorderTexels(true);
   EXPECT_EQ(3, data.num_tiles_x());
   EXPECT_EQ(5, data.num_tiles_y());
 
   data.SetHasBorderTexels(true);
   EXPECT_EQ(3, data.num_tiles_x());
   EXPECT_EQ(5, data.num_tiles_y());
 
   data.SetHasBorderTexels(false);
   EXPECT_EQ(2, data.num_tiles_x());
   EXPECT_EQ(4, data.num_tiles_y());
 }
 
-TEST(TilingDataTest, largeBorders)
-{
+TEST(TilingDataTest, LargeBorders) {
   TilingData data(gfx::Size(100, 80), gfx::Size(200, 145), 30);
   EXPECT_EQ(30, data.border_texels());
 
   EXPECT_EQ(70, data.TileSizeX(0));
   EXPECT_EQ(40, data.TileSizeX(1));
   EXPECT_EQ(40, data.TileSizeX(2));
   EXPECT_EQ(50, data.TileSizeX(3));
   EXPECT_EQ(4, data.num_tiles_x());
 
   EXPECT_EQ(50, data.TileSizeY(0));
@@ skipping 134 matching lines @@
           found = true;
           break;
         }
       }
       EXPECT_TRUE(found);
     }
     EXPECT_EQ(0, expected.size());
   }
 }
 
-TEST(TilingDataTest, iteratorNoBorderTexels)
-{
+TEST(TilingDataTest, IteratorNoBorderTexels) {
   TilingData data(gfx::Size(10, 10), gfx::Size(40, 25), false);
   // X border index by src coord: [0-10), [10-20), [20, 30), [30, 40)
   // Y border index by src coord: [0-10), [10-20), [20, 25)
   TestIterate(data, gfx::Rect(0, 0, 40, 25), 0, 0, 3, 2);
   TestIterate(data, gfx::Rect(15, 15, 8, 8), 1, 1, 2, 2);
 
   // Oversized.
   TestIterate(data, gfx::Rect(-100, -100, 1000, 1000), 0, 0, 3, 2);
   TestIterate(data, gfx::Rect(-100, 20, 1000, 1), 0, 2, 3, 2);
   TestIterate(data, gfx::Rect(29, -100, 31, 1000), 2, 0, 3, 2);
   // Nonintersecting.
   TestIterate(data, gfx::Rect(60, 80, 100, 100), 0, 0, -1, -1);
 }
 
-TEST(TilingDataTest, iteratorOneBorderTexel)
-{
+TEST(TilingDataTest, IteratorOneBorderTexel) {
   TilingData data(gfx::Size(10, 20), gfx::Size(25, 45), true);
   // X border index by src coord: [0-10), [8-18), [16-25)
   // Y border index by src coord: [0-20), [18-38), [36-45)
   TestIterate(data, gfx::Rect(0, 0, 25, 45), 0, 0, 2, 2);
   TestIterate(data, gfx::Rect(18, 19, 3, 17), 2, 0, 2, 1);
   TestIterate(data, gfx::Rect(10, 20, 6, 16), 1, 1, 1, 1);
   TestIterate(data, gfx::Rect(9, 19, 8, 18), 0, 0, 2, 2);
 
   // Oversized.
   TestIterate(data, gfx::Rect(-100, -100, 1000, 1000), 0, 0, 2, 2);
   TestIterate(data, gfx::Rect(-100, 20, 1000, 1), 0, 1, 2, 1);
   TestIterate(data, gfx::Rect(18, -100, 6, 1000), 2, 0, 2, 2);
   // Nonintersecting.
   TestIterate(data, gfx::Rect(60, 80, 100, 100), 0, 0, -1, -1);
 }
 
-TEST(TilingDataTest, iteratorManyBorderTexels)
-{
+TEST(TilingDataTest, IteratorManyBorderTexels) {
   TilingData data(gfx::Size(50, 60), gfx::Size(65, 110), 20);
   // X border index by src coord: [0-50), [10-60), [20-65)
   // Y border index by src coord: [0-60), [20-80), [40-100), [60-110)
   TestIterate(data, gfx::Rect(0, 0, 65, 110), 0, 0, 2, 3);
   TestIterate(data, gfx::Rect(50, 60, 15, 65), 1, 1, 2, 3);
   TestIterate(data, gfx::Rect(60, 30, 2, 10), 2, 0, 2, 1);
 
   // Oversized.
   TestIterate(data, gfx::Rect(-100, -100, 1000, 1000), 0, 0, 2, 3);
   TestIterate(data, gfx::Rect(-100, 10, 1000, 10), 0, 0, 2, 0);
   TestIterate(data, gfx::Rect(10, -100, 10, 1000), 0, 0, 1, 3);
   // Nonintersecting.
   TestIterate(data, gfx::Rect(65, 110, 100, 100), 0, 0, -1, -1);
 }
 
-TEST(TilingDataTest, iteratorOneTile)
-{
+TEST(TilingDataTest, IteratorOneTile) {
   TilingData no_border(gfx::Size(1000, 1000), gfx::Size(30, 40), false);
   TestIterate(no_border, gfx::Rect(0, 0, 30, 40), 0, 0, 0, 0);
   TestIterate(no_border, gfx::Rect(10, 10, 20, 20), 0, 0, 0, 0);
   TestIterate(no_border, gfx::Rect(30, 40, 100, 100), 0, 0, -1, -1);
 
   TilingData one_border(gfx::Size(1000, 1000), gfx::Size(30, 40), true);
   TestIterate(one_border, gfx::Rect(0, 0, 30, 40), 0, 0, 0, 0);
   TestIterate(one_border, gfx::Rect(10, 10, 20, 20), 0, 0, 0, 0);
   TestIterate(one_border, gfx::Rect(30, 40, 100, 100), 0, 0, -1, -1);
 
   TilingData big_border(gfx::Size(1000, 1000), gfx::Size(30, 40), 50);
   TestIterate(big_border, gfx::Rect(0, 0, 30, 40), 0, 0, 0, 0);
   TestIterate(big_border, gfx::Rect(10, 10, 20, 20), 0, 0, 0, 0);
   TestIterate(big_border, gfx::Rect(30, 40, 100, 100), 0, 0, -1, -1);
 }
 
-TEST(TilingDataTest, iteratorNoTiles)
-{
+TEST(TilingDataTest, IteratorNoTiles) {
   TilingData data(gfx::Size(100, 100), gfx::Size(), false);
   TestIterate(data, gfx::Rect(0, 0, 100, 100), 0, 0, -1, -1);
 }
 
 void TestDiff(
     const TilingData& data,
     gfx::Rect consider,
     gfx::Rect ignore,
     size_t num_tiles) {
 
@@ skipping 18 matching lines @@
         expected.pop_back();
         found = true;
         break;
       }
     }
     EXPECT_TRUE(found);
   }
   EXPECT_EQ(0, expected.size());
 }
 
-TEST(TilingDataTest, differenceIteratorIgnoreGeometry)
-{
+TEST(TilingDataTest, DifferenceIteratorIgnoreGeometry) {
   // This test is checking that the iterator can handle different geometries of
   // ignore rects relative to the consider rect.  The consider rect indices
   // themselves are mostly tested by the non-difference iterator tests, so the
   // full rect is mostly used here for simplicity.
 
   // X border index by src coord: [0-10), [10-20), [20, 30), [30, 40)
   // Y border index by src coord: [0-10), [10-20), [20, 25)
   TilingData data(gfx::Size(10, 10), gfx::Size(40, 25), false);
 
   // Fully ignored
@@ skipping 31 matching lines @@
   // Bottom row, flush bottom, removing two rows
   TestDiff(data, gfx::Rect(0, 0, 40, 25), gfx::Rect(0, 13, 40, 12), 4);
 
   // Non-intersecting, but still touching two of the same tiles.
   TestDiff(data, gfx::Rect(8, 0, 32, 25), gfx::Rect(0, 12, 5, 12), 10);
 
   // Intersecting, but neither contains the other. 2x3 with one overlap.
   TestDiff(data, gfx::Rect(5, 2, 20, 10), gfx::Rect(25, 15, 5, 10), 5);
 }
 
-TEST(TilingDataTest, differenceIteratorManyBorderTexels)
-{
+TEST(TilingDataTest, DifferenceIteratorManyBorderTexels) {
   // X border index by src coord: [0-50), [10-60), [20-65)
   // Y border index by src coord: [0-60), [20-80), [40-100), [60-110)
   TilingData data(gfx::Size(50, 60), gfx::Size(65, 110), 20);
 
   // Ignore one column, three rows
   TestDiff(data, gfx::Rect(0, 30, 55, 80), gfx::Rect(5, 30, 5, 15), 9);
 
   // Knock out three columns, leaving only one.
   TestDiff(data, gfx::Rect(10, 30, 55, 80), gfx::Rect(30, 59, 20, 1), 3);
 
   // Overlap all tiles with ignore rect.
   TestDiff(data, gfx::Rect(0, 0, 65, 110), gfx::Rect(30, 59, 1, 2), 0);
 }
 
-TEST(TilingDataTest, differenceIteratorOneTile)
-{
+TEST(TilingDataTest, DifferenceIteratorOneTile) {
   TilingData no_border(gfx::Size(1000, 1000), gfx::Size(30, 40), false);
   TestDiff(no_border, gfx::Rect(0, 0, 30, 40), gfx::Rect(), 1);
   TestDiff(no_border, gfx::Rect(5, 5, 100, 100), gfx::Rect(5, 5, 1, 1), 0);
 
   TilingData one_border(gfx::Size(1000, 1000), gfx::Size(30, 40), true);
   TestDiff(one_border, gfx::Rect(0, 0, 30, 40), gfx::Rect(), 1);
   TestDiff(one_border, gfx::Rect(5, 5, 100, 100), gfx::Rect(5, 5, 1, 1), 0);
 
   TilingData big_border(gfx::Size(1000, 1000), gfx::Size(30, 40), 50);
   TestDiff(big_border, gfx::Rect(0, 0, 30, 40), gfx::Rect(), 1);
   TestDiff(big_border, gfx::Rect(5, 5, 100, 100), gfx::Rect(5, 5, 1, 1), 0);
 }
 
-TEST(TilingDataTest, differenceIteratorNoTiles)
-{
+TEST(TilingDataTest, DifferenceIteratorNoTiles) {
   TilingData data(gfx::Size(100, 100), gfx::Size(), false);
   TestDiff(data, gfx::Rect(0, 0, 100, 100), gfx::Rect(0, 0, 5, 5), 0);
 }
 
 }  // namespace
 }  // namespace cc