src/cc/base/tiling_data_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/base/tiling_data.h"
   6
   7 #include <algorithm>
   8 #include <vector>
   9
  10 #include "cc/test/geometry_test_utils.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 namespace cc {
  14 namespace {
  15
  16 int NumTiles(const gfx::Size& max_texture_size,
  17              const gfx::Rect& tiling_rect,
  18              bool has_border_texels) {
  19   TilingData tiling(max_texture_size, tiling_rect, has_border_texels);
  20   int num_tiles = tiling.num_tiles_x() * tiling.num_tiles_y();
  21
  22   // Assert no overflow.
  23   EXPECT_GE(num_tiles, 0);
  24   if (num_tiles > 0)
  25     EXPECT_EQ(num_tiles / tiling.num_tiles_x(), tiling.num_tiles_y());
  26
  27   return num_tiles;
  28 }
  29
  30 int XIndex(const gfx::Size& max_texture_size,
  31            const gfx::Rect& tiling_rect,
  32            bool has_border_texels,
  33            int x_coord) {
  34   TilingData tiling(max_texture_size, tiling_rect, has_border_texels);
  35   return tiling.TileXIndexFromSrcCoord(x_coord);
  36 }
  37
  38 int YIndex(const gfx::Size& max_texture_size,
  39            const gfx::Rect& tiling_rect,
  40            bool has_border_texels,
  41            int y_coord) {
  42   TilingData tiling(max_texture_size, tiling_rect, has_border_texels);
  43   return tiling.TileYIndexFromSrcCoord(y_coord);
  44 }
  45
  46 int MinBorderXIndex(const gfx::Size& max_texture_size,
  47                     const gfx::Rect& tiling_rect,
  48                     bool has_border_texels,
  49                     int x_coord) {
  50   TilingData tiling(max_texture_size, tiling_rect, has_border_texels);
  51   return tiling.FirstBorderTileXIndexFromSrcCoord(x_coord);
  52 }
  53
  54 int MinBorderYIndex(const gfx::Size& max_texture_size,
  55                     const gfx::Rect& tiling_rect,
  56                     bool has_border_texels,
  57                     int y_coord) {
  58   TilingData tiling(max_texture_size, tiling_rect, has_border_texels);
  59   return tiling.FirstBorderTileYIndexFromSrcCoord(y_coord);
  60 }
  61
  62 int MaxBorderXIndex(const gfx::Size& max_texture_size,
  63                     const gfx::Rect& tiling_rect,
  64                     bool has_border_texels,
  65                     int x_coord) {
  66   TilingData tiling(max_texture_size, tiling_rect, has_border_texels);
  67   return tiling.LastBorderTileXIndexFromSrcCoord(x_coord);
  68 }
  69
  70 int MaxBorderYIndex(const gfx::Size& max_texture_size,
  71                     const gfx::Rect& tiling_rect,
  72                     bool has_border_texels,
  73                     int y_coord) {
  74   TilingData tiling(max_texture_size, tiling_rect, has_border_texels);
  75   return tiling.LastBorderTileYIndexFromSrcCoord(y_coord);
  76 }
  77
  78 int PosX(const gfx::Size& max_texture_size,
  79          const gfx::Rect& tiling_rect,
  80          bool has_border_texels,
  81          int x_index) {
  82   TilingData tiling(max_texture_size, tiling_rect, has_border_texels);
  83   return tiling.TilePositionX(x_index);
  84 }
  85
  86 int PosY(const gfx::Size& max_texture_size,
  87          const gfx::Rect& tiling_rect,
  88          bool has_border_texels,
  89          int y_index) {
  90   TilingData tiling(max_texture_size, tiling_rect, has_border_texels);
  91   return tiling.TilePositionY(y_index);
  92 }
  93
  94 int SizeX(const gfx::Size& max_texture_size,
  95           const gfx::Rect& tiling_rect,
  96           bool has_border_texels,
  97           int x_index) {
  98   TilingData tiling(max_texture_size, tiling_rect, has_border_texels);
  99   return tiling.TileSizeX(x_index);
 100 }
 101
 102 int SizeY(const gfx::Size& max_texture_size,
 103           const gfx::Rect& tiling_rect,
 104           bool has_border_texels,
 105           int y_index) {
 106   TilingData tiling(max_texture_size, tiling_rect, has_border_texels);
 107   return tiling.TileSizeY(y_index);
 108 }
 109
 110 class TilingDataTest : public ::testing::TestWithParam<gfx::Point> {};
 111
 112 TEST_P(TilingDataTest, NumTiles_NoTiling) {
 113   gfx::Point origin = GetParam();
 114
 115   EXPECT_EQ(
 116       1,
 117       NumTiles(gfx::Size(16, 16), gfx::Rect(origin, gfx::Size(16, 16)), false));
 118   EXPECT_EQ(
 119       1,
 120       NumTiles(gfx::Size(16, 16), gfx::Rect(origin, gfx::Size(15, 15)), true));
 121   EXPECT_EQ(
 122       1,
 123       NumTiles(gfx::Size(16, 16), gfx::Rect(origin, gfx::Size(16, 16)), true));
 124   EXPECT_EQ(
 125       1,
 126       NumTiles(gfx::Size(16, 16), gfx::Rect(origin, gfx::Size(1, 16)), false));
 127   EXPECT_EQ(
 128       1,
 129       NumTiles(gfx::Size(15, 15), gfx::Rect(origin, gfx::Size(15, 15)), true));
 130   EXPECT_EQ(
 131       1,
 132       NumTiles(gfx::Size(32, 16), gfx::Rect(origin, gfx::Size(32, 16)), false));
 133   EXPECT_EQ(
 134       1,
 135       NumTiles(gfx::Size(32, 16), gfx::Rect(origin, gfx::Size(32, 16)), true));
 136 }
 137
 138 TEST_P(TilingDataTest, NumTiles_TilingNoBorders) {
 139   gfx::Point origin = GetParam();
 140
 141   EXPECT_EQ(
 142       0, NumTiles(gfx::Size(0, 0), gfx::Rect(origin, gfx::Size(0, 0)), false));
 143   EXPECT_EQ(
 144       0, NumTiles(gfx::Size(0, 0), gfx::Rect(origin, gfx::Size(4, 0)), false));
 145   EXPECT_EQ(
 146       0, NumTiles(gfx::Size(0, 0), gfx::Rect(origin, gfx::Size(0, 4)), false));
 147   EXPECT_EQ(
 148       0, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(4, 0)), false));
 149   EXPECT_EQ(
 150       0, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(0, 4)), false));
 151   EXPECT_EQ(
 152       0, NumTiles(gfx::Size(0, 0), gfx::Rect(origin, gfx::Size(1, 1)), false));
 153
 154   EXPECT_EQ(
 155       1, NumTiles(gfx::Size(1, 1), gfx::Rect(origin, gfx::Size(1, 1)), false));
 156   EXPECT_EQ(
 157       2, NumTiles(gfx::Size(1, 1), gfx::Rect(origin, gfx::Size(1, 2)), false));
 158   EXPECT_EQ(
 159       2, NumTiles(gfx::Size(1, 1), gfx::Rect(origin, gfx::Size(2, 1)), false));
 160   EXPECT_EQ(
 161       1, NumTiles(gfx::Size(2, 2), gfx::Rect(origin, gfx::Size(1, 1)), false));
 162   EXPECT_EQ(
 163       1, NumTiles(gfx::Size(2, 2), gfx::Rect(origin, gfx::Size(1, 2)), false));
 164   EXPECT_EQ(
 165       1, NumTiles(gfx::Size(2, 2), gfx::Rect(origin, gfx::Size(2, 1)), false));
 166   EXPECT_EQ(
 167       1, NumTiles(gfx::Size(2, 2), gfx::Rect(origin, gfx::Size(2, 2)), false));
 168   EXPECT_EQ(
 169       1, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 3)), false));
 170
 171   EXPECT_EQ(
 172       1, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(1, 4)), false));
 173   EXPECT_EQ(
 174       1, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(2, 4)), false));
 175   EXPECT_EQ(
 176       1, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(3, 4)), false));
 177   EXPECT_EQ(
 178       1, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(4, 4)), false));
 179   EXPECT_EQ(
 180       2, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(5, 4)), false));
 181   EXPECT_EQ(
 182       2, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(6, 4)), false));
 183   EXPECT_EQ(
 184       2, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(7, 4)), false));
 185   EXPECT_EQ(
 186       2, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(8, 4)), false));
 187   EXPECT_EQ(
 188       3, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(9, 4)), false));
 189   EXPECT_EQ(
 190       3, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(10, 4)), false));
 191   EXPECT_EQ(
 192       3, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(11, 4)), false));
 193
 194   EXPECT_EQ(
 195       1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(1, 5)), false));
 196   EXPECT_EQ(
 197       1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(2, 5)), false));
 198   EXPECT_EQ(
 199       1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(3, 5)), false));
 200   EXPECT_EQ(
 201       1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(4, 5)), false));
 202   EXPECT_EQ(
 203       1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(5, 5)), false));
 204   EXPECT_EQ(
 205       2, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 5)), false));
 206   EXPECT_EQ(
 207       2, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(7, 5)), false));
 208   EXPECT_EQ(
 209       2, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 5)), false));
 210   EXPECT_EQ(
 211       2, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(9, 5)), false));
 212   EXPECT_EQ(
 213       2, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 5)), false));
 214   EXPECT_EQ(
 215       3, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(11, 5)), false));
 216
 217   EXPECT_EQ(
 218       1,
 219       NumTiles(gfx::Size(16, 16), gfx::Rect(origin, gfx::Size(16, 16)), false));
 220   EXPECT_EQ(
 221       1,
 222       NumTiles(gfx::Size(17, 17), gfx::Rect(origin, gfx::Size(16, 16)), false));
 223   EXPECT_EQ(
 224       4,
 225       NumTiles(gfx::Size(15, 15), gfx::Rect(origin, gfx::Size(16, 16)), false));
 226   EXPECT_EQ(
 227       4,
 228       NumTiles(gfx::Size(8, 8), gfx::Rect(origin, gfx::Size(16, 16)), false));
 229   EXPECT_EQ(
 230       6,
 231       NumTiles(gfx::Size(8, 8), gfx::Rect(origin, gfx::Size(17, 16)), false));
 232
 233   EXPECT_EQ(
 234       8,
 235       NumTiles(gfx::Size(5, 8), gfx::Rect(origin, gfx::Size(17, 16)), false));
 236 }
 237
 238 TEST_P(TilingDataTest, NumTiles_TilingWithBorders) {
 239   gfx::Point origin = GetParam();
 240
 241   EXPECT_EQ(
 242       0, NumTiles(gfx::Size(0, 0), gfx::Rect(origin, gfx::Size(0, 0)), true));
 243   EXPECT_EQ(
 244       0, NumTiles(gfx::Size(0, 0), gfx::Rect(origin, gfx::Size(4, 0)), true));
 245   EXPECT_EQ(
 246       0, NumTiles(gfx::Size(0, 0), gfx::Rect(origin, gfx::Size(0, 4)), true));
 247   EXPECT_EQ(
 248       0, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(4, 0)), true));
 249   EXPECT_EQ(
 250       0, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(0, 4)), true));
 251   EXPECT_EQ(
 252       0, NumTiles(gfx::Size(0, 0), gfx::Rect(origin, gfx::Size(1, 1)), true));
 253
 254   EXPECT_EQ(
 255       1, NumTiles(gfx::Size(1, 1), gfx::Rect(origin, gfx::Size(1, 1)), true));
 256   EXPECT_EQ(
 257       0, NumTiles(gfx::Size(1, 1), gfx::Rect(origin, gfx::Size(1, 2)), true));
 258   EXPECT_EQ(
 259       0, NumTiles(gfx::Size(1, 1), gfx::Rect(origin, gfx::Size(2, 1)), true));
 260   EXPECT_EQ(
 261       1, NumTiles(gfx::Size(2, 2), gfx::Rect(origin, gfx::Size(1, 1)), true));
 262   EXPECT_EQ(
 263       1, NumTiles(gfx::Size(2, 2), gfx::Rect(origin, gfx::Size(1, 2)), true));
 264   EXPECT_EQ(
 265       1, NumTiles(gfx::Size(2, 2), gfx::Rect(origin, gfx::Size(2, 1)), true));
 266   EXPECT_EQ(
 267       1, NumTiles(gfx::Size(2, 2), gfx::Rect(origin, gfx::Size(2, 2)), true));
 268
 269   EXPECT_EQ(
 270       1, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 3)), true));
 271   EXPECT_EQ(
 272       1, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(2, 3)), true));
 273   EXPECT_EQ(
 274       1, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 3)), true));
 275   EXPECT_EQ(
 276       2, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(4, 3)), true));
 277   EXPECT_EQ(
 278       3, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(5, 3)), true));
 279   EXPECT_EQ(
 280       4, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 3)), true));
 281   EXPECT_EQ(
 282       5, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(7, 3)), true));
 283
 284   EXPECT_EQ(
 285       1, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(1, 4)), true));
 286   EXPECT_EQ(
 287       1, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(2, 4)), true));
 288   EXPECT_EQ(
 289       1, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(3, 4)), true));
 290   EXPECT_EQ(
 291       1, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(4, 4)), true));
 292   EXPECT_EQ(
 293       2, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(5, 4)), true));
 294   EXPECT_EQ(
 295       2, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(6, 4)), true));
 296   EXPECT_EQ(
 297       3, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(7, 4)), true));
 298   EXPECT_EQ(
 299       3, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(8, 4)), true));
 300   EXPECT_EQ(
 301       4, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(9, 4)), true));
 302   EXPECT_EQ(
 303       4, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(10, 4)), true));
 304   EXPECT_EQ(
 305       5, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(11, 4)), true));
 306
 307   EXPECT_EQ(
 308       1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(1, 5)), true));
 309   EXPECT_EQ(
 310       1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(2, 5)), true));
 311   EXPECT_EQ(
 312       1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(3, 5)), true));
 313   EXPECT_EQ(
 314       1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(4, 5)), true));
 315   EXPECT_EQ(
 316       1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(5, 5)), true));
 317   EXPECT_EQ(
 318       2, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 5)), true));
 319   EXPECT_EQ(
 320       2, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(7, 5)), true));
 321   EXPECT_EQ(
 322       2, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 5)), true));
 323   EXPECT_EQ(
 324       3, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(9, 5)), true));
 325   EXPECT_EQ(
 326       3, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 5)), true));
 327   EXPECT_EQ(
 328       3, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(11, 5)), true));
 329
 330   EXPECT_EQ(
 331       30,
 332       NumTiles(gfx::Size(8, 5), gfx::Rect(origin, gfx::Size(16, 32)), true));
 333 }
 334
 335 TEST_P(TilingDataTest, TileXIndexFromSrcCoord) {
 336   gfx::Point origin = GetParam();
 337
 338   EXPECT_EQ(0,
 339             XIndex(gfx::Size(3, 3),
 340                    gfx::Rect(origin, gfx::Size(10, 10)),
 341                    false,
 342                    origin.x() + 0));
 343   EXPECT_EQ(0,
 344             XIndex(gfx::Size(3, 3),
 345                    gfx::Rect(origin, gfx::Size(10, 10)),
 346                    false,
 347                    origin.x() + 1));
 348   EXPECT_EQ(0,
 349             XIndex(gfx::Size(3, 3),
 350                    gfx::Rect(origin, gfx::Size(10, 10)),
 351                    false,
 352                    origin.x() + 2));
 353   EXPECT_EQ(1,
 354             XIndex(gfx::Size(3, 3),
 355                    gfx::Rect(origin, gfx::Size(10, 10)),
 356                    false,
 357                    origin.x() + 3));
 358   EXPECT_EQ(1,
 359             XIndex(gfx::Size(3, 3),
 360                    gfx::Rect(origin, gfx::Size(10, 10)),
 361                    false,
 362                    origin.x() + 4));
 363   EXPECT_EQ(1,
 364             XIndex(gfx::Size(3, 3),
 365                    gfx::Rect(origin, gfx::Size(10, 10)),
 366                    false,
 367                    origin.x() + 5));
 368   EXPECT_EQ(2,
 369             XIndex(gfx::Size(3, 3),
 370                    gfx::Rect(origin, gfx::Size(10, 10)),
 371                    false,
 372                    origin.x() + 6));
 373   EXPECT_EQ(2,
 374             XIndex(gfx::Size(3, 3),
 375                    gfx::Rect(origin, gfx::Size(10, 10)),
 376                    false,
 377                    origin.x() + 7));
 378   EXPECT_EQ(2,
 379             XIndex(gfx::Size(3, 3),
 380                    gfx::Rect(origin, gfx::Size(10, 10)),
 381                    false,
 382                    origin.x() + 8));
 383   EXPECT_EQ(3,
 384             XIndex(gfx::Size(3, 3),
 385                    gfx::Rect(origin, gfx::Size(10, 10)),
 386                    false,
 387                    origin.x() + 9));
 388   EXPECT_EQ(3,
 389             XIndex(gfx::Size(3, 3),
 390                    gfx::Rect(origin, gfx::Size(10, 10)),
 391                    false,
 392                    origin.x() + 10));
 393   EXPECT_EQ(3,
 394             XIndex(gfx::Size(3, 3),
 395                    gfx::Rect(origin, gfx::Size(10, 10)),
 396                    false,
 397                    origin.x() + 11));
 398
 399   EXPECT_EQ(0,
 400             XIndex(gfx::Size(3, 3),
 401                    gfx::Rect(origin, gfx::Size(10, 10)),
 402                    true,
 403                    origin.x()));
 404   EXPECT_EQ(0,
 405             XIndex(gfx::Size(3, 3),
 406                    gfx::Rect(origin, gfx::Size(10, 10)),
 407                    true,
 408                    origin.x() + 1));
 409   EXPECT_EQ(1,
 410             XIndex(gfx::Size(3, 3),
 411                    gfx::Rect(origin, gfx::Size(10, 10)),
 412                    true,
 413                    origin.x() + 2));
 414   EXPECT_EQ(2,
 415             XIndex(gfx::Size(3, 3),
 416                    gfx::Rect(origin, gfx::Size(10, 10)),
 417                    true,
 418                    origin.x() + 3));
 419   EXPECT_EQ(3,
 420             XIndex(gfx::Size(3, 3),
 421                    gfx::Rect(origin, gfx::Size(10, 10)),
 422                    true,
 423                    origin.x() + 4));
 424   EXPECT_EQ(4,
 425             XIndex(gfx::Size(3, 3),
 426                    gfx::Rect(origin, gfx::Size(10, 10)),
 427                    true,
 428                    origin.x() + 5));
 429   EXPECT_EQ(5,
 430             XIndex(gfx::Size(3, 3),
 431                    gfx::Rect(origin, gfx::Size(10, 10)),
 432                    true,
 433                    origin.x() + 6));
 434   EXPECT_EQ(6,
 435             XIndex(gfx::Size(3, 3),
 436                    gfx::Rect(origin, gfx::Size(10, 10)),
 437                    true,
 438                    origin.x() + 7));
 439   EXPECT_EQ(7,
 440             XIndex(gfx::Size(3, 3),
 441                    gfx::Rect(origin, gfx::Size(10, 10)),
 442                    true,
 443                    origin.x() + 8));
 444   EXPECT_EQ(7,
 445             XIndex(gfx::Size(3, 3),
 446                    gfx::Rect(origin, gfx::Size(10, 10)),
 447                    true,
 448                    origin.x() + 9));
 449   EXPECT_EQ(7,
 450             XIndex(gfx::Size(3, 3),
 451                    gfx::Rect(origin, gfx::Size(10, 10)),
 452                    true,
 453                    origin.x() + 10));
 454   EXPECT_EQ(7,
 455             XIndex(gfx::Size(3, 3),
 456                    gfx::Rect(origin, gfx::Size(10, 10)),
 457                    true,
 458                    origin.x() + 11));
 459
 460   EXPECT_EQ(0,
 461             XIndex(gfx::Size(1, 1),
 462                    gfx::Rect(origin, gfx::Size(1, 1)),
 463                    false,
 464                    origin.x() + 0));
 465   EXPECT_EQ(0,
 466             XIndex(gfx::Size(2, 2),
 467                    gfx::Rect(origin, gfx::Size(2, 2)),
 468                    false,
 469                    origin.x() + 0));
 470   EXPECT_EQ(0,
 471             XIndex(gfx::Size(2, 2),
 472                    gfx::Rect(origin, gfx::Size(2, 2)),
 473                    false,
 474                    origin.x() + 1));
 475   EXPECT_EQ(0,
 476             XIndex(gfx::Size(3, 3),
 477                    gfx::Rect(origin, gfx::Size(3, 3)),
 478                    false,
 479                    origin.x() + 0));
 480   EXPECT_EQ(0,
 481             XIndex(gfx::Size(3, 3),
 482                    gfx::Rect(origin, gfx::Size(3, 3)),
 483                    false,
 484                    origin.x() + 1));
 485   EXPECT_EQ(0,
 486             XIndex(gfx::Size(3, 3),
 487                    gfx::Rect(origin, gfx::Size(3, 3)),
 488                    false,
 489                    origin.x() + 2));
 490
 491   EXPECT_EQ(0,
 492             XIndex(gfx::Size(3, 3),
 493                    gfx::Rect(origin, gfx::Size(4, 3)),
 494                    false,
 495                    origin.x() + 0));
 496   EXPECT_EQ(0,
 497             XIndex(gfx::Size(3, 3),
 498                    gfx::Rect(origin, gfx::Size(4, 3)),
 499                    false,
 500                    origin.x() + 1));
 501   EXPECT_EQ(0,
 502             XIndex(gfx::Size(3, 3),
 503                    gfx::Rect(origin, gfx::Size(4, 3)),
 504                    false,
 505                    origin.x() + 2));
 506   EXPECT_EQ(1,
 507             XIndex(gfx::Size(3, 3),
 508                    gfx::Rect(origin, gfx::Size(4, 3)),
 509                    false,
 510                    origin.x() + 3));
 511
 512   EXPECT_EQ(0,
 513             XIndex(gfx::Size(1, 1),
 514                    gfx::Rect(origin, gfx::Size(1, 1)),
 515                    true,
 516                    origin.x() + 0));
 517   EXPECT_EQ(0,
 518             XIndex(gfx::Size(2, 2),
 519                    gfx::Rect(origin, gfx::Size(2, 2)),
 520                    true,
 521                    origin.x() + 0));
 522   EXPECT_EQ(0,
 523             XIndex(gfx::Size(2, 2),
 524                    gfx::Rect(origin, gfx::Size(2, 2)),
 525                    true,
 526                    origin.x() + 1));
 527   EXPECT_EQ(0,
 528             XIndex(gfx::Size(3, 3),
 529                    gfx::Rect(origin, gfx::Size(3, 3)),
 530                    true,
 531                    origin.x() + 0));
 532   EXPECT_EQ(0,
 533             XIndex(gfx::Size(3, 3),
 534                    gfx::Rect(origin, gfx::Size(3, 3)),
 535                    true,
 536                    origin.x() + 1));
 537   EXPECT_EQ(0,
 538             XIndex(gfx::Size(3, 3),
 539                    gfx::Rect(origin, gfx::Size(3, 3)),
 540                    true,
 541                    origin.x() + 2));
 542
 543   EXPECT_EQ(0,
 544             XIndex(gfx::Size(3, 3),
 545                    gfx::Rect(origin, gfx::Size(4, 3)),
 546                    true,
 547                    origin.x() + 0));
 548   EXPECT_EQ(0,
 549             XIndex(gfx::Size(3, 3),
 550                    gfx::Rect(origin, gfx::Size(4, 3)),
 551                    true,
 552                    origin.x() + 1));
 553   EXPECT_EQ(1,
 554             XIndex(gfx::Size(3, 3),
 555                    gfx::Rect(origin, gfx::Size(4, 3)),
 556                    true,
 557                    origin.x() + 2));
 558   EXPECT_EQ(1,
 559             XIndex(gfx::Size(3, 3),
 560                    gfx::Rect(origin, gfx::Size(4, 3)),
 561                    true,
 562                    origin.x() + 3));
 563 }
 564
 565 TEST_P(TilingDataTest, FirstBorderTileXIndexFromSrcCoord) {
 566   gfx::Point origin = GetParam();
 567
 568   EXPECT_EQ(0,
 569             MinBorderXIndex(gfx::Size(3, 3),
 570                             gfx::Rect(origin, gfx::Size(10, 10)),
 571                             false,
 572                             origin.x() + 0));
 573   EXPECT_EQ(0,
 574             MinBorderXIndex(gfx::Size(3, 3),
 575                             gfx::Rect(origin, gfx::Size(10, 10)),
 576                             false,
 577                             origin.x() + 1));
 578   EXPECT_EQ(0,
 579             MinBorderXIndex(gfx::Size(3, 3),
 580                             gfx::Rect(origin, gfx::Size(10, 10)),
 581                             false,
 582                             origin.x() + 2));
 583   EXPECT_EQ(1,
 584             MinBorderXIndex(gfx::Size(3, 3),
 585                             gfx::Rect(origin, gfx::Size(10, 10)),
 586                             false,
 587                             origin.x() + 3));
 588   EXPECT_EQ(1,
 589             MinBorderXIndex(gfx::Size(3, 3),
 590                             gfx::Rect(origin, gfx::Size(10, 10)),
 591                             false,
 592                             origin.x() + 4));
 593   EXPECT_EQ(1,
 594             MinBorderXIndex(gfx::Size(3, 3),
 595                             gfx::Rect(origin, gfx::Size(10, 10)),
 596                             false,
 597                             origin.x() + 5));
 598   EXPECT_EQ(2,
 599             MinBorderXIndex(gfx::Size(3, 3),
 600                             gfx::Rect(origin, gfx::Size(10, 10)),
 601                             false,
 602                             origin.x() + 6));
 603   EXPECT_EQ(2,
 604             MinBorderXIndex(gfx::Size(3, 3),
 605                             gfx::Rect(origin, gfx::Size(10, 10)),
 606                             false,
 607                             origin.x() + 7));
 608   EXPECT_EQ(2,
 609             MinBorderXIndex(gfx::Size(3, 3),
 610                             gfx::Rect(origin, gfx::Size(10, 10)),
 611                             false,
 612                             origin.x() + 8));
 613   EXPECT_EQ(3,
 614             MinBorderXIndex(gfx::Size(3, 3),
 615                             gfx::Rect(origin, gfx::Size(10, 10)),
 616                             false,
 617                             origin.x() + 9));
 618   EXPECT_EQ(3,
 619             MinBorderXIndex(gfx::Size(3, 3),
 620                             gfx::Rect(origin, gfx::Size(10, 10)),
 621                             false,
 622                             origin.x() + 10));
 623   EXPECT_EQ(3,
 624             MinBorderXIndex(gfx::Size(3, 3),
 625                             gfx::Rect(origin, gfx::Size(10, 10)),
 626                             false,
 627                             origin.x() + 11));
 628
 629   EXPECT_EQ(0,
 630             MinBorderXIndex(gfx::Size(3, 3),
 631                             gfx::Rect(origin, gfx::Size(10, 10)),
 632                             true,
 633                             origin.x() + 0));
 634   EXPECT_EQ(0,
 635             MinBorderXIndex(gfx::Size(3, 3),
 636                             gfx::Rect(origin, gfx::Size(10, 10)),
 637                             true,
 638                             origin.x() + 1));
 639   EXPECT_EQ(0,
 640             MinBorderXIndex(gfx::Size(3, 3),
 641                             gfx::Rect(origin, gfx::Size(10, 10)),
 642                             true,
 643                             origin.x() + 2));
 644   EXPECT_EQ(1,
 645             MinBorderXIndex(gfx::Size(3, 3),
 646                             gfx::Rect(origin, gfx::Size(10, 10)),
 647                             true,
 648                             origin.x() + 3));
 649   EXPECT_EQ(2,
 650             MinBorderXIndex(gfx::Size(3, 3),
 651                             gfx::Rect(origin, gfx::Size(10, 10)),
 652                             true,
 653                             origin.x() + 4));
 654   EXPECT_EQ(3,
 655             MinBorderXIndex(gfx::Size(3, 3),
 656                             gfx::Rect(origin, gfx::Size(10, 10)),
 657                             true,
 658                             origin.x() + 5));
 659   EXPECT_EQ(4,
 660             MinBorderXIndex(gfx::Size(3, 3),
 661                             gfx::Rect(origin, gfx::Size(10, 10)),
 662                             true,
 663                             origin.x() + 6));
 664   EXPECT_EQ(5,
 665             MinBorderXIndex(gfx::Size(3, 3),
 666                             gfx::Rect(origin, gfx::Size(10, 10)),
 667                             true,
 668                             origin.x() + 7));
 669   EXPECT_EQ(6,
 670             MinBorderXIndex(gfx::Size(3, 3),
 671                             gfx::Rect(origin, gfx::Size(10, 10)),
 672                             true,
 673                             origin.x() + 8));
 674   EXPECT_EQ(7,
 675             MinBorderXIndex(gfx::Size(3, 3),
 676                             gfx::Rect(origin, gfx::Size(10, 10)),
 677                             true,
 678                             origin.x() + 9));
 679   EXPECT_EQ(7,
 680             MinBorderXIndex(gfx::Size(3, 3),
 681                             gfx::Rect(origin, gfx::Size(10, 10)),
 682                             true,
 683                             origin.x() + 10));
 684   EXPECT_EQ(7,
 685             MinBorderXIndex(gfx::Size(3, 3),
 686                             gfx::Rect(origin, gfx::Size(10, 10)),
 687                             true,
 688                             origin.x() + 11));
 689
 690   EXPECT_EQ(0,
 691             MinBorderXIndex(gfx::Size(1, 1),
 692                             gfx::Rect(origin, gfx::Size(1, 1)),
 693                             false,
 694                             origin.x() + 0));
 695   EXPECT_EQ(0,
 696             MinBorderXIndex(gfx::Size(2, 2),
 697                             gfx::Rect(origin, gfx::Size(2, 2)),
 698                             false,
 699                             origin.x() + 0));
 700   EXPECT_EQ(0,
 701             MinBorderXIndex(gfx::Size(2, 2),
 702                             gfx::Rect(origin, gfx::Size(2, 2)),
 703                             false,
 704                             origin.x() + 1));
 705   EXPECT_EQ(0,
 706             MinBorderXIndex(gfx::Size(3, 3),
 707                             gfx::Rect(origin, gfx::Size(3, 3)),
 708                             false,
 709                             origin.x() + 0));
 710   EXPECT_EQ(0,
 711             MinBorderXIndex(gfx::Size(3, 3),
 712                             gfx::Rect(origin, gfx::Size(3, 3)),
 713                             false,
 714                             origin.x() + 1));
 715   EXPECT_EQ(0,
 716             MinBorderXIndex(gfx::Size(3, 3),
 717                             gfx::Rect(origin, gfx::Size(3, 3)),
 718                             false,
 719                             origin.x() + 2));
 720
 721   EXPECT_EQ(0,
 722             MinBorderXIndex(gfx::Size(3, 3),
 723                             gfx::Rect(origin, gfx::Size(4, 3)),
 724                             false,
 725                             origin.x() + 0));
 726   EXPECT_EQ(0,
 727             MinBorderXIndex(gfx::Size(3, 3),
 728                             gfx::Rect(origin, gfx::Size(4, 3)),
 729                             false,
 730                             origin.x() + 1));
 731   EXPECT_EQ(0,
 732             MinBorderXIndex(gfx::Size(3, 3),
 733                             gfx::Rect(origin, gfx::Size(4, 3)),
 734                             false,
 735                             origin.x() + 2));
 736   EXPECT_EQ(1,
 737             MinBorderXIndex(gfx::Size(3, 3),
 738                             gfx::Rect(origin, gfx::Size(4, 3)),
 739                             false,
 740                             origin.x() + 3));
 741
 742   EXPECT_EQ(0,
 743             MinBorderXIndex(gfx::Size(1, 1),
 744                             gfx::Rect(origin, gfx::Size(1, 1)),
 745                             true,
 746                             origin.x() + 0));
 747   EXPECT_EQ(0,
 748             MinBorderXIndex(gfx::Size(2, 2),
 749                             gfx::Rect(origin, gfx::Size(2, 2)),
 750                             true,
 751                             origin.x() + 0));
 752   EXPECT_EQ(0,
 753             MinBorderXIndex(gfx::Size(2, 2),
 754                             gfx::Rect(origin, gfx::Size(2, 2)),
 755                             true,
 756                             origin.x() + 1));
 757   EXPECT_EQ(0,
 758             MinBorderXIndex(gfx::Size(3, 3),
 759                             gfx::Rect(origin, gfx::Size(3, 3)),
 760                             true,
 761                             origin.x() + 0));
 762   EXPECT_EQ(0,
 763             MinBorderXIndex(gfx::Size(3, 3),
 764                             gfx::Rect(origin, gfx::Size(3, 3)),
 765                             true,
 766                             origin.x() + 1));
 767   EXPECT_EQ(0,
 768             MinBorderXIndex(gfx::Size(3, 3),
 769                             gfx::Rect(origin, gfx::Size(3, 3)),
 770                             true,
 771                             origin.x() + 2));
 772
 773   EXPECT_EQ(0,
 774             MinBorderXIndex(gfx::Size(3, 3),
 775                             gfx::Rect(origin, gfx::Size(4, 3)),
 776                             true,
 777                             origin.x() + 0));
 778   EXPECT_EQ(0,
 779             MinBorderXIndex(gfx::Size(3, 3),
 780                             gfx::Rect(origin, gfx::Size(4, 3)),
 781                             true,
 782                             origin.x() + 1));
 783   EXPECT_EQ(0,
 784             MinBorderXIndex(gfx::Size(3, 3),
 785                             gfx::Rect(origin, gfx::Size(4, 3)),
 786                             true,
 787                             origin.x() + 2));
 788   EXPECT_EQ(1,
 789             MinBorderXIndex(gfx::Size(3, 3),
 790                             gfx::Rect(origin, gfx::Size(4, 3)),
 791                             true,
 792                             origin.x() + 3));
 793 }
 794
 795 TEST_P(TilingDataTest, LastBorderTileXIndexFromSrcCoord) {
 796   gfx::Point origin = GetParam();
 797
 798   EXPECT_EQ(0,
 799             MaxBorderXIndex(gfx::Size(3, 3),
 800                             gfx::Rect(origin, gfx::Size(10, 10)),
 801                             false,
 802                             origin.x() + 0));
 803   EXPECT_EQ(0,
 804             MaxBorderXIndex(gfx::Size(3, 3),
 805                             gfx::Rect(origin, gfx::Size(10, 10)),
 806                             false,
 807                             origin.x() + 1));
 808   EXPECT_EQ(0,
 809             MaxBorderXIndex(gfx::Size(3, 3),
 810                             gfx::Rect(origin, gfx::Size(10, 10)),
 811                             false,
 812                             origin.x() + 2));
 813   EXPECT_EQ(1,
 814             MaxBorderXIndex(gfx::Size(3, 3),
 815                             gfx::Rect(origin, gfx::Size(10, 10)),
 816                             false,
 817                             origin.x() + 3));
 818   EXPECT_EQ(1,
 819             MaxBorderXIndex(gfx::Size(3, 3),
 820                             gfx::Rect(origin, gfx::Size(10, 10)),
 821                             false,
 822                             origin.x() + 4));
 823   EXPECT_EQ(1,
 824             MaxBorderXIndex(gfx::Size(3, 3),
 825                             gfx::Rect(origin, gfx::Size(10, 10)),
 826                             false,
 827                             origin.x() + 5));
 828   EXPECT_EQ(2,
 829             MaxBorderXIndex(gfx::Size(3, 3),
 830                             gfx::Rect(origin, gfx::Size(10, 10)),
 831                             false,
 832                             origin.x() + 6));
 833   EXPECT_EQ(2,
 834             MaxBorderXIndex(gfx::Size(3, 3),
 835                             gfx::Rect(origin, gfx::Size(10, 10)),
 836                             false,
 837                             origin.x() + 7));
 838   EXPECT_EQ(2,
 839             MaxBorderXIndex(gfx::Size(3, 3),
 840                             gfx::Rect(origin, gfx::Size(10, 10)),
 841                             false,
 842                             origin.x() + 8));
 843   EXPECT_EQ(3,
 844             MaxBorderXIndex(gfx::Size(3, 3),
 845                             gfx::Rect(origin, gfx::Size(10, 10)),
 846                             false,
 847                             origin.x() + 9));
 848   EXPECT_EQ(3,
 849             MaxBorderXIndex(gfx::Size(3, 3),
 850                             gfx::Rect(origin, gfx::Size(10, 10)),
 851                             false,
 852                             origin.x() + 10));
 853   EXPECT_EQ(3,
 854             MaxBorderXIndex(gfx::Size(3, 3),
 855                             gfx::Rect(origin, gfx::Size(10, 10)),
 856                             false,
 857                             origin.x() + 11));
 858
 859   EXPECT_EQ(0,
 860             MaxBorderXIndex(gfx::Size(3, 3),
 861                             gfx::Rect(origin, gfx::Size(10, 10)),
 862                             true,
 863                             origin.x() + 0));
 864   EXPECT_EQ(1,
 865             MaxBorderXIndex(gfx::Size(3, 3),
 866                             gfx::Rect(origin, gfx::Size(10, 10)),
 867                             true,
 868                             origin.x() + 1));
 869   EXPECT_EQ(2,
 870             MaxBorderXIndex(gfx::Size(3, 3),
 871                             gfx::Rect(origin, gfx::Size(10, 10)),
 872                             true,
 873                             origin.x() + 2));
 874   EXPECT_EQ(3,
 875             MaxBorderXIndex(gfx::Size(3, 3),
 876                             gfx::Rect(origin, gfx::Size(10, 10)),
 877                             true,
 878                             origin.x() + 3));
 879   EXPECT_EQ(4,
 880             MaxBorderXIndex(gfx::Size(3, 3),
 881                             gfx::Rect(origin, gfx::Size(10, 10)),
 882                             true,
 883                             origin.x() + 4));
 884   EXPECT_EQ(5,
 885             MaxBorderXIndex(gfx::Size(3, 3),
 886                             gfx::Rect(origin, gfx::Size(10, 10)),
 887                             true,
 888                             origin.x() + 5));
 889   EXPECT_EQ(6,
 890             MaxBorderXIndex(gfx::Size(3, 3),
 891                             gfx::Rect(origin, gfx::Size(10, 10)),
 892                             true,
 893                             origin.x() + 6));
 894   EXPECT_EQ(7,
 895             MaxBorderXIndex(gfx::Size(3, 3),
 896                             gfx::Rect(origin, gfx::Size(10, 10)),
 897                             true,
 898                             origin.x() + 7));
 899   EXPECT_EQ(7,
 900             MaxBorderXIndex(gfx::Size(3, 3),
 901                             gfx::Rect(origin, gfx::Size(10, 10)),
 902                             true,
 903                             origin.x() + 8));
 904   EXPECT_EQ(7,
 905             MaxBorderXIndex(gfx::Size(3, 3),
 906                             gfx::Rect(origin, gfx::Size(10, 10)),
 907                             true,
 908                             origin.x() + 9));
 909   EXPECT_EQ(7,
 910             MaxBorderXIndex(gfx::Size(3, 3),
 911                             gfx::Rect(origin, gfx::Size(10, 10)),
 912                             true,
 913                             origin.x() + 10));
 914   EXPECT_EQ(7,
 915             MaxBorderXIndex(gfx::Size(3, 3),
 916                             gfx::Rect(origin, gfx::Size(10, 10)),
 917                             true,
 918                             origin.x() + 11));
 919
 920   EXPECT_EQ(0,
 921             MaxBorderXIndex(gfx::Size(1, 1),
 922                             gfx::Rect(origin, gfx::Size(1, 1)),
 923                             false,
 924                             origin.x() + 0));
 925   EXPECT_EQ(0,
 926             MaxBorderXIndex(gfx::Size(2, 2),
 927                             gfx::Rect(origin, gfx::Size(2, 2)),
 928                             false,
 929                             origin.x() + 0));
 930   EXPECT_EQ(0,
 931             MaxBorderXIndex(gfx::Size(2, 2),
 932                             gfx::Rect(origin, gfx::Size(2, 2)),
 933                             false,
 934                             origin.x() + 1));
 935   EXPECT_EQ(0,
 936             MaxBorderXIndex(gfx::Size(3, 3),
 937                             gfx::Rect(origin, gfx::Size(3, 3)),
 938                             false,
 939                             origin.x() + 0));
 940   EXPECT_EQ(0,
 941             MaxBorderXIndex(gfx::Size(3, 3),
 942                             gfx::Rect(origin, gfx::Size(3, 3)),
 943                             false,
 944                             origin.x() + 1));
 945   EXPECT_EQ(0,
 946             MaxBorderXIndex(gfx::Size(3, 3),
 947                             gfx::Rect(origin, gfx::Size(3, 3)),
 948                             false,
 949                             origin.x() + 2));
 950
 951   EXPECT_EQ(0,
 952             MaxBorderXIndex(gfx::Size(3, 3),
 953                             gfx::Rect(origin, gfx::Size(4, 3)),
 954                             false,
 955                             origin.x() + 0));
 956   EXPECT_EQ(0,
 957             MaxBorderXIndex(gfx::Size(3, 3),
 958                             gfx::Rect(origin, gfx::Size(4, 3)),
 959                             false,
 960                             origin.x() + 1));
 961   EXPECT_EQ(0,
 962             MaxBorderXIndex(gfx::Size(3, 3),
 963                             gfx::Rect(origin, gfx::Size(4, 3)),
 964                             false,
 965                             origin.x() + 2));
 966   EXPECT_EQ(1,
 967             MaxBorderXIndex(gfx::Size(3, 3),
 968                             gfx::Rect(origin, gfx::Size(4, 3)),
 969                             false,
 970                             origin.x() + 3));
 971
 972   EXPECT_EQ(0,
 973             MaxBorderXIndex(gfx::Size(1, 1),
 974                             gfx::Rect(origin, gfx::Size(1, 1)),
 975                             true,
 976                             origin.x() + 0));
 977   EXPECT_EQ(0,
 978             MaxBorderXIndex(gfx::Size(2, 2),
 979                             gfx::Rect(origin, gfx::Size(2, 2)),
 980                             true,
 981                             origin.x() + 0));
 982   EXPECT_EQ(0,
 983             MaxBorderXIndex(gfx::Size(2, 2),
 984                             gfx::Rect(origin, gfx::Size(2, 2)),
 985                             true,
 986                             origin.x() + 1));
 987   EXPECT_EQ(0,
 988             MaxBorderXIndex(gfx::Size(3, 3),
 989                             gfx::Rect(origin, gfx::Size(3, 3)),
 990                             true,
 991                             origin.x() + 0));
 992   EXPECT_EQ(0,
 993             MaxBorderXIndex(gfx::Size(3, 3),
 994                             gfx::Rect(origin, gfx::Size(3, 3)),
 995                             true,
 996                             origin.x() + 1));
 997   EXPECT_EQ(0,
 998             MaxBorderXIndex(gfx::Size(3, 3),
 999                             gfx::Rect(origin, gfx::Size(3, 3)),
1000                             true,
1001                             origin.x() + 2));
1002
1003   EXPECT_EQ(0,
1004             MaxBorderXIndex(gfx::Size(3, 3),
1005                             gfx::Rect(origin, gfx::Size(4, 3)),
1006                             true,
1007                             origin.x() + 0));
1008   EXPECT_EQ(1,
1009             MaxBorderXIndex(gfx::Size(3, 3),
1010                             gfx::Rect(origin, gfx::Size(4, 3)),
1011                             true,
1012                             origin.x() + 1));
1013   EXPECT_EQ(1,
1014             MaxBorderXIndex(gfx::Size(3, 3),
1015                             gfx::Rect(origin, gfx::Size(4, 3)),
1016                             true,
1017                             origin.x() + 2));
1018   EXPECT_EQ(1,
1019             MaxBorderXIndex(gfx::Size(3, 3),
1020                             gfx::Rect(origin, gfx::Size(4, 3)),
1021                             true,
1022                             origin.x() + 3));
1023 }
1024
1025 TEST_P(TilingDataTest, TileYIndexFromSrcCoord) {
1026   gfx::Point origin = GetParam();
1027
1028   EXPECT_EQ(0,
1029             YIndex(gfx::Size(3, 3),
1030                    gfx::Rect(origin, gfx::Size(10, 10)),
1031                    false,
1032                    origin.y() + 0));
1033   EXPECT_EQ(0,
1034             YIndex(gfx::Size(3, 3),
1035                    gfx::Rect(origin, gfx::Size(10, 10)),
1036                    false,
1037                    origin.y() + 1));
1038   EXPECT_EQ(0,
1039             YIndex(gfx::Size(3, 3),
1040                    gfx::Rect(origin, gfx::Size(10, 10)),
1041                    false,
1042                    origin.y() + 2));
1043   EXPECT_EQ(1,
1044             YIndex(gfx::Size(3, 3),
1045                    gfx::Rect(origin, gfx::Size(10, 10)),
1046                    false,
1047                    origin.y() + 3));
1048   EXPECT_EQ(1,
1049             YIndex(gfx::Size(3, 3),
1050                    gfx::Rect(origin, gfx::Size(10, 10)),
1051                    false,
1052                    origin.y() + 4));
1053   EXPECT_EQ(1,
1054             YIndex(gfx::Size(3, 3),
1055                    gfx::Rect(origin, gfx::Size(10, 10)),
1056                    false,
1057                    origin.y() + 5));
1058   EXPECT_EQ(2,
1059             YIndex(gfx::Size(3, 3),
1060                    gfx::Rect(origin, gfx::Size(10, 10)),
1061                    false,
1062                    origin.y() + 6));
1063   EXPECT_EQ(2,
1064             YIndex(gfx::Size(3, 3),
1065                    gfx::Rect(origin, gfx::Size(10, 10)),
1066                    false,
1067                    origin.y() + 7));
1068   EXPECT_EQ(2,
1069             YIndex(gfx::Size(3, 3),
1070                    gfx::Rect(origin, gfx::Size(10, 10)),
1071                    false,
1072                    origin.y() + 8));
1073   EXPECT_EQ(3,
1074             YIndex(gfx::Size(3, 3),
1075                    gfx::Rect(origin, gfx::Size(10, 10)),
1076                    false,
1077                    origin.y() + 9));
1078   EXPECT_EQ(3,
1079             YIndex(gfx::Size(3, 3),
1080                    gfx::Rect(origin, gfx::Size(10, 10)),
1081                    false,
1082                    origin.y() + 10));
1083   EXPECT_EQ(3,
1084             YIndex(gfx::Size(3, 3),
1085                    gfx::Rect(origin, gfx::Size(10, 10)),
1086                    false,
1087                    origin.y() + 11));
1088
1089   EXPECT_EQ(0,
1090             YIndex(gfx::Size(3, 3),
1091                    gfx::Rect(origin, gfx::Size(10, 10)),
1092                    true,
1093                    origin.y() + 0));
1094   EXPECT_EQ(0,
1095             YIndex(gfx::Size(3, 3),
1096                    gfx::Rect(origin, gfx::Size(10, 10)),
1097                    true,
1098                    origin.y() + 1));
1099   EXPECT_EQ(1,
1100             YIndex(gfx::Size(3, 3),
1101                    gfx::Rect(origin, gfx::Size(10, 10)),
1102                    true,
1103                    origin.y() + 2));
1104   EXPECT_EQ(2,
1105             YIndex(gfx::Size(3, 3),
1106                    gfx::Rect(origin, gfx::Size(10, 10)),
1107                    true,
1108                    origin.y() + 3));
1109   EXPECT_EQ(3,
1110             YIndex(gfx::Size(3, 3),
1111                    gfx::Rect(origin, gfx::Size(10, 10)),
1112                    true,
1113                    origin.y() + 4));
1114   EXPECT_EQ(4,
1115             YIndex(gfx::Size(3, 3),
1116                    gfx::Rect(origin, gfx::Size(10, 10)),
1117                    true,
1118                    origin.y() + 5));
1119   EXPECT_EQ(5,
1120             YIndex(gfx::Size(3, 3),
1121                    gfx::Rect(origin, gfx::Size(10, 10)),
1122                    true,
1123                    origin.y() + 6));
1124   EXPECT_EQ(6,
1125             YIndex(gfx::Size(3, 3),
1126                    gfx::Rect(origin, gfx::Size(10, 10)),
1127                    true,
1128                    origin.y() + 7));
1129   EXPECT_EQ(7,
1130             YIndex(gfx::Size(3, 3),
1131                    gfx::Rect(origin, gfx::Size(10, 10)),
1132                    true,
1133                    origin.y() + 8));
1134   EXPECT_EQ(7,
1135             YIndex(gfx::Size(3, 3),
1136                    gfx::Rect(origin, gfx::Size(10, 10)),
1137                    true,
1138                    origin.y() + 9));
1139   EXPECT_EQ(7,
1140             YIndex(gfx::Size(3, 3),
1141                    gfx::Rect(origin, gfx::Size(10, 10)),
1142                    true,
1143                    origin.y() + 10));
1144   EXPECT_EQ(7,
1145             YIndex(gfx::Size(3, 3),
1146                    gfx::Rect(origin, gfx::Size(10, 10)),
1147                    true,
1148                    origin.y() + 11));
1149
1150   EXPECT_EQ(0,
1151             YIndex(gfx::Size(1, 1),
1152                    gfx::Rect(origin, gfx::Size(1, 1)),
1153                    false,
1154                    origin.y() + 0));
1155   EXPECT_EQ(0,
1156             YIndex(gfx::Size(2, 2),
1157                    gfx::Rect(origin, gfx::Size(2, 2)),
1158                    false,
1159                    origin.y() + 0));
1160   EXPECT_EQ(0,
1161             YIndex(gfx::Size(2, 2),
1162                    gfx::Rect(origin, gfx::Size(2, 2)),
1163                    false,
1164                    origin.y() + 1));
1165   EXPECT_EQ(0,
1166             YIndex(gfx::Size(3, 3),
1167                    gfx::Rect(origin, gfx::Size(3, 3)),
1168                    false,
1169                    origin.y() + 0));
1170   EXPECT_EQ(0,
1171             YIndex(gfx::Size(3, 3),
1172                    gfx::Rect(origin, gfx::Size(3, 3)),
1173                    false,
1174                    origin.y() + 1));
1175   EXPECT_EQ(0,
1176             YIndex(gfx::Size(3, 3),
1177                    gfx::Rect(origin, gfx::Size(3, 3)),
1178                    false,
1179                    origin.y() + 2));
1180
1181   EXPECT_EQ(0,
1182             YIndex(gfx::Size(3, 3),
1183                    gfx::Rect(origin, gfx::Size(3, 4)),
1184                    false,
1185                    origin.y() + 0));
1186   EXPECT_EQ(0,
1187             YIndex(gfx::Size(3, 3),
1188                    gfx::Rect(origin, gfx::Size(3, 4)),
1189                    false,
1190                    origin.y() + 1));
1191   EXPECT_EQ(0,
1192             YIndex(gfx::Size(3, 3),
1193                    gfx::Rect(origin, gfx::Size(3, 4)),
1194                    false,
1195                    origin.y() + 2));
1196   EXPECT_EQ(1,
1197             YIndex(gfx::Size(3, 3),
1198                    gfx::Rect(origin, gfx::Size(3, 4)),
1199                    false,
1200                    origin.y() + 3));
1201
1202   EXPECT_EQ(0,
1203             YIndex(gfx::Size(1, 1),
1204                    gfx::Rect(origin, gfx::Size(1, 1)),
1205                    true,
1206                    origin.y() + 0));
1207   EXPECT_EQ(0,
1208             YIndex(gfx::Size(2, 2),
1209                    gfx::Rect(origin, gfx::Size(2, 2)),
1210                    true,
1211                    origin.y() + 0));
1212   EXPECT_EQ(0,
1213             YIndex(gfx::Size(2, 2),
1214                    gfx::Rect(origin, gfx::Size(2, 2)),
1215                    true,
1216                    origin.y() + 1));
1217   EXPECT_EQ(0,
1218             YIndex(gfx::Size(3, 3),
1219                    gfx::Rect(origin, gfx::Size(3, 3)),
1220                    true,
1221                    origin.y() + 0));
1222   EXPECT_EQ(0,
1223             YIndex(gfx::Size(3, 3),
1224                    gfx::Rect(origin, gfx::Size(3, 3)),
1225                    true,
1226                    origin.y() + 1));
1227   EXPECT_EQ(0,
1228             YIndex(gfx::Size(3, 3),
1229                    gfx::Rect(origin, gfx::Size(3, 3)),
1230                    true,
1231                    origin.y() + 2));
1232
1233   EXPECT_EQ(0,
1234             YIndex(gfx::Size(3, 3),
1235                    gfx::Rect(origin, gfx::Size(3, 4)),
1236                    true,
1237                    origin.y() + 0));
1238   EXPECT_EQ(0,
1239             YIndex(gfx::Size(3, 3),
1240                    gfx::Rect(origin, gfx::Size(3, 4)),
1241                    true,
1242                    origin.y() + 1));
1243   EXPECT_EQ(1,
1244             YIndex(gfx::Size(3, 3),
1245                    gfx::Rect(origin, gfx::Size(3, 4)),
1246                    true,
1247                    origin.y() + 2));
1248   EXPECT_EQ(1,
1249             YIndex(gfx::Size(3, 3),
1250                    gfx::Rect(origin, gfx::Size(3, 4)),
1251                    true,
1252                    origin.y() + 3));
1253 }
1254
1255 TEST_P(TilingDataTest, FirstBorderTileYIndexFromSrcCoord) {
1256   gfx::Point origin = GetParam();
1257
1258   EXPECT_EQ(0,
1259             MinBorderYIndex(gfx::Size(3, 3),
1260                             gfx::Rect(origin, gfx::Size(10, 10)),
1261                             false,
1262                             origin.y() + 0));
1263   EXPECT_EQ(0,
1264             MinBorderYIndex(gfx::Size(3, 3),
1265                             gfx::Rect(origin, gfx::Size(10, 10)),
1266                             false,
1267                             origin.y() + 1));
1268   EXPECT_EQ(0,
1269             MinBorderYIndex(gfx::Size(3, 3),
1270                             gfx::Rect(origin, gfx::Size(10, 10)),
1271                             false,
1272                             origin.y() + 2));
1273   EXPECT_EQ(1,
1274             MinBorderYIndex(gfx::Size(3, 3),
1275                             gfx::Rect(origin, gfx::Size(10, 10)),
1276                             false,
1277                             origin.y() + 3));
1278   EXPECT_EQ(1,
1279             MinBorderYIndex(gfx::Size(3, 3),
1280                             gfx::Rect(origin, gfx::Size(10, 10)),
1281                             false,
1282                             origin.y() + 4));
1283   EXPECT_EQ(1,
1284             MinBorderYIndex(gfx::Size(3, 3),
1285                             gfx::Rect(origin, gfx::Size(10, 10)),
1286                             false,
1287                             origin.y() + 5));
1288   EXPECT_EQ(2,
1289             MinBorderYIndex(gfx::Size(3, 3),
1290                             gfx::Rect(origin, gfx::Size(10, 10)),
1291                             false,
1292                             origin.y() + 6));
1293   EXPECT_EQ(2,
1294             MinBorderYIndex(gfx::Size(3, 3),
1295                             gfx::Rect(origin, gfx::Size(10, 10)),
1296                             false,
1297                             origin.y() + 7));
1298   EXPECT_EQ(2,
1299             MinBorderYIndex(gfx::Size(3, 3),
1300                             gfx::Rect(origin, gfx::Size(10, 10)),
1301                             false,
1302                             origin.y() + 8));
1303   EXPECT_EQ(3,
1304             MinBorderYIndex(gfx::Size(3, 3),
1305                             gfx::Rect(origin, gfx::Size(10, 10)),
1306                             false,
1307                             origin.y() + 9));
1308   EXPECT_EQ(3,
1309             MinBorderYIndex(gfx::Size(3, 3),
1310                             gfx::Rect(origin, gfx::Size(10, 10)),
1311                             false,
1312                             origin.y() + 10));
1313   EXPECT_EQ(3,
1314             MinBorderYIndex(gfx::Size(3, 3),
1315                             gfx::Rect(origin, gfx::Size(10, 10)),
1316                             false,
1317                             origin.y() + 11));
1318
1319   EXPECT_EQ(0,
1320             MinBorderYIndex(gfx::Size(3, 3),
1321                             gfx::Rect(origin, gfx::Size(10, 10)),
1322                             true,
1323                             origin.y() + 0));
1324   EXPECT_EQ(0,
1325             MinBorderYIndex(gfx::Size(3, 3),
1326                             gfx::Rect(origin, gfx::Size(10, 10)),
1327                             true,
1328                             origin.y() + 1));
1329   EXPECT_EQ(0,
1330             MinBorderYIndex(gfx::Size(3, 3),
1331                             gfx::Rect(origin, gfx::Size(10, 10)),
1332                             true,
1333                             origin.y() + 2));
1334   EXPECT_EQ(1,
1335             MinBorderYIndex(gfx::Size(3, 3),
1336                             gfx::Rect(origin, gfx::Size(10, 10)),
1337                             true,
1338                             origin.y() + 3));
1339   EXPECT_EQ(2,
1340             MinBorderYIndex(gfx::Size(3, 3),
1341                             gfx::Rect(origin, gfx::Size(10, 10)),
1342                             true,
1343                             origin.y() + 4));
1344   EXPECT_EQ(3,
1345             MinBorderYIndex(gfx::Size(3, 3),
1346                             gfx::Rect(origin, gfx::Size(10, 10)),
1347                             true,
1348                             origin.y() + 5));
1349   EXPECT_EQ(4,
1350             MinBorderYIndex(gfx::Size(3, 3),
1351                             gfx::Rect(origin, gfx::Size(10, 10)),
1352                             true,
1353                             origin.y() + 6));
1354   EXPECT_EQ(5,
1355             MinBorderYIndex(gfx::Size(3, 3),
1356                             gfx::Rect(origin, gfx::Size(10, 10)),
1357                             true,
1358                             origin.y() + 7));
1359   EXPECT_EQ(6,
1360             MinBorderYIndex(gfx::Size(3, 3),
1361                             gfx::Rect(origin, gfx::Size(10, 10)),
1362                             true,
1363                             origin.y() + 8));
1364   EXPECT_EQ(7,
1365             MinBorderYIndex(gfx::Size(3, 3),
1366                             gfx::Rect(origin, gfx::Size(10, 10)),
1367                             true,
1368                             origin.y() + 9));
1369   EXPECT_EQ(7,
1370             MinBorderYIndex(gfx::Size(3, 3),
1371                             gfx::Rect(origin, gfx::Size(10, 10)),
1372                             true,
1373                             origin.y() + 10));
1374   EXPECT_EQ(7,
1375             MinBorderYIndex(gfx::Size(3, 3),
1376                             gfx::Rect(origin, gfx::Size(10, 10)),
1377                             true,
1378                             origin.y() + 11));
1379
1380   EXPECT_EQ(0,
1381             MinBorderYIndex(gfx::Size(1, 1),
1382                             gfx::Rect(origin, gfx::Size(1, 1)),
1383                             false,
1384                             origin.y() + 0));
1385   EXPECT_EQ(0,
1386             MinBorderYIndex(gfx::Size(2, 2),
1387                             gfx::Rect(origin, gfx::Size(2, 2)),
1388                             false,
1389                             origin.y() + 0));
1390   EXPECT_EQ(0,
1391             MinBorderYIndex(gfx::Size(2, 2),
1392                             gfx::Rect(origin, gfx::Size(2, 2)),
1393                             false,
1394                             origin.y() + 1));
1395   EXPECT_EQ(0,
1396             MinBorderYIndex(gfx::Size(3, 3),
1397                             gfx::Rect(origin, gfx::Size(3, 3)),
1398                             false,
1399                             origin.y() + 0));
1400   EXPECT_EQ(0,
1401             MinBorderYIndex(gfx::Size(3, 3),
1402                             gfx::Rect(origin, gfx::Size(3, 3)),
1403                             false,
1404                             origin.y() + 1));
1405   EXPECT_EQ(0,
1406             MinBorderYIndex(gfx::Size(3, 3),
1407                             gfx::Rect(origin, gfx::Size(3, 3)),
1408                             false,
1409                             origin.y() + 2));
1410
1411   EXPECT_EQ(0,
1412             MinBorderYIndex(gfx::Size(3, 3),
1413                             gfx::Rect(origin, gfx::Size(3, 4)),
1414                             false,
1415                             origin.y() + 0));
1416   EXPECT_EQ(0,
1417             MinBorderYIndex(gfx::Size(3, 3),
1418                             gfx::Rect(origin, gfx::Size(3, 4)),
1419                             false,
1420                             origin.y() + 1));
1421   EXPECT_EQ(0,
1422             MinBorderYIndex(gfx::Size(3, 3),
1423                             gfx::Rect(origin, gfx::Size(3, 4)),
1424                             false,
1425                             origin.y() + 2));
1426   EXPECT_EQ(1,
1427             MinBorderYIndex(gfx::Size(3, 3),
1428                             gfx::Rect(origin, gfx::Size(3, 4)),
1429                             false,
1430                             origin.y() + 3));
1431
1432   EXPECT_EQ(0,
1433             MinBorderYIndex(gfx::Size(1, 1),
1434                             gfx::Rect(origin, gfx::Size(1, 1)),
1435                             true,
1436                             origin.y() + 0));
1437   EXPECT_EQ(0,
1438             MinBorderYIndex(gfx::Size(2, 2),
1439                             gfx::Rect(origin, gfx::Size(2, 2)),
1440                             true,
1441                             origin.y() + 0));
1442   EXPECT_EQ(0,
1443             MinBorderYIndex(gfx::Size(2, 2),
1444                             gfx::Rect(origin, gfx::Size(2, 2)),
1445                             true,
1446                             origin.y() + 1));
1447   EXPECT_EQ(0,
1448             MinBorderYIndex(gfx::Size(3, 3),
1449                             gfx::Rect(origin, gfx::Size(3, 3)),
1450                             true,
1451                             origin.y() + 0));
1452   EXPECT_EQ(0,
1453             MinBorderYIndex(gfx::Size(3, 3),
1454                             gfx::Rect(origin, gfx::Size(3, 3)),
1455                             true,
1456                             origin.y() + 1));
1457   EXPECT_EQ(0,
1458             MinBorderYIndex(gfx::Size(3, 3),
1459                             gfx::Rect(origin, gfx::Size(3, 3)),
1460                             true,
1461                             origin.y() + 2));
1462
1463   EXPECT_EQ(0,
1464             MinBorderYIndex(gfx::Size(3, 3),
1465                             gfx::Rect(origin, gfx::Size(3, 4)),
1466                             true,
1467                             origin.y() + 0));
1468   EXPECT_EQ(0,
1469             MinBorderYIndex(gfx::Size(3, 3),
1470                             gfx::Rect(origin, gfx::Size(3, 4)),
1471                             true,
1472                             origin.y() + 1));
1473   EXPECT_EQ(0,
1474             MinBorderYIndex(gfx::Size(3, 3),
1475                             gfx::Rect(origin, gfx::Size(3, 4)),
1476                             true,
1477                             origin.y() + 2));
1478   EXPECT_EQ(1,
1479             MinBorderYIndex(gfx::Size(3, 3),
1480                             gfx::Rect(origin, gfx::Size(3, 4)),
1481                             true,
1482                             origin.y() + 3));
1483 }
1484
1485 TEST_P(TilingDataTest, LastBorderTileYIndexFromSrcCoord) {
1486   gfx::Point origin = GetParam();
1487
1488   EXPECT_EQ(0,
1489             MaxBorderYIndex(gfx::Size(3, 3),
1490                             gfx::Rect(origin, gfx::Size(10, 10)),
1491                             false,
1492                             origin.y() + 0));
1493   EXPECT_EQ(0,
1494             MaxBorderYIndex(gfx::Size(3, 3),
1495                             gfx::Rect(origin, gfx::Size(10, 10)),
1496                             false,
1497                             origin.y() + 1));
1498   EXPECT_EQ(0,
1499             MaxBorderYIndex(gfx::Size(3, 3),
1500                             gfx::Rect(origin, gfx::Size(10, 10)),
1501                             false,
1502                             origin.y() + 2));
1503   EXPECT_EQ(1,
1504             MaxBorderYIndex(gfx::Size(3, 3),
1505                             gfx::Rect(origin, gfx::Size(10, 10)),
1506                             false,
1507                             origin.y() + 3));
1508   EXPECT_EQ(1,
1509             MaxBorderYIndex(gfx::Size(3, 3),
1510                             gfx::Rect(origin, gfx::Size(10, 10)),
1511                             false,
1512                             origin.y() + 4));
1513   EXPECT_EQ(1,
1514             MaxBorderYIndex(gfx::Size(3, 3),
1515                             gfx::Rect(origin, gfx::Size(10, 10)),
1516                             false,
1517                             origin.y() + 5));
1518   EXPECT_EQ(2,
1519             MaxBorderYIndex(gfx::Size(3, 3),
1520                             gfx::Rect(origin, gfx::Size(10, 10)),
1521                             false,
1522                             origin.y() + 6));
1523   EXPECT_EQ(2,
1524             MaxBorderYIndex(gfx::Size(3, 3),
1525                             gfx::Rect(origin, gfx::Size(10, 10)),
1526                             false,
1527                             origin.y() + 7));
1528   EXPECT_EQ(2,
1529             MaxBorderYIndex(gfx::Size(3, 3),
1530                             gfx::Rect(origin, gfx::Size(10, 10)),
1531                             false,
1532                             origin.y() + 8));
1533   EXPECT_EQ(3,
1534             MaxBorderYIndex(gfx::Size(3, 3),
1535                             gfx::Rect(origin, gfx::Size(10, 10)),
1536                             false,
1537                             origin.y() + 9));
1538   EXPECT_EQ(3,
1539             MaxBorderYIndex(gfx::Size(3, 3),
1540                             gfx::Rect(origin, gfx::Size(10, 10)),
1541                             false,
1542                             origin.y() + 10));
1543   EXPECT_EQ(3,
1544             MaxBorderYIndex(gfx::Size(3, 3),
1545                             gfx::Rect(origin, gfx::Size(10, 10)),
1546                             false,
1547                             origin.y() + 11));
1548
1549   EXPECT_EQ(0,
1550             MaxBorderYIndex(gfx::Size(3, 3),
1551                             gfx::Rect(origin, gfx::Size(10, 10)),
1552                             true,
1553                             origin.y() + 0));
1554   EXPECT_EQ(1,
1555             MaxBorderYIndex(gfx::Size(3, 3),
1556                             gfx::Rect(origin, gfx::Size(10, 10)),
1557                             true,
1558                             origin.y() + 1));
1559   EXPECT_EQ(2,
1560             MaxBorderYIndex(gfx::Size(3, 3),
1561                             gfx::Rect(origin, gfx::Size(10, 10)),
1562                             true,
1563                             origin.y() + 2));
1564   EXPECT_EQ(3,
1565             MaxBorderYIndex(gfx::Size(3, 3),
1566                             gfx::Rect(origin, gfx::Size(10, 10)),
1567                             true,
1568                             origin.y() + 3));
1569   EXPECT_EQ(4,
1570             MaxBorderYIndex(gfx::Size(3, 3),
1571                             gfx::Rect(origin, gfx::Size(10, 10)),
1572                             true,
1573                             origin.y() + 4));
1574   EXPECT_EQ(5,
1575             MaxBorderYIndex(gfx::Size(3, 3),
1576                             gfx::Rect(origin, gfx::Size(10, 10)),
1577                             true,
1578                             origin.y() + 5));
1579   EXPECT_EQ(6,
1580             MaxBorderYIndex(gfx::Size(3, 3),
1581                             gfx::Rect(origin, gfx::Size(10, 10)),
1582                             true,
1583                             origin.y() + 6));
1584   EXPECT_EQ(7,
1585             MaxBorderYIndex(gfx::Size(3, 3),
1586                             gfx::Rect(origin, gfx::Size(10, 10)),
1587                             true,
1588                             origin.y() + 7));
1589   EXPECT_EQ(7,
1590             MaxBorderYIndex(gfx::Size(3, 3),
1591                             gfx::Rect(origin, gfx::Size(10, 10)),
1592                             true,
1593                             origin.y() + 8));
1594   EXPECT_EQ(7,
1595             MaxBorderYIndex(gfx::Size(3, 3),
1596                             gfx::Rect(origin, gfx::Size(10, 10)),
1597                             true,
1598                             origin.y() + 9));
1599   EXPECT_EQ(7,
1600             MaxBorderYIndex(gfx::Size(3, 3),
1601                             gfx::Rect(origin, gfx::Size(10, 10)),
1602                             true,
1603                             origin.y() + 10));
1604   EXPECT_EQ(7,
1605             MaxBorderYIndex(gfx::Size(3, 3),
1606                             gfx::Rect(origin, gfx::Size(10, 10)),
1607                             true,
1608                             origin.y() + 11));
1609
1610   EXPECT_EQ(0,
1611             MaxBorderYIndex(gfx::Size(1, 1),
1612                             gfx::Rect(origin, gfx::Size(1, 1)),
1613                             false,
1614                             origin.y() + 0));
1615   EXPECT_EQ(0,
1616             MaxBorderYIndex(gfx::Size(2, 2),
1617                             gfx::Rect(origin, gfx::Size(2, 2)),
1618                             false,
1619                             origin.y() + 0));
1620   EXPECT_EQ(0,
1621             MaxBorderYIndex(gfx::Size(2, 2),
1622                             gfx::Rect(origin, gfx::Size(2, 2)),
1623                             false,
1624                             origin.y() + 1));
1625   EXPECT_EQ(0,
1626             MaxBorderYIndex(gfx::Size(3, 3),
1627                             gfx::Rect(origin, gfx::Size(3, 3)),
1628                             false,
1629                             origin.y() + 0));
1630   EXPECT_EQ(0,
1631             MaxBorderYIndex(gfx::Size(3, 3),
1632                             gfx::Rect(origin, gfx::Size(3, 3)),
1633                             false,
1634                             origin.y() + 1));
1635   EXPECT_EQ(0,
1636             MaxBorderYIndex(gfx::Size(3, 3),
1637                             gfx::Rect(origin, gfx::Size(3, 3)),
1638                             false,
1639                             origin.y() + 2));
1640
1641   EXPECT_EQ(0,
1642             MaxBorderYIndex(gfx::Size(3, 3),
1643                             gfx::Rect(origin, gfx::Size(3, 4)),
1644                             false,
1645                             origin.y() + 0));
1646   EXPECT_EQ(0,
1647             MaxBorderYIndex(gfx::Size(3, 3),
1648                             gfx::Rect(origin, gfx::Size(3, 4)),
1649                             false,
1650                             origin.y() + 1));
1651   EXPECT_EQ(0,
1652             MaxBorderYIndex(gfx::Size(3, 3),
1653                             gfx::Rect(origin, gfx::Size(3, 4)),
1654                             false,
1655                             origin.y() + 2));
1656   EXPECT_EQ(1,
1657             MaxBorderYIndex(gfx::Size(3, 3),
1658                             gfx::Rect(origin, gfx::Size(3, 4)),
1659                             false,
1660                             origin.y() + 3));
1661
1662   EXPECT_EQ(0,
1663             MaxBorderYIndex(gfx::Size(1, 1),
1664                             gfx::Rect(origin, gfx::Size(1, 1)),
1665                             true,
1666                             origin.y() + 0));
1667   EXPECT_EQ(0,
1668             MaxBorderYIndex(gfx::Size(2, 2),
1669                             gfx::Rect(origin, gfx::Size(2, 2)),
1670                             true,
1671                             origin.y() + 0));
1672   EXPECT_EQ(0,
1673             MaxBorderYIndex(gfx::Size(2, 2),
1674                             gfx::Rect(origin, gfx::Size(2, 2)),
1675                             true,
1676                             origin.y() + 1));
1677   EXPECT_EQ(0,
1678             MaxBorderYIndex(gfx::Size(3, 3),
1679                             gfx::Rect(origin, gfx::Size(3, 3)),
1680                             true,
1681                             origin.y() + 0));
1682   EXPECT_EQ(0,
1683             MaxBorderYIndex(gfx::Size(3, 3),
1684                             gfx::Rect(origin, gfx::Size(3, 3)),
1685                             true,
1686                             origin.y() + 1));
1687   EXPECT_EQ(0,
1688             MaxBorderYIndex(gfx::Size(3, 3),
1689                             gfx::Rect(origin, gfx::Size(3, 3)),
1690                             true,
1691                             origin.y() + 2));
1692
1693   EXPECT_EQ(0,
1694             MaxBorderYIndex(gfx::Size(3, 3),
1695                             gfx::Rect(origin, gfx::Size(3, 4)),
1696                             true,
1697                             origin.y() + 0));
1698   EXPECT_EQ(1,
1699             MaxBorderYIndex(gfx::Size(3, 3),
1700                             gfx::Rect(origin, gfx::Size(3, 4)),
1701                             true,
1702                             origin.y() + 1));
1703   EXPECT_EQ(1,
1704             MaxBorderYIndex(gfx::Size(3, 3),
1705                             gfx::Rect(origin, gfx::Size(3, 4)),
1706                             true,
1707                             origin.y() + 2));
1708   EXPECT_EQ(1,
1709             MaxBorderYIndex(gfx::Size(3, 3),
1710                             gfx::Rect(origin, gfx::Size(3, 4)),
1711                             true,
1712                             origin.y() + 3));
1713 }
1714
1715 TEST_P(TilingDataTest, TileSizeX) {
1716   gfx::Point origin = GetParam();
1717
1718   EXPECT_EQ(
1719       5, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(5, 5)), false, 0));
1720   EXPECT_EQ(
1721       5, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(5, 5)), true, 0));
1722
1723   EXPECT_EQ(
1724       5, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 6)), false, 0));
1725   EXPECT_EQ(
1726       1, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 6)), false, 1));
1727   EXPECT_EQ(
1728       4, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 6)), true, 0));
1729   EXPECT_EQ(
1730       2, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 6)), true, 1));
1731
1732   EXPECT_EQ(
1733       5, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 8)), false, 0));
1734   EXPECT_EQ(
1735       3, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 8)), false, 1));
1736   EXPECT_EQ(
1737       4, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 8)), true, 0));
1738   EXPECT_EQ(
1739       4, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 8)), true, 1));
1740
1741   EXPECT_EQ(
1742       5,
1743       SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), false, 0));
1744   EXPECT_EQ(
1745       5,
1746       SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), false, 1));
1747   EXPECT_EQ(
1748       4, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), true, 0));
1749   EXPECT_EQ(
1750       3, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), true, 1));
1751   EXPECT_EQ(
1752       3, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), true, 2));
1753
1754   EXPECT_EQ(
1755       4, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(11, 11)), true, 2));
1756   EXPECT_EQ(
1757       3, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(12, 12)), true, 2));
1758
1759   EXPECT_EQ(
1760       3, SizeX(gfx::Size(5, 9), gfx::Rect(origin, gfx::Size(12, 17)), true, 2));
1761 }
1762
1763 TEST_P(TilingDataTest, TileSizeY) {
1764   gfx::Point origin = GetParam();
1765
1766   EXPECT_EQ(
1767       5, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(5, 5)), false, 0));
1768   EXPECT_EQ(
1769       5, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(5, 5)), true, 0));
1770
1771   EXPECT_EQ(
1772       5, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 6)), false, 0));
1773   EXPECT_EQ(
1774       1, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 6)), false, 1));
1775   EXPECT_EQ(
1776       4, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 6)), true, 0));
1777   EXPECT_EQ(
1778       2, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 6)), true, 1));
1779
1780   EXPECT_EQ(
1781       5, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 8)), false, 0));
1782   EXPECT_EQ(
1783       3, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 8)), false, 1));
1784   EXPECT_EQ(
1785       4, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 8)), true, 0));
1786   EXPECT_EQ(
1787       4, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 8)), true, 1));
1788
1789   EXPECT_EQ(
1790       5,
1791       SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), false, 0));
1792   EXPECT_EQ(
1793       5,
1794       SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), false, 1));
1795   EXPECT_EQ(
1796       4, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), true, 0));
1797   EXPECT_EQ(
1798       3, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), true, 1));
1799   EXPECT_EQ(
1800       3, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), true, 2));
1801
1802   EXPECT_EQ(
1803       4, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(11, 11)), true, 2));
1804   EXPECT_EQ(
1805       3, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(12, 12)), true, 2));
1806
1807   EXPECT_EQ(
1808       3, SizeY(gfx::Size(9, 5), gfx::Rect(origin, gfx::Size(17, 12)), true, 2));
1809 }
1810
1811 TEST_P(TilingDataTest, TileSizeX_and_TilePositionX) {
1812   gfx::Point origin = GetParam();
1813
1814   // Single tile cases:
1815   EXPECT_EQ(
1816       1, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 1)), false, 0));
1817   EXPECT_EQ(
1818       origin.x(),
1819       PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 1)), false, 0));
1820   EXPECT_EQ(
1821       1,
1822       SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 100)), false, 0));
1823   EXPECT_EQ(
1824       origin.x(),
1825       PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 100)), false, 0));
1826   EXPECT_EQ(
1827       3, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 1)), false, 0));
1828   EXPECT_EQ(
1829       origin.x(),
1830       PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 1)), false, 0));
1831   EXPECT_EQ(
1832       3,
1833       SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 100)), false, 0));
1834   EXPECT_EQ(
1835       origin.x(),
1836       PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 100)), false, 0));
1837   EXPECT_EQ(
1838       1, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 1)), true, 0));
1839   EXPECT_EQ(origin.x(),
1840             PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 1)), true, 0));
1841   EXPECT_EQ(
1842       1, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 100)), true, 0));
1843   EXPECT_EQ(
1844       origin.x(),
1845       PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 100)), true, 0));
1846   EXPECT_EQ(
1847       3, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 1)), true, 0));
1848   EXPECT_EQ(origin.x(),
1849             PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 1)), true, 0));
1850   EXPECT_EQ(
1851       3, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 100)), true, 0));
1852   EXPECT_EQ(
1853       origin.x(),
1854       PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 100)), true, 0));
1855
1856   // Multiple tiles:
1857   // no border
1858   // positions 0, 3
1859   EXPECT_EQ(
1860       2, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), false));
1861   EXPECT_EQ(
1862       3, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), false, 0));
1863   EXPECT_EQ(
1864       3, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), false, 1));
1865   EXPECT_EQ(
1866       origin.x() + 0,
1867       PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), false, 0));
1868   EXPECT_EQ(
1869       origin.x() + 3,
1870       PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), false, 1));
1871   EXPECT_EQ(
1872       3,
1873       SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 100)), false, 0));
1874   EXPECT_EQ(
1875       3,
1876       SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 100)), false, 1));
1877   EXPECT_EQ(
1878       origin.x() + 0,
1879       PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 100)), false, 0));
1880   EXPECT_EQ(
1881       origin.x() + 3,
1882       PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 100)), false, 1));
1883
1884   // Multiple tiles:
1885   // with border
1886   // positions 0, 2, 3, 4
1887   EXPECT_EQ(
1888       4, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), true));
1889   EXPECT_EQ(
1890       2, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), true, 0));
1891   EXPECT_EQ(
1892       1, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), true, 1));
1893   EXPECT_EQ(
1894       1, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), true, 2));
1895   EXPECT_EQ(
1896       2, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), true, 3));
1897   EXPECT_EQ(origin.x() + 0,
1898             PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), true, 0));
1899   EXPECT_EQ(origin.x() + 2,
1900             PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), true, 1));
1901   EXPECT_EQ(origin.x() + 3,
1902             PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), true, 2));
1903   EXPECT_EQ(origin.x() + 4,
1904             PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), true, 3));
1905   EXPECT_EQ(
1906       2, SizeX(gfx::Size(3, 7), gfx::Rect(origin, gfx::Size(6, 100)), true, 0));
1907   EXPECT_EQ(
1908       1, SizeX(gfx::Size(3, 7), gfx::Rect(origin, gfx::Size(6, 100)), true, 1));
1909   EXPECT_EQ(
1910       1, SizeX(gfx::Size(3, 7), gfx::Rect(origin, gfx::Size(6, 100)), true, 2));
1911   EXPECT_EQ(
1912       2, SizeX(gfx::Size(3, 7), gfx::Rect(origin, gfx::Size(6, 100)), true, 3));
1913   EXPECT_EQ(
1914       origin.x() + 0,
1915       PosX(gfx::Size(3, 7), gfx::Rect(origin, gfx::Size(6, 100)), true, 0));
1916   EXPECT_EQ(
1917       origin.x() + 2,
1918       PosX(gfx::Size(3, 7), gfx::Rect(origin, gfx::Size(6, 100)), true, 1));
1919   EXPECT_EQ(
1920       origin.x() + 3,
1921       PosX(gfx::Size(3, 7), gfx::Rect(origin, gfx::Size(6, 100)), true, 2));
1922   EXPECT_EQ(
1923       origin.x() + 4,
1924       PosX(gfx::Size(3, 7), gfx::Rect(origin, gfx::Size(6, 100)), true, 3));
1925 }
1926
1927 TEST_P(TilingDataTest, TileSizeY_and_TilePositionY) {
1928   gfx::Point origin = GetParam();
1929
1930   // Single tile cases:
1931   EXPECT_EQ(
1932       1, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 1)), false, 0));
1933   EXPECT_EQ(
1934       origin.y(),
1935       PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 1)), false, 0));
1936   EXPECT_EQ(
1937       1,
1938       SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 1)), false, 0));
1939   EXPECT_EQ(
1940       origin.y(),
1941       PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 1)), false, 0));
1942   EXPECT_EQ(
1943       3, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 3)), false, 0));
1944   EXPECT_EQ(
1945       origin.y(),
1946       PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 3)), false, 0));
1947   EXPECT_EQ(
1948       3,
1949       SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 3)), false, 0));
1950   EXPECT_EQ(
1951       origin.y(),
1952       PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 3)), false, 0));
1953   EXPECT_EQ(
1954       1, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 1)), true, 0));
1955   EXPECT_EQ(origin.y(),
1956             PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 1)), true, 0));
1957   EXPECT_EQ(
1958       1, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 1)), true, 0));
1959   EXPECT_EQ(
1960       origin.y(),
1961       PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 1)), true, 0));
1962   EXPECT_EQ(
1963       3, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 3)), true, 0));
1964   EXPECT_EQ(origin.y(),
1965             PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 3)), true, 0));
1966   EXPECT_EQ(
1967       3, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 3)), true, 0));
1968   EXPECT_EQ(
1969       origin.y(),
1970       PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 3)), true, 0));
1971
1972   // Multiple tiles:
1973   // no border
1974   // positions 0, 3
1975   EXPECT_EQ(
1976       2, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), false));
1977   EXPECT_EQ(
1978       3, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), false, 0));
1979   EXPECT_EQ(
1980       3, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), false, 1));
1981   EXPECT_EQ(
1982       origin.y() + 0,
1983       PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), false, 0));
1984   EXPECT_EQ(
1985       origin.y() + 3,
1986       PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), false, 1));
1987   EXPECT_EQ(
1988       3,
1989       SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 6)), false, 0));
1990   EXPECT_EQ(
1991       3,
1992       SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 6)), false, 1));
1993   EXPECT_EQ(
1994       origin.y() + 0,
1995       PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 6)), false, 0));
1996   EXPECT_EQ(
1997       origin.y() + 3,
1998       PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 6)), false, 1));
1999
2000   // Multiple tiles:
2001   // with border
2002   // positions 0, 2, 3, 4
2003   EXPECT_EQ(
2004       4, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), true));
2005   EXPECT_EQ(
2006       2, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), true, 0));
2007   EXPECT_EQ(
2008       1, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), true, 1));
2009   EXPECT_EQ(
2010       1, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), true, 2));
2011   EXPECT_EQ(
2012       2, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), true, 3));
2013   EXPECT_EQ(origin.y() + 0,
2014             PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), true, 0));
2015   EXPECT_EQ(origin.y() + 2,
2016             PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), true, 1));
2017   EXPECT_EQ(origin.y() + 3,
2018             PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), true, 2));
2019   EXPECT_EQ(origin.y() + 4,
2020             PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), true, 3));
2021   EXPECT_EQ(
2022       2, SizeY(gfx::Size(7, 3), gfx::Rect(origin, gfx::Size(100, 6)), true, 0));
2023   EXPECT_EQ(
2024       1, SizeY(gfx::Size(7, 3), gfx::Rect(origin, gfx::Size(100, 6)), true, 1));
2025   EXPECT_EQ(
2026       1, SizeY(gfx::Size(7, 3), gfx::Rect(origin, gfx::Size(100, 6)), true, 2));
2027   EXPECT_EQ(
2028       2, SizeY(gfx::Size(7, 3), gfx::Rect(origin, gfx::Size(100, 6)), true, 3));
2029   EXPECT_EQ(
2030       origin.y() + 0,
2031       PosY(gfx::Size(7, 3), gfx::Rect(origin, gfx::Size(100, 6)), true, 0));
2032   EXPECT_EQ(
2033       origin.y() + 2,
2034       PosY(gfx::Size(7, 3), gfx::Rect(origin, gfx::Size(100, 6)), true, 1));
2035   EXPECT_EQ(
2036       origin.y() + 3,
2037       PosY(gfx::Size(7, 3), gfx::Rect(origin, gfx::Size(100, 6)), true, 2));
2038   EXPECT_EQ(
2039       origin.y() + 4,
2040       PosY(gfx::Size(7, 3), gfx::Rect(origin, gfx::Size(100, 6)), true, 3));
2041 }
2042
2043 TEST_P(TilingDataTest, SetTotalSize) {
2044   gfx::Point origin = GetParam();
2045
2046   TilingData data(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(5, 5)), false);
2047   EXPECT_EQ(origin.x(), data.tiling_rect().x());
2048   EXPECT_EQ(origin.y(), data.tiling_rect().y());
2049   EXPECT_EQ(5, data.tiling_rect().width());
2050   EXPECT_EQ(5, data.tiling_rect().height());
2051   EXPECT_EQ(1, data.num_tiles_x());
2052   EXPECT_EQ(5, data.TileSizeX(0));
2053   EXPECT_EQ(1, data.num_tiles_y());
2054   EXPECT_EQ(5, data.TileSizeY(0));
2055
2056   data.SetTilingRect(gfx::Rect(36, 82, 6, 5));
2057   EXPECT_EQ(36, data.tiling_rect().x());
2058   EXPECT_EQ(82, data.tiling_rect().y());
2059   EXPECT_EQ(6, data.tiling_rect().width());
2060   EXPECT_EQ(5, data.tiling_rect().height());
2061   EXPECT_EQ(2, data.num_tiles_x());
2062   EXPECT_EQ(5, data.TileSizeX(0));
2063   EXPECT_EQ(1, data.TileSizeX(1));
2064   EXPECT_EQ(1, data.num_tiles_y());
2065   EXPECT_EQ(5, data.TileSizeY(0));
2066
2067   data.SetTilingRect(gfx::Rect(4, 22, 5, 12));
2068   EXPECT_EQ(4, data.tiling_rect().x());
2069   EXPECT_EQ(22, data.tiling_rect().y());
2070   EXPECT_EQ(5, data.tiling_rect().width());
2071   EXPECT_EQ(12, data.tiling_rect().height());
2072   EXPECT_EQ(1, data.num_tiles_x());
2073   EXPECT_EQ(5, data.TileSizeX(0));
2074   EXPECT_EQ(3, data.num_tiles_y());
2075   EXPECT_EQ(5, data.TileSizeY(0));
2076   EXPECT_EQ(5, data.TileSizeY(1));
2077   EXPECT_EQ(2, data.TileSizeY(2));
2078 }
2079
2080 TEST_P(TilingDataTest, SetMaxTextureSizeNoBorders) {
2081   gfx::Point origin = GetParam();
2082
2083   TilingData data(gfx::Size(8, 8), gfx::Rect(origin, gfx::Size(16, 32)), false);
2084   EXPECT_EQ(2, data.num_tiles_x());
2085   EXPECT_EQ(4, data.num_tiles_y());
2086
2087   data.SetMaxTextureSize(gfx::Size(32, 32));
2088   EXPECT_EQ(gfx::Size(32, 32), data.max_texture_size());
2089   EXPECT_EQ(1, data.num_tiles_x());
2090   EXPECT_EQ(1, data.num_tiles_y());
2091
2092   data.SetMaxTextureSize(gfx::Size(2, 2));
2093   EXPECT_EQ(gfx::Size(2, 2), data.max_texture_size());
2094   EXPECT_EQ(8, data.num_tiles_x());
2095   EXPECT_EQ(16, data.num_tiles_y());
2096
2097   data.SetMaxTextureSize(gfx::Size(5, 5));
2098   EXPECT_EQ(gfx::Size(5, 5), data.max_texture_size());
2099   EXPECT_EQ(4, data.num_tiles_x());
2100   EXPECT_EQ(7, data.num_tiles_y());
2101
2102   data.SetMaxTextureSize(gfx::Size(8, 5));
2103   EXPECT_EQ(gfx::Size(8, 5), data.max_texture_size());
2104   EXPECT_EQ(2, data.num_tiles_x());
2105   EXPECT_EQ(7, data.num_tiles_y());
2106 }
2107
2108 TEST_P(TilingDataTest, SetMaxTextureSizeBorders) {
2109   gfx::Point origin = GetParam();
2110
2111   TilingData data(gfx::Size(8, 8), gfx::Rect(origin, gfx::Size(16, 32)), true);
2112   EXPECT_EQ(3, data.num_tiles_x());
2113   EXPECT_EQ(5, data.num_tiles_y());
2114
2115   data.SetMaxTextureSize(gfx::Size(32, 32));
2116   EXPECT_EQ(gfx::Size(32, 32), data.max_texture_size());
2117   EXPECT_EQ(1, data.num_tiles_x());
2118   EXPECT_EQ(1, data.num_tiles_y());
2119
2120   data.SetMaxTextureSize(gfx::Size(2, 2));
2121   EXPECT_EQ(gfx::Size(2, 2), data.max_texture_size());
2122   EXPECT_EQ(0, data.num_tiles_x());
2123   EXPECT_EQ(0, data.num_tiles_y());
2124
2125   data.SetMaxTextureSize(gfx::Size(5, 5));
2126   EXPECT_EQ(gfx::Size(5, 5), data.max_texture_size());
2127   EXPECT_EQ(5, data.num_tiles_x());
2128   EXPECT_EQ(10, data.num_tiles_y());
2129
2130   data.SetMaxTextureSize(gfx::Size(8, 5));
2131   EXPECT_EQ(gfx::Size(8, 5), data.max_texture_size());
2132   EXPECT_EQ(3, data.num_tiles_x());
2133   EXPECT_EQ(10, data.num_tiles_y());
2134 }
2135
2136 TEST_P(TilingDataTest, ExpandRectToTileBoundsWithBordersEmpty) {
2137   gfx::Point origin = GetParam();
2138   TilingData empty_total_size(
2139       gfx::Size(0, 0), gfx::Rect(origin, gfx::Size(8, 8)), true);
2140   EXPECT_RECT_EQ(
2141       gfx::Rect(),
2142       empty_total_size.ExpandRectToTileBoundsWithBorders(gfx::Rect()));
2143   EXPECT_RECT_EQ(gfx::Rect(),
2144                  empty_total_size.ExpandRectToTileBoundsWithBorders(
2145                      gfx::Rect(100, 100, 100, 100)));
2146   EXPECT_RECT_EQ(gfx::Rect(),
2147                  empty_total_size.ExpandRectToTileBoundsWithBorders(
2148                      gfx::Rect(0, 0, 100, 100)));
2149
2150   TilingData empty_max_texture_size(
2151       gfx::Size(8, 8), gfx::Rect(origin, gfx::Size(0, 0)), true);
2152   EXPECT_RECT_EQ(
2153       gfx::Rect(),
2154       empty_max_texture_size.ExpandRectToTileBoundsWithBorders(gfx::Rect()));
2155   EXPECT_RECT_EQ(gfx::Rect(),
2156                  empty_max_texture_size.ExpandRectToTileBoundsWithBorders(
2157                      gfx::Rect(100, 100, 100, 100)));
2158   EXPECT_RECT_EQ(gfx::Rect(),
2159                  empty_max_texture_size.ExpandRectToTileBoundsWithBorders(
2160                      gfx::Rect(0, 0, 100, 100)));
2161 }
2162
2163 TEST_P(TilingDataTest, ExpandRectToTileBoundsWithBorders) {
2164   gfx::Point origin = GetParam();
2165   TilingData data(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(16, 32)), true);
2166
2167   // Small rect at origin rounds up to tile 0, 0.
2168   gfx::Rect at_origin_src(origin, gfx::Size(1, 1));
2169   gfx::Rect at_origin_result(data.TileBoundsWithBorder(0, 0));
2170   EXPECT_NE(at_origin_src, at_origin_result);
2171   EXPECT_RECT_EQ(at_origin_result,
2172                  data.ExpandRectToTileBoundsWithBorders(at_origin_src));
2173
2174   // Arbitrary internal rect.
2175   gfx::Rect rect_src(origin.x() + 6, origin.y() + 6, 1, 3);
2176   // Tile 2, 2 => gfx::Rect(4, 4, 4, 4)
2177   // Tile 3, 4 => gfx::Rect(6, 8, 4, 4)
2178   gfx::Rect rect_result(gfx::UnionRects(data.TileBoundsWithBorder(2, 2),
2179                                         data.TileBoundsWithBorder(3, 4)));
2180   EXPECT_NE(rect_src, rect_result);
2181   EXPECT_RECT_EQ(rect_result, data.ExpandRectToTileBoundsWithBorders(rect_src));
2182
2183   // On tile bounds rounds up to next tile (since border overlaps).
2184   gfx::Rect border_rect_src(
2185       gfx::UnionRects(data.TileBounds(1, 2), data.TileBounds(3, 4)));
2186   gfx::Rect border_rect_result(gfx::UnionRects(
2187       data.TileBoundsWithBorder(0, 1), data.TileBoundsWithBorder(4, 5)));
2188   EXPECT_RECT_EQ(border_rect_result,
2189                  data.ExpandRectToTileBoundsWithBorders(border_rect_src));
2190
2191   // Equal to tiling rect.
2192   EXPECT_RECT_EQ(data.tiling_rect(),
2193                  data.ExpandRectToTileBoundsWithBorders(data.tiling_rect()));
2194
2195   // Containing, but larger than tiling rect.
2196   EXPECT_RECT_EQ(data.tiling_rect(),
2197                  data.ExpandRectToTileBoundsWithBorders(
2198                      gfx::Rect(origin, gfx::Size(100, 100))));
2199
2200   // Non-intersecting with tiling rect.
2201   gfx::Rect non_intersect(origin.x() + 200, origin.y() + 200, 100, 100);
2202   EXPECT_FALSE(non_intersect.Intersects(data.tiling_rect()));
2203   EXPECT_RECT_EQ(gfx::Rect(),
2204                  data.ExpandRectToTileBoundsWithBorders(non_intersect));
2205 }
2206
2207 TEST_P(TilingDataTest, Assignment) {
2208   gfx::Point origin = GetParam();
2209
2210   {
2211     TilingData source(
2212         gfx::Size(8, 8), gfx::Rect(origin, gfx::Size(16, 32)), true);
2213     TilingData dest = source;
2214     EXPECT_EQ(source.border_texels(), dest.border_texels());
2215     EXPECT_EQ(source.max_texture_size(), dest.max_texture_size());
2216     EXPECT_EQ(source.num_tiles_x(), dest.num_tiles_x());
2217     EXPECT_EQ(source.num_tiles_y(), dest.num_tiles_y());
2218     EXPECT_EQ(source.tiling_rect().x(), dest.tiling_rect().x());
2219     EXPECT_EQ(source.tiling_rect().y(), dest.tiling_rect().y());
2220     EXPECT_EQ(source.tiling_rect().width(), dest.tiling_rect().width());
2221     EXPECT_EQ(source.tiling_rect().height(), dest.tiling_rect().height());
2222   }
2223   {
2224     TilingData source(
2225         gfx::Size(7, 3), gfx::Rect(origin, gfx::Size(6, 100)), false);
2226     TilingData dest(source);
2227     EXPECT_EQ(source.border_texels(), dest.border_texels());
2228     EXPECT_EQ(source.max_texture_size(), dest.max_texture_size());
2229     EXPECT_EQ(source.num_tiles_x(), dest.num_tiles_x());
2230     EXPECT_EQ(source.num_tiles_y(), dest.num_tiles_y());
2231     EXPECT_EQ(source.tiling_rect().x(), dest.tiling_rect().x());
2232     EXPECT_EQ(source.tiling_rect().y(), dest.tiling_rect().y());
2233     EXPECT_EQ(source.tiling_rect().width(), dest.tiling_rect().width());
2234     EXPECT_EQ(source.tiling_rect().height(), dest.tiling_rect().height());
2235   }
2236 }
2237
2238 TEST_P(TilingDataTest, SetBorderTexels) {
2239   gfx::Point origin = GetParam();
2240
2241   TilingData data(gfx::Size(8, 8), gfx::Rect(origin, gfx::Size(16, 32)), false);
2242   EXPECT_EQ(2, data.num_tiles_x());
2243   EXPECT_EQ(4, data.num_tiles_y());
2244
2245   data.SetHasBorderTexels(true);
2246   EXPECT_EQ(3, data.num_tiles_x());
2247   EXPECT_EQ(5, data.num_tiles_y());
2248
2249   data.SetHasBorderTexels(false);
2250   EXPECT_EQ(2, data.num_tiles_x());
2251   EXPECT_EQ(4, data.num_tiles_y());
2252 }
2253
2254 TEST_P(TilingDataTest, LargeBorders) {
2255   gfx::Point origin = GetParam();
2256
2257   TilingData data(
2258       gfx::Size(100, 80), gfx::Rect(origin, gfx::Size(200, 145)), 30);
2259   EXPECT_EQ(30, data.border_texels());
2260
2261   EXPECT_EQ(70, data.TileSizeX(0));
2262   EXPECT_EQ(40, data.TileSizeX(1));
2263   EXPECT_EQ(40, data.TileSizeX(2));
2264   EXPECT_EQ(50, data.TileSizeX(3));
2265   EXPECT_EQ(4, data.num_tiles_x());
2266
2267   EXPECT_EQ(50, data.TileSizeY(0));
2268   EXPECT_EQ(20, data.TileSizeY(1));
2269   EXPECT_EQ(20, data.TileSizeY(2));
2270   EXPECT_EQ(20, data.TileSizeY(3));
2271   EXPECT_EQ(35, data.TileSizeY(4));
2272   EXPECT_EQ(5, data.num_tiles_y());
2273
2274   EXPECT_RECT_EQ(gfx::Rect(origin.x() + 0, origin.y() + 0, 70, 50),
2275                  data.TileBounds(0, 0));
2276   EXPECT_RECT_EQ(gfx::Rect(origin.x() + 70, origin.y() + 50, 40, 20),
2277                  data.TileBounds(1, 1));
2278   EXPECT_RECT_EQ(gfx::Rect(origin.x() + 110, origin.y() + 110, 40, 35),
2279                  data.TileBounds(2, 4));
2280   EXPECT_RECT_EQ(gfx::Rect(origin.x() + 150, origin.y() + 70, 50, 20),
2281                  data.TileBounds(3, 2));
2282   EXPECT_RECT_EQ(gfx::Rect(origin.x() + 150, origin.y() + 110, 50, 35),
2283                  data.TileBounds(3, 4));
2284
2285   EXPECT_RECT_EQ(gfx::Rect(origin.x() + 0, origin.y() + 0, 100, 80),
2286                  data.TileBoundsWithBorder(0, 0));
2287   EXPECT_RECT_EQ(gfx::Rect(origin.x() + 40, origin.y() + 20, 100, 80),
2288                  data.TileBoundsWithBorder(1, 1));
2289   EXPECT_RECT_EQ(gfx::Rect(origin.x() + 80, origin.y() + 80, 100, 65),
2290                  data.TileBoundsWithBorder(2, 4));
2291   EXPECT_RECT_EQ(gfx::Rect(origin.x() + 120, origin.y() + 40, 80, 80),
2292                  data.TileBoundsWithBorder(3, 2));
2293   EXPECT_RECT_EQ(gfx::Rect(origin.x() + 120, origin.y() + 80, 80, 65),
2294                  data.TileBoundsWithBorder(3, 4));
2295
2296   EXPECT_EQ(0, data.TileXIndexFromSrcCoord(origin.x() + 0));
2297   EXPECT_EQ(0, data.TileXIndexFromSrcCoord(origin.x() + 69));
2298   EXPECT_EQ(1, data.TileXIndexFromSrcCoord(origin.x() + 70));
2299   EXPECT_EQ(1, data.TileXIndexFromSrcCoord(origin.x() + 109));
2300   EXPECT_EQ(2, data.TileXIndexFromSrcCoord(origin.x() + 110));
2301   EXPECT_EQ(2, data.TileXIndexFromSrcCoord(origin.x() + 149));
2302   EXPECT_EQ(3, data.TileXIndexFromSrcCoord(origin.x() + 150));
2303   EXPECT_EQ(3, data.TileXIndexFromSrcCoord(origin.x() + 199));
2304
2305   EXPECT_EQ(0, data.TileYIndexFromSrcCoord(origin.y() + 0));
2306   EXPECT_EQ(0, data.TileYIndexFromSrcCoord(origin.y() + 49));
2307   EXPECT_EQ(1, data.TileYIndexFromSrcCoord(origin.y() + 50));
2308   EXPECT_EQ(1, data.TileYIndexFromSrcCoord(origin.y() + 69));
2309   EXPECT_EQ(2, data.TileYIndexFromSrcCoord(origin.y() + 70));
2310   EXPECT_EQ(2, data.TileYIndexFromSrcCoord(origin.y() + 89));
2311   EXPECT_EQ(3, data.TileYIndexFromSrcCoord(origin.y() + 90));
2312   EXPECT_EQ(3, data.TileYIndexFromSrcCoord(origin.y() + 109));
2313   EXPECT_EQ(4, data.TileYIndexFromSrcCoord(origin.y() + 110));
2314   EXPECT_EQ(4, data.TileYIndexFromSrcCoord(origin.y() + 144));
2315
2316   EXPECT_EQ(0, data.FirstBorderTileXIndexFromSrcCoord(origin.x() + 0));
2317   EXPECT_EQ(0, data.FirstBorderTileXIndexFromSrcCoord(origin.x() + 99));
2318   EXPECT_EQ(1, data.FirstBorderTileXIndexFromSrcCoord(origin.x() + 100));
2319   EXPECT_EQ(1, data.FirstBorderTileXIndexFromSrcCoord(origin.x() + 139));
2320   EXPECT_EQ(2, data.FirstBorderTileXIndexFromSrcCoord(origin.x() + 140));
2321   EXPECT_EQ(2, data.FirstBorderTileXIndexFromSrcCoord(origin.x() + 179));
2322   EXPECT_EQ(3, data.FirstBorderTileXIndexFromSrcCoord(origin.x() + 180));
2323   EXPECT_EQ(3, data.FirstBorderTileXIndexFromSrcCoord(origin.x() + 199));
2324
2325   EXPECT_EQ(0, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 0));
2326   EXPECT_EQ(0, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 79));
2327   EXPECT_EQ(1, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 80));
2328   EXPECT_EQ(1, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 99));
2329   EXPECT_EQ(2, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 100));
2330   EXPECT_EQ(2, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 119));
2331   EXPECT_EQ(3, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 120));
2332   EXPECT_EQ(3, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 139));
2333   EXPECT_EQ(4, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 140));
2334   EXPECT_EQ(4, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 144));
2335
2336   EXPECT_EQ(0, data.LastBorderTileXIndexFromSrcCoord(origin.x() + 0));
2337   EXPECT_EQ(0, data.LastBorderTileXIndexFromSrcCoord(origin.x() + 39));
2338   EXPECT_EQ(1, data.LastBorderTileXIndexFromSrcCoord(origin.x() + 40));
2339   EXPECT_EQ(1, data.LastBorderTileXIndexFromSrcCoord(origin.x() + 79));
2340   EXPECT_EQ(2, data.LastBorderTileXIndexFromSrcCoord(origin.x() + 80));
2341   EXPECT_EQ(2, data.LastBorderTileXIndexFromSrcCoord(origin.x() + 119));
2342   EXPECT_EQ(3, data.LastBorderTileXIndexFromSrcCoord(origin.x() + 120));
2343   EXPECT_EQ(3, data.LastBorderTileXIndexFromSrcCoord(origin.x() + 199));
2344
2345   EXPECT_EQ(0, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 0));
2346   EXPECT_EQ(0, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 19));
2347   EXPECT_EQ(1, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 20));
2348   EXPECT_EQ(1, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 39));
2349   EXPECT_EQ(2, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 40));
2350   EXPECT_EQ(2, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 59));
2351   EXPECT_EQ(3, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 60));
2352   EXPECT_EQ(3, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 79));
2353   EXPECT_EQ(4, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 80));
2354   EXPECT_EQ(4, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 144));
2355 }
2356
2357 void TestIterate(const TilingData& data,
2358                  gfx::Rect rect,
2359                  int expect_left,
2360                  int expect_top,
2361                  int expect_right,
2362                  int expect_bottom,
2363                  bool include_borders) {
2364   EXPECT_GE(expect_left, 0);
2365   EXPECT_GE(expect_top, 0);
2366   EXPECT_LT(expect_right, data.num_tiles_x());
2367   EXPECT_LT(expect_bottom, data.num_tiles_y());
2368
2369   std::vector<std::pair<int, int> > original_expected;
2370   for (int x = 0; x < data.num_tiles_x(); ++x) {
2371     for (int y = 0; y < data.num_tiles_y(); ++y) {
2372       gfx::Rect bounds;
2373       if (include_borders)
2374         bounds = data.TileBoundsWithBorder(x, y);
2375       else
2376         bounds = data.TileBounds(x, y);
2377       if (x >= expect_left && x <= expect_right &&
2378           y >= expect_top && y <= expect_bottom) {
2379         EXPECT_TRUE(bounds.Intersects(rect));
2380         original_expected.push_back(std::make_pair(x, y));
2381       } else {
2382         EXPECT_FALSE(bounds.Intersects(rect));
2383       }
2384     }
2385   }
2386
2387   // Verify with vanilla iterator.
2388   {
2389     std::vector<std::pair<int, int> > expected = original_expected;
2390     for (TilingData::Iterator iter(&data, rect, include_borders); iter;
2391          ++iter) {
2392       bool found = false;
2393       for (size_t i = 0; i < expected.size(); ++i) {
2394         if (expected[i] == iter.index()) {
2395           expected[i] = expected.back();
2396           expected.pop_back();
2397           found = true;
2398           break;
2399         }
2400       }
2401       EXPECT_TRUE(found);
2402     }
2403     EXPECT_EQ(0u, expected.size());
2404   }
2405
2406   // Make sure this also works with a difference iterator and an empty ignore.
2407   // The difference iterator always includes borders, so ignore it otherwise.
2408   if (include_borders) {
2409     std::vector<std::pair<int, int> > expected = original_expected;
2410     for (TilingData::DifferenceIterator iter(&data, rect, gfx::Rect());
2411          iter; ++iter) {
2412       bool found = false;
2413       for (size_t i = 0; i < expected.size(); ++i) {
2414         if (expected[i] == iter.index()) {
2415           expected[i] = expected.back();
2416           expected.pop_back();
2417           found = true;
2418           break;
2419         }
2420       }
2421       EXPECT_TRUE(found);
2422     }
2423     EXPECT_EQ(0u, expected.size());
2424   }
2425 }
2426
2427 void TestIterateBorders(const TilingData& data,
2428                         gfx::Rect rect,
2429                         int expect_left,
2430                         int expect_top,
2431                         int expect_right,
2432                         int expect_bottom) {
2433   bool include_borders = true;
2434   TestIterate(data,
2435               rect,
2436               expect_left,
2437               expect_top,
2438               expect_right,
2439               expect_bottom,
2440               include_borders);
2441 }
2442
2443 void TestIterateNoBorders(const TilingData& data,
2444                           gfx::Rect rect,
2445                           int expect_left,
2446                           int expect_top,
2447                           int expect_right,
2448                           int expect_bottom) {
2449   bool include_borders = false;
2450   TestIterate(data,
2451               rect,
2452               expect_left,
2453               expect_top,
2454               expect_right,
2455               expect_bottom,
2456               include_borders);
2457 }
2458
2459 void TestIterateAll(const TilingData& data,
2460                     gfx::Rect rect,
2461                     int expect_left,
2462                     int expect_top,
2463                     int expect_right,
2464                     int expect_bottom) {
2465   TestIterateBorders(
2466       data, rect, expect_left, expect_top, expect_right, expect_bottom);
2467   TestIterateNoBorders(
2468       data, rect, expect_left, expect_top, expect_right, expect_bottom);
2469 }
2470
2471 TEST_P(TilingDataTest, IteratorNoBorderTexels) {
2472   gfx::Point origin = GetParam();
2473
2474   TilingData data(
2475       gfx::Size(10, 10), gfx::Rect(origin, gfx::Size(40, 25)), false);
2476   // The following Coordinates are relative to the origin.
2477   // X border index by src coord: [0-10), [10-20), [20, 30), [30, 40)
2478   // Y border index by src coord: [0-10), [10-20), [20, 25)
2479   TestIterateAll(data, gfx::Rect(origin.x(), origin.y(), 40, 25), 0, 0, 3, 2);
2480   TestIterateAll(
2481       data, gfx::Rect(origin.x() + 15, origin.y() + 15, 8, 8), 1, 1, 2, 2);
2482
2483   // Oversized.
2484   TestIterateAll(data,
2485                  gfx::Rect(origin.x() - 100, origin.y() - 100, 1000, 1000),
2486                  0,
2487                  0,
2488                  3,
2489                  2);
2490   TestIterateAll(
2491       data, gfx::Rect(origin.x() - 100, origin.y() + 20, 1000, 1), 0, 2, 3, 2);
2492   TestIterateAll(
2493       data, gfx::Rect(origin.x() + 29, origin.y() - 100, 31, 1000), 2, 0, 3, 2);
2494   // Nonintersecting.
2495   TestIterateAll(data,
2496                  gfx::Rect(origin.x() + 60, origin.y() + 80, 100, 100),
2497                  0,
2498                  0,
2499                  -1,
2500                  -1);
2501 }
2502
2503 TEST_P(TilingDataTest, BordersIteratorOneBorderTexel) {
2504   gfx::Point origin = GetParam();
2505
2506   TilingData data(
2507       gfx::Size(10, 20), gfx::Rect(origin, gfx::Size(25, 45)), true);
2508   // The following Coordinates are relative to the origin.
2509   // X border index by src coord: [0-10), [8-18), [16-25)
2510   // Y border index by src coord: [0-20), [18-38), [36-45)
2511   TestIterateBorders(
2512       data, gfx::Rect(origin.x(), origin.y(), 25, 45), 0, 0, 2, 2);
2513   TestIterateBorders(
2514       data, gfx::Rect(origin.x() + 18, origin.y() + 19, 3, 17), 2, 0, 2, 1);
2515   TestIterateBorders(
2516       data, gfx::Rect(origin.x() + 10, origin.y() + 20, 6, 16), 1, 1, 1, 1);
2517   TestIterateBorders(
2518       data, gfx::Rect(origin.x() + 9, origin.y() + 19, 8, 18), 0, 0, 2, 2);
2519   // Oversized.
2520   TestIterateBorders(data,
2521                      gfx::Rect(origin.x() - 100, origin.y() - 100, 1000, 1000),
2522                      0,
2523                      0,
2524                      2,
2525                      2);
2526   TestIterateBorders(
2527       data, gfx::Rect(origin.x() - 100, origin.y() + 20, 1000, 1), 0, 1, 2, 1);
2528   TestIterateBorders(
2529       data, gfx::Rect(origin.x() + 18, origin.y() - 100, 6, 1000), 2, 0, 2, 2);
2530   // Nonintersecting.
2531   TestIterateBorders(data,
2532                      gfx::Rect(origin.x() + 60, origin.y() + 80, 100, 100),
2533                      0,
2534                      0,
2535                      -1,
2536                      -1);
2537 }
2538
2539 TEST_P(TilingDataTest, NoBordersIteratorOneBorderTexel) {
2540   gfx::Point origin = GetParam();
2541
2542   TilingData data(
2543       gfx::Size(10, 20), gfx::Rect(origin, gfx::Size(25, 45)), true);
2544   // The following Coordinates are relative to the origin.
2545   // X index by src coord: [0-9), [9-17), [17-25)
2546   // Y index by src coord: [0-19), [19-37), [37-45)
2547   TestIterateNoBorders(
2548       data, gfx::Rect(origin.x(), origin.y(), 25, 45), 0, 0, 2, 2);
2549   TestIterateNoBorders(
2550       data, gfx::Rect(origin.x() + 17, origin.y() + 19, 3, 18), 2, 1, 2, 1);
2551   TestIterateNoBorders(
2552       data, gfx::Rect(origin.x() + 17, origin.y() + 19, 3, 19), 2, 1, 2, 2);
2553   TestIterateNoBorders(
2554       data, gfx::Rect(origin.x() + 8, origin.y() + 18, 9, 19), 0, 0, 1, 1);
2555   TestIterateNoBorders(
2556       data, gfx::Rect(origin.x() + 9, origin.y() + 19, 9, 19), 1, 1, 2, 2);
2557   // Oversized.
2558   TestIterateNoBorders(
2559       data,
2560       gfx::Rect(origin.x() - 100, origin.y() - 100, 1000, 1000),
2561       0,
2562       0,
2563       2,
2564       2);
2565   TestIterateNoBorders(
2566       data, gfx::Rect(origin.x() - 100, origin.y() + 20, 1000, 1), 0, 1, 2, 1);
2567   TestIterateNoBorders(
2568       data, gfx::Rect(origin.x() + 18, origin.y() - 100, 6, 1000), 2, 0, 2, 2);
2569   // Nonintersecting.
2570   TestIterateNoBorders(data,
2571                        gfx::Rect(origin.x() + 60, origin.y() + 80, 100, 100),
2572                        0,
2573                        0,
2574                        -1,
2575                        -1);
2576 }
2577
2578 TEST_P(TilingDataTest, BordersIteratorManyBorderTexels) {
2579   gfx::Point origin = GetParam();
2580
2581   TilingData data(gfx::Size(50, 60), gfx::Rect(origin, gfx::Size(65, 110)), 20);
2582   // The following Coordinates are relative to the origin.
2583   // X border index by src coord: [0-50), [10-60), [20-65)
2584   // Y border index by src coord: [0-60), [20-80), [40-100), [60-110)
2585   TestIterateBorders(
2586       data, gfx::Rect(origin.x(), origin.y(), 65, 110), 0, 0, 2, 3);
2587   TestIterateBorders(
2588       data, gfx::Rect(origin.x() + 50, origin.y() + 60, 15, 65), 1, 1, 2, 3);
2589   TestIterateBorders(
2590       data, gfx::Rect(origin.x() + 60, origin.y() + 30, 2, 10), 2, 0, 2, 1);
2591   // Oversized.
2592   TestIterateBorders(data,
2593                      gfx::Rect(origin.x() - 100, origin.y() - 100, 1000, 1000),
2594                      0,
2595                      0,
2596                      2,
2597                      3);
2598   TestIterateBorders(
2599       data, gfx::Rect(origin.x() - 100, origin.y() + 10, 1000, 10), 0, 0, 2, 0);
2600   TestIterateBorders(
2601       data, gfx::Rect(origin.x() + 10, origin.y() - 100, 10, 1000), 0, 0, 1, 3);
2602   // Nonintersecting.
2603   TestIterateBorders(data,
2604                      gfx::Rect(origin.x() + 65, origin.y() + 110, 100, 100),
2605                      0,
2606                      0,
2607                      -1,
2608                      -1);
2609 }
2610
2611 TEST_P(TilingDataTest, NoBordersIteratorManyBorderTexels) {
2612   gfx::Point origin = GetParam();
2613
2614   TilingData data(gfx::Size(50, 60), gfx::Rect(origin, gfx::Size(65, 110)), 20);
2615   // The following Coordinates are relative to the origin.
2616   // X index by src coord: [0-30), [30-40), [40, 65)
2617   // Y index by src coord: [0-40), [40-60), [60, 80), [80-110)
2618   TestIterateNoBorders(
2619       data, gfx::Rect(origin.x(), origin.y(), 65, 110), 0, 0, 2, 3);
2620   TestIterateNoBorders(
2621       data, gfx::Rect(origin.x() + 30, origin.y() + 40, 15, 65), 1, 1, 2, 3);
2622   TestIterateNoBorders(
2623       data, gfx::Rect(origin.x() + 60, origin.y() + 20, 2, 21), 2, 0, 2, 1);
2624   // Oversized.
2625   TestIterateNoBorders(
2626       data,
2627       gfx::Rect(origin.x() - 100, origin.y() - 100, 1000, 1000),
2628       0,
2629       0,
2630       2,
2631       3);
2632   TestIterateNoBorders(
2633       data, gfx::Rect(origin.x() - 100, origin.y() + 10, 1000, 10), 0, 0, 2, 0);
2634   TestIterateNoBorders(
2635       data, gfx::Rect(origin.x() + 10, origin.y() - 100, 10, 1000), 0, 0, 0, 3);
2636   // Nonintersecting.
2637   TestIterateNoBorders(data,
2638                        gfx::Rect(origin.x() + 65, origin.y() + 110, 100, 100),
2639                        0,
2640                        0,
2641                        -1,
2642                        -1);
2643 }
2644
2645 TEST_P(TilingDataTest, IteratorOneTile) {
2646   gfx::Point origin = GetParam();
2647
2648   TilingData no_border(
2649       gfx::Size(1000, 1000), gfx::Rect(origin, gfx::Size(30, 40)), false);
2650   TestIterateAll(
2651       no_border, gfx::Rect(origin.x(), origin.y(), 30, 40), 0, 0, 0, 0);
2652   TestIterateAll(no_border,
2653                  gfx::Rect(origin.x() + 10, origin.y() + 10, 20, 20),
2654                  0,
2655                  0,
2656                  0,
2657                  0);
2658   TestIterateAll(no_border,
2659                  gfx::Rect(origin.x() + 30, origin.y() + 40, 100, 100),
2660                  0,
2661                  0,
2662                  -1,
2663                  -1);
2664
2665   TilingData one_border(
2666       gfx::Size(1000, 1000), gfx::Rect(origin, gfx::Size(30, 40)), true);
2667   TestIterateAll(
2668       one_border, gfx::Rect(origin.x(), origin.y(), 30, 40), 0, 0, 0, 0);
2669   TestIterateAll(one_border,
2670                  gfx::Rect(origin.x() + 10, origin.y() + 10, 20, 20),
2671                  0,
2672                  0,
2673                  0,
2674                  0);
2675   TestIterateAll(one_border,
2676                  gfx::Rect(origin.x() + 30, origin.y() + 40, 100, 100),
2677                  0,
2678                  0,
2679                  -1,
2680                  -1);
2681
2682   TilingData big_border(
2683       gfx::Size(1000, 1000), gfx::Rect(origin, gfx::Size(30, 40)), 50);
2684   TestIterateAll(
2685       big_border, gfx::Rect(origin.x(), origin.y(), 30, 40), 0, 0, 0, 0);
2686   TestIterateAll(big_border,
2687                  gfx::Rect(origin.x() + 10, origin.y() + 10, 20, 20),
2688                  0,
2689                  0,
2690                  0,
2691                  0);
2692   TestIterateAll(big_border,
2693                  gfx::Rect(origin.x() + 30, origin.y() + 40, 100, 100),
2694                  0,
2695                  0,
2696                  -1,
2697                  -1);
2698 }
2699
2700 TEST(TilingDataTest, IteratorNoTiles) {
2701   TilingData data(gfx::Size(100, 100), gfx::Rect(), false);
2702   TestIterateAll(data, gfx::Rect(0, 0, 100, 100), 0, 0, -1, -1);
2703 }
2704
2705 void TestDiff(
2706     const TilingData& data,
2707     gfx::Rect consider,
2708     gfx::Rect ignore,
2709     size_t num_tiles) {
2710
2711   std::vector<std::pair<int, int> > expected;
2712   for (int y = 0; y < data.num_tiles_y(); ++y) {
2713     for (int x = 0; x < data.num_tiles_x(); ++x) {
2714       gfx::Rect bounds = data.TileBoundsWithBorder(x, y);
2715       if (bounds.Intersects(consider) && !bounds.Intersects(ignore))
2716         expected.push_back(std::make_pair(x, y));
2717     }
2718   }
2719
2720   // Sanity check the test.
2721   EXPECT_EQ(num_tiles, expected.size());
2722
2723   for (TilingData::DifferenceIterator iter(&data, consider, ignore);
2724        iter; ++iter) {
2725     bool found = false;
2726     for (size_t i = 0; i < expected.size(); ++i) {
2727       if (expected[i] == iter.index()) {
2728         expected[i] = expected.back();
2729         expected.pop_back();
2730         found = true;
2731         break;
2732       }
2733     }
2734     EXPECT_TRUE(found);
2735   }
2736   EXPECT_EQ(0u, expected.size());
2737 }
2738
2739 TEST_P(TilingDataTest, DifferenceIteratorIgnoreGeometry) {
2740   // This test is checking that the iterator can handle different geometries of
2741   // ignore rects relative to the consider rect.  The consider rect indices
2742   // themselves are mostly tested by the non-difference iterator tests, so the
2743   // full rect is mostly used here for simplicity.
2744
2745   gfx::Point origin = GetParam();
2746
2747   // The following Coordinates are relative to the origin.
2748   // X border index by src coord: [0-10), [10-20), [20, 30), [30, 40)
2749   // Y border index by src coord: [0-10), [10-20), [20, 25)
2750   TilingData data(
2751       gfx::Size(10, 10), gfx::Rect(origin, gfx::Size(40, 25)), false);
2752
2753   // Fully ignored
2754   TestDiff(data,
2755            gfx::Rect(origin.x(), origin.y(), 40, 25),
2756            gfx::Rect(origin.x(), origin.y(), 40, 25),
2757            0);
2758   TestDiff(data,
2759            gfx::Rect(origin.x(), origin.y(), 40, 25),
2760            gfx::Rect(origin.x() - 100, origin.y() - 100, 200, 200),
2761            0);
2762   TestDiff(data,
2763            gfx::Rect(origin.x(), origin.y(), 40, 25),
2764            gfx::Rect(origin.x() + 9, origin.y() + 9, 30, 15),
2765            0);
2766   TestDiff(data,
2767            gfx::Rect(origin.x() + 15, origin.y() + 15, 8, 8),
2768            gfx::Rect(origin.x() + 15, origin.y() + 15, 8, 8),
2769            0);
2770
2771   // Fully un-ignored
2772   TestDiff(data,
2773            gfx::Rect(origin.x(), origin.y(), 40, 25),
2774            gfx::Rect(origin.x() - 30, origin.y() - 20, 8, 8),
2775            12);
2776   TestDiff(data, gfx::Rect(origin.x(), origin.y(), 40, 25), gfx::Rect(), 12);
2777
2778   // Top left, remove 2x2 tiles
2779   TestDiff(data,
2780            gfx::Rect(origin.x(), origin.y(), 40, 25),
2781            gfx::Rect(origin.x(), origin.y(), 20, 19),
2782            8);
2783   // Bottom right, remove 2x2 tiles
2784   TestDiff(data,
2785            gfx::Rect(origin.x(), origin.y(), 40, 25),
2786            gfx::Rect(origin.x() + 20, origin.y() + 15, 20, 6),
2787            8);
2788   // Bottom left, remove 2x2 tiles
2789   TestDiff(data,
2790            gfx::Rect(origin.x(), origin.y(), 40, 25),
2791            gfx::Rect(origin.x(), origin.y() + 15, 20, 6),
2792            8);
2793   // Top right, remove 2x2 tiles
2794   TestDiff(data,
2795            gfx::Rect(origin.x(), origin.y(), 40, 25),
2796            gfx::Rect(origin.x() + 20, origin.y(), 20, 19),
2797            8);
2798   // Center, remove only one tile
2799   TestDiff(data,
2800            gfx::Rect(origin.x(), origin.y(), 40, 25),
2801            gfx::Rect(origin.x() + 10, origin.y() + 10, 5, 5),
2802            11);
2803
2804   // Left column, flush left, removing two columns
2805   TestDiff(data,
2806            gfx::Rect(origin.x(), origin.y(), 40, 25),
2807            gfx::Rect(origin.x(), origin.y(), 11, 25),
2808            6);
2809   // Middle column, removing two columns
2810   TestDiff(data,
2811            gfx::Rect(origin.x(), origin.y(), 40, 25),
2812            gfx::Rect(origin.x() + 11, origin.y(), 11, 25),
2813            6);
2814   // Right column, flush right, removing one column
2815   TestDiff(data,
2816            gfx::Rect(origin.x(), origin.y(), 40, 25),
2817            gfx::Rect(origin.x() + 30, origin.y(), 2, 25),
2818            9);
2819
2820   // Top row, flush top, removing one row
2821   TestDiff(data,
2822            gfx::Rect(origin.x(), origin.y(), 40, 25),
2823            gfx::Rect(origin.x(), origin.y() + 5, 40, 5),
2824            8);
2825   // Middle row, removing one row
2826   TestDiff(data,
2827            gfx::Rect(origin.x(), origin.y(), 40, 25),
2828            gfx::Rect(origin.x(), origin.y() + 13, 40, 5),
2829            8);
2830   // Bottom row, flush bottom, removing two rows
2831   TestDiff(data,
2832            gfx::Rect(origin.x(), origin.y(), 40, 25),
2833            gfx::Rect(origin.x(), origin.y() + 13, 40, 12),
2834            4);
2835
2836   // Non-intersecting, but still touching two of the same tiles.
2837   TestDiff(data,
2838            gfx::Rect(origin.x() + 8, origin.y(), 32, 25),
2839            gfx::Rect(origin.x(), origin.y() + 12, 5, 12),
2840            10);
2841
2842   // Intersecting, but neither contains the other. 2x3 with one overlap.
2843   TestDiff(data,
2844            gfx::Rect(origin.x() + 5, origin.y() + 2, 20, 10),
2845            gfx::Rect(origin.x() + 25, origin.y() + 15, 5, 10),
2846            5);
2847 }
2848
2849 TEST_P(TilingDataTest, DifferenceIteratorManyBorderTexels) {
2850   gfx::Point origin = GetParam();
2851
2852   // The following Coordinates are relative to the origin.
2853   // X border index by src coord: [0-50), [10-60), [20-65)
2854   // Y border index by src coord: [0-60), [20-80), [40-100), [60-110)
2855   TilingData data(gfx::Size(50, 60), gfx::Rect(origin, gfx::Size(65, 110)), 20);
2856
2857   // Ignore one column, three rows
2858   TestDiff(data,
2859            gfx::Rect(origin.x(), origin.y() + 30, 55, 80),
2860            gfx::Rect(origin.x() + 5, origin.y() + 30, 5, 15),
2861            9);
2862
2863   // Knock out three columns, leaving only one.
2864   TestDiff(data,
2865            gfx::Rect(origin.x() + 10, origin.y() + 30, 55, 80),
2866            gfx::Rect(origin.x() + 30, origin.y() + 59, 20, 1),
2867            3);
2868
2869   // Overlap all tiles with ignore rect.
2870   TestDiff(data,
2871            gfx::Rect(origin.x(), origin.y(), 65, 110),
2872            gfx::Rect(origin.x() + 30, origin.y() + 59, 1, 2),
2873            0);
2874 }
2875
2876 TEST_P(TilingDataTest, DifferenceIteratorOneTile) {
2877   gfx::Point origin = GetParam();
2878
2879   TilingData no_border(
2880       gfx::Size(1000, 1000), gfx::Rect(origin, gfx::Size(30, 40)), false);
2881   TestDiff(
2882       no_border, gfx::Rect(origin.x(), origin.y(), 30, 40), gfx::Rect(), 1);
2883   TestDiff(no_border,
2884            gfx::Rect(origin.x() + 5, origin.y() + 5, 100, 100),
2885            gfx::Rect(origin.x() + 5, origin.y() + 5, 1, 1),
2886            0);
2887
2888   TilingData one_border(
2889       gfx::Size(1000, 1000), gfx::Rect(origin, gfx::Size(30, 40)), true);
2890   TestDiff(
2891       one_border, gfx::Rect(origin.x(), origin.y(), 30, 40), gfx::Rect(), 1);
2892   TestDiff(one_border,
2893            gfx::Rect(origin.x() + 5, origin.y() + 5, 100, 100),
2894            gfx::Rect(origin.x() + 5, origin.y() + 5, 1, 1),
2895            0);
2896
2897   TilingData big_border(
2898       gfx::Size(1000, 1000), gfx::Rect(origin, gfx::Size(30, 40)), 50);
2899   TestDiff(
2900       big_border, gfx::Rect(origin.x(), origin.y(), 30, 40), gfx::Rect(), 1);
2901   TestDiff(big_border,
2902            gfx::Rect(origin.x() + 5, origin.y() + 5, 100, 100),
2903            gfx::Rect(origin.x() + 5, origin.y() + 5, 1, 1),
2904            0);
2905 }
2906
2907 TEST(TilingDataTest, DifferenceIteratorNoTiles) {
2908   TilingData data(gfx::Size(100, 100), gfx::Rect(), false);
2909   TestDiff(data, gfx::Rect(0, 0, 100, 100), gfx::Rect(0, 0, 5, 5), 0);
2910 }
2911
2912 void TestSpiralIterate(int source_line_number,
2913                        const TilingData& tiling_data,
2914                        const gfx::Rect& consider,
2915                        const gfx::Rect& ignore,
2916                        const gfx::Rect& center,
2917                        const std::vector<std::pair<int, int> >& expected) {
2918   std::vector<std::pair<int, int> > actual;
2919   for (TilingData::SpiralDifferenceIterator it(
2920            &tiling_data, consider, ignore, center);
2921        it;
2922        ++it) {
2923     actual.push_back(it.index());
2924   }
2925
2926   EXPECT_EQ(expected.size(), actual.size()) << "error from line "
2927                                             << source_line_number;
2928   for (size_t i = 0; i < std::min(expected.size(), actual.size()); ++i) {
2929     EXPECT_EQ(expected[i].first, actual[i].first)
2930         << "i: " << i << " error from line: " << source_line_number;
2931     EXPECT_EQ(expected[i].second, actual[i].second)
2932         << "i: " << i << " error from line: " << source_line_number;
2933   }
2934 }
2935
2936 TEST_P(TilingDataTest, SpiralDifferenceIteratorNoIgnoreFullConsider) {
2937   gfx::Point origin = GetParam();
2938   TilingData tiling_data(
2939       gfx::Size(10, 10), gfx::Rect(origin, gfx::Size(30, 30)), false);
2940   gfx::Rect consider(origin.x(), origin.y(), 30, 30);
2941   gfx::Rect ignore;
2942   std::vector<std::pair<int, int> > expected;
2943
2944   // Center is in the center of the tiling.
2945   gfx::Rect center(origin.x() + 15, origin.y() + 15, 1, 1);
2946
2947   // Layout of the tiling data, and expected return order:
2948   //   x 0 1 2
2949   //  y.------
2950   //  0| 4 3 2
2951   //  1| 5 * 1
2952   //  2| 6 7 8
2953   expected.push_back(std::make_pair(2, 1));
2954   expected.push_back(std::make_pair(2, 0));
2955   expected.push_back(std::make_pair(1, 0));
2956   expected.push_back(std::make_pair(0, 0));
2957   expected.push_back(std::make_pair(0, 1));
2958   expected.push_back(std::make_pair(0, 2));
2959   expected.push_back(std::make_pair(1, 2));
2960   expected.push_back(std::make_pair(2, 2));
2961
2962   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
2963
2964   // Center is off to the right side of the tiling (and far away).
2965   center = gfx::Rect(origin.x() + 100, origin.y() + 15, 1, 1);
2966
2967   // Layout of the tiling data, and expected return order:
2968   //   x 0 1 2
2969   //  y.------
2970   //  0| 7 4 1
2971   //  1| 8 5 2 *
2972   //  2| 9 6 3
2973   expected.clear();
2974   expected.push_back(std::make_pair(2, 0));
2975   expected.push_back(std::make_pair(2, 1));
2976   expected.push_back(std::make_pair(2, 2));
2977   expected.push_back(std::make_pair(1, 0));
2978   expected.push_back(std::make_pair(1, 1));
2979   expected.push_back(std::make_pair(1, 2));
2980   expected.push_back(std::make_pair(0, 0));
2981   expected.push_back(std::make_pair(0, 1));
2982   expected.push_back(std::make_pair(0, 2));
2983
2984   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
2985
2986   // Center is the bottom right corner of the tiling.
2987   center = gfx::Rect(origin.x() + 25, origin.y() + 25, 1, 1);
2988
2989   // Layout of the tiling data, and expected return order:
2990   //   x 0 1 2
2991   //  y.------
2992   //  0| 6 5 4
2993   //  1| 7 2 1
2994   //  2| 8 3 *
2995   expected.clear();
2996   expected.push_back(std::make_pair(2, 1));
2997   expected.push_back(std::make_pair(1, 1));
2998   expected.push_back(std::make_pair(1, 2));
2999   expected.push_back(std::make_pair(2, 0));
3000   expected.push_back(std::make_pair(1, 0));
3001   expected.push_back(std::make_pair(0, 0));
3002   expected.push_back(std::make_pair(0, 1));
3003   expected.push_back(std::make_pair(0, 2));
3004
3005   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
3006
3007   // Center is off the top left side of the tiling.
3008   center = gfx::Rect(origin.x() - 60, origin.y() - 50, 1, 1);
3009
3010   // Layout of the tiling data, and expected return order:
3011   // * x 0 1 2
3012   //  y.------
3013   //  0| 1 2 6
3014   //  1| 3 4 5
3015   //  2| 7 8 9
3016   expected.clear();
3017   expected.push_back(std::make_pair(0, 0));
3018   expected.push_back(std::make_pair(1, 0));
3019   expected.push_back(std::make_pair(0, 1));
3020   expected.push_back(std::make_pair(1, 1));
3021   expected.push_back(std::make_pair(2, 1));
3022   expected.push_back(std::make_pair(2, 0));
3023   expected.push_back(std::make_pair(0, 2));
3024   expected.push_back(std::make_pair(1, 2));
3025   expected.push_back(std::make_pair(2, 2));
3026
3027   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
3028
3029   // Two tile center.
3030   center = gfx::Rect(origin.x() + 15, origin.y() + 15, 1, 10);
3031
3032   // Layout of the tiling data, and expected return order:
3033   //   x 0 1 2
3034   //  y.------
3035   //  0| 5 4 3
3036   //  1| 6 * 2
3037   //  2| 7 * 1
3038   expected.clear();
3039   expected.push_back(std::make_pair(2, 2));
3040   expected.push_back(std::make_pair(2, 1));
3041   expected.push_back(std::make_pair(2, 0));
3042   expected.push_back(std::make_pair(1, 0));
3043   expected.push_back(std::make_pair(0, 0));
3044   expected.push_back(std::make_pair(0, 1));
3045   expected.push_back(std::make_pair(0, 2));
3046
3047   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
3048 }
3049
3050 TEST_P(TilingDataTest, SpiralDifferenceIteratorSmallConsider) {
3051   gfx::Point origin = GetParam();
3052   TilingData tiling_data(
3053       gfx::Size(10, 10), gfx::Rect(origin, gfx::Size(50, 50)), false);
3054   gfx::Rect ignore;
3055   std::vector<std::pair<int, int> > expected;
3056   gfx::Rect center(origin.x() + 15, origin.y() + 15, 1, 1);
3057
3058   // Consider is one cell.
3059   gfx::Rect consider(origin.x(), origin.y(), 1, 1);
3060
3061   // Layout of the tiling data, and expected return order:
3062   //   x 0 1 2 3 4
3063   //  y.----------
3064   //  0| 1
3065   //  1|   *
3066   //  2|
3067   //  3|
3068   //  4|
3069   expected.push_back(std::make_pair(0, 0));
3070
3071   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
3072
3073   // Consider is bottom right corner.
3074   consider = gfx::Rect(origin.x() + 25, origin.y() + 25, 10, 10);
3075
3076   // Layout of the tiling data, and expected return order:
3077   //   x 0 1 2 3 4
3078   //  y.----------
3079   //  0|
3080   //  1|   *
3081   //  2|     1 2
3082   //  3|     3 4
3083   //  4|
3084   expected.clear();
3085   expected.push_back(std::make_pair(2, 2));
3086   expected.push_back(std::make_pair(3, 2));
3087   expected.push_back(std::make_pair(2, 3));
3088   expected.push_back(std::make_pair(3, 3));
3089
3090   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
3091
3092   // Consider is one column.
3093   consider = gfx::Rect(origin.x() + 11, origin.y(), 1, 100);
3094
3095   // Layout of the tiling data, and expected return order:
3096   //   x 0 1 2 3 4
3097   //  y.----------
3098   //  0|   2
3099   //  1|   *
3100   //  2|   3
3101   //  3|   4
3102   //  4|   5
3103   expected.clear();
3104   expected.push_back(std::make_pair(1, 0));
3105   expected.push_back(std::make_pair(1, 2));
3106   expected.push_back(std::make_pair(1, 3));
3107   expected.push_back(std::make_pair(1, 4));
3108
3109   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
3110 }
3111
3112 TEST_P(TilingDataTest, SpiralDifferenceIteratorHasIgnore) {
3113   gfx::Point origin = GetParam();
3114   TilingData tiling_data(
3115       gfx::Size(10, 10), gfx::Rect(origin, gfx::Size(50, 50)), false);
3116   gfx::Rect consider(origin.x(), origin.y(), 50, 50);
3117   std::vector<std::pair<int, int> > expected;
3118   gfx::Rect center(origin.x() + 15, origin.y() + 15, 1, 1);
3119
3120   // Full ignore.
3121   gfx::Rect ignore(origin.x(), origin.y(), 50, 50);
3122
3123   // Layout of the tiling data, and expected return order:
3124   //   x 0 1 2 3 4
3125   //  y.----------
3126   //  0| . . . . .
3127   //  1| . * . . .
3128   //  2| . . . . .
3129   //  3| . . . . .
3130   //  4| . . . . .
3131   expected.clear();
3132
3133   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
3134
3135   // 3 column ignore.
3136   ignore = gfx::Rect(origin.x() + 15, origin.y(), 20, 100);
3137
3138   // Layout of the tiling data, and expected return order:
3139   //   x 0 1 2 3 4
3140   //  y.----------
3141   //  0| 1 . . . 8
3142   //  1| 2 * . . 7
3143   //  2| 3 . . . 6
3144   //  3| 4 . . . 5
3145   //  4| 9 . . . 10
3146   expected.clear();
3147
3148   expected.push_back(std::make_pair(0, 0));
3149   expected.push_back(std::make_pair(0, 1));
3150   expected.push_back(std::make_pair(0, 2));
3151   expected.push_back(std::make_pair(0, 3));
3152   expected.push_back(std::make_pair(4, 3));
3153   expected.push_back(std::make_pair(4, 2));
3154   expected.push_back(std::make_pair(4, 1));
3155   expected.push_back(std::make_pair(4, 0));
3156   expected.push_back(std::make_pair(0, 4));
3157   expected.push_back(std::make_pair(4, 4));
3158
3159   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
3160
3161   // Ignore covers the top half.
3162   ignore = gfx::Rect(origin.x(), origin.y(), 50, 25);
3163
3164   // Layout of the tiling data, and expected return order:
3165   //   x 0 1 2 3 4
3166   //  y.----------
3167   //  0| . . . . .
3168   //  1| . * . . .
3169   //  2| . . . . .
3170   //  3| 1 2 3 4 5
3171   //  4| 6 7 8 9 10
3172   expected.clear();
3173
3174   expected.push_back(std::make_pair(0, 3));
3175   expected.push_back(std::make_pair(1, 3));
3176   expected.push_back(std::make_pair(2, 3));
3177   expected.push_back(std::make_pair(3, 3));
3178   expected.push_back(std::make_pair(4, 3));
3179   expected.push_back(std::make_pair(0, 4));
3180   expected.push_back(std::make_pair(1, 4));
3181   expected.push_back(std::make_pair(2, 4));
3182   expected.push_back(std::make_pair(3, 4));
3183   expected.push_back(std::make_pair(4, 4));
3184
3185   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
3186 }
3187
3188 TEST_P(TilingDataTest, SpiralDifferenceIteratorRectangleCenter) {
3189   gfx::Point origin = GetParam();
3190   TilingData tiling_data(
3191       gfx::Size(10, 10), gfx::Rect(origin, gfx::Size(50, 50)), false);
3192   gfx::Rect consider(origin.x(), origin.y(), 50, 50);
3193   std::vector<std::pair<int, int> > expected;
3194   gfx::Rect ignore;
3195
3196   // Two cell center
3197   gfx::Rect center(origin.x() + 25, origin.y() + 25, 1, 10);
3198
3199   // Layout of the tiling data, and expected return order:
3200   //   x 0 1 2 3 4
3201   //  y.----------
3202   //  0| J I H G F
3203   //  1| K 5 4 3 E
3204   //  2| L 6 * 2 D
3205   //  3| M 7 * 1 C
3206   //  4| N 8 9 A B
3207   expected.clear();
3208
3209   expected.push_back(std::make_pair(3, 3));
3210   expected.push_back(std::make_pair(3, 2));
3211   expected.push_back(std::make_pair(3, 1));
3212   expected.push_back(std::make_pair(2, 1));
3213   expected.push_back(std::make_pair(1, 1));
3214   expected.push_back(std::make_pair(1, 2));
3215   expected.push_back(std::make_pair(1, 3));
3216   expected.push_back(std::make_pair(1, 4));
3217   expected.push_back(std::make_pair(2, 4));
3218   expected.push_back(std::make_pair(3, 4));
3219   expected.push_back(std::make_pair(4, 4));
3220   expected.push_back(std::make_pair(4, 3));
3221   expected.push_back(std::make_pair(4, 2));
3222   expected.push_back(std::make_pair(4, 1));
3223   expected.push_back(std::make_pair(4, 0));
3224   expected.push_back(std::make_pair(3, 0));
3225   expected.push_back(std::make_pair(2, 0));
3226   expected.push_back(std::make_pair(1, 0));
3227   expected.push_back(std::make_pair(0, 0));
3228   expected.push_back(std::make_pair(0, 1));
3229   expected.push_back(std::make_pair(0, 2));
3230   expected.push_back(std::make_pair(0, 3));
3231   expected.push_back(std::make_pair(0, 4));
3232
3233   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
3234
3235   // Three by two center.
3236   center = gfx::Rect(origin.x() + 15, origin.y() + 25, 20, 10);
3237
3238   // Layout of the tiling data, and expected return order:
3239   //   x 0 1 2 3 4
3240   //  y.----------
3241   //  0| J I H G F
3242   //  1| 7 6 5 4 3
3243   //  2| 8 * * * 2
3244   //  3| 9 * * * 1
3245   //  4| A B C D E
3246   expected.clear();
3247
3248   expected.push_back(std::make_pair(4, 3));
3249   expected.push_back(std::make_pair(4, 2));
3250   expected.push_back(std::make_pair(4, 1));
3251   expected.push_back(std::make_pair(3, 1));
3252   expected.push_back(std::make_pair(2, 1));
3253   expected.push_back(std::make_pair(1, 1));
3254   expected.push_back(std::make_pair(0, 1));
3255   expected.push_back(std::make_pair(0, 2));
3256   expected.push_back(std::make_pair(0, 3));
3257   expected.push_back(std::make_pair(0, 4));
3258   expected.push_back(std::make_pair(1, 4));
3259   expected.push_back(std::make_pair(2, 4));
3260   expected.push_back(std::make_pair(3, 4));
3261   expected.push_back(std::make_pair(4, 4));
3262   expected.push_back(std::make_pair(4, 0));
3263   expected.push_back(std::make_pair(3, 0));
3264   expected.push_back(std::make_pair(2, 0));
3265   expected.push_back(std::make_pair(1, 0));
3266   expected.push_back(std::make_pair(0, 0));
3267
3268   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
3269
3270   // Column center off the left side.
3271   center = gfx::Rect(origin.x() - 50, origin.y(), 30, 50);
3272
3273   // Layout of the tiling data, and expected return order:
3274   //    x 0 1 2 3 4
3275   //   y.----------
3276   // * 0| 5 A F K P
3277   // * 1| 4 9 E J O
3278   // * 2| 3 8 D I N
3279   // * 3| 2 7 C H M
3280   // * 4| 1 6 B G L
3281   expected.clear();
3282
3283   expected.push_back(std::make_pair(0, 4));
3284   expected.push_back(std::make_pair(0, 3));
3285   expected.push_back(std::make_pair(0, 2));
3286   expected.push_back(std::make_pair(0, 1));
3287   expected.push_back(std::make_pair(0, 0));
3288   expected.push_back(std::make_pair(1, 4));
3289   expected.push_back(std::make_pair(1, 3));
3290   expected.push_back(std::make_pair(1, 2));
3291   expected.push_back(std::make_pair(1, 1));
3292   expected.push_back(std::make_pair(1, 0));
3293   expected.push_back(std::make_pair(2, 4));
3294   expected.push_back(std::make_pair(2, 3));
3295   expected.push_back(std::make_pair(2, 2));
3296   expected.push_back(std::make_pair(2, 1));
3297   expected.push_back(std::make_pair(2, 0));
3298   expected.push_back(std::make_pair(3, 4));
3299   expected.push_back(std::make_pair(3, 3));
3300   expected.push_back(std::make_pair(3, 2));
3301   expected.push_back(std::make_pair(3, 1));
3302   expected.push_back(std::make_pair(3, 0));
3303   expected.push_back(std::make_pair(4, 4));
3304   expected.push_back(std::make_pair(4, 3));
3305   expected.push_back(std::make_pair(4, 2));
3306   expected.push_back(std::make_pair(4, 1));
3307   expected.push_back(std::make_pair(4, 0));
3308
3309   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
3310 }
3311
3312 TEST_P(TilingDataTest, SpiralDifferenceIteratorEdgeCases) {
3313   gfx::Point origin = GetParam();
3314   TilingData tiling_data(
3315       gfx::Size(10, 10), gfx::Rect(origin, gfx::Size(30, 30)), false);
3316   std::vector<std::pair<int, int> > expected;
3317   gfx::Rect center;
3318   gfx::Rect consider;
3319   gfx::Rect ignore;
3320
3321   // Ignore contains, but is not equal to, consider and center.
3322   ignore = gfx::Rect(origin.x() + 15, origin.y(), 20, 30);
3323   consider = gfx::Rect(origin.x() + 20, origin.y() + 10, 10, 20);
3324   center = gfx::Rect(origin.x() + 25, origin.y(), 5, 5);
3325
3326   // Layout of the tiling data, and expected return order:
3327   //   x 0 1 2
3328   //  y.------
3329   //  0|   . *
3330   //  1|   . .
3331   //  2|   . .
3332   expected.clear();
3333
3334   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
3335
3336   // Center intersects with consider.
3337   ignore = gfx::Rect();
3338   center = gfx::Rect(origin.x(), origin.y() + 15, 30, 15);
3339   consider = gfx::Rect(origin.x(), origin.y(), 15, 30);
3340
3341   // Layout of the tiling data, and expected return order:
3342   //   x 0 1 2
3343   //  y.------
3344   //  0| 2 1
3345   //  1| * * *
3346   //  2| * * *
3347   expected.clear();
3348
3349   expected.push_back(std::make_pair(1, 0));
3350   expected.push_back(std::make_pair(0, 0));
3351
3352   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
3353
3354   // Consider and ignore are non-intersecting.
3355   ignore = gfx::Rect(origin.x(), origin.y(), 5, 30);
3356   consider = gfx::Rect(origin.x() + 25, origin.y(), 5, 30);
3357   center = gfx::Rect(origin.x() + 15, origin.y(), 1, 1);
3358
3359   // Layout of the tiling data, and expected return order:
3360   //   x 0 1 2
3361   //  y.------
3362   //  0| . * 1
3363   //  1| .   2
3364   //  2| .   3
3365   expected.clear();
3366
3367   expected.push_back(std::make_pair(2, 0));
3368   expected.push_back(std::make_pair(2, 1));
3369   expected.push_back(std::make_pair(2, 2));
3370
3371   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
3372
3373   // Center intersects with ignore.
3374   consider = gfx::Rect(origin.x(), origin.y(), 30, 30);
3375   center = gfx::Rect(origin.x() + 15, origin.y(), 1, 30);
3376   ignore = gfx::Rect(origin.x(), origin.y() + 15, 30, 1);
3377
3378   // Layout of the tiling data, and expected return order:
3379   //   x 0 1 2
3380   //  y.------
3381   //  0| 3 * 2
3382   //  1| . * .
3383   //  2| 4 * 1
3384   expected.clear();
3385
3386   expected.push_back(std::make_pair(2, 2));
3387   expected.push_back(std::make_pair(2, 0));
3388   expected.push_back(std::make_pair(0, 0));
3389   expected.push_back(std::make_pair(0, 2));
3390
3391   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
3392
3393   // Center and ignore are the same.
3394   consider = gfx::Rect(origin.x(), origin.y(), 30, 30);
3395   center = gfx::Rect(origin.x() + 15, origin.y(), 1, 30);
3396   ignore = center;
3397
3398   // Layout of the tiling data, and expected return order:
3399   //   x 0 1 2
3400   //  y.------
3401   //  0| 4 * 3
3402   //  1| 5 * 2
3403   //  2| 6 * 1
3404   expected.clear();
3405
3406   expected.push_back(std::make_pair(2, 2));
3407   expected.push_back(std::make_pair(2, 1));
3408   expected.push_back(std::make_pair(2, 0));
3409   expected.push_back(std::make_pair(0, 0));
3410   expected.push_back(std::make_pair(0, 1));
3411   expected.push_back(std::make_pair(0, 2));
3412
3413   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
3414
3415   // Empty tiling data.
3416   TilingData empty_data(gfx::Size(0, 0), gfx::Rect(0, 0, 0, 0), false);
3417
3418   expected.clear();
3419   TestSpiralIterate(__LINE__, empty_data, consider, ignore, center, expected);
3420
3421   // Empty consider.
3422   ignore = gfx::Rect();
3423   center = gfx::Rect(1, 1, 1, 1);
3424   consider = gfx::Rect();
3425
3426   expected.clear();
3427   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
3428
3429   // Empty center. Note: This arbitrarily puts the center to be off the top-left
3430   // corner.
3431   consider = gfx::Rect(origin.x(), origin.y(), 30, 30);
3432   ignore = gfx::Rect();
3433   center = gfx::Rect();
3434
3435   // Layout of the tiling data, and expected return order:
3436   // * x 0 1 2
3437   //  y.------
3438   //  0| 1 2 6
3439   //  1| 3 4 5
3440   //  2| 7 8 9
3441   expected.clear();
3442
3443   expected.push_back(std::make_pair(0, 0));
3444   expected.push_back(std::make_pair(1, 0));
3445   expected.push_back(std::make_pair(0, 1));
3446   expected.push_back(std::make_pair(1, 1));
3447   expected.push_back(std::make_pair(2, 1));
3448   expected.push_back(std::make_pair(2, 0));
3449   expected.push_back(std::make_pair(0, 2));
3450   expected.push_back(std::make_pair(1, 2));
3451   expected.push_back(std::make_pair(2, 2));
3452
3453   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
3454
3455   // Every rect is empty.
3456   ignore = gfx::Rect();
3457   center = gfx::Rect();
3458   consider = gfx::Rect();
3459
3460   expected.clear();
3461   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
3462
3463   // Center is just to the left of cover, and off of the tiling's left side.
3464   consider = gfx::Rect(origin.x(), origin.y(), 30, 30);
3465   ignore = gfx::Rect();
3466   center = gfx::Rect(origin.x() - 20, origin.y(), 19, 30);
3467
3468   // Layout of the tiling data, and expected return order:
3469   //   x 0 1 2
3470   //  y.------
3471   // *0| 3 6 9
3472   // *1| 2 5 8
3473   // *2| 1 4 7
3474   expected.clear();
3475
3476   expected.push_back(std::make_pair(0, 2));
3477   expected.push_back(std::make_pair(0, 1));
3478   expected.push_back(std::make_pair(0, 0));
3479   expected.push_back(std::make_pair(1, 2));
3480   expected.push_back(std::make_pair(1, 1));
3481   expected.push_back(std::make_pair(1, 0));
3482   expected.push_back(std::make_pair(2, 2));
3483   expected.push_back(std::make_pair(2, 1));
3484   expected.push_back(std::make_pair(2, 0));
3485
3486   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
3487 }
3488
3489 INSTANTIATE_TEST_CASE_P(TilingData,
3490                         TilingDataTest,
3491                         ::testing::Values(gfx::Point(42, 17),
3492                                           gfx::Point(0, 0),
3493                                           gfx::Point(-8, 15),
3494                                           gfx::Point(-12, 4),
3495                                           gfx::Point(-16, -35),
3496                                           gfx::Point(-10000, -15000)));
3497 }  // namespace
3498
3499 }  // namespace cc