// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "cc/base/tiling_data.h"

#include <algorithm>
#include <vector>

#include "cc/test/geometry_test_utils.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace cc {
namespace {

int NumTiles(const gfx::Size& max_texture_size,
             const gfx::Rect& tiling_rect,
             bool has_border_texels) {
  TilingData tiling(max_texture_size, tiling_rect, has_border_texels);
  int num_tiles = tiling.num_tiles_x() * tiling.num_tiles_y();

  // Assert no overflow.
  EXPECT_GE(num_tiles, 0);
  if (num_tiles > 0)
    EXPECT_EQ(num_tiles / tiling.num_tiles_x(), tiling.num_tiles_y());

  return num_tiles;
}

int XIndex(const gfx::Size& max_texture_size,
           const gfx::Rect& tiling_rect,
           bool has_border_texels,
           int x_coord) {
  TilingData tiling(max_texture_size, tiling_rect, has_border_texels);
  return tiling.TileXIndexFromSrcCoord(x_coord);
}

int YIndex(const gfx::Size& max_texture_size,
           const gfx::Rect& tiling_rect,
           bool has_border_texels,
           int y_coord) {
  TilingData tiling(max_texture_size, tiling_rect, has_border_texels);
  return tiling.TileYIndexFromSrcCoord(y_coord);
}

int MinBorderXIndex(const gfx::Size& max_texture_size,
                    const gfx::Rect& tiling_rect,
                    bool has_border_texels,
                    int x_coord) {
  TilingData tiling(max_texture_size, tiling_rect, has_border_texels);
  return tiling.FirstBorderTileXIndexFromSrcCoord(x_coord);
}

int MinBorderYIndex(const gfx::Size& max_texture_size,
                    const gfx::Rect& tiling_rect,
                    bool has_border_texels,
                    int y_coord) {
  TilingData tiling(max_texture_size, tiling_rect, has_border_texels);
  return tiling.FirstBorderTileYIndexFromSrcCoord(y_coord);
}

int MaxBorderXIndex(const gfx::Size& max_texture_size,
                    const gfx::Rect& tiling_rect,
                    bool has_border_texels,
                    int x_coord) {
  TilingData tiling(max_texture_size, tiling_rect, has_border_texels);
  return tiling.LastBorderTileXIndexFromSrcCoord(x_coord);
}

int MaxBorderYIndex(const gfx::Size& max_texture_size,
                    const gfx::Rect& tiling_rect,
                    bool has_border_texels,
                    int y_coord) {
  TilingData tiling(max_texture_size, tiling_rect, has_border_texels);
  return tiling.LastBorderTileYIndexFromSrcCoord(y_coord);
}

int PosX(const gfx::Size& max_texture_size,
         const gfx::Rect& tiling_rect,
         bool has_border_texels,
         int x_index) {
  TilingData tiling(max_texture_size, tiling_rect, has_border_texels);
  return tiling.TilePositionX(x_index);
}

int PosY(const gfx::Size& max_texture_size,
         const gfx::Rect& tiling_rect,
         bool has_border_texels,
         int y_index) {
  TilingData tiling(max_texture_size, tiling_rect, has_border_texels);
  return tiling.TilePositionY(y_index);
}

int SizeX(const gfx::Size& max_texture_size,
          const gfx::Rect& tiling_rect,
          bool has_border_texels,
          int x_index) {
  TilingData tiling(max_texture_size, tiling_rect, has_border_texels);
  return tiling.TileSizeX(x_index);
}

int SizeY(const gfx::Size& max_texture_size,
          const gfx::Rect& tiling_rect,
          bool has_border_texels,
          int y_index) {
  TilingData tiling(max_texture_size, tiling_rect, has_border_texels);
  return tiling.TileSizeY(y_index);
}

class TilingDataTest : public ::testing::TestWithParam<gfx::Point> {};

TEST_P(TilingDataTest, NumTiles_NoTiling) {
  gfx::Point origin = GetParam();

  EXPECT_EQ(
      1,
      NumTiles(gfx::Size(16, 16), gfx::Rect(origin, gfx::Size(16, 16)), false));
  EXPECT_EQ(
      1,
      NumTiles(gfx::Size(16, 16), gfx::Rect(origin, gfx::Size(15, 15)), true));
  EXPECT_EQ(
      1,
      NumTiles(gfx::Size(16, 16), gfx::Rect(origin, gfx::Size(16, 16)), true));
  EXPECT_EQ(
      1,
      NumTiles(gfx::Size(16, 16), gfx::Rect(origin, gfx::Size(1, 16)), false));
  EXPECT_EQ(
      1,
      NumTiles(gfx::Size(15, 15), gfx::Rect(origin, gfx::Size(15, 15)), true));
  EXPECT_EQ(
      1,
      NumTiles(gfx::Size(32, 16), gfx::Rect(origin, gfx::Size(32, 16)), false));
  EXPECT_EQ(
      1,
      NumTiles(gfx::Size(32, 16), gfx::Rect(origin, gfx::Size(32, 16)), true));
}

TEST_P(TilingDataTest, NumTiles_TilingNoBorders) {
  gfx::Point origin = GetParam();

  EXPECT_EQ(
      0, NumTiles(gfx::Size(0, 0), gfx::Rect(origin, gfx::Size(0, 0)), false));
  EXPECT_EQ(
      0, NumTiles(gfx::Size(0, 0), gfx::Rect(origin, gfx::Size(4, 0)), false));
  EXPECT_EQ(
      0, NumTiles(gfx::Size(0, 0), gfx::Rect(origin, gfx::Size(0, 4)), false));
  EXPECT_EQ(
      0, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(4, 0)), false));
  EXPECT_EQ(
      0, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(0, 4)), false));
  EXPECT_EQ(
      0, NumTiles(gfx::Size(0, 0), gfx::Rect(origin, gfx::Size(1, 1)), false));

  EXPECT_EQ(
      1, NumTiles(gfx::Size(1, 1), gfx::Rect(origin, gfx::Size(1, 1)), false));
  EXPECT_EQ(
      2, NumTiles(gfx::Size(1, 1), gfx::Rect(origin, gfx::Size(1, 2)), false));
  EXPECT_EQ(
      2, NumTiles(gfx::Size(1, 1), gfx::Rect(origin, gfx::Size(2, 1)), false));
  EXPECT_EQ(
      1, NumTiles(gfx::Size(2, 2), gfx::Rect(origin, gfx::Size(1, 1)), false));
  EXPECT_EQ(
      1, NumTiles(gfx::Size(2, 2), gfx::Rect(origin, gfx::Size(1, 2)), false));
  EXPECT_EQ(
      1, NumTiles(gfx::Size(2, 2), gfx::Rect(origin, gfx::Size(2, 1)), false));
  EXPECT_EQ(
      1, NumTiles(gfx::Size(2, 2), gfx::Rect(origin, gfx::Size(2, 2)), false));
  EXPECT_EQ(
      1, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 3)), false));

  EXPECT_EQ(
      1, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(1, 4)), false));
  EXPECT_EQ(
      1, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(2, 4)), false));
  EXPECT_EQ(
      1, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(3, 4)), false));
  EXPECT_EQ(
      1, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(4, 4)), false));
  EXPECT_EQ(
      2, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(5, 4)), false));
  EXPECT_EQ(
      2, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(6, 4)), false));
  EXPECT_EQ(
      2, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(7, 4)), false));
  EXPECT_EQ(
      2, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(8, 4)), false));
  EXPECT_EQ(
      3, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(9, 4)), false));
  EXPECT_EQ(
      3, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(10, 4)), false));
  EXPECT_EQ(
      3, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(11, 4)), false));

  EXPECT_EQ(
      1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(1, 5)), false));
  EXPECT_EQ(
      1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(2, 5)), false));
  EXPECT_EQ(
      1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(3, 5)), false));
  EXPECT_EQ(
      1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(4, 5)), false));
  EXPECT_EQ(
      1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(5, 5)), false));
  EXPECT_EQ(
      2, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 5)), false));
  EXPECT_EQ(
      2, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(7, 5)), false));
  EXPECT_EQ(
      2, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 5)), false));
  EXPECT_EQ(
      2, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(9, 5)), false));
  EXPECT_EQ(
      2, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 5)), false));
  EXPECT_EQ(
      3, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(11, 5)), false));

  EXPECT_EQ(
      1,
      NumTiles(gfx::Size(16, 16), gfx::Rect(origin, gfx::Size(16, 16)), false));
  EXPECT_EQ(
      1,
      NumTiles(gfx::Size(17, 17), gfx::Rect(origin, gfx::Size(16, 16)), false));
  EXPECT_EQ(
      4,
      NumTiles(gfx::Size(15, 15), gfx::Rect(origin, gfx::Size(16, 16)), false));
  EXPECT_EQ(
      4,
      NumTiles(gfx::Size(8, 8), gfx::Rect(origin, gfx::Size(16, 16)), false));
  EXPECT_EQ(
      6,
      NumTiles(gfx::Size(8, 8), gfx::Rect(origin, gfx::Size(17, 16)), false));

  EXPECT_EQ(
      8,
      NumTiles(gfx::Size(5, 8), gfx::Rect(origin, gfx::Size(17, 16)), false));
}

TEST_P(TilingDataTest, NumTiles_TilingWithBorders) {
  gfx::Point origin = GetParam();

  EXPECT_EQ(
      0, NumTiles(gfx::Size(0, 0), gfx::Rect(origin, gfx::Size(0, 0)), true));
  EXPECT_EQ(
      0, NumTiles(gfx::Size(0, 0), gfx::Rect(origin, gfx::Size(4, 0)), true));
  EXPECT_EQ(
      0, NumTiles(gfx::Size(0, 0), gfx::Rect(origin, gfx::Size(0, 4)), true));
  EXPECT_EQ(
      0, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(4, 0)), true));
  EXPECT_EQ(
      0, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(0, 4)), true));
  EXPECT_EQ(
      0, NumTiles(gfx::Size(0, 0), gfx::Rect(origin, gfx::Size(1, 1)), true));

  EXPECT_EQ(
      1, NumTiles(gfx::Size(1, 1), gfx::Rect(origin, gfx::Size(1, 1)), true));
  EXPECT_EQ(
      0, NumTiles(gfx::Size(1, 1), gfx::Rect(origin, gfx::Size(1, 2)), true));
  EXPECT_EQ(
      0, NumTiles(gfx::Size(1, 1), gfx::Rect(origin, gfx::Size(2, 1)), true));
  EXPECT_EQ(
      1, NumTiles(gfx::Size(2, 2), gfx::Rect(origin, gfx::Size(1, 1)), true));
  EXPECT_EQ(
      1, NumTiles(gfx::Size(2, 2), gfx::Rect(origin, gfx::Size(1, 2)), true));
  EXPECT_EQ(
      1, NumTiles(gfx::Size(2, 2), gfx::Rect(origin, gfx::Size(2, 1)), true));
  EXPECT_EQ(
      1, NumTiles(gfx::Size(2, 2), gfx::Rect(origin, gfx::Size(2, 2)), true));

  EXPECT_EQ(
      1, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 3)), true));
  EXPECT_EQ(
      1, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(2, 3)), true));
  EXPECT_EQ(
      1, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 3)), true));
  EXPECT_EQ(
      2, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(4, 3)), true));
  EXPECT_EQ(
      3, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(5, 3)), true));
  EXPECT_EQ(
      4, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 3)), true));
  EXPECT_EQ(
      5, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(7, 3)), true));

  EXPECT_EQ(
      1, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(1, 4)), true));
  EXPECT_EQ(
      1, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(2, 4)), true));
  EXPECT_EQ(
      1, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(3, 4)), true));
  EXPECT_EQ(
      1, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(4, 4)), true));
  EXPECT_EQ(
      2, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(5, 4)), true));
  EXPECT_EQ(
      2, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(6, 4)), true));
  EXPECT_EQ(
      3, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(7, 4)), true));
  EXPECT_EQ(
      3, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(8, 4)), true));
  EXPECT_EQ(
      4, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(9, 4)), true));
  EXPECT_EQ(
      4, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(10, 4)), true));
  EXPECT_EQ(
      5, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(11, 4)), true));

  EXPECT_EQ(
      1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(1, 5)), true));
  EXPECT_EQ(
      1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(2, 5)), true));
  EXPECT_EQ(
      1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(3, 5)), true));
  EXPECT_EQ(
      1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(4, 5)), true));
  EXPECT_EQ(
      1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(5, 5)), true));
  EXPECT_EQ(
      2, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 5)), true));
  EXPECT_EQ(
      2, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(7, 5)), true));
  EXPECT_EQ(
      2, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 5)), true));
  EXPECT_EQ(
      3, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(9, 5)), true));
  EXPECT_EQ(
      3, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 5)), true));
  EXPECT_EQ(
      3, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(11, 5)), true));

  EXPECT_EQ(
      30,
      NumTiles(gfx::Size(8, 5), gfx::Rect(origin, gfx::Size(16, 32)), true));
}

TEST_P(TilingDataTest, TileXIndexFromSrcCoord) {
  gfx::Point origin = GetParam();

  EXPECT_EQ(0,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   false,
                   origin.x() + 0));
  EXPECT_EQ(0,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   false,
                   origin.x() + 1));
  EXPECT_EQ(0,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   false,
                   origin.x() + 2));
  EXPECT_EQ(1,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   false,
                   origin.x() + 3));
  EXPECT_EQ(1,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   false,
                   origin.x() + 4));
  EXPECT_EQ(1,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   false,
                   origin.x() + 5));
  EXPECT_EQ(2,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   false,
                   origin.x() + 6));
  EXPECT_EQ(2,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   false,
                   origin.x() + 7));
  EXPECT_EQ(2,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   false,
                   origin.x() + 8));
  EXPECT_EQ(3,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   false,
                   origin.x() + 9));
  EXPECT_EQ(3,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   false,
                   origin.x() + 10));
  EXPECT_EQ(3,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   false,
                   origin.x() + 11));

  EXPECT_EQ(0,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   true,
                   origin.x()));
  EXPECT_EQ(0,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   true,
                   origin.x() + 1));
  EXPECT_EQ(1,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   true,
                   origin.x() + 2));
  EXPECT_EQ(2,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   true,
                   origin.x() + 3));
  EXPECT_EQ(3,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   true,
                   origin.x() + 4));
  EXPECT_EQ(4,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   true,
                   origin.x() + 5));
  EXPECT_EQ(5,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   true,
                   origin.x() + 6));
  EXPECT_EQ(6,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   true,
                   origin.x() + 7));
  EXPECT_EQ(7,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   true,
                   origin.x() + 8));
  EXPECT_EQ(7,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   true,
                   origin.x() + 9));
  EXPECT_EQ(7,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   true,
                   origin.x() + 10));
  EXPECT_EQ(7,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   true,
                   origin.x() + 11));

  EXPECT_EQ(0,
            XIndex(gfx::Size(1, 1),
                   gfx::Rect(origin, gfx::Size(1, 1)),
                   false,
                   origin.x() + 0));
  EXPECT_EQ(0,
            XIndex(gfx::Size(2, 2),
                   gfx::Rect(origin, gfx::Size(2, 2)),
                   false,
                   origin.x() + 0));
  EXPECT_EQ(0,
            XIndex(gfx::Size(2, 2),
                   gfx::Rect(origin, gfx::Size(2, 2)),
                   false,
                   origin.x() + 1));
  EXPECT_EQ(0,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(3, 3)),
                   false,
                   origin.x() + 0));
  EXPECT_EQ(0,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(3, 3)),
                   false,
                   origin.x() + 1));
  EXPECT_EQ(0,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(3, 3)),
                   false,
                   origin.x() + 2));

  EXPECT_EQ(0,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(4, 3)),
                   false,
                   origin.x() + 0));
  EXPECT_EQ(0,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(4, 3)),
                   false,
                   origin.x() + 1));
  EXPECT_EQ(0,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(4, 3)),
                   false,
                   origin.x() + 2));
  EXPECT_EQ(1,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(4, 3)),
                   false,
                   origin.x() + 3));

  EXPECT_EQ(0,
            XIndex(gfx::Size(1, 1),
                   gfx::Rect(origin, gfx::Size(1, 1)),
                   true,
                   origin.x() + 0));
  EXPECT_EQ(0,
            XIndex(gfx::Size(2, 2),
                   gfx::Rect(origin, gfx::Size(2, 2)),
                   true,
                   origin.x() + 0));
  EXPECT_EQ(0,
            XIndex(gfx::Size(2, 2),
                   gfx::Rect(origin, gfx::Size(2, 2)),
                   true,
                   origin.x() + 1));
  EXPECT_EQ(0,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(3, 3)),
                   true,
                   origin.x() + 0));
  EXPECT_EQ(0,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(3, 3)),
                   true,
                   origin.x() + 1));
  EXPECT_EQ(0,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(3, 3)),
                   true,
                   origin.x() + 2));

  EXPECT_EQ(0,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(4, 3)),
                   true,
                   origin.x() + 0));
  EXPECT_EQ(0,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(4, 3)),
                   true,
                   origin.x() + 1));
  EXPECT_EQ(1,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(4, 3)),
                   true,
                   origin.x() + 2));
  EXPECT_EQ(1,
            XIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(4, 3)),
                   true,
                   origin.x() + 3));
}

TEST_P(TilingDataTest, FirstBorderTileXIndexFromSrcCoord) {
  gfx::Point origin = GetParam();

  EXPECT_EQ(0,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.x() + 0));
  EXPECT_EQ(0,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.x() + 1));
  EXPECT_EQ(0,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.x() + 2));
  EXPECT_EQ(1,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.x() + 3));
  EXPECT_EQ(1,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.x() + 4));
  EXPECT_EQ(1,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.x() + 5));
  EXPECT_EQ(2,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.x() + 6));
  EXPECT_EQ(2,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.x() + 7));
  EXPECT_EQ(2,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.x() + 8));
  EXPECT_EQ(3,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.x() + 9));
  EXPECT_EQ(3,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.x() + 10));
  EXPECT_EQ(3,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.x() + 11));

  EXPECT_EQ(0,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.x() + 0));
  EXPECT_EQ(0,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.x() + 1));
  EXPECT_EQ(0,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.x() + 2));
  EXPECT_EQ(1,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.x() + 3));
  EXPECT_EQ(2,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.x() + 4));
  EXPECT_EQ(3,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.x() + 5));
  EXPECT_EQ(4,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.x() + 6));
  EXPECT_EQ(5,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.x() + 7));
  EXPECT_EQ(6,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.x() + 8));
  EXPECT_EQ(7,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.x() + 9));
  EXPECT_EQ(7,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.x() + 10));
  EXPECT_EQ(7,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.x() + 11));

  EXPECT_EQ(0,
            MinBorderXIndex(gfx::Size(1, 1),
                            gfx::Rect(origin, gfx::Size(1, 1)),
                            false,
                            origin.x() + 0));
  EXPECT_EQ(0,
            MinBorderXIndex(gfx::Size(2, 2),
                            gfx::Rect(origin, gfx::Size(2, 2)),
                            false,
                            origin.x() + 0));
  EXPECT_EQ(0,
            MinBorderXIndex(gfx::Size(2, 2),
                            gfx::Rect(origin, gfx::Size(2, 2)),
                            false,
                            origin.x() + 1));
  EXPECT_EQ(0,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 3)),
                            false,
                            origin.x() + 0));
  EXPECT_EQ(0,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 3)),
                            false,
                            origin.x() + 1));
  EXPECT_EQ(0,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 3)),
                            false,
                            origin.x() + 2));

  EXPECT_EQ(0,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(4, 3)),
                            false,
                            origin.x() + 0));
  EXPECT_EQ(0,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(4, 3)),
                            false,
                            origin.x() + 1));
  EXPECT_EQ(0,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(4, 3)),
                            false,
                            origin.x() + 2));
  EXPECT_EQ(1,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(4, 3)),
                            false,
                            origin.x() + 3));

  EXPECT_EQ(0,
            MinBorderXIndex(gfx::Size(1, 1),
                            gfx::Rect(origin, gfx::Size(1, 1)),
                            true,
                            origin.x() + 0));
  EXPECT_EQ(0,
            MinBorderXIndex(gfx::Size(2, 2),
                            gfx::Rect(origin, gfx::Size(2, 2)),
                            true,
                            origin.x() + 0));
  EXPECT_EQ(0,
            MinBorderXIndex(gfx::Size(2, 2),
                            gfx::Rect(origin, gfx::Size(2, 2)),
                            true,
                            origin.x() + 1));
  EXPECT_EQ(0,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 3)),
                            true,
                            origin.x() + 0));
  EXPECT_EQ(0,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 3)),
                            true,
                            origin.x() + 1));
  EXPECT_EQ(0,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 3)),
                            true,
                            origin.x() + 2));

  EXPECT_EQ(0,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(4, 3)),
                            true,
                            origin.x() + 0));
  EXPECT_EQ(0,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(4, 3)),
                            true,
                            origin.x() + 1));
  EXPECT_EQ(0,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(4, 3)),
                            true,
                            origin.x() + 2));
  EXPECT_EQ(1,
            MinBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(4, 3)),
                            true,
                            origin.x() + 3));
}

TEST_P(TilingDataTest, LastBorderTileXIndexFromSrcCoord) {
  gfx::Point origin = GetParam();

  EXPECT_EQ(0,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.x() + 0));
  EXPECT_EQ(0,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.x() + 1));
  EXPECT_EQ(0,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.x() + 2));
  EXPECT_EQ(1,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.x() + 3));
  EXPECT_EQ(1,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.x() + 4));
  EXPECT_EQ(1,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.x() + 5));
  EXPECT_EQ(2,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.x() + 6));
  EXPECT_EQ(2,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.x() + 7));
  EXPECT_EQ(2,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.x() + 8));
  EXPECT_EQ(3,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.x() + 9));
  EXPECT_EQ(3,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.x() + 10));
  EXPECT_EQ(3,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.x() + 11));

  EXPECT_EQ(0,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.x() + 0));
  EXPECT_EQ(1,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.x() + 1));
  EXPECT_EQ(2,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.x() + 2));
  EXPECT_EQ(3,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.x() + 3));
  EXPECT_EQ(4,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.x() + 4));
  EXPECT_EQ(5,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.x() + 5));
  EXPECT_EQ(6,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.x() + 6));
  EXPECT_EQ(7,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.x() + 7));
  EXPECT_EQ(7,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.x() + 8));
  EXPECT_EQ(7,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.x() + 9));
  EXPECT_EQ(7,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.x() + 10));
  EXPECT_EQ(7,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.x() + 11));

  EXPECT_EQ(0,
            MaxBorderXIndex(gfx::Size(1, 1),
                            gfx::Rect(origin, gfx::Size(1, 1)),
                            false,
                            origin.x() + 0));
  EXPECT_EQ(0,
            MaxBorderXIndex(gfx::Size(2, 2),
                            gfx::Rect(origin, gfx::Size(2, 2)),
                            false,
                            origin.x() + 0));
  EXPECT_EQ(0,
            MaxBorderXIndex(gfx::Size(2, 2),
                            gfx::Rect(origin, gfx::Size(2, 2)),
                            false,
                            origin.x() + 1));
  EXPECT_EQ(0,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 3)),
                            false,
                            origin.x() + 0));
  EXPECT_EQ(0,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 3)),
                            false,
                            origin.x() + 1));
  EXPECT_EQ(0,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 3)),
                            false,
                            origin.x() + 2));

  EXPECT_EQ(0,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(4, 3)),
                            false,
                            origin.x() + 0));
  EXPECT_EQ(0,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(4, 3)),
                            false,
                            origin.x() + 1));
  EXPECT_EQ(0,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(4, 3)),
                            false,
                            origin.x() + 2));
  EXPECT_EQ(1,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(4, 3)),
                            false,
                            origin.x() + 3));

  EXPECT_EQ(0,
            MaxBorderXIndex(gfx::Size(1, 1),
                            gfx::Rect(origin, gfx::Size(1, 1)),
                            true,
                            origin.x() + 0));
  EXPECT_EQ(0,
            MaxBorderXIndex(gfx::Size(2, 2),
                            gfx::Rect(origin, gfx::Size(2, 2)),
                            true,
                            origin.x() + 0));
  EXPECT_EQ(0,
            MaxBorderXIndex(gfx::Size(2, 2),
                            gfx::Rect(origin, gfx::Size(2, 2)),
                            true,
                            origin.x() + 1));
  EXPECT_EQ(0,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 3)),
                            true,
                            origin.x() + 0));
  EXPECT_EQ(0,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 3)),
                            true,
                            origin.x() + 1));
  EXPECT_EQ(0,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 3)),
                            true,
                            origin.x() + 2));

  EXPECT_EQ(0,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(4, 3)),
                            true,
                            origin.x() + 0));
  EXPECT_EQ(1,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(4, 3)),
                            true,
                            origin.x() + 1));
  EXPECT_EQ(1,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(4, 3)),
                            true,
                            origin.x() + 2));
  EXPECT_EQ(1,
            MaxBorderXIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(4, 3)),
                            true,
                            origin.x() + 3));
}

TEST_P(TilingDataTest, TileYIndexFromSrcCoord) {
  gfx::Point origin = GetParam();

  EXPECT_EQ(0,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   false,
                   origin.y() + 0));
  EXPECT_EQ(0,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   false,
                   origin.y() + 1));
  EXPECT_EQ(0,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   false,
                   origin.y() + 2));
  EXPECT_EQ(1,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   false,
                   origin.y() + 3));
  EXPECT_EQ(1,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   false,
                   origin.y() + 4));
  EXPECT_EQ(1,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   false,
                   origin.y() + 5));
  EXPECT_EQ(2,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   false,
                   origin.y() + 6));
  EXPECT_EQ(2,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   false,
                   origin.y() + 7));
  EXPECT_EQ(2,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   false,
                   origin.y() + 8));
  EXPECT_EQ(3,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   false,
                   origin.y() + 9));
  EXPECT_EQ(3,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   false,
                   origin.y() + 10));
  EXPECT_EQ(3,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   false,
                   origin.y() + 11));

  EXPECT_EQ(0,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   true,
                   origin.y() + 0));
  EXPECT_EQ(0,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   true,
                   origin.y() + 1));
  EXPECT_EQ(1,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   true,
                   origin.y() + 2));
  EXPECT_EQ(2,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   true,
                   origin.y() + 3));
  EXPECT_EQ(3,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   true,
                   origin.y() + 4));
  EXPECT_EQ(4,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   true,
                   origin.y() + 5));
  EXPECT_EQ(5,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   true,
                   origin.y() + 6));
  EXPECT_EQ(6,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   true,
                   origin.y() + 7));
  EXPECT_EQ(7,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   true,
                   origin.y() + 8));
  EXPECT_EQ(7,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   true,
                   origin.y() + 9));
  EXPECT_EQ(7,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   true,
                   origin.y() + 10));
  EXPECT_EQ(7,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(10, 10)),
                   true,
                   origin.y() + 11));

  EXPECT_EQ(0,
            YIndex(gfx::Size(1, 1),
                   gfx::Rect(origin, gfx::Size(1, 1)),
                   false,
                   origin.y() + 0));
  EXPECT_EQ(0,
            YIndex(gfx::Size(2, 2),
                   gfx::Rect(origin, gfx::Size(2, 2)),
                   false,
                   origin.y() + 0));
  EXPECT_EQ(0,
            YIndex(gfx::Size(2, 2),
                   gfx::Rect(origin, gfx::Size(2, 2)),
                   false,
                   origin.y() + 1));
  EXPECT_EQ(0,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(3, 3)),
                   false,
                   origin.y() + 0));
  EXPECT_EQ(0,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(3, 3)),
                   false,
                   origin.y() + 1));
  EXPECT_EQ(0,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(3, 3)),
                   false,
                   origin.y() + 2));

  EXPECT_EQ(0,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(3, 4)),
                   false,
                   origin.y() + 0));
  EXPECT_EQ(0,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(3, 4)),
                   false,
                   origin.y() + 1));
  EXPECT_EQ(0,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(3, 4)),
                   false,
                   origin.y() + 2));
  EXPECT_EQ(1,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(3, 4)),
                   false,
                   origin.y() + 3));

  EXPECT_EQ(0,
            YIndex(gfx::Size(1, 1),
                   gfx::Rect(origin, gfx::Size(1, 1)),
                   true,
                   origin.y() + 0));
  EXPECT_EQ(0,
            YIndex(gfx::Size(2, 2),
                   gfx::Rect(origin, gfx::Size(2, 2)),
                   true,
                   origin.y() + 0));
  EXPECT_EQ(0,
            YIndex(gfx::Size(2, 2),
                   gfx::Rect(origin, gfx::Size(2, 2)),
                   true,
                   origin.y() + 1));
  EXPECT_EQ(0,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(3, 3)),
                   true,
                   origin.y() + 0));
  EXPECT_EQ(0,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(3, 3)),
                   true,
                   origin.y() + 1));
  EXPECT_EQ(0,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(3, 3)),
                   true,
                   origin.y() + 2));

  EXPECT_EQ(0,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(3, 4)),
                   true,
                   origin.y() + 0));
  EXPECT_EQ(0,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(3, 4)),
                   true,
                   origin.y() + 1));
  EXPECT_EQ(1,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(3, 4)),
                   true,
                   origin.y() + 2));
  EXPECT_EQ(1,
            YIndex(gfx::Size(3, 3),
                   gfx::Rect(origin, gfx::Size(3, 4)),
                   true,
                   origin.y() + 3));
}

TEST_P(TilingDataTest, FirstBorderTileYIndexFromSrcCoord) {
  gfx::Point origin = GetParam();

  EXPECT_EQ(0,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.y() + 0));
  EXPECT_EQ(0,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.y() + 1));
  EXPECT_EQ(0,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.y() + 2));
  EXPECT_EQ(1,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.y() + 3));
  EXPECT_EQ(1,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.y() + 4));
  EXPECT_EQ(1,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.y() + 5));
  EXPECT_EQ(2,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.y() + 6));
  EXPECT_EQ(2,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.y() + 7));
  EXPECT_EQ(2,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.y() + 8));
  EXPECT_EQ(3,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.y() + 9));
  EXPECT_EQ(3,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.y() + 10));
  EXPECT_EQ(3,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.y() + 11));

  EXPECT_EQ(0,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.y() + 0));
  EXPECT_EQ(0,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.y() + 1));
  EXPECT_EQ(0,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.y() + 2));
  EXPECT_EQ(1,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.y() + 3));
  EXPECT_EQ(2,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.y() + 4));
  EXPECT_EQ(3,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.y() + 5));
  EXPECT_EQ(4,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.y() + 6));
  EXPECT_EQ(5,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.y() + 7));
  EXPECT_EQ(6,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.y() + 8));
  EXPECT_EQ(7,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.y() + 9));
  EXPECT_EQ(7,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.y() + 10));
  EXPECT_EQ(7,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.y() + 11));

  EXPECT_EQ(0,
            MinBorderYIndex(gfx::Size(1, 1),
                            gfx::Rect(origin, gfx::Size(1, 1)),
                            false,
                            origin.y() + 0));
  EXPECT_EQ(0,
            MinBorderYIndex(gfx::Size(2, 2),
                            gfx::Rect(origin, gfx::Size(2, 2)),
                            false,
                            origin.y() + 0));
  EXPECT_EQ(0,
            MinBorderYIndex(gfx::Size(2, 2),
                            gfx::Rect(origin, gfx::Size(2, 2)),
                            false,
                            origin.y() + 1));
  EXPECT_EQ(0,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 3)),
                            false,
                            origin.y() + 0));
  EXPECT_EQ(0,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 3)),
                            false,
                            origin.y() + 1));
  EXPECT_EQ(0,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 3)),
                            false,
                            origin.y() + 2));

  EXPECT_EQ(0,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 4)),
                            false,
                            origin.y() + 0));
  EXPECT_EQ(0,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 4)),
                            false,
                            origin.y() + 1));
  EXPECT_EQ(0,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 4)),
                            false,
                            origin.y() + 2));
  EXPECT_EQ(1,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 4)),
                            false,
                            origin.y() + 3));

  EXPECT_EQ(0,
            MinBorderYIndex(gfx::Size(1, 1),
                            gfx::Rect(origin, gfx::Size(1, 1)),
                            true,
                            origin.y() + 0));
  EXPECT_EQ(0,
            MinBorderYIndex(gfx::Size(2, 2),
                            gfx::Rect(origin, gfx::Size(2, 2)),
                            true,
                            origin.y() + 0));
  EXPECT_EQ(0,
            MinBorderYIndex(gfx::Size(2, 2),
                            gfx::Rect(origin, gfx::Size(2, 2)),
                            true,
                            origin.y() + 1));
  EXPECT_EQ(0,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 3)),
                            true,
                            origin.y() + 0));
  EXPECT_EQ(0,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 3)),
                            true,
                            origin.y() + 1));
  EXPECT_EQ(0,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 3)),
                            true,
                            origin.y() + 2));

  EXPECT_EQ(0,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 4)),
                            true,
                            origin.y() + 0));
  EXPECT_EQ(0,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 4)),
                            true,
                            origin.y() + 1));
  EXPECT_EQ(0,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 4)),
                            true,
                            origin.y() + 2));
  EXPECT_EQ(1,
            MinBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 4)),
                            true,
                            origin.y() + 3));
}

TEST_P(TilingDataTest, LastBorderTileYIndexFromSrcCoord) {
  gfx::Point origin = GetParam();

  EXPECT_EQ(0,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.y() + 0));
  EXPECT_EQ(0,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.y() + 1));
  EXPECT_EQ(0,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.y() + 2));
  EXPECT_EQ(1,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.y() + 3));
  EXPECT_EQ(1,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.y() + 4));
  EXPECT_EQ(1,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.y() + 5));
  EXPECT_EQ(2,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.y() + 6));
  EXPECT_EQ(2,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.y() + 7));
  EXPECT_EQ(2,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.y() + 8));
  EXPECT_EQ(3,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.y() + 9));
  EXPECT_EQ(3,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.y() + 10));
  EXPECT_EQ(3,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            false,
                            origin.y() + 11));

  EXPECT_EQ(0,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.y() + 0));
  EXPECT_EQ(1,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.y() + 1));
  EXPECT_EQ(2,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.y() + 2));
  EXPECT_EQ(3,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.y() + 3));
  EXPECT_EQ(4,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.y() + 4));
  EXPECT_EQ(5,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.y() + 5));
  EXPECT_EQ(6,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.y() + 6));
  EXPECT_EQ(7,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.y() + 7));
  EXPECT_EQ(7,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.y() + 8));
  EXPECT_EQ(7,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.y() + 9));
  EXPECT_EQ(7,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.y() + 10));
  EXPECT_EQ(7,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(10, 10)),
                            true,
                            origin.y() + 11));

  EXPECT_EQ(0,
            MaxBorderYIndex(gfx::Size(1, 1),
                            gfx::Rect(origin, gfx::Size(1, 1)),
                            false,
                            origin.y() + 0));
  EXPECT_EQ(0,
            MaxBorderYIndex(gfx::Size(2, 2),
                            gfx::Rect(origin, gfx::Size(2, 2)),
                            false,
                            origin.y() + 0));
  EXPECT_EQ(0,
            MaxBorderYIndex(gfx::Size(2, 2),
                            gfx::Rect(origin, gfx::Size(2, 2)),
                            false,
                            origin.y() + 1));
  EXPECT_EQ(0,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 3)),
                            false,
                            origin.y() + 0));
  EXPECT_EQ(0,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 3)),
                            false,
                            origin.y() + 1));
  EXPECT_EQ(0,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 3)),
                            false,
                            origin.y() + 2));

  EXPECT_EQ(0,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 4)),
                            false,
                            origin.y() + 0));
  EXPECT_EQ(0,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 4)),
                            false,
                            origin.y() + 1));
  EXPECT_EQ(0,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 4)),
                            false,
                            origin.y() + 2));
  EXPECT_EQ(1,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 4)),
                            false,
                            origin.y() + 3));

  EXPECT_EQ(0,
            MaxBorderYIndex(gfx::Size(1, 1),
                            gfx::Rect(origin, gfx::Size(1, 1)),
                            true,
                            origin.y() + 0));
  EXPECT_EQ(0,
            MaxBorderYIndex(gfx::Size(2, 2),
                            gfx::Rect(origin, gfx::Size(2, 2)),
                            true,
                            origin.y() + 0));
  EXPECT_EQ(0,
            MaxBorderYIndex(gfx::Size(2, 2),
                            gfx::Rect(origin, gfx::Size(2, 2)),
                            true,
                            origin.y() + 1));
  EXPECT_EQ(0,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 3)),
                            true,
                            origin.y() + 0));
  EXPECT_EQ(0,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 3)),
                            true,
                            origin.y() + 1));
  EXPECT_EQ(0,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 3)),
                            true,
                            origin.y() + 2));

  EXPECT_EQ(0,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 4)),
                            true,
                            origin.y() + 0));
  EXPECT_EQ(1,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 4)),
                            true,
                            origin.y() + 1));
  EXPECT_EQ(1,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 4)),
                            true,
                            origin.y() + 2));
  EXPECT_EQ(1,
            MaxBorderYIndex(gfx::Size(3, 3),
                            gfx::Rect(origin, gfx::Size(3, 4)),
                            true,
                            origin.y() + 3));
}

TEST_P(TilingDataTest, TileSizeX) {
  gfx::Point origin = GetParam();

  EXPECT_EQ(
      5, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(5, 5)), false, 0));
  EXPECT_EQ(
      5, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(5, 5)), true, 0));

  EXPECT_EQ(
      5, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 6)), false, 0));
  EXPECT_EQ(
      1, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 6)), false, 1));
  EXPECT_EQ(
      4, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 6)), true, 0));
  EXPECT_EQ(
      2, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 6)), true, 1));

  EXPECT_EQ(
      5, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 8)), false, 0));
  EXPECT_EQ(
      3, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 8)), false, 1));
  EXPECT_EQ(
      4, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 8)), true, 0));
  EXPECT_EQ(
      4, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 8)), true, 1));

  EXPECT_EQ(
      5,
      SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), false, 0));
  EXPECT_EQ(
      5,
      SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), false, 1));
  EXPECT_EQ(
      4, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), true, 0));
  EXPECT_EQ(
      3, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), true, 1));
  EXPECT_EQ(
      3, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), true, 2));

  EXPECT_EQ(
      4, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(11, 11)), true, 2));
  EXPECT_EQ(
      3, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(12, 12)), true, 2));

  EXPECT_EQ(
      3, SizeX(gfx::Size(5, 9), gfx::Rect(origin, gfx::Size(12, 17)), true, 2));
}

TEST_P(TilingDataTest, TileSizeY) {
  gfx::Point origin = GetParam();

  EXPECT_EQ(
      5, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(5, 5)), false, 0));
  EXPECT_EQ(
      5, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(5, 5)), true, 0));

  EXPECT_EQ(
      5, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 6)), false, 0));
  EXPECT_EQ(
      1, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 6)), false, 1));
  EXPECT_EQ(
      4, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 6)), true, 0));
  EXPECT_EQ(
      2, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 6)), true, 1));

  EXPECT_EQ(
      5, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 8)), false, 0));
  EXPECT_EQ(
      3, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 8)), false, 1));
  EXPECT_EQ(
      4, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 8)), true, 0));
  EXPECT_EQ(
      4, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 8)), true, 1));

  EXPECT_EQ(
      5,
      SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), false, 0));
  EXPECT_EQ(
      5,
      SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), false, 1));
  EXPECT_EQ(
      4, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), true, 0));
  EXPECT_EQ(
      3, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), true, 1));
  EXPECT_EQ(
      3, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), true, 2));

  EXPECT_EQ(
      4, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(11, 11)), true, 2));
  EXPECT_EQ(
      3, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(12, 12)), true, 2));

  EXPECT_EQ(
      3, SizeY(gfx::Size(9, 5), gfx::Rect(origin, gfx::Size(17, 12)), true, 2));
}

TEST_P(TilingDataTest, TileSizeX_and_TilePositionX) {
  gfx::Point origin = GetParam();

  // Single tile cases:
  EXPECT_EQ(
      1, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 1)), false, 0));
  EXPECT_EQ(
      origin.x(),
      PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 1)), false, 0));
  EXPECT_EQ(
      1,
      SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 100)), false, 0));
  EXPECT_EQ(
      origin.x(),
      PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 100)), false, 0));
  EXPECT_EQ(
      3, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 1)), false, 0));
  EXPECT_EQ(
      origin.x(),
      PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 1)), false, 0));
  EXPECT_EQ(
      3,
      SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 100)), false, 0));
  EXPECT_EQ(
      origin.x(),
      PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 100)), false, 0));
  EXPECT_EQ(
      1, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 1)), true, 0));
  EXPECT_EQ(origin.x(),
            PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 1)), true, 0));
  EXPECT_EQ(
      1, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 100)), true, 0));
  EXPECT_EQ(
      origin.x(),
      PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 100)), true, 0));
  EXPECT_EQ(
      3, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 1)), true, 0));
  EXPECT_EQ(origin.x(),
            PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 1)), true, 0));
  EXPECT_EQ(
      3, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 100)), true, 0));
  EXPECT_EQ(
      origin.x(),
      PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 100)), true, 0));

  // Multiple tiles:
  // no border
  // positions 0, 3
  EXPECT_EQ(
      2, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), false));
  EXPECT_EQ(
      3, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), false, 0));
  EXPECT_EQ(
      3, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), false, 1));
  EXPECT_EQ(
      origin.x() + 0,
      PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), false, 0));
  EXPECT_EQ(
      origin.x() + 3,
      PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), false, 1));
  EXPECT_EQ(
      3,
      SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 100)), false, 0));
  EXPECT_EQ(
      3,
      SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 100)), false, 1));
  EXPECT_EQ(
      origin.x() + 0,
      PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 100)), false, 0));
  EXPECT_EQ(
      origin.x() + 3,
      PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 100)), false, 1));

  // Multiple tiles:
  // with border
  // positions 0, 2, 3, 4
  EXPECT_EQ(
      4, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), true));
  EXPECT_EQ(
      2, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), true, 0));
  EXPECT_EQ(
      1, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), true, 1));
  EXPECT_EQ(
      1, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), true, 2));
  EXPECT_EQ(
      2, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), true, 3));
  EXPECT_EQ(origin.x() + 0,
            PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), true, 0));
  EXPECT_EQ(origin.x() + 2,
            PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), true, 1));
  EXPECT_EQ(origin.x() + 3,
            PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), true, 2));
  EXPECT_EQ(origin.x() + 4,
            PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), true, 3));
  EXPECT_EQ(
      2, SizeX(gfx::Size(3, 7), gfx::Rect(origin, gfx::Size(6, 100)), true, 0));
  EXPECT_EQ(
      1, SizeX(gfx::Size(3, 7), gfx::Rect(origin, gfx::Size(6, 100)), true, 1));
  EXPECT_EQ(
      1, SizeX(gfx::Size(3, 7), gfx::Rect(origin, gfx::Size(6, 100)), true, 2));
  EXPECT_EQ(
      2, SizeX(gfx::Size(3, 7), gfx::Rect(origin, gfx::Size(6, 100)), true, 3));
  EXPECT_EQ(
      origin.x() + 0,
      PosX(gfx::Size(3, 7), gfx::Rect(origin, gfx::Size(6, 100)), true, 0));
  EXPECT_EQ(
      origin.x() + 2,
      PosX(gfx::Size(3, 7), gfx::Rect(origin, gfx::Size(6, 100)), true, 1));
  EXPECT_EQ(
      origin.x() + 3,
      PosX(gfx::Size(3, 7), gfx::Rect(origin, gfx::Size(6, 100)), true, 2));
  EXPECT_EQ(
      origin.x() + 4,
      PosX(gfx::Size(3, 7), gfx::Rect(origin, gfx::Size(6, 100)), true, 3));
}

TEST_P(TilingDataTest, TileSizeY_and_TilePositionY) {
  gfx::Point origin = GetParam();

  // Single tile cases:
  EXPECT_EQ(
      1, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 1)), false, 0));
  EXPECT_EQ(
      origin.y(),
      PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 1)), false, 0));
  EXPECT_EQ(
      1,
      SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 1)), false, 0));
  EXPECT_EQ(
      origin.y(),
      PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 1)), false, 0));
  EXPECT_EQ(
      3, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 3)), false, 0));
  EXPECT_EQ(
      origin.y(),
      PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 3)), false, 0));
  EXPECT_EQ(
      3,
      SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 3)), false, 0));
  EXPECT_EQ(
      origin.y(),
      PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 3)), false, 0));
  EXPECT_EQ(
      1, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 1)), true, 0));
  EXPECT_EQ(origin.y(),
            PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 1)), true, 0));
  EXPECT_EQ(
      1, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 1)), true, 0));
  EXPECT_EQ(
      origin.y(),
      PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 1)), true, 0));
  EXPECT_EQ(
      3, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 3)), true, 0));
  EXPECT_EQ(origin.y(),
            PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 3)), true, 0));
  EXPECT_EQ(
      3, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 3)), true, 0));
  EXPECT_EQ(
      origin.y(),
      PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 3)), true, 0));

  // Multiple tiles:
  // no border
  // positions 0, 3
  EXPECT_EQ(
      2, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), false));
  EXPECT_EQ(
      3, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), false, 0));
  EXPECT_EQ(
      3, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), false, 1));
  EXPECT_EQ(
      origin.y() + 0,
      PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), false, 0));
  EXPECT_EQ(
      origin.y() + 3,
      PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), false, 1));
  EXPECT_EQ(
      3,
      SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 6)), false, 0));
  EXPECT_EQ(
      3,
      SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 6)), false, 1));
  EXPECT_EQ(
      origin.y() + 0,
      PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 6)), false, 0));
  EXPECT_EQ(
      origin.y() + 3,
      PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 6)), false, 1));

  // Multiple tiles:
  // with border
  // positions 0, 2, 3, 4
  EXPECT_EQ(
      4, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), true));
  EXPECT_EQ(
      2, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), true, 0));
  EXPECT_EQ(
      1, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), true, 1));
  EXPECT_EQ(
      1, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), true, 2));
  EXPECT_EQ(
      2, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), true, 3));
  EXPECT_EQ(origin.y() + 0,
            PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), true, 0));
  EXPECT_EQ(origin.y() + 2,
            PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), true, 1));
  EXPECT_EQ(origin.y() + 3,
            PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), true, 2));
  EXPECT_EQ(origin.y() + 4,
            PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), true, 3));
  EXPECT_EQ(
      2, SizeY(gfx::Size(7, 3), gfx::Rect(origin, gfx::Size(100, 6)), true, 0));
  EXPECT_EQ(
      1, SizeY(gfx::Size(7, 3), gfx::Rect(origin, gfx::Size(100, 6)), true, 1));
  EXPECT_EQ(
      1, SizeY(gfx::Size(7, 3), gfx::Rect(origin, gfx::Size(100, 6)), true, 2));
  EXPECT_EQ(
      2, SizeY(gfx::Size(7, 3), gfx::Rect(origin, gfx::Size(100, 6)), true, 3));
  EXPECT_EQ(
      origin.y() + 0,
      PosY(gfx::Size(7, 3), gfx::Rect(origin, gfx::Size(100, 6)), true, 0));
  EXPECT_EQ(
      origin.y() + 2,
      PosY(gfx::Size(7, 3), gfx::Rect(origin, gfx::Size(100, 6)), true, 1));
  EXPECT_EQ(
      origin.y() + 3,
      PosY(gfx::Size(7, 3), gfx::Rect(origin, gfx::Size(100, 6)), true, 2));
  EXPECT_EQ(
      origin.y() + 4,
      PosY(gfx::Size(7, 3), gfx::Rect(origin, gfx::Size(100, 6)), true, 3));
}

TEST_P(TilingDataTest, SetTotalSize) {
  gfx::Point origin = GetParam();

  TilingData data(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(5, 5)), false);
  EXPECT_EQ(origin.x(), data.tiling_rect().x());
  EXPECT_EQ(origin.y(), data.tiling_rect().y());
  EXPECT_EQ(5, data.tiling_rect().width());
  EXPECT_EQ(5, data.tiling_rect().height());
  EXPECT_EQ(1, data.num_tiles_x());
  EXPECT_EQ(5, data.TileSizeX(0));
  EXPECT_EQ(1, data.num_tiles_y());
  EXPECT_EQ(5, data.TileSizeY(0));

  data.SetTilingRect(gfx::Rect(36, 82, 6, 5));
  EXPECT_EQ(36, data.tiling_rect().x());
  EXPECT_EQ(82, data.tiling_rect().y());
  EXPECT_EQ(6, data.tiling_rect().width());
  EXPECT_EQ(5, data.tiling_rect().height());
  EXPECT_EQ(2, data.num_tiles_x());
  EXPECT_EQ(5, data.TileSizeX(0));
  EXPECT_EQ(1, data.TileSizeX(1));
  EXPECT_EQ(1, data.num_tiles_y());
  EXPECT_EQ(5, data.TileSizeY(0));

  data.SetTilingRect(gfx::Rect(4, 22, 5, 12));
  EXPECT_EQ(4, data.tiling_rect().x());
  EXPECT_EQ(22, data.tiling_rect().y());
  EXPECT_EQ(5, data.tiling_rect().width());
  EXPECT_EQ(12, data.tiling_rect().height());
  EXPECT_EQ(1, data.num_tiles_x());
  EXPECT_EQ(5, data.TileSizeX(0));
  EXPECT_EQ(3, data.num_tiles_y());
  EXPECT_EQ(5, data.TileSizeY(0));
  EXPECT_EQ(5, data.TileSizeY(1));
  EXPECT_EQ(2, data.TileSizeY(2));
}

TEST_P(TilingDataTest, SetMaxTextureSizeNoBorders) {
  gfx::Point origin = GetParam();

  TilingData data(gfx::Size(8, 8), gfx::Rect(origin, gfx::Size(16, 32)), false);
  EXPECT_EQ(2, data.num_tiles_x());
  EXPECT_EQ(4, data.num_tiles_y());

  data.SetMaxTextureSize(gfx::Size(32, 32));
  EXPECT_EQ(gfx::Size(32, 32), data.max_texture_size());
  EXPECT_EQ(1, data.num_tiles_x());
  EXPECT_EQ(1, data.num_tiles_y());

  data.SetMaxTextureSize(gfx::Size(2, 2));
  EXPECT_EQ(gfx::Size(2, 2), data.max_texture_size());
  EXPECT_EQ(8, data.num_tiles_x());
  EXPECT_EQ(16, data.num_tiles_y());

  data.SetMaxTextureSize(gfx::Size(5, 5));
  EXPECT_EQ(gfx::Size(5, 5), data.max_texture_size());
  EXPECT_EQ(4, data.num_tiles_x());
  EXPECT_EQ(7, data.num_tiles_y());

  data.SetMaxTextureSize(gfx::Size(8, 5));
  EXPECT_EQ(gfx::Size(8, 5), data.max_texture_size());
  EXPECT_EQ(2, data.num_tiles_x());
  EXPECT_EQ(7, data.num_tiles_y());
}

TEST_P(TilingDataTest, SetMaxTextureSizeBorders) {
  gfx::Point origin = GetParam();

  TilingData data(gfx::Size(8, 8), gfx::Rect(origin, gfx::Size(16, 32)), true);
  EXPECT_EQ(3, data.num_tiles_x());
  EXPECT_EQ(5, data.num_tiles_y());

  data.SetMaxTextureSize(gfx::Size(32, 32));
  EXPECT_EQ(gfx::Size(32, 32), data.max_texture_size());
  EXPECT_EQ(1, data.num_tiles_x());
  EXPECT_EQ(1, data.num_tiles_y());

  data.SetMaxTextureSize(gfx::Size(2, 2));
  EXPECT_EQ(gfx::Size(2, 2), data.max_texture_size());
  EXPECT_EQ(0, data.num_tiles_x());
  EXPECT_EQ(0, data.num_tiles_y());

  data.SetMaxTextureSize(gfx::Size(5, 5));
  EXPECT_EQ(gfx::Size(5, 5), data.max_texture_size());
  EXPECT_EQ(5, data.num_tiles_x());
  EXPECT_EQ(10, data.num_tiles_y());

  data.SetMaxTextureSize(gfx::Size(8, 5));
  EXPECT_EQ(gfx::Size(8, 5), data.max_texture_size());
  EXPECT_EQ(3, data.num_tiles_x());
  EXPECT_EQ(10, data.num_tiles_y());
}

TEST_P(TilingDataTest, ExpandRectToTileBoundsWithBordersEmpty) {
  gfx::Point origin = GetParam();
  TilingData empty_total_size(
      gfx::Size(0, 0), gfx::Rect(origin, gfx::Size(8, 8)), true);
  EXPECT_RECT_EQ(
      gfx::Rect(),
      empty_total_size.ExpandRectToTileBoundsWithBorders(gfx::Rect()));
  EXPECT_RECT_EQ(gfx::Rect(),
                 empty_total_size.ExpandRectToTileBoundsWithBorders(
                     gfx::Rect(100, 100, 100, 100)));
  EXPECT_RECT_EQ(gfx::Rect(),
                 empty_total_size.ExpandRectToTileBoundsWithBorders(
                     gfx::Rect(0, 0, 100, 100)));

  TilingData empty_max_texture_size(
      gfx::Size(8, 8), gfx::Rect(origin, gfx::Size(0, 0)), true);
  EXPECT_RECT_EQ(
      gfx::Rect(),
      empty_max_texture_size.ExpandRectToTileBoundsWithBorders(gfx::Rect()));
  EXPECT_RECT_EQ(gfx::Rect(),
                 empty_max_texture_size.ExpandRectToTileBoundsWithBorders(
                     gfx::Rect(100, 100, 100, 100)));
  EXPECT_RECT_EQ(gfx::Rect(),
                 empty_max_texture_size.ExpandRectToTileBoundsWithBorders(
                     gfx::Rect(0, 0, 100, 100)));
}

TEST_P(TilingDataTest, ExpandRectToTileBoundsWithBorders) {
  gfx::Point origin = GetParam();
  TilingData data(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(16, 32)), true);

  // Small rect at origin rounds up to tile 0, 0.
  gfx::Rect at_origin_src(origin, gfx::Size(1, 1));
  gfx::Rect at_origin_result(data.TileBoundsWithBorder(0, 0));
  EXPECT_NE(at_origin_src, at_origin_result);
  EXPECT_RECT_EQ(at_origin_result,
                 data.ExpandRectToTileBoundsWithBorders(at_origin_src));

  // Arbitrary internal rect.
  gfx::Rect rect_src(origin.x() + 6, origin.y() + 6, 1, 3);
  // Tile 2, 2 => gfx::Rect(4, 4, 4, 4)
  // Tile 3, 4 => gfx::Rect(6, 8, 4, 4)
  gfx::Rect rect_result(gfx::UnionRects(data.TileBoundsWithBorder(2, 2),
                                        data.TileBoundsWithBorder(3, 4)));
  EXPECT_NE(rect_src, rect_result);
  EXPECT_RECT_EQ(rect_result, data.ExpandRectToTileBoundsWithBorders(rect_src));

  // On tile bounds rounds up to next tile (since border overlaps).
  gfx::Rect border_rect_src(
      gfx::UnionRects(data.TileBounds(1, 2), data.TileBounds(3, 4)));
  gfx::Rect border_rect_result(gfx::UnionRects(
      data.TileBoundsWithBorder(0, 1), data.TileBoundsWithBorder(4, 5)));
  EXPECT_RECT_EQ(border_rect_result,
                 data.ExpandRectToTileBoundsWithBorders(border_rect_src));

  // Equal to tiling rect.
  EXPECT_RECT_EQ(data.tiling_rect(),
                 data.ExpandRectToTileBoundsWithBorders(data.tiling_rect()));

  // Containing, but larger than tiling rect.
  EXPECT_RECT_EQ(data.tiling_rect(),
                 data.ExpandRectToTileBoundsWithBorders(
                     gfx::Rect(origin, gfx::Size(100, 100))));

  // Non-intersecting with tiling rect.
  gfx::Rect non_intersect(origin.x() + 200, origin.y() + 200, 100, 100);
  EXPECT_FALSE(non_intersect.Intersects(data.tiling_rect()));
  EXPECT_RECT_EQ(gfx::Rect(),
                 data.ExpandRectToTileBoundsWithBorders(non_intersect));

  TilingData data2(gfx::Size(8, 8), gfx::Rect(origin, gfx::Size(32, 64)), true);

  // Inside other tile border texels doesn't include other tiles.
  gfx::Rect inner_rect_src(data2.TileBounds(1, 1));
  inner_rect_src.Inset(data2.border_texels(), data.border_texels());
  gfx::Rect inner_rect_result(data2.TileBoundsWithBorder(1, 1));
  gfx::Rect expanded = data2.ExpandRectToTileBoundsWithBorders(inner_rect_src);
  EXPECT_EQ(inner_rect_result.ToString(), expanded.ToString());
}

TEST_P(TilingDataTest, ExpandRectToTileBounds) {
  gfx::Point origin = GetParam();
  TilingData data(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(16, 32)), true);

  // Small rect at origin rounds up to tile 0, 0.
  gfx::Rect at_origin_src(origin, gfx::Size(1, 1));
  gfx::Rect at_origin_result(data.TileBounds(0, 0));
  EXPECT_NE(at_origin_src, at_origin_result);
  EXPECT_RECT_EQ(at_origin_result, data.ExpandRectToTileBounds(at_origin_src));

  // Arbitrary internal rect.
  gfx::Rect rect_src(origin.x() + 6, origin.y() + 6, 1, 3);
  // Tile 2, 2 => gfx::Rect(4, 4, 4, 4)
  // Tile 3, 4 => gfx::Rect(6, 8, 4, 4)
  gfx::Rect rect_result(
      gfx::UnionRects(data.TileBounds(2, 2), data.TileBounds(3, 4)));
  EXPECT_NE(rect_src, rect_result);
  EXPECT_RECT_EQ(rect_result, data.ExpandRectToTileBounds(rect_src));

  // On tile bounds rounds up to next tile (since border overlaps).
  gfx::Rect border_rect_src(
      gfx::UnionRects(data.TileBounds(1, 2), data.TileBounds(3, 4)));
  gfx::Rect border_rect_result(
      gfx::UnionRects(data.TileBounds(0, 1), data.TileBounds(4, 5)));
  EXPECT_RECT_EQ(border_rect_result,
                 data.ExpandRectToTileBounds(border_rect_src));

  // Equal to tiling rect.
  EXPECT_RECT_EQ(data.tiling_rect(),
                 data.ExpandRectToTileBounds(data.tiling_rect()));

  // Containing, but larger than tiling rect.
  EXPECT_RECT_EQ(
      data.tiling_rect(),
      data.ExpandRectToTileBounds(gfx::Rect(origin, gfx::Size(100, 100))));

  // Non-intersecting with tiling rect.
  gfx::Rect non_intersect(origin.x() + 200, origin.y() + 200, 100, 100);
  EXPECT_FALSE(non_intersect.Intersects(data.tiling_rect()));
  EXPECT_RECT_EQ(gfx::Rect(), data.ExpandRectToTileBounds(non_intersect));

  TilingData data2(gfx::Size(8, 8), gfx::Rect(origin, gfx::Size(32, 64)), true);

  // Inside other tile border texels doesn't include other tiles.
  gfx::Rect inner_rect_src(data2.TileBounds(1, 1));
  inner_rect_src.Inset(data2.border_texels(), data.border_texels());
  gfx::Rect inner_rect_result(data2.TileBounds(1, 1));
  gfx::Rect expanded = data2.ExpandRectToTileBounds(inner_rect_src);
  EXPECT_EQ(inner_rect_result.ToString(), expanded.ToString());
}

TEST_P(TilingDataTest, Assignment) {
  gfx::Point origin = GetParam();

  {
    TilingData source(
        gfx::Size(8, 8), gfx::Rect(origin, gfx::Size(16, 32)), true);
    TilingData dest = source;
    EXPECT_EQ(source.border_texels(), dest.border_texels());
    EXPECT_EQ(source.max_texture_size(), dest.max_texture_size());
    EXPECT_EQ(source.num_tiles_x(), dest.num_tiles_x());
    EXPECT_EQ(source.num_tiles_y(), dest.num_tiles_y());
    EXPECT_EQ(source.tiling_rect().x(), dest.tiling_rect().x());
    EXPECT_EQ(source.tiling_rect().y(), dest.tiling_rect().y());
    EXPECT_EQ(source.tiling_rect().width(), dest.tiling_rect().width());
    EXPECT_EQ(source.tiling_rect().height(), dest.tiling_rect().height());
  }
  {
    TilingData source(
        gfx::Size(7, 3), gfx::Rect(origin, gfx::Size(6, 100)), false);
    TilingData dest(source);
    EXPECT_EQ(source.border_texels(), dest.border_texels());
    EXPECT_EQ(source.max_texture_size(), dest.max_texture_size());
    EXPECT_EQ(source.num_tiles_x(), dest.num_tiles_x());
    EXPECT_EQ(source.num_tiles_y(), dest.num_tiles_y());
    EXPECT_EQ(source.tiling_rect().x(), dest.tiling_rect().x());
    EXPECT_EQ(source.tiling_rect().y(), dest.tiling_rect().y());
    EXPECT_EQ(source.tiling_rect().width(), dest.tiling_rect().width());
    EXPECT_EQ(source.tiling_rect().height(), dest.tiling_rect().height());
  }
}

TEST_P(TilingDataTest, SetBorderTexels) {
  gfx::Point origin = GetParam();

  TilingData data(gfx::Size(8, 8), gfx::Rect(origin, gfx::Size(16, 32)), false);
  EXPECT_EQ(2, data.num_tiles_x());
  EXPECT_EQ(4, data.num_tiles_y());

  data.SetHasBorderTexels(true);
  EXPECT_EQ(3, data.num_tiles_x());
  EXPECT_EQ(5, data.num_tiles_y());

  data.SetHasBorderTexels(false);
  EXPECT_EQ(2, data.num_tiles_x());
  EXPECT_EQ(4, data.num_tiles_y());
}

TEST_P(TilingDataTest, LargeBorders) {
  gfx::Point origin = GetParam();

  TilingData data(
      gfx::Size(100, 80), gfx::Rect(origin, gfx::Size(200, 145)), 30);
  EXPECT_EQ(30, data.border_texels());

  EXPECT_EQ(70, data.TileSizeX(0));
  EXPECT_EQ(40, data.TileSizeX(1));
  EXPECT_EQ(40, data.TileSizeX(2));
  EXPECT_EQ(50, data.TileSizeX(3));
  EXPECT_EQ(4, data.num_tiles_x());

  EXPECT_EQ(50, data.TileSizeY(0));
  EXPECT_EQ(20, data.TileSizeY(1));
  EXPECT_EQ(20, data.TileSizeY(2));
  EXPECT_EQ(20, data.TileSizeY(3));
  EXPECT_EQ(35, data.TileSizeY(4));
  EXPECT_EQ(5, data.num_tiles_y());

  EXPECT_RECT_EQ(gfx::Rect(origin.x() + 0, origin.y() + 0, 70, 50),
                 data.TileBounds(0, 0));
  EXPECT_RECT_EQ(gfx::Rect(origin.x() + 70, origin.y() + 50, 40, 20),
                 data.TileBounds(1, 1));
  EXPECT_RECT_EQ(gfx::Rect(origin.x() + 110, origin.y() + 110, 40, 35),
                 data.TileBounds(2, 4));
  EXPECT_RECT_EQ(gfx::Rect(origin.x() + 150, origin.y() + 70, 50, 20),
                 data.TileBounds(3, 2));
  EXPECT_RECT_EQ(gfx::Rect(origin.x() + 150, origin.y() + 110, 50, 35),
                 data.TileBounds(3, 4));

  EXPECT_RECT_EQ(gfx::Rect(origin.x() + 0, origin.y() + 0, 100, 80),
                 data.TileBoundsWithBorder(0, 0));
  EXPECT_RECT_EQ(gfx::Rect(origin.x() + 40, origin.y() + 20, 100, 80),
                 data.TileBoundsWithBorder(1, 1));
  EXPECT_RECT_EQ(gfx::Rect(origin.x() + 80, origin.y() + 80, 100, 65),
                 data.TileBoundsWithBorder(2, 4));
  EXPECT_RECT_EQ(gfx::Rect(origin.x() + 120, origin.y() + 40, 80, 80),
                 data.TileBoundsWithBorder(3, 2));
  EXPECT_RECT_EQ(gfx::Rect(origin.x() + 120, origin.y() + 80, 80, 65),
                 data.TileBoundsWithBorder(3, 4));

  EXPECT_EQ(0, data.TileXIndexFromSrcCoord(origin.x() + 0));
  EXPECT_EQ(0, data.TileXIndexFromSrcCoord(origin.x() + 69));
  EXPECT_EQ(1, data.TileXIndexFromSrcCoord(origin.x() + 70));
  EXPECT_EQ(1, data.TileXIndexFromSrcCoord(origin.x() + 109));
  EXPECT_EQ(2, data.TileXIndexFromSrcCoord(origin.x() + 110));
  EXPECT_EQ(2, data.TileXIndexFromSrcCoord(origin.x() + 149));
  EXPECT_EQ(3, data.TileXIndexFromSrcCoord(origin.x() + 150));
  EXPECT_EQ(3, data.TileXIndexFromSrcCoord(origin.x() + 199));

  EXPECT_EQ(0, data.TileYIndexFromSrcCoord(origin.y() + 0));
  EXPECT_EQ(0, data.TileYIndexFromSrcCoord(origin.y() + 49));
  EXPECT_EQ(1, data.TileYIndexFromSrcCoord(origin.y() + 50));
  EXPECT_EQ(1, data.TileYIndexFromSrcCoord(origin.y() + 69));
  EXPECT_EQ(2, data.TileYIndexFromSrcCoord(origin.y() + 70));
  EXPECT_EQ(2, data.TileYIndexFromSrcCoord(origin.y() + 89));
  EXPECT_EQ(3, data.TileYIndexFromSrcCoord(origin.y() + 90));
  EXPECT_EQ(3, data.TileYIndexFromSrcCoord(origin.y() + 109));
  EXPECT_EQ(4, data.TileYIndexFromSrcCoord(origin.y() + 110));
  EXPECT_EQ(4, data.TileYIndexFromSrcCoord(origin.y() + 144));

  EXPECT_EQ(0, data.FirstBorderTileXIndexFromSrcCoord(origin.x() + 0));
  EXPECT_EQ(0, data.FirstBorderTileXIndexFromSrcCoord(origin.x() + 99));
  EXPECT_EQ(1, data.FirstBorderTileXIndexFromSrcCoord(origin.x() + 100));
  EXPECT_EQ(1, data.FirstBorderTileXIndexFromSrcCoord(origin.x() + 139));
  EXPECT_EQ(2, data.FirstBorderTileXIndexFromSrcCoord(origin.x() + 140));
  EXPECT_EQ(2, data.FirstBorderTileXIndexFromSrcCoord(origin.x() + 179));
  EXPECT_EQ(3, data.FirstBorderTileXIndexFromSrcCoord(origin.x() + 180));
  EXPECT_EQ(3, data.FirstBorderTileXIndexFromSrcCoord(origin.x() + 199));

  EXPECT_EQ(0, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 0));
  EXPECT_EQ(0, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 79));
  EXPECT_EQ(1, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 80));
  EXPECT_EQ(1, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 99));
  EXPECT_EQ(2, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 100));
  EXPECT_EQ(2, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 119));
  EXPECT_EQ(3, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 120));
  EXPECT_EQ(3, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 139));
  EXPECT_EQ(4, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 140));
  EXPECT_EQ(4, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 144));

  EXPECT_EQ(0, data.LastBorderTileXIndexFromSrcCoord(origin.x() + 0));
  EXPECT_EQ(0, data.LastBorderTileXIndexFromSrcCoord(origin.x() + 39));
  EXPECT_EQ(1, data.LastBorderTileXIndexFromSrcCoord(origin.x() + 40));
  EXPECT_EQ(1, data.LastBorderTileXIndexFromSrcCoord(origin.x() + 79));
  EXPECT_EQ(2, data.LastBorderTileXIndexFromSrcCoord(origin.x() + 80));
  EXPECT_EQ(2, data.LastBorderTileXIndexFromSrcCoord(origin.x() + 119));
  EXPECT_EQ(3, data.LastBorderTileXIndexFromSrcCoord(origin.x() + 120));
  EXPECT_EQ(3, data.LastBorderTileXIndexFromSrcCoord(origin.x() + 199));

  EXPECT_EQ(0, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 0));
  EXPECT_EQ(0, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 19));
  EXPECT_EQ(1, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 20));
  EXPECT_EQ(1, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 39));
  EXPECT_EQ(2, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 40));
  EXPECT_EQ(2, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 59));
  EXPECT_EQ(3, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 60));
  EXPECT_EQ(3, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 79));
  EXPECT_EQ(4, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 80));
  EXPECT_EQ(4, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 144));
}

void TestIterate(const TilingData& data,
                 gfx::Rect rect,
                 int expect_left,
                 int expect_top,
                 int expect_right,
                 int expect_bottom,
                 bool include_borders) {
  EXPECT_GE(expect_left, 0);
  EXPECT_GE(expect_top, 0);
  EXPECT_LT(expect_right, data.num_tiles_x());
  EXPECT_LT(expect_bottom, data.num_tiles_y());

  std::vector<std::pair<int, int> > original_expected;
  for (int x = 0; x < data.num_tiles_x(); ++x) {
    for (int y = 0; y < data.num_tiles_y(); ++y) {
      gfx::Rect bounds;
      if (include_borders)
        bounds = data.TileBoundsWithBorder(x, y);
      else
        bounds = data.TileBounds(x, y);
      if (x >= expect_left && x <= expect_right &&
          y >= expect_top && y <= expect_bottom) {
        EXPECT_TRUE(bounds.Intersects(rect));
        original_expected.push_back(std::make_pair(x, y));
      } else {
        EXPECT_FALSE(bounds.Intersects(rect));
      }
    }
  }

  // Verify with vanilla iterator.
  {
    std::vector<std::pair<int, int> > expected = original_expected;
    for (TilingData::Iterator iter(&data, rect, include_borders); iter;
         ++iter) {
      bool found = false;
      for (size_t i = 0; i < expected.size(); ++i) {
        if (expected[i] == iter.index()) {
          expected[i] = expected.back();
          expected.pop_back();
          found = true;
          break;
        }
      }
      EXPECT_TRUE(found);
    }
    EXPECT_EQ(0u, expected.size());
  }

  // Make sure this also works with a difference iterator and an empty ignore.
  // The difference iterator always includes borders, so ignore it otherwise.
  if (include_borders) {
    std::vector<std::pair<int, int> > expected = original_expected;
    for (TilingData::DifferenceIterator iter(&data, rect, gfx::Rect());
         iter; ++iter) {
      bool found = false;
      for (size_t i = 0; i < expected.size(); ++i) {
        if (expected[i] == iter.index()) {
          expected[i] = expected.back();
          expected.pop_back();
          found = true;
          break;
        }
      }
      EXPECT_TRUE(found);
    }
    EXPECT_EQ(0u, expected.size());
  }
}

void TestIterateBorders(const TilingData& data,
                        gfx::Rect rect,
                        int expect_left,
                        int expect_top,
                        int expect_right,
                        int expect_bottom) {
  bool include_borders = true;
  TestIterate(data,
              rect,
              expect_left,
              expect_top,
              expect_right,
              expect_bottom,
              include_borders);
}

void TestIterateNoBorders(const TilingData& data,
                          gfx::Rect rect,
                          int expect_left,
                          int expect_top,
                          int expect_right,
                          int expect_bottom) {
  bool include_borders = false;
  TestIterate(data,
              rect,
              expect_left,
              expect_top,
              expect_right,
              expect_bottom,
              include_borders);
}

void TestIterateAll(const TilingData& data,
                    gfx::Rect rect,
                    int expect_left,
                    int expect_top,
                    int expect_right,
                    int expect_bottom) {
  TestIterateBorders(
      data, rect, expect_left, expect_top, expect_right, expect_bottom);
  TestIterateNoBorders(
      data, rect, expect_left, expect_top, expect_right, expect_bottom);
}

TEST_P(TilingDataTest, IteratorNoBorderTexels) {
  gfx::Point origin = GetParam();

  TilingData data(
      gfx::Size(10, 10), gfx::Rect(origin, gfx::Size(40, 25)), false);
  // The following Coordinates are relative to the origin.
  // X border index by src coord: [0-10), [10-20), [20, 30), [30, 40)
  // Y border index by src coord: [0-10), [10-20), [20, 25)
  TestIterateAll(data, gfx::Rect(origin.x(), origin.y(), 40, 25), 0, 0, 3, 2);
  TestIterateAll(
      data, gfx::Rect(origin.x() + 15, origin.y() + 15, 8, 8), 1, 1, 2, 2);

  // Oversized.
  TestIterateAll(data,
                 gfx::Rect(origin.x() - 100, origin.y() - 100, 1000, 1000),
                 0,
                 0,
                 3,
                 2);
  TestIterateAll(
      data, gfx::Rect(origin.x() - 100, origin.y() + 20, 1000, 1), 0, 2, 3, 2);
  TestIterateAll(
      data, gfx::Rect(origin.x() + 29, origin.y() - 100, 31, 1000), 2, 0, 3, 2);
  // Nonintersecting.
  TestIterateAll(data,
                 gfx::Rect(origin.x() + 60, origin.y() + 80, 100, 100),
                 0,
                 0,
                 -1,
                 -1);
}

TEST_P(TilingDataTest, BordersIteratorOneBorderTexel) {
  gfx::Point origin = GetParam();

  TilingData data(
      gfx::Size(10, 20), gfx::Rect(origin, gfx::Size(25, 45)), true);
  // The following Coordinates are relative to the origin.
  // X border index by src coord: [0-10), [8-18), [16-25)
  // Y border index by src coord: [0-20), [18-38), [36-45)
  TestIterateBorders(
      data, gfx::Rect(origin.x(), origin.y(), 25, 45), 0, 0, 2, 2);
  TestIterateBorders(
      data, gfx::Rect(origin.x() + 18, origin.y() + 19, 3, 17), 2, 0, 2, 1);
  TestIterateBorders(
      data, gfx::Rect(origin.x() + 10, origin.y() + 20, 6, 16), 1, 1, 1, 1);
  TestIterateBorders(
      data, gfx::Rect(origin.x() + 9, origin.y() + 19, 8, 18), 0, 0, 2, 2);
  // Oversized.
  TestIterateBorders(data,
                     gfx::Rect(origin.x() - 100, origin.y() - 100, 1000, 1000),
                     0,
                     0,
                     2,
                     2);
  TestIterateBorders(
      data, gfx::Rect(origin.x() - 100, origin.y() + 20, 1000, 1), 0, 1, 2, 1);
  TestIterateBorders(
      data, gfx::Rect(origin.x() + 18, origin.y() - 100, 6, 1000), 2, 0, 2, 2);
  // Nonintersecting.
  TestIterateBorders(data,
                     gfx::Rect(origin.x() + 60, origin.y() + 80, 100, 100),
                     0,
                     0,
                     -1,
                     -1);
}

TEST_P(TilingDataTest, NoBordersIteratorOneBorderTexel) {
  gfx::Point origin = GetParam();

  TilingData data(
      gfx::Size(10, 20), gfx::Rect(origin, gfx::Size(25, 45)), true);
  // The following Coordinates are relative to the origin.
  // X index by src coord: [0-9), [9-17), [17-25)
  // Y index by src coord: [0-19), [19-37), [37-45)
  TestIterateNoBorders(
      data, gfx::Rect(origin.x(), origin.y(), 25, 45), 0, 0, 2, 2);
  TestIterateNoBorders(
      data, gfx::Rect(origin.x() + 17, origin.y() + 19, 3, 18), 2, 1, 2, 1);
  TestIterateNoBorders(
      data, gfx::Rect(origin.x() + 17, origin.y() + 19, 3, 19), 2, 1, 2, 2);
  TestIterateNoBorders(
      data, gfx::Rect(origin.x() + 8, origin.y() + 18, 9, 19), 0, 0, 1, 1);
  TestIterateNoBorders(
      data, gfx::Rect(origin.x() + 9, origin.y() + 19, 9, 19), 1, 1, 2, 2);
  // Oversized.
  TestIterateNoBorders(
      data,
      gfx::Rect(origin.x() - 100, origin.y() - 100, 1000, 1000),
      0,
      0,
      2,
      2);
  TestIterateNoBorders(
      data, gfx::Rect(origin.x() - 100, origin.y() + 20, 1000, 1), 0, 1, 2, 1);
  TestIterateNoBorders(
      data, gfx::Rect(origin.x() + 18, origin.y() - 100, 6, 1000), 2, 0, 2, 2);
  // Nonintersecting.
  TestIterateNoBorders(data,
                       gfx::Rect(origin.x() + 60, origin.y() + 80, 100, 100),
                       0,
                       0,
                       -1,
                       -1);
}

TEST_P(TilingDataTest, BordersIteratorManyBorderTexels) {
  gfx::Point origin = GetParam();

  TilingData data(gfx::Size(50, 60), gfx::Rect(origin, gfx::Size(65, 110)), 20);
  // The following Coordinates are relative to the origin.
  // X border index by src coord: [0-50), [10-60), [20-65)
  // Y border index by src coord: [0-60), [20-80), [40-100), [60-110)
  TestIterateBorders(
      data, gfx::Rect(origin.x(), origin.y(), 65, 110), 0, 0, 2, 3);
  TestIterateBorders(
      data, gfx::Rect(origin.x() + 50, origin.y() + 60, 15, 65), 1, 1, 2, 3);
  TestIterateBorders(
      data, gfx::Rect(origin.x() + 60, origin.y() + 30, 2, 10), 2, 0, 2, 1);
  // Oversized.
  TestIterateBorders(data,
                     gfx::Rect(origin.x() - 100, origin.y() - 100, 1000, 1000),
                     0,
                     0,
                     2,
                     3);
  TestIterateBorders(
      data, gfx::Rect(origin.x() - 100, origin.y() + 10, 1000, 10), 0, 0, 2, 0);
  TestIterateBorders(
      data, gfx::Rect(origin.x() + 10, origin.y() - 100, 10, 1000), 0, 0, 1, 3);
  // Nonintersecting.
  TestIterateBorders(data,
                     gfx::Rect(origin.x() + 65, origin.y() + 110, 100, 100),
                     0,
                     0,
                     -1,
                     -1);
}

TEST_P(TilingDataTest, NoBordersIteratorManyBorderTexels) {
  gfx::Point origin = GetParam();

  TilingData data(gfx::Size(50, 60), gfx::Rect(origin, gfx::Size(65, 110)), 20);
  // The following Coordinates are relative to the origin.
  // X index by src coord: [0-30), [30-40), [40, 65)
  // Y index by src coord: [0-40), [40-60), [60, 80), [80-110)
  TestIterateNoBorders(
      data, gfx::Rect(origin.x(), origin.y(), 65, 110), 0, 0, 2, 3);
  TestIterateNoBorders(
      data, gfx::Rect(origin.x() + 30, origin.y() + 40, 15, 65), 1, 1, 2, 3);
  TestIterateNoBorders(
      data, gfx::Rect(origin.x() + 60, origin.y() + 20, 2, 21), 2, 0, 2, 1);
  // Oversized.
  TestIterateNoBorders(
      data,
      gfx::Rect(origin.x() - 100, origin.y() - 100, 1000, 1000),
      0,
      0,
      2,
      3);
  TestIterateNoBorders(
      data, gfx::Rect(origin.x() - 100, origin.y() + 10, 1000, 10), 0, 0, 2, 0);
  TestIterateNoBorders(
      data, gfx::Rect(origin.x() + 10, origin.y() - 100, 10, 1000), 0, 0, 0, 3);
  // Nonintersecting.
  TestIterateNoBorders(data,
                       gfx::Rect(origin.x() + 65, origin.y() + 110, 100, 100),
                       0,
                       0,
                       -1,
                       -1);
}

TEST_P(TilingDataTest, IteratorOneTile) {
  gfx::Point origin = GetParam();

  TilingData no_border(
      gfx::Size(1000, 1000), gfx::Rect(origin, gfx::Size(30, 40)), false);
  TestIterateAll(
      no_border, gfx::Rect(origin.x(), origin.y(), 30, 40), 0, 0, 0, 0);
  TestIterateAll(no_border,
                 gfx::Rect(origin.x() + 10, origin.y() + 10, 20, 20),
                 0,
                 0,
                 0,
                 0);
  TestIterateAll(no_border,
                 gfx::Rect(origin.x() + 30, origin.y() + 40, 100, 100),
                 0,
                 0,
                 -1,
                 -1);

  TilingData one_border(
      gfx::Size(1000, 1000), gfx::Rect(origin, gfx::Size(30, 40)), true);
  TestIterateAll(
      one_border, gfx::Rect(origin.x(), origin.y(), 30, 40), 0, 0, 0, 0);
  TestIterateAll(one_border,
                 gfx::Rect(origin.x() + 10, origin.y() + 10, 20, 20),
                 0,
                 0,
                 0,
                 0);
  TestIterateAll(one_border,
                 gfx::Rect(origin.x() + 30, origin.y() + 40, 100, 100),
                 0,
                 0,
                 -1,
                 -1);

  TilingData big_border(
      gfx::Size(1000, 1000), gfx::Rect(origin, gfx::Size(30, 40)), 50);
  TestIterateAll(
      big_border, gfx::Rect(origin.x(), origin.y(), 30, 40), 0, 0, 0, 0);
  TestIterateAll(big_border,
                 gfx::Rect(origin.x() + 10, origin.y() + 10, 20, 20),
                 0,
                 0,
                 0,
                 0);
  TestIterateAll(big_border,
                 gfx::Rect(origin.x() + 30, origin.y() + 40, 100, 100),
                 0,
                 0,
                 -1,
                 -1);
}

TEST(TilingDataTest, IteratorNoTiles) {
  TilingData data(gfx::Size(100, 100), gfx::Rect(), false);
  TestIterateAll(data, gfx::Rect(0, 0, 100, 100), 0, 0, -1, -1);
}

void TestDiff(
    const TilingData& data,
    gfx::Rect consider,
    gfx::Rect ignore,
    size_t num_tiles) {

  std::vector<std::pair<int, int> > expected;
  for (int y = 0; y < data.num_tiles_y(); ++y) {
    for (int x = 0; x < data.num_tiles_x(); ++x) {
      gfx::Rect bounds = data.TileBoundsWithBorder(x, y);
      if (bounds.Intersects(consider) && !bounds.Intersects(ignore))
        expected.push_back(std::make_pair(x, y));
    }
  }

  // Sanity check the test.
  EXPECT_EQ(num_tiles, expected.size());

  for (TilingData::DifferenceIterator iter(&data, consider, ignore);
       iter; ++iter) {
    bool found = false;
    for (size_t i = 0; i < expected.size(); ++i) {
      if (expected[i] == iter.index()) {
        expected[i] = expected.back();
        expected.pop_back();
        found = true;
        break;
      }
    }
    EXPECT_TRUE(found);
  }
  EXPECT_EQ(0u, expected.size());
}

TEST_P(TilingDataTest, DifferenceIteratorIgnoreGeometry) {
  // This test is checking that the iterator can handle different geometries of
  // ignore rects relative to the consider rect.  The consider rect indices
  // themselves are mostly tested by the non-difference iterator tests, so the
  // full rect is mostly used here for simplicity.

  gfx::Point origin = GetParam();

  // The following Coordinates are relative to the origin.
  // X border index by src coord: [0-10), [10-20), [20, 30), [30, 40)
  // Y border index by src coord: [0-10), [10-20), [20, 25)
  TilingData data(
      gfx::Size(10, 10), gfx::Rect(origin, gfx::Size(40, 25)), false);

  // Fully ignored
  TestDiff(data,
           gfx::Rect(origin.x(), origin.y(), 40, 25),
           gfx::Rect(origin.x(), origin.y(), 40, 25),
           0);
  TestDiff(data,
           gfx::Rect(origin.x(), origin.y(), 40, 25),
           gfx::Rect(origin.x() - 100, origin.y() - 100, 200, 200),
           0);
  TestDiff(data,
           gfx::Rect(origin.x(), origin.y(), 40, 25),
           gfx::Rect(origin.x() + 9, origin.y() + 9, 30, 15),
           0);
  TestDiff(data,
           gfx::Rect(origin.x() + 15, origin.y() + 15, 8, 8),
           gfx::Rect(origin.x() + 15, origin.y() + 15, 8, 8),
           0);

  // Fully un-ignored
  TestDiff(data,
           gfx::Rect(origin.x(), origin.y(), 40, 25),
           gfx::Rect(origin.x() - 30, origin.y() - 20, 8, 8),
           12);
  TestDiff(data, gfx::Rect(origin.x(), origin.y(), 40, 25), gfx::Rect(), 12);

  // Top left, remove 2x2 tiles
  TestDiff(data,
           gfx::Rect(origin.x(), origin.y(), 40, 25),
           gfx::Rect(origin.x(), origin.y(), 20, 19),
           8);
  // Bottom right, remove 2x2 tiles
  TestDiff(data,
           gfx::Rect(origin.x(), origin.y(), 40, 25),
           gfx::Rect(origin.x() + 20, origin.y() + 15, 20, 6),
           8);
  // Bottom left, remove 2x2 tiles
  TestDiff(data,
           gfx::Rect(origin.x(), origin.y(), 40, 25),
           gfx::Rect(origin.x(), origin.y() + 15, 20, 6),
           8);
  // Top right, remove 2x2 tiles
  TestDiff(data,
           gfx::Rect(origin.x(), origin.y(), 40, 25),
           gfx::Rect(origin.x() + 20, origin.y(), 20, 19),
           8);
  // Center, remove only one tile
  TestDiff(data,
           gfx::Rect(origin.x(), origin.y(), 40, 25),
           gfx::Rect(origin.x() + 10, origin.y() + 10, 5, 5),
           11);

  // Left column, flush left, removing two columns
  TestDiff(data,
           gfx::Rect(origin.x(), origin.y(), 40, 25),
           gfx::Rect(origin.x(), origin.y(), 11, 25),
           6);
  // Middle column, removing two columns
  TestDiff(data,
           gfx::Rect(origin.x(), origin.y(), 40, 25),
           gfx::Rect(origin.x() + 11, origin.y(), 11, 25),
           6);
  // Right column, flush right, removing one column
  TestDiff(data,
           gfx::Rect(origin.x(), origin.y(), 40, 25),
           gfx::Rect(origin.x() + 30, origin.y(), 2, 25),
           9);

  // Top row, flush top, removing one row
  TestDiff(data,
           gfx::Rect(origin.x(), origin.y(), 40, 25),
           gfx::Rect(origin.x(), origin.y() + 5, 40, 5),
           8);
  // Middle row, removing one row
  TestDiff(data,
           gfx::Rect(origin.x(), origin.y(), 40, 25),
           gfx::Rect(origin.x(), origin.y() + 13, 40, 5),
           8);
  // Bottom row, flush bottom, removing two rows
  TestDiff(data,
           gfx::Rect(origin.x(), origin.y(), 40, 25),
           gfx::Rect(origin.x(), origin.y() + 13, 40, 12),
           4);

  // Non-intersecting, but still touching two of the same tiles.
  TestDiff(data,
           gfx::Rect(origin.x() + 8, origin.y(), 32, 25),
           gfx::Rect(origin.x(), origin.y() + 12, 5, 12),
           10);

  // Intersecting, but neither contains the other. 2x3 with one overlap.
  TestDiff(data,
           gfx::Rect(origin.x() + 5, origin.y() + 2, 20, 10),
           gfx::Rect(origin.x() + 25, origin.y() + 15, 5, 10),
           5);
}

TEST_P(TilingDataTest, DifferenceIteratorManyBorderTexels) {
  gfx::Point origin = GetParam();

  // The following Coordinates are relative to the origin.
  // X border index by src coord: [0-50), [10-60), [20-65)
  // Y border index by src coord: [0-60), [20-80), [40-100), [60-110)
  TilingData data(gfx::Size(50, 60), gfx::Rect(origin, gfx::Size(65, 110)), 20);

  // Ignore one column, three rows
  TestDiff(data,
           gfx::Rect(origin.x(), origin.y() + 30, 55, 80),
           gfx::Rect(origin.x() + 5, origin.y() + 30, 5, 15),
           9);

  // Knock out three columns, leaving only one.
  TestDiff(data,
           gfx::Rect(origin.x() + 10, origin.y() + 30, 55, 80),
           gfx::Rect(origin.x() + 30, origin.y() + 59, 20, 1),
           3);

  // Overlap all tiles with ignore rect.
  TestDiff(data,
           gfx::Rect(origin.x(), origin.y(), 65, 110),
           gfx::Rect(origin.x() + 30, origin.y() + 59, 1, 2),
           0);
}

TEST_P(TilingDataTest, DifferenceIteratorOneTile) {
  gfx::Point origin = GetParam();

  TilingData no_border(
      gfx::Size(1000, 1000), gfx::Rect(origin, gfx::Size(30, 40)), false);
  TestDiff(
      no_border, gfx::Rect(origin.x(), origin.y(), 30, 40), gfx::Rect(), 1);
  TestDiff(no_border,
           gfx::Rect(origin.x() + 5, origin.y() + 5, 100, 100),
           gfx::Rect(origin.x() + 5, origin.y() + 5, 1, 1),
           0);

  TilingData one_border(
      gfx::Size(1000, 1000), gfx::Rect(origin, gfx::Size(30, 40)), true);
  TestDiff(
      one_border, gfx::Rect(origin.x(), origin.y(), 30, 40), gfx::Rect(), 1);
  TestDiff(one_border,
           gfx::Rect(origin.x() + 5, origin.y() + 5, 100, 100),
           gfx::Rect(origin.x() + 5, origin.y() + 5, 1, 1),
           0);

  TilingData big_border(
      gfx::Size(1000, 1000), gfx::Rect(origin, gfx::Size(30, 40)), 50);
  TestDiff(
      big_border, gfx::Rect(origin.x(), origin.y(), 30, 40), gfx::Rect(), 1);
  TestDiff(big_border,
           gfx::Rect(origin.x() + 5, origin.y() + 5, 100, 100),
           gfx::Rect(origin.x() + 5, origin.y() + 5, 1, 1),
           0);
}

TEST(TilingDataTest, DifferenceIteratorNoTiles) {
  TilingData data(gfx::Size(100, 100), gfx::Rect(), false);
  TestDiff(data, gfx::Rect(0, 0, 100, 100), gfx::Rect(0, 0, 5, 5), 0);
}

void TestSpiralIterate(int source_line_number,
                       const TilingData& tiling_data,
                       const gfx::Rect& consider,
                       const gfx::Rect& ignore,
                       const gfx::Rect& center,
                       const std::vector<std::pair<int, int> >& expected) {
  std::vector<std::pair<int, int> > actual;
  for (TilingData::SpiralDifferenceIterator it(
           &tiling_data, consider, ignore, center);
       it;
       ++it) {
    actual.push_back(it.index());
  }

  EXPECT_EQ(expected.size(), actual.size()) << "error from line "
                                            << source_line_number;
  for (size_t i = 0; i < std::min(expected.size(), actual.size()); ++i) {
    EXPECT_EQ(expected[i].first, actual[i].first)
        << "i: " << i << " error from line: " << source_line_number;
    EXPECT_EQ(expected[i].second, actual[i].second)
        << "i: " << i << " error from line: " << source_line_number;
  }
}

TEST_P(TilingDataTest, SpiralDifferenceIteratorNoIgnoreFullConsider) {
  gfx::Point origin = GetParam();
  TilingData tiling_data(
      gfx::Size(10, 10), gfx::Rect(origin, gfx::Size(30, 30)), false);
  gfx::Rect consider(origin.x(), origin.y(), 30, 30);
  gfx::Rect ignore;
  std::vector<std::pair<int, int> > expected;

  // Center is in the center of the tiling.
  gfx::Rect center(origin.x() + 15, origin.y() + 15, 1, 1);

  // Layout of the tiling data, and expected return order:
  //   x 0 1 2
  //  y.------
  //  0| 4 3 2
  //  1| 5 * 1
  //  2| 6 7 8
  expected.push_back(std::make_pair(2, 1));
  expected.push_back(std::make_pair(2, 0));
  expected.push_back(std::make_pair(1, 0));
  expected.push_back(std::make_pair(0, 0));
  expected.push_back(std::make_pair(0, 1));
  expected.push_back(std::make_pair(0, 2));
  expected.push_back(std::make_pair(1, 2));
  expected.push_back(std::make_pair(2, 2));

  TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);

  // Center is off to the right side of the tiling (and far away).
  center = gfx::Rect(origin.x() + 100, origin.y() + 15, 1, 1);

  // Layout of the tiling data, and expected return order:
  //   x 0 1 2
  //  y.------
  //  0| 7 4 1
  //  1| 8 5 2 *
  //  2| 9 6 3
  expected.clear();
  expected.push_back(std::make_pair(2, 0));
  expected.push_back(std::make_pair(2, 1));
  expected.push_back(std::make_pair(2, 2));
  expected.push_back(std::make_pair(1, 0));
  expected.push_back(std::make_pair(1, 1));
  expected.push_back(std::make_pair(1, 2));
  expected.push_back(std::make_pair(0, 0));
  expected.push_back(std::make_pair(0, 1));
  expected.push_back(std::make_pair(0, 2));

  TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);

  // Center is the bottom right corner of the tiling.
  center = gfx::Rect(origin.x() + 25, origin.y() + 25, 1, 1);

  // Layout of the tiling data, and expected return order:
  //   x 0 1 2
  //  y.------
  //  0| 6 5 4
  //  1| 7 2 1
  //  2| 8 3 *
  expected.clear();
  expected.push_back(std::make_pair(2, 1));
  expected.push_back(std::make_pair(1, 1));
  expected.push_back(std::make_pair(1, 2));
  expected.push_back(std::make_pair(2, 0));
  expected.push_back(std::make_pair(1, 0));
  expected.push_back(std::make_pair(0, 0));
  expected.push_back(std::make_pair(0, 1));
  expected.push_back(std::make_pair(0, 2));

  TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);

  // Center is off the top left side of the tiling.
  center = gfx::Rect(origin.x() - 60, origin.y() - 50, 1, 1);

  // Layout of the tiling data, and expected return order:
  // * x 0 1 2
  //  y.------
  //  0| 1 2 6
  //  1| 3 4 5
  //  2| 7 8 9
  expected.clear();
  expected.push_back(std::make_pair(0, 0));
  expected.push_back(std::make_pair(1, 0));
  expected.push_back(std::make_pair(0, 1));
  expected.push_back(std::make_pair(1, 1));
  expected.push_back(std::make_pair(2, 1));
  expected.push_back(std::make_pair(2, 0));
  expected.push_back(std::make_pair(0, 2));
  expected.push_back(std::make_pair(1, 2));
  expected.push_back(std::make_pair(2, 2));

  TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);

  // Two tile center.
  center = gfx::Rect(origin.x() + 15, origin.y() + 15, 1, 10);

  // Layout of the tiling data, and expected return order:
  //   x 0 1 2
  //  y.------
  //  0| 5 4 3
  //  1| 6 * 2
  //  2| 7 * 1
  expected.clear();
  expected.push_back(std::make_pair(2, 2));
  expected.push_back(std::make_pair(2, 1));
  expected.push_back(std::make_pair(2, 0));
  expected.push_back(std::make_pair(1, 0));
  expected.push_back(std::make_pair(0, 0));
  expected.push_back(std::make_pair(0, 1));
  expected.push_back(std::make_pair(0, 2));

  TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
}

TEST_P(TilingDataTest, SpiralDifferenceIteratorSmallConsider) {
  gfx::Point origin = GetParam();
  TilingData tiling_data(
      gfx::Size(10, 10), gfx::Rect(origin, gfx::Size(50, 50)), false);
  gfx::Rect ignore;
  std::vector<std::pair<int, int> > expected;
  gfx::Rect center(origin.x() + 15, origin.y() + 15, 1, 1);

  // Consider is one cell.
  gfx::Rect consider(origin.x(), origin.y(), 1, 1);

  // Layout of the tiling data, and expected return order:
  //   x 0 1 2 3 4
  //  y.----------
  //  0| 1
  //  1|   *
  //  2|
  //  3|
  //  4|
  expected.push_back(std::make_pair(0, 0));

  TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);

  // Consider is bottom right corner.
  consider = gfx::Rect(origin.x() + 25, origin.y() + 25, 10, 10);

  // Layout of the tiling data, and expected return order:
  //   x 0 1 2 3 4
  //  y.----------
  //  0|
  //  1|   *
  //  2|     1 2
  //  3|     3 4
  //  4|
  expected.clear();
  expected.push_back(std::make_pair(2, 2));
  expected.push_back(std::make_pair(3, 2));
  expected.push_back(std::make_pair(2, 3));
  expected.push_back(std::make_pair(3, 3));

  TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);

  // Consider is one column.
  consider = gfx::Rect(origin.x() + 11, origin.y(), 1, 100);

  // Layout of the tiling data, and expected return order:
  //   x 0 1 2 3 4
  //  y.----------
  //  0|   2
  //  1|   *
  //  2|   3
  //  3|   4
  //  4|   5
  expected.clear();
  expected.push_back(std::make_pair(1, 0));
  expected.push_back(std::make_pair(1, 2));
  expected.push_back(std::make_pair(1, 3));
  expected.push_back(std::make_pair(1, 4));

  TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
}

TEST_P(TilingDataTest, SpiralDifferenceIteratorHasIgnore) {
  gfx::Point origin = GetParam();
  TilingData tiling_data(
      gfx::Size(10, 10), gfx::Rect(origin, gfx::Size(50, 50)), false);
  gfx::Rect consider(origin.x(), origin.y(), 50, 50);
  std::vector<std::pair<int, int> > expected;
  gfx::Rect center(origin.x() + 15, origin.y() + 15, 1, 1);

  // Full ignore.
  gfx::Rect ignore(origin.x(), origin.y(), 50, 50);

  // Layout of the tiling data, and expected return order:
  //   x 0 1 2 3 4
  //  y.----------
  //  0| . . . . .
  //  1| . * . . .
  //  2| . . . . .
  //  3| . . . . .
  //  4| . . . . .
  expected.clear();

  TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);

  // 3 column ignore.
  ignore = gfx::Rect(origin.x() + 15, origin.y(), 20, 100);

  // Layout of the tiling data, and expected return order:
  //   x 0 1 2 3 4
  //  y.----------
  //  0| 1 . . . 8
  //  1| 2 * . . 7
  //  2| 3 . . . 6
  //  3| 4 . . . 5
  //  4| 9 . . . 10
  expected.clear();

  expected.push_back(std::make_pair(0, 0));
  expected.push_back(std::make_pair(0, 1));
  expected.push_back(std::make_pair(0, 2));
  expected.push_back(std::make_pair(0, 3));
  expected.push_back(std::make_pair(4, 3));
  expected.push_back(std::make_pair(4, 2));
  expected.push_back(std::make_pair(4, 1));
  expected.push_back(std::make_pair(4, 0));
  expected.push_back(std::make_pair(0, 4));
  expected.push_back(std::make_pair(4, 4));

  TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);

  // Ignore covers the top half.
  ignore = gfx::Rect(origin.x(), origin.y(), 50, 25);

  // Layout of the tiling data, and expected return order:
  //   x 0 1 2 3 4
  //  y.----------
  //  0| . . . . .
  //  1| . * . . .
  //  2| . . . . .
  //  3| 1 2 3 4 5
  //  4| 6 7 8 9 10
  expected.clear();

  expected.push_back(std::make_pair(0, 3));
  expected.push_back(std::make_pair(1, 3));
  expected.push_back(std::make_pair(2, 3));
  expected.push_back(std::make_pair(3, 3));
  expected.push_back(std::make_pair(4, 3));
  expected.push_back(std::make_pair(0, 4));
  expected.push_back(std::make_pair(1, 4));
  expected.push_back(std::make_pair(2, 4));
  expected.push_back(std::make_pair(3, 4));
  expected.push_back(std::make_pair(4, 4));

  TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
}

TEST_P(TilingDataTest, SpiralDifferenceIteratorRectangleCenter) {
  gfx::Point origin = GetParam();
  TilingData tiling_data(
      gfx::Size(10, 10), gfx::Rect(origin, gfx::Size(50, 50)), false);
  gfx::Rect consider(origin.x(), origin.y(), 50, 50);
  std::vector<std::pair<int, int> > expected;
  gfx::Rect ignore;

  // Two cell center
  gfx::Rect center(origin.x() + 25, origin.y() + 25, 1, 10);

  // Layout of the tiling data, and expected return order:
  //   x 0 1 2 3 4
  //  y.----------
  //  0| J I H G F
  //  1| K 5 4 3 E
  //  2| L 6 * 2 D
  //  3| M 7 * 1 C
  //  4| N 8 9 A B
  expected.clear();

  expected.push_back(std::make_pair(3, 3));
  expected.push_back(std::make_pair(3, 2));
  expected.push_back(std::make_pair(3, 1));
  expected.push_back(std::make_pair(2, 1));
  expected.push_back(std::make_pair(1, 1));
  expected.push_back(std::make_pair(1, 2));
  expected.push_back(std::make_pair(1, 3));
  expected.push_back(std::make_pair(1, 4));
  expected.push_back(std::make_pair(2, 4));
  expected.push_back(std::make_pair(3, 4));
  expected.push_back(std::make_pair(4, 4));
  expected.push_back(std::make_pair(4, 3));
  expected.push_back(std::make_pair(4, 2));
  expected.push_back(std::make_pair(4, 1));
  expected.push_back(std::make_pair(4, 0));
  expected.push_back(std::make_pair(3, 0));
  expected.push_back(std::make_pair(2, 0));
  expected.push_back(std::make_pair(1, 0));
  expected.push_back(std::make_pair(0, 0));
  expected.push_back(std::make_pair(0, 1));
  expected.push_back(std::make_pair(0, 2));
  expected.push_back(std::make_pair(0, 3));
  expected.push_back(std::make_pair(0, 4));

  TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);

  // Three by two center.
  center = gfx::Rect(origin.x() + 15, origin.y() + 25, 20, 10);

  // Layout of the tiling data, and expected return order:
  //   x 0 1 2 3 4
  //  y.----------
  //  0| J I H G F
  //  1| 7 6 5 4 3
  //  2| 8 * * * 2
  //  3| 9 * * * 1
  //  4| A B C D E
  expected.clear();

  expected.push_back(std::make_pair(4, 3));
  expected.push_back(std::make_pair(4, 2));
  expected.push_back(std::make_pair(4, 1));
  expected.push_back(std::make_pair(3, 1));
  expected.push_back(std::make_pair(2, 1));
  expected.push_back(std::make_pair(1, 1));
  expected.push_back(std::make_pair(0, 1));
  expected.push_back(std::make_pair(0, 2));
  expected.push_back(std::make_pair(0, 3));
  expected.push_back(std::make_pair(0, 4));
  expected.push_back(std::make_pair(1, 4));
  expected.push_back(std::make_pair(2, 4));
  expected.push_back(std::make_pair(3, 4));
  expected.push_back(std::make_pair(4, 4));
  expected.push_back(std::make_pair(4, 0));
  expected.push_back(std::make_pair(3, 0));
  expected.push_back(std::make_pair(2, 0));
  expected.push_back(std::make_pair(1, 0));
  expected.push_back(std::make_pair(0, 0));

  TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);

  // Column center off the left side.
  center = gfx::Rect(origin.x() - 50, origin.y(), 30, 50);

  // Layout of the tiling data, and expected return order:
  //    x 0 1 2 3 4
  //   y.----------
  // * 0| 5 A F K P
  // * 1| 4 9 E J O
  // * 2| 3 8 D I N
  // * 3| 2 7 C H M
  // * 4| 1 6 B G L
  expected.clear();

  expected.push_back(std::make_pair(0, 4));
  expected.push_back(std::make_pair(0, 3));
  expected.push_back(std::make_pair(0, 2));
  expected.push_back(std::make_pair(0, 1));
  expected.push_back(std::make_pair(0, 0));
  expected.push_back(std::make_pair(1, 4));
  expected.push_back(std::make_pair(1, 3));
  expected.push_back(std::make_pair(1, 2));
  expected.push_back(std::make_pair(1, 1));
  expected.push_back(std::make_pair(1, 0));
  expected.push_back(std::make_pair(2, 4));
  expected.push_back(std::make_pair(2, 3));
  expected.push_back(std::make_pair(2, 2));
  expected.push_back(std::make_pair(2, 1));
  expected.push_back(std::make_pair(2, 0));
  expected.push_back(std::make_pair(3, 4));
  expected.push_back(std::make_pair(3, 3));
  expected.push_back(std::make_pair(3, 2));
  expected.push_back(std::make_pair(3, 1));
  expected.push_back(std::make_pair(3, 0));
  expected.push_back(std::make_pair(4, 4));
  expected.push_back(std::make_pair(4, 3));
  expected.push_back(std::make_pair(4, 2));
  expected.push_back(std::make_pair(4, 1));
  expected.push_back(std::make_pair(4, 0));

  TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
}

TEST_P(TilingDataTest, SpiralDifferenceIteratorEdgeCases) {
  gfx::Point origin = GetParam();
  TilingData tiling_data(
      gfx::Size(10, 10), gfx::Rect(origin, gfx::Size(30, 30)), false);
  std::vector<std::pair<int, int> > expected;
  gfx::Rect center;
  gfx::Rect consider;
  gfx::Rect ignore;

  // Ignore contains, but is not equal to, consider and center.
  ignore = gfx::Rect(origin.x() + 15, origin.y(), 20, 30);
  consider = gfx::Rect(origin.x() + 20, origin.y() + 10, 10, 20);
  center = gfx::Rect(origin.x() + 25, origin.y(), 5, 5);

  // Layout of the tiling data, and expected return order:
  //   x 0 1 2
  //  y.------
  //  0|   . *
  //  1|   . .
  //  2|   . .
  expected.clear();

  TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);

  // Center intersects with consider.
  ignore = gfx::Rect();
  center = gfx::Rect(origin.x(), origin.y() + 15, 30, 15);
  consider = gfx::Rect(origin.x(), origin.y(), 15, 30);

  // Layout of the tiling data, and expected return order:
  //   x 0 1 2
  //  y.------
  //  0| 2 1
  //  1| * * *
  //  2| * * *
  expected.clear();

  expected.push_back(std::make_pair(1, 0));
  expected.push_back(std::make_pair(0, 0));

  TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);

  // Consider and ignore are non-intersecting.
  ignore = gfx::Rect(origin.x(), origin.y(), 5, 30);
  consider = gfx::Rect(origin.x() + 25, origin.y(), 5, 30);
  center = gfx::Rect(origin.x() + 15, origin.y(), 1, 1);

  // Layout of the tiling data, and expected return order:
  //   x 0 1 2
  //  y.------
  //  0| . * 1
  //  1| .   2
  //  2| .   3
  expected.clear();

  expected.push_back(std::make_pair(2, 0));
  expected.push_back(std::make_pair(2, 1));
  expected.push_back(std::make_pair(2, 2));

  TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);

  // Center intersects with ignore.
  consider = gfx::Rect(origin.x(), origin.y(), 30, 30);
  center = gfx::Rect(origin.x() + 15, origin.y(), 1, 30);
  ignore = gfx::Rect(origin.x(), origin.y() + 15, 30, 1);

  // Layout of the tiling data, and expected return order:
  //   x 0 1 2
  //  y.------
  //  0| 3 * 2
  //  1| . * .
  //  2| 4 * 1
  expected.clear();

  expected.push_back(std::make_pair(2, 2));
  expected.push_back(std::make_pair(2, 0));
  expected.push_back(std::make_pair(0, 0));
  expected.push_back(std::make_pair(0, 2));

  TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);

  // Center and ignore are the same.
  consider = gfx::Rect(origin.x(), origin.y(), 30, 30);
  center = gfx::Rect(origin.x() + 15, origin.y(), 1, 30);
  ignore = center;

  // Layout of the tiling data, and expected return order:
  //   x 0 1 2
  //  y.------
  //  0| 4 * 3
  //  1| 5 * 2
  //  2| 6 * 1
  expected.clear();

  expected.push_back(std::make_pair(2, 2));
  expected.push_back(std::make_pair(2, 1));
  expected.push_back(std::make_pair(2, 0));
  expected.push_back(std::make_pair(0, 0));
  expected.push_back(std::make_pair(0, 1));
  expected.push_back(std::make_pair(0, 2));

  TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);

  // Empty tiling data.
  TilingData empty_data(gfx::Size(0, 0), gfx::Rect(0, 0, 0, 0), false);

  expected.clear();
  TestSpiralIterate(__LINE__, empty_data, consider, ignore, center, expected);

  // Empty consider.
  ignore = gfx::Rect();
  center = gfx::Rect(1, 1, 1, 1);
  consider = gfx::Rect();

  expected.clear();
  TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);

  // Empty center. Note: This arbitrarily puts the center to be off the top-left
  // corner.
  consider = gfx::Rect(origin.x(), origin.y(), 30, 30);
  ignore = gfx::Rect();
  center = gfx::Rect();

  // Layout of the tiling data, and expected return order:
  // * x 0 1 2
  //  y.------
  //  0| 1 2 6
  //  1| 3 4 5
  //  2| 7 8 9
  expected.clear();

  expected.push_back(std::make_pair(0, 0));
  expected.push_back(std::make_pair(1, 0));
  expected.push_back(std::make_pair(0, 1));
  expected.push_back(std::make_pair(1, 1));
  expected.push_back(std::make_pair(2, 1));
  expected.push_back(std::make_pair(2, 0));
  expected.push_back(std::make_pair(0, 2));
  expected.push_back(std::make_pair(1, 2));
  expected.push_back(std::make_pair(2, 2));

  TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);

  // Every rect is empty.
  ignore = gfx::Rect();
  center = gfx::Rect();
  consider = gfx::Rect();

  expected.clear();
  TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);

  // Center is just to the left of cover, and off of the tiling's left side.
  consider = gfx::Rect(origin.x(), origin.y(), 30, 30);
  ignore = gfx::Rect();
  center = gfx::Rect(origin.x() - 20, origin.y(), 19, 30);

  // Layout of the tiling data, and expected return order:
  //   x 0 1 2
  //  y.------
  // *0| 3 6 9
  // *1| 2 5 8
  // *2| 1 4 7
  expected.clear();

  expected.push_back(std::make_pair(0, 2));
  expected.push_back(std::make_pair(0, 1));
  expected.push_back(std::make_pair(0, 0));
  expected.push_back(std::make_pair(1, 2));
  expected.push_back(std::make_pair(1, 1));
  expected.push_back(std::make_pair(1, 0));
  expected.push_back(std::make_pair(2, 2));
  expected.push_back(std::make_pair(2, 1));
  expected.push_back(std::make_pair(2, 0));

  TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
}

INSTANTIATE_TEST_CASE_P(TilingData,
                        TilingDataTest,
                        ::testing::Values(gfx::Point(42, 17),
                                          gfx::Point(0, 0),
                                          gfx::Point(-8, 15),
                                          gfx::Point(-12, 4),
                                          gfx::Point(-16, -35),
                                          gfx::Point(-10000, -15000)));
}  // namespace

}  // namespace cc