cc: Give TilingData a Rect instead of a Size

This patch changes the assumption that the tiling covers the entire layer. It
can now cover an arbitray sub-rect, called the tiling_rect. This will be used
to implement viewport tiling in a separate patch.

R=enne@chromium.org
BUG=362668

Review URL: https://codereview.chromium.org/235753002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@264083 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 2535 insertions, 919 deletions

diff --git a/cc/base/tiling_data.cc b/cc/base/tiling_data.cc
index 7573ec3..af581ff 100644
--- a/cc/base/tiling_data.cc
+++ b/cc/base/tiling_data.cc
@@ -28,28 +28,26 @@ TilingData::TilingData()
   RecomputeNumTiles();
 }
 
-TilingData::TilingData(
-    const gfx::Size& max_texture_size,
-    const gfx::Size& total_size,
-    bool has_border_texels)
+TilingData::TilingData(const gfx::Size& max_texture_size,
+                       const gfx::Rect& tiling_rect,
+                       bool has_border_texels)
     : max_texture_size_(max_texture_size),
-      total_size_(total_size),
+      tiling_rect_(tiling_rect),
       border_texels_(has_border_texels ? 1 : 0) {
   RecomputeNumTiles();
 }
 
-TilingData::TilingData(
-    const gfx::Size& max_texture_size,
-    const gfx::Size& total_size,
-    int border_texels)
+TilingData::TilingData(const gfx::Size& max_texture_size,
+                       const gfx::Rect& tiling_rect,
+                       int border_texels)
     : max_texture_size_(max_texture_size),
-      total_size_(total_size),
+      tiling_rect_(tiling_rect),
       border_texels_(border_texels) {
   RecomputeNumTiles();
 }
 
-void TilingData::SetTotalSize(const gfx::Size& total_size) {
-  total_size_ = total_size;
+void TilingData::SetTilingRect(const gfx::Rect& tiling_rect) {
+  tiling_rect_ = tiling_rect;
   RecomputeNumTiles();
 }
 
@@ -72,6 +70,8 @@ int TilingData::TileXIndexFromSrcCoord(int src_position) const {
   if (num_tiles_x_ <= 1)
     return 0;
 
+  src_position -= tiling_rect_.x();
+
   DCHECK_GT(max_texture_size_.width() - 2 * border_texels_, 0);
   int x = (src_position - border_texels_) /
       (max_texture_size_.width() - 2 * border_texels_);
@@ -82,6 +82,8 @@ int TilingData::TileYIndexFromSrcCoord(int src_position) const {
   if (num_tiles_y_ <= 1)
     return 0;
 
+  src_position -= tiling_rect_.y();
+
   DCHECK_GT(max_texture_size_.height() - 2 * border_texels_, 0);
   int y = (src_position - border_texels_) /
       (max_texture_size_.height() - 2 * border_texels_);
@@ -92,6 +94,8 @@ int TilingData::FirstBorderTileXIndexFromSrcCoord(int src_position) const {
   if (num_tiles_x_ <= 1)
     return 0;
 
+  src_position -= tiling_rect_.x();
+
   DCHECK_GT(max_texture_size_.width() - 2 * border_texels_, 0);
   int inner_tile_size = max_texture_size_.width() - 2 * border_texels_;
   int x = (src_position - 2 * border_texels_) / inner_tile_size;
@@ -102,6 +106,8 @@ int TilingData::FirstBorderTileYIndexFromSrcCoord(int src_position) const {
   if (num_tiles_y_ <= 1)
     return 0;
 
+  src_position -= tiling_rect_.y();
+
   DCHECK_GT(max_texture_size_.height() - 2 * border_texels_, 0);
   int inner_tile_size = max_texture_size_.height() - 2 * border_texels_;
   int y = (src_position - 2 * border_texels_) / inner_tile_size;
@@ -112,6 +118,8 @@ int TilingData::LastBorderTileXIndexFromSrcCoord(int src_position) const {
   if (num_tiles_x_ <= 1)
     return 0;
 
+  src_position -= tiling_rect_.x();
+
   DCHECK_GT(max_texture_size_.width() - 2 * border_texels_, 0);
   int inner_tile_size = max_texture_size_.width() - 2 * border_texels_;
   int x = src_position / inner_tile_size;
@@ -122,6 +130,8 @@ int TilingData::LastBorderTileYIndexFromSrcCoord(int src_position) const {
   if (num_tiles_y_ <= 1)
     return 0;
 
+  src_position -= tiling_rect_.y();
+
   DCHECK_GT(max_texture_size_.height() - 2 * border_texels_, 0);
   int inner_tile_size = max_texture_size_.height() - 2 * border_texels_;
   int y = src_position / inner_tile_size;
@@ -132,38 +142,36 @@ gfx::Rect TilingData::TileBounds(int i, int j) const {
   AssertTile(i, j);
   int max_texture_size_x = max_texture_size_.width() - 2 * border_texels_;
   int max_texture_size_y = max_texture_size_.height() - 2 * border_texels_;
-  int total_size_x = total_size_.width();
-  int total_size_y = total_size_.height();
 
-  int lo_x = max_texture_size_x * i;
+  int lo_x = tiling_rect_.x() + max_texture_size_x * i;
   if (i != 0)
     lo_x += border_texels_;
 
-  int lo_y = max_texture_size_y * j;
+  int lo_y = tiling_rect_.y() + max_texture_size_y * j;
   if (j != 0)
     lo_y += border_texels_;
 
-  int hi_x = max_texture_size_x * (i + 1) + border_texels_;
+  int hi_x = tiling_rect_.x() + max_texture_size_x * (i + 1) + border_texels_;
   if (i + 1 == num_tiles_x_)
     hi_x += border_texels_;
 
-  int hi_y = max_texture_size_y * (j + 1) + border_texels_;
+  int hi_y = tiling_rect_.y() + max_texture_size_y * (j + 1) + border_texels_;
   if (j + 1 == num_tiles_y_)
     hi_y += border_texels_;
 
-  hi_x = std::min(hi_x, total_size_x);
-  hi_y = std::min(hi_y, total_size_y);
+  hi_x = std::min(hi_x, tiling_rect_.right());
+  hi_y = std::min(hi_y, tiling_rect_.bottom());
 
   int x = lo_x;
   int y = lo_y;
   int width = hi_x - lo_x;
   int height = hi_y - lo_y;
-  DCHECK_GE(x, 0);
-  DCHECK_GE(y, 0);
+  DCHECK_GE(x, tiling_rect_.x());
+  DCHECK_GE(y, tiling_rect_.y());
   DCHECK_GE(width, 0);
   DCHECK_GE(height, 0);
-  DCHECK_LE(x, total_size_.width());
-  DCHECK_LE(y, total_size_.height());
+  DCHECK_LE(x, tiling_rect_.right());
+  DCHECK_LE(y, tiling_rect_.bottom());
   return gfx::Rect(x, y, width, height);
 }
 
@@ -171,28 +179,26 @@ gfx::Rect TilingData::TileBoundsWithBorder(int i, int j) const {
   AssertTile(i, j);
   int max_texture_size_x = max_texture_size_.width() - 2 * border_texels_;
   int max_texture_size_y = max_texture_size_.height() - 2 * border_texels_;
-  int total_size_x = total_size_.width();
-  int total_size_y = total_size_.height();
 
-  int lo_x = max_texture_size_x * i;
-  int lo_y = max_texture_size_y * j;
+  int lo_x = tiling_rect_.x() + max_texture_size_x * i;
+  int lo_y = tiling_rect_.y() + max_texture_size_y * j;
 
   int hi_x = lo_x + max_texture_size_x + 2 * border_texels_;
   int hi_y = lo_y + max_texture_size_y + 2 * border_texels_;
 
-  hi_x = std::min(hi_x, total_size_x);
-  hi_y = std::min(hi_y, total_size_y);
+  hi_x = std::min(hi_x, tiling_rect_.right());
+  hi_y = std::min(hi_y, tiling_rect_.bottom());
 
   int x = lo_x;
   int y = lo_y;
   int width = hi_x - lo_x;
   int height = hi_y - lo_y;
-  DCHECK_GE(x, 0);
-  DCHECK_GE(y, 0);
+  DCHECK_GE(x, tiling_rect_.x());
+  DCHECK_GE(y, tiling_rect_.y());
   DCHECK_GE(width, 0);
   DCHECK_GE(height, 0);
-  DCHECK_LE(x, total_size_.width());
-  DCHECK_LE(y, total_size_.height());
+  DCHECK_LE(x, tiling_rect_.right());
+  DCHECK_LE(y, tiling_rect_.bottom());
   return gfx::Rect(x, y, width, height);
 }
 
@@ -204,6 +210,8 @@ int TilingData::TilePositionX(int x_index) const {
   if (x_index != 0)
     pos += border_texels_;
 
+  pos += tiling_rect_.x();
+
   return pos;
 }
 
@@ -215,6 +223,8 @@ int TilingData::TilePositionY(int y_index) const {
   if (y_index != 0)
     pos += border_texels_;
 
+  pos += tiling_rect_.y();
+
   return pos;
 }
 
@@ -223,13 +233,13 @@ int TilingData::TileSizeX(int x_index) const {
   DCHECK_LT(x_index, num_tiles_x_);
 
   if (!x_index && num_tiles_x_ == 1)
-    return total_size_.width();
+    return tiling_rect_.width();
   if (!x_index && num_tiles_x_ > 1)
     return max_texture_size_.width() - border_texels_;
   if (x_index < num_tiles_x_ - 1)
     return max_texture_size_.width() - 2 * border_texels_;
   if (x_index == num_tiles_x_ - 1)
-    return total_size_.width() - TilePositionX(x_index);
+    return tiling_rect_.right() - TilePositionX(x_index);
 
   NOTREACHED();
   return 0;
@@ -240,13 +250,13 @@ int TilingData::TileSizeY(int y_index) const {
   DCHECK_LT(y_index, num_tiles_y_);
 
   if (!y_index && num_tiles_y_ == 1)
-    return total_size_.height();
+    return tiling_rect_.height();
   if (!y_index && num_tiles_y_ > 1)
     return max_texture_size_.height() - border_texels_;
   if (y_index < num_tiles_y_ - 1)
     return max_texture_size_.height() - 2 * border_texels_;
   if (y_index == num_tiles_y_ - 1)
-    return total_size_.height() - TilePositionY(y_index);
+    return tiling_rect_.bottom() - TilePositionY(y_index);
 
   NOTREACHED();
   return 0;
@@ -261,9 +271,9 @@ gfx::Vector2d TilingData::TextureOffset(int x_index, int y_index) const {
 
 void TilingData::RecomputeNumTiles() {
   num_tiles_x_ = ComputeNumTiles(
-      max_texture_size_.width(), total_size_.width(), border_texels_);
+      max_texture_size_.width(), tiling_rect_.width(), border_texels_);
   num_tiles_y_ = ComputeNumTiles(
-      max_texture_size_.height(), total_size_.height(), border_texels_);
+      max_texture_size_.height(), tiling_rect_.height(), border_texels_);
 }
 
 TilingData::BaseIterator::BaseIterator(const TilingData* tiling_data)
@@ -284,7 +294,7 @@ TilingData::Iterator::Iterator(const TilingData* tiling_data,
   }
 
   gfx::Rect rect(tiling_rect);
-  rect.Intersect(gfx::Rect(tiling_data_->total_size()));
+  rect.Intersect(tiling_data_->tiling_rect());
 
   gfx::Rect top_left_tile;
   if (include_borders) {
@@ -341,11 +351,10 @@ TilingData::DifferenceIterator::DifferenceIterator(
     return;
   }
 
-  gfx::Rect bounds(tiling_data_->total_size());
   gfx::Rect consider(consider_rect);
   gfx::Rect ignore(ignore_rect);
-  consider.Intersect(bounds);
-  ignore.Intersect(bounds);
+  consider.Intersect(tiling_data_->tiling_rect());
+  ignore.Intersect(tiling_data_->tiling_rect());
   if (consider.IsEmpty()) {
     done();
     return;
@@ -449,12 +458,11 @@ TilingData::SpiralDifferenceIterator::SpiralDifferenceIterator(
     return;
   }
 
-  gfx::Rect bounds(tiling_data_->total_size());
   gfx::Rect consider(consider_rect);
   gfx::Rect ignore(ignore_rect);
   gfx::Rect center(center_rect);
-  consider.Intersect(bounds);
-  ignore.Intersect(bounds);
+  consider.Intersect(tiling_data_->tiling_rect());
+  ignore.Intersect(tiling_data_->tiling_rect());
   if (consider.IsEmpty()) {
     done();
     return;
@@ -491,18 +499,18 @@ TilingData::SpiralDifferenceIterator::SpiralDifferenceIterator(
 
   // Determine around left, such that it is between -1 and num_tiles_x.
   int around_left = 0;
-  if (center.x() < 0 || center.IsEmpty())
+  if (center.x() < tiling_data->tiling_rect().x() || center.IsEmpty())
     around_left = -1;
-  else if (center.x() > tiling_data->total_size().width())
+  else if (center.x() > tiling_data->tiling_rect().right())
     around_left = tiling_data->num_tiles_x();
   else
     around_left = tiling_data->FirstBorderTileXIndexFromSrcCoord(center.x());
 
   // Determine around top, such that it is between -1 and num_tiles_y.
   int around_top = 0;
-  if (center.y() < 0 || center.IsEmpty())
+  if (center.y() < tiling_data->tiling_rect().y() || center.IsEmpty())
     around_top = -1;
-  else if (center.y() > tiling_data->total_size().height())
+  else if (center.y() > tiling_data->tiling_rect().bottom())
     around_top = tiling_data->num_tiles_y();
   else
     around_top = tiling_data->FirstBorderTileYIndexFromSrcCoord(center.y());
@@ -510,9 +518,9 @@ TilingData::SpiralDifferenceIterator::SpiralDifferenceIterator(
   // Determine around right, such that it is between -1 and num_tiles_x.
   int right_src_coord = center.right() - 1;
   int around_right = 0;
-  if (right_src_coord < 0 || center.IsEmpty()) {
+  if (right_src_coord < tiling_data->tiling_rect().x() || center.IsEmpty()) {
     around_right = -1;
-  } else if (right_src_coord > tiling_data->total_size().width()) {
+  } else if (right_src_coord > tiling_data->tiling_rect().right()) {
     around_right = tiling_data->num_tiles_x();
   } else {
     around_right =
@@ -522,9 +530,9 @@ TilingData::SpiralDifferenceIterator::SpiralDifferenceIterator(
   // Determine around bottom, such that it is between -1 and num_tiles_y.
   int bottom_src_coord = center.bottom() - 1;
   int around_bottom = 0;
-  if (bottom_src_coord < 0 || center.IsEmpty()) {
+  if (bottom_src_coord < tiling_data->tiling_rect().y() || center.IsEmpty()) {
     around_bottom = -1;
-  } else if (bottom_src_coord > tiling_data->total_size().height()) {
+  } else if (bottom_src_coord > tiling_data->tiling_rect().bottom()) {
     around_bottom = tiling_data->num_tiles_y();
   } else {
     around_bottom =
diff --git a/cc/base/tiling_data.h b/cc/base/tiling_data.h
index d885c9b..27ec034 100644
--- a/cc/base/tiling_data.h
+++ b/cc/base/tiling_data.h
@@ -22,17 +22,15 @@ namespace cc {
 class CC_EXPORT TilingData {
  public:
   TilingData();
-  TilingData(
-      const gfx::Size& max_texture_size,
-      const gfx::Size& total_size,
-      bool has_border_texels);
-  TilingData(
-      const gfx::Size& max_texture_size,
-      const gfx::Size& total_size,
-      int border_texels);
-
-  gfx::Size total_size() const { return total_size_; }
-  void SetTotalSize(const gfx::Size& total_size);
+  TilingData(const gfx::Size& max_texture_size,
+             const gfx::Rect& tiling_rect,
+             bool has_border_texels);
+  TilingData(const gfx::Size& max_texture_size,
+             const gfx::Rect& tiling_rect,
+             int border_texels);
+
+  gfx::Rect tiling_rect() const { return tiling_rect_; }
+  void SetTilingRect(const gfx::Rect& tiling_rect);
 
   gfx::Size max_texture_size() const { return max_texture_size_; }
   void SetMaxTextureSize(const gfx::Size& max_texture_size);
@@ -193,7 +191,7 @@ class CC_EXPORT TilingData {
   void RecomputeNumTiles();
 
   gfx::Size max_texture_size_;
-  gfx::Size total_size_;
+  gfx::Rect tiling_rect_;
   int border_texels_;
 
   // These are computed values.
diff --git a/cc/base/tiling_data_unittest.cc b/cc/base/tiling_data_unittest.cc
index 8fb6442..1563b02 100644
--- a/cc/base/tiling_data_unittest.cc
+++ b/cc/base/tiling_data_unittest.cc
@@ -13,11 +13,10 @@
 namespace cc {
 namespace {
 
-int NumTiles(
-    const gfx::Size& max_texture_size,
-    const gfx::Size& total_size,
-    bool has_border_texels) {
-  TilingData tiling(max_texture_size, total_size, has_border_texels);
+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.
@@ -28,700 +27,2048 @@ int NumTiles(
   return num_tiles;
 }
 
-int XIndex(
-    const gfx::Size& max_texture_size,
-    const gfx::Size& total_size,
-    bool has_border_texels,
-    int x_coord) {
-  TilingData tiling(max_texture_size, total_size, has_border_texels);
+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::Size& total_size,
-    bool has_border_texels,
-    int y_coord) {
-  TilingData tiling(max_texture_size, total_size, has_border_texels);
+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::Size& total_size,
-    bool has_border_texels,
-    int x_coord) {
-  TilingData tiling(max_texture_size, total_size, has_border_texels);
+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::Size& total_size,
-    bool has_border_texels,
-    int y_coord) {
-  TilingData tiling(max_texture_size, total_size, has_border_texels);
+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::Size& total_size,
-    bool has_border_texels,
-    int x_coord) {
-  TilingData tiling(max_texture_size, total_size, has_border_texels);
+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::Size& total_size,
-    bool has_border_texels,
-    int y_coord) {
-  TilingData tiling(max_texture_size, total_size, has_border_texels);
+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::Size& total_size,
-    bool has_border_texels,
-    int x_index) {
-  TilingData tiling(max_texture_size, total_size, has_border_texels);
+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::Size& total_size,
-    bool has_border_texels,
-    int y_index) {
-  TilingData tiling(max_texture_size, total_size, has_border_texels);
+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::Size& total_size,
-    bool has_border_texels,
-    int x_index) {
-  TilingData tiling(max_texture_size, total_size, has_border_texels);
+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::Size& total_size,
-    bool has_border_texels,
-    int y_index) {
-  TilingData tiling(max_texture_size, total_size, has_border_texels);
+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);
 }
 
-TEST(TilingDataTest, NumTiles_NoTiling) {
-  EXPECT_EQ(1, NumTiles(gfx::Size(16, 16), gfx::Size(16, 16), false));
-  EXPECT_EQ(1, NumTiles(gfx::Size(16, 16), gfx::Size(15, 15), true));
-  EXPECT_EQ(1, NumTiles(gfx::Size(16, 16), gfx::Size(16, 16), true));
-  EXPECT_EQ(1, NumTiles(gfx::Size(16, 16), gfx::Size(1, 16), false));
-  EXPECT_EQ(1, NumTiles(gfx::Size(15, 15), gfx::Size(15, 15), true));
-  EXPECT_EQ(1, NumTiles(gfx::Size(32, 16), gfx::Size(32, 16), false));
-  EXPECT_EQ(1, NumTiles(gfx::Size(32, 16), gfx::Size(32, 16), true));
+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(TilingDataTest, NumTiles_TilingNoBorders) {
-  EXPECT_EQ(0, NumTiles(gfx::Size(0, 0), gfx::Size(0, 0), false));
-  EXPECT_EQ(0, NumTiles(gfx::Size(0, 0), gfx::Size(4, 0), false));
-  EXPECT_EQ(0, NumTiles(gfx::Size(0, 0), gfx::Size(0, 4), false));
-  EXPECT_EQ(0, NumTiles(gfx::Size(4, 4), gfx::Size(4, 0), false));
-  EXPECT_EQ(0, NumTiles(gfx::Size(4, 4), gfx::Size(0, 4), false));
-  EXPECT_EQ(0, NumTiles(gfx::Size(0, 0), gfx::Size(1, 1), false));
-
-  EXPECT_EQ(1, NumTiles(gfx::Size(1, 1), gfx::Size(1, 1), false));
-  EXPECT_EQ(2, NumTiles(gfx::Size(1, 1), gfx::Size(1, 2), false));
-  EXPECT_EQ(2, NumTiles(gfx::Size(1, 1), gfx::Size(2, 1), false));
-  EXPECT_EQ(1, NumTiles(gfx::Size(2, 2), gfx::Size(1, 1), false));
-  EXPECT_EQ(1, NumTiles(gfx::Size(2, 2), gfx::Size(1, 2), false));
-  EXPECT_EQ(1, NumTiles(gfx::Size(2, 2), gfx::Size(2, 1), false));
-  EXPECT_EQ(1, NumTiles(gfx::Size(2, 2), gfx::Size(2, 2), false));
-  EXPECT_EQ(1, NumTiles(gfx::Size(3, 3), gfx::Size(3, 3), false));
-
-  EXPECT_EQ(1, NumTiles(gfx::Size(4, 4), gfx::Size(1, 4), false));
-  EXPECT_EQ(1, NumTiles(gfx::Size(4, 4), gfx::Size(2, 4), false));
-  EXPECT_EQ(1, NumTiles(gfx::Size(4, 4), gfx::Size(3, 4), false));
-  EXPECT_EQ(1, NumTiles(gfx::Size(4, 4), gfx::Size(4, 4), false));
-  EXPECT_EQ(2, NumTiles(gfx::Size(4, 4), gfx::Size(5, 4), false));
-  EXPECT_EQ(2, NumTiles(gfx::Size(4, 4), gfx::Size(6, 4), false));
-  EXPECT_EQ(2, NumTiles(gfx::Size(4, 4), gfx::Size(7, 4), false));
-  EXPECT_EQ(2, NumTiles(gfx::Size(4, 4), gfx::Size(8, 4), false));
-  EXPECT_EQ(3, NumTiles(gfx::Size(4, 4), gfx::Size(9, 4), false));
-  EXPECT_EQ(3, NumTiles(gfx::Size(4, 4), gfx::Size(10, 4), false));
-  EXPECT_EQ(3, NumTiles(gfx::Size(4, 4), gfx::Size(11, 4), false));
-
-  EXPECT_EQ(1, NumTiles(gfx::Size(5, 5), gfx::Size(1, 5), false));
-  EXPECT_EQ(1, NumTiles(gfx::Size(5, 5), gfx::Size(2, 5), false));
-  EXPECT_EQ(1, NumTiles(gfx::Size(5, 5), gfx::Size(3, 5), false));
-  EXPECT_EQ(1, NumTiles(gfx::Size(5, 5), gfx::Size(4, 5), false));
-  EXPECT_EQ(1, NumTiles(gfx::Size(5, 5), gfx::Size(5, 5), false));
-  EXPECT_EQ(2, NumTiles(gfx::Size(5, 5), gfx::Size(6, 5), false));
-  EXPECT_EQ(2, NumTiles(gfx::Size(5, 5), gfx::Size(7, 5), false));
-  EXPECT_EQ(2, NumTiles(gfx::Size(5, 5), gfx::Size(8, 5), false));
-  EXPECT_EQ(2, NumTiles(gfx::Size(5, 5), gfx::Size(9, 5), false));
-  EXPECT_EQ(2, NumTiles(gfx::Size(5, 5), gfx::Size(10, 5), false));
-  EXPECT_EQ(3, NumTiles(gfx::Size(5, 5), gfx::Size(11, 5), false));
-
-  EXPECT_EQ(1, NumTiles(gfx::Size(16, 16), gfx::Size(16, 16), false));
-  EXPECT_EQ(1, NumTiles(gfx::Size(17, 17), gfx::Size(16, 16), false));
-  EXPECT_EQ(4, NumTiles(gfx::Size(15, 15), gfx::Size(16, 16), false));
-  EXPECT_EQ(4, NumTiles(gfx::Size(8, 8), gfx::Size(16, 16), false));
-  EXPECT_EQ(6, NumTiles(gfx::Size(8, 8), gfx::Size(17, 16), false));
-
-  EXPECT_EQ(8, NumTiles(gfx::Size(5, 8), gfx::Size(17, 16), false));
+TEST_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(TilingDataTest, NumTiles_TilingWithBorders) {
-  EXPECT_EQ(0, NumTiles(gfx::Size(0, 0), gfx::Size(0, 0), true));
-  EXPECT_EQ(0, NumTiles(gfx::Size(0, 0), gfx::Size(4, 0), true));
-  EXPECT_EQ(0, NumTiles(gfx::Size(0, 0), gfx::Size(0, 4), true));
-  EXPECT_EQ(0, NumTiles(gfx::Size(4, 4), gfx::Size(4, 0), true));
-  EXPECT_EQ(0, NumTiles(gfx::Size(4, 4), gfx::Size(0, 4), true));
-  EXPECT_EQ(0, NumTiles(gfx::Size(0, 0), gfx::Size(1, 1), true));
-
-  EXPECT_EQ(1, NumTiles(gfx::Size(1, 1), gfx::Size(1, 1), true));
-  EXPECT_EQ(0, NumTiles(gfx::Size(1, 1), gfx::Size(1, 2), true));
-  EXPECT_EQ(0, NumTiles(gfx::Size(1, 1), gfx::Size(2, 1), true));
-  EXPECT_EQ(1, NumTiles(gfx::Size(2, 2), gfx::Size(1, 1), true));
-  EXPECT_EQ(1, NumTiles(gfx::Size(2, 2), gfx::Size(1, 2), true));
-  EXPECT_EQ(1, NumTiles(gfx::Size(2, 2), gfx::Size(2, 1), true));
-  EXPECT_EQ(1, NumTiles(gfx::Size(2, 2), gfx::Size(2, 2), true));
-
-  EXPECT_EQ(1, NumTiles(gfx::Size(3, 3), gfx::Size(1, 3), true));
-  EXPECT_EQ(1, NumTiles(gfx::Size(3, 3), gfx::Size(2, 3), true));
-  EXPECT_EQ(1, NumTiles(gfx::Size(3, 3), gfx::Size(3, 3), true));
-  EXPECT_EQ(2, NumTiles(gfx::Size(3, 3), gfx::Size(4, 3), true));
-  EXPECT_EQ(3, NumTiles(gfx::Size(3, 3), gfx::Size(5, 3), true));
-  EXPECT_EQ(4, NumTiles(gfx::Size(3, 3), gfx::Size(6, 3), true));
-  EXPECT_EQ(5, NumTiles(gfx::Size(3, 3), gfx::Size(7, 3), true));
-
-  EXPECT_EQ(1, NumTiles(gfx::Size(4, 4), gfx::Size(1, 4), true));
-  EXPECT_EQ(1, NumTiles(gfx::Size(4, 4), gfx::Size(2, 4), true));
-  EXPECT_EQ(1, NumTiles(gfx::Size(4, 4), gfx::Size(3, 4), true));
-  EXPECT_EQ(1, NumTiles(gfx::Size(4, 4), gfx::Size(4, 4), true));
-  EXPECT_EQ(2, NumTiles(gfx::Size(4, 4), gfx::Size(5, 4), true));
-  EXPECT_EQ(2, NumTiles(gfx::Size(4, 4), gfx::Size(6, 4), true));
-  EXPECT_EQ(3, NumTiles(gfx::Size(4, 4), gfx::Size(7, 4), true));
-  EXPECT_EQ(3, NumTiles(gfx::Size(4, 4), gfx::Size(8, 4), true));
-  EXPECT_EQ(4, NumTiles(gfx::Size(4, 4), gfx::Size(9, 4), true));
-  EXPECT_EQ(4, NumTiles(gfx::Size(4, 4), gfx::Size(10, 4), true));
-  EXPECT_EQ(5, NumTiles(gfx::Size(4, 4), gfx::Size(11, 4), true));
-
-  EXPECT_EQ(1, NumTiles(gfx::Size(5, 5), gfx::Size(1, 5), true));
-  EXPECT_EQ(1, NumTiles(gfx::Size(5, 5), gfx::Size(2, 5), true));
-  EXPECT_EQ(1, NumTiles(gfx::Size(5, 5), gfx::Size(3, 5), true));
-  EXPECT_EQ(1, NumTiles(gfx::Size(5, 5), gfx::Size(4, 5), true));
-  EXPECT_EQ(1, NumTiles(gfx::Size(5, 5), gfx::Size(5, 5), true));
-  EXPECT_EQ(2, NumTiles(gfx::Size(5, 5), gfx::Size(6, 5), true));
-  EXPECT_EQ(2, NumTiles(gfx::Size(5, 5), gfx::Size(7, 5), true));
-  EXPECT_EQ(2, NumTiles(gfx::Size(5, 5), gfx::Size(8, 5), true));
-  EXPECT_EQ(3, NumTiles(gfx::Size(5, 5), gfx::Size(9, 5), true));
-  EXPECT_EQ(3, NumTiles(gfx::Size(5, 5), gfx::Size(10, 5), true));
-  EXPECT_EQ(3, NumTiles(gfx::Size(5, 5), gfx::Size(11, 5), true));
-
-  EXPECT_EQ(30, NumTiles(gfx::Size(8, 5), gfx::Size(16, 32), true));
+TEST_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(TilingDataTest, TileXIndexFromSrcCoord) {
-  EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 0));
-  EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 1));
-  EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 2));
-  EXPECT_EQ(1, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 3));
-  EXPECT_EQ(1, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 4));
-  EXPECT_EQ(1, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 5));
-  EXPECT_EQ(2, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 6));
-  EXPECT_EQ(2, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 7));
-  EXPECT_EQ(2, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 8));
-  EXPECT_EQ(3, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 9));
-  EXPECT_EQ(3, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 10));
-  EXPECT_EQ(3, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 11));
-
-  EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 0));
-  EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 1));
-  EXPECT_EQ(1, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 2));
-  EXPECT_EQ(2, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 3));
-  EXPECT_EQ(3, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 4));
-  EXPECT_EQ(4, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 5));
-  EXPECT_EQ(5, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 6));
-  EXPECT_EQ(6, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 7));
-  EXPECT_EQ(7, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 8));
-  EXPECT_EQ(7, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 9));
-  EXPECT_EQ(7, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 10));
-  EXPECT_EQ(7, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 11));
-
-  EXPECT_EQ(0, XIndex(gfx::Size(1, 1), gfx::Size(1, 1), false, 0));
-  EXPECT_EQ(0, XIndex(gfx::Size(2, 2), gfx::Size(2, 2), false, 0));
-  EXPECT_EQ(0, XIndex(gfx::Size(2, 2), gfx::Size(2, 2), false, 1));
-  EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 0));
-  EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 1));
-  EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 2));
-
-  EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(4, 3), false, 0));
-  EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(4, 3), false, 1));
-  EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(4, 3), false, 2));
-  EXPECT_EQ(1, XIndex(gfx::Size(3, 3), gfx::Size(4, 3), false, 3));
-
-  EXPECT_EQ(0, XIndex(gfx::Size(1, 1), gfx::Size(1, 1), true, 0));
-  EXPECT_EQ(0, XIndex(gfx::Size(2, 2), gfx::Size(2, 2), true, 0));
-  EXPECT_EQ(0, XIndex(gfx::Size(2, 2), gfx::Size(2, 2), true, 1));
-  EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 0));
-  EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 1));
-  EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 2));
-
-  EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 0));
-  EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 1));
-  EXPECT_EQ(1, XIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 2));
-  EXPECT_EQ(1, XIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 3));
+TEST_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(TilingDataTest, FirstBorderTileXIndexFromSrcCoord) {
-  EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 0));
-  EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 1));
-  EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 2));
-  EXPECT_EQ(1, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 3));
-  EXPECT_EQ(1, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 4));
-  EXPECT_EQ(1, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 5));
-  EXPECT_EQ(2, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 6));
-  EXPECT_EQ(2, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 7));
-  EXPECT_EQ(2, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 8));
-  EXPECT_EQ(3, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 9));
-  EXPECT_EQ(3, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 10));
-  EXPECT_EQ(3, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 11));
-
-  EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 0));
-  EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 1));
-  EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 2));
-  EXPECT_EQ(1, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 3));
-  EXPECT_EQ(2, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 4));
-  EXPECT_EQ(3, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 5));
-  EXPECT_EQ(4, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 6));
-  EXPECT_EQ(5, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 7));
-  EXPECT_EQ(6, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 8));
-  EXPECT_EQ(7, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 9));
-  EXPECT_EQ(7, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 10));
-  EXPECT_EQ(7, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 11));
-
-  EXPECT_EQ(0, MinBorderXIndex(gfx::Size(1, 1), gfx::Size(1, 1), false, 0));
-  EXPECT_EQ(0, MinBorderXIndex(gfx::Size(2, 2), gfx::Size(2, 2), false, 0));
-  EXPECT_EQ(0, MinBorderXIndex(gfx::Size(2, 2), gfx::Size(2, 2), false, 1));
-  EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 0));
-  EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 1));
-  EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 2));
-
-  EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), false, 0));
-  EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), false, 1));
-  EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), false, 2));
-  EXPECT_EQ(1, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), false, 3));
-
-  EXPECT_EQ(0, MinBorderXIndex(gfx::Size(1, 1), gfx::Size(1, 1), true, 0));
-  EXPECT_EQ(0, MinBorderXIndex(gfx::Size(2, 2), gfx::Size(2, 2), true, 0));
-  EXPECT_EQ(0, MinBorderXIndex(gfx::Size(2, 2), gfx::Size(2, 2), true, 1));
-  EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 0));
-  EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 1));
-  EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 2));
-
-  EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 0));
-  EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 1));
-  EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 2));
-  EXPECT_EQ(1, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 3));
+TEST_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(TilingDataTest, LastBorderTileXIndexFromSrcCoord) {
-  EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 0));
-  EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 1));
-  EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 2));
-  EXPECT_EQ(1, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 3));
-  EXPECT_EQ(1, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 4));
-  EXPECT_EQ(1, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 5));
-  EXPECT_EQ(2, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 6));
-  EXPECT_EQ(2, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 7));
-  EXPECT_EQ(2, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 8));
-  EXPECT_EQ(3, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 9));
-  EXPECT_EQ(3, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 10));
-  EXPECT_EQ(3, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 11));
-
-  EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 0));
-  EXPECT_EQ(1, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 1));
-  EXPECT_EQ(2, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 2));
-  EXPECT_EQ(3, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 3));
-  EXPECT_EQ(4, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 4));
-  EXPECT_EQ(5, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 5));
-  EXPECT_EQ(6, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 6));
-  EXPECT_EQ(7, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 7));
-  EXPECT_EQ(7, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 8));
-  EXPECT_EQ(7, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 9));
-  EXPECT_EQ(7, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 10));
-  EXPECT_EQ(7, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 11));
-
-  EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(1, 1), gfx::Size(1, 1), false, 0));
-  EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(2, 2), gfx::Size(2, 2), false, 0));
-  EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(2, 2), gfx::Size(2, 2), false, 1));
-  EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 0));
-  EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 1));
-  EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 2));
-
-  EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), false, 0));
-  EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), false, 1));
-  EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), false, 2));
-  EXPECT_EQ(1, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), false, 3));
-
-  EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(1, 1), gfx::Size(1, 1), true, 0));
-  EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(2, 2), gfx::Size(2, 2), true, 0));
-  EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(2, 2), gfx::Size(2, 2), true, 1));
-  EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 0));
-  EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 1));
-  EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 2));
-
-  EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 0));
-  EXPECT_EQ(1, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 1));
-  EXPECT_EQ(1, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 2));
-  EXPECT_EQ(1, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 3));
+TEST_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(TilingDataTest, TileYIndexFromSrcCoord) {
-  EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 0));
-  EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 1));
-  EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 2));
-  EXPECT_EQ(1, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 3));
-  EXPECT_EQ(1, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 4));
-  EXPECT_EQ(1, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 5));
-  EXPECT_EQ(2, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 6));
-  EXPECT_EQ(2, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 7));
-  EXPECT_EQ(2, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 8));
-  EXPECT_EQ(3, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 9));
-  EXPECT_EQ(3, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 10));
-  EXPECT_EQ(3, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 11));
-
-  EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 0));
-  EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 1));
-  EXPECT_EQ(1, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 2));
-  EXPECT_EQ(2, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 3));
-  EXPECT_EQ(3, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 4));
-  EXPECT_EQ(4, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 5));
-  EXPECT_EQ(5, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 6));
-  EXPECT_EQ(6, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 7));
-  EXPECT_EQ(7, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 8));
-  EXPECT_EQ(7, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 9));
-  EXPECT_EQ(7, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 10));
-  EXPECT_EQ(7, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 11));
-
-  EXPECT_EQ(0, YIndex(gfx::Size(1, 1), gfx::Size(1, 1), false, 0));
-  EXPECT_EQ(0, YIndex(gfx::Size(2, 2), gfx::Size(2, 2), false, 0));
-  EXPECT_EQ(0, YIndex(gfx::Size(2, 2), gfx::Size(2, 2), false, 1));
-  EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 0));
-  EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 1));
-  EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 2));
-
-  EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(3, 4), false, 0));
-  EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(3, 4), false, 1));
-  EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(3, 4), false, 2));
-  EXPECT_EQ(1, YIndex(gfx::Size(3, 3), gfx::Size(3, 4), false, 3));
-
-  EXPECT_EQ(0, YIndex(gfx::Size(1, 1), gfx::Size(1, 1), true, 0));
-  EXPECT_EQ(0, YIndex(gfx::Size(2, 2), gfx::Size(2, 2), true, 0));
-  EXPECT_EQ(0, YIndex(gfx::Size(2, 2), gfx::Size(2, 2), true, 1));
-  EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 0));
-  EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 1));
-  EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 2));
-
-  EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 0));
-  EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 1));
-  EXPECT_EQ(1, YIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 2));
-  EXPECT_EQ(1, YIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 3));
+TEST_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(TilingDataTest, FirstBorderTileYIndexFromSrcCoord) {
-  EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 0));
-  EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 1));
-  EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 2));
-  EXPECT_EQ(1, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 3));
-  EXPECT_EQ(1, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 4));
-  EXPECT_EQ(1, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 5));
-  EXPECT_EQ(2, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 6));
-  EXPECT_EQ(2, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 7));
-  EXPECT_EQ(2, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 8));
-  EXPECT_EQ(3, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 9));
-  EXPECT_EQ(3, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 10));
-  EXPECT_EQ(3, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 11));
-
-  EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 0));
-  EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 1));
-  EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 2));
-  EXPECT_EQ(1, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 3));
-  EXPECT_EQ(2, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 4));
-  EXPECT_EQ(3, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 5));
-  EXPECT_EQ(4, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 6));
-  EXPECT_EQ(5, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 7));
-  EXPECT_EQ(6, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 8));
-  EXPECT_EQ(7, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 9));
-  EXPECT_EQ(7, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 10));
-  EXPECT_EQ(7, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 11));
-
-  EXPECT_EQ(0, MinBorderYIndex(gfx::Size(1, 1), gfx::Size(1, 1), false, 0));
-  EXPECT_EQ(0, MinBorderYIndex(gfx::Size(2, 2), gfx::Size(2, 2), false, 0));
-  EXPECT_EQ(0, MinBorderYIndex(gfx::Size(2, 2), gfx::Size(2, 2), false, 1));
-  EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 0));
-  EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 1));
-  EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 2));
-
-  EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), false, 0));
-  EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), false, 1));
-  EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), false, 2));
-  EXPECT_EQ(1, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), false, 3));
-
-  EXPECT_EQ(0, MinBorderYIndex(gfx::Size(1, 1), gfx::Size(1, 1), true, 0));
-  EXPECT_EQ(0, MinBorderYIndex(gfx::Size(2, 2), gfx::Size(2, 2), true, 0));
-  EXPECT_EQ(0, MinBorderYIndex(gfx::Size(2, 2), gfx::Size(2, 2), true, 1));
-  EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 0));
-  EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 1));
-  EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 2));
-
-  EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 0));
-  EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 1));
-  EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 2));
-  EXPECT_EQ(1, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 3));
+TEST_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(TilingDataTest, LastBorderTileYIndexFromSrcCoord) {
-  EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 0));
-  EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 1));
-  EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 2));
-  EXPECT_EQ(1, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 3));
-  EXPECT_EQ(1, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 4));
-  EXPECT_EQ(1, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 5));
-  EXPECT_EQ(2, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 6));
-  EXPECT_EQ(2, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 7));
-  EXPECT_EQ(2, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 8));
-  EXPECT_EQ(3, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 9));
-  EXPECT_EQ(3, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 10));
-  EXPECT_EQ(3, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 11));
-
-  EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 0));
-  EXPECT_EQ(1, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 1));
-  EXPECT_EQ(2, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 2));
-  EXPECT_EQ(3, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 3));
-  EXPECT_EQ(4, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 4));
-  EXPECT_EQ(5, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 5));
-  EXPECT_EQ(6, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 6));
-  EXPECT_EQ(7, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 7));
-  EXPECT_EQ(7, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 8));
-  EXPECT_EQ(7, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 9));
-  EXPECT_EQ(7, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 10));
-  EXPECT_EQ(7, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 11));
-
-  EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(1, 1), gfx::Size(1, 1), false, 0));
-  EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(2, 2), gfx::Size(2, 2), false, 0));
-  EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(2, 2), gfx::Size(2, 2), false, 1));
-  EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 0));
-  EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 1));
-  EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 2));
-
-  EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), false, 0));
-  EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), false, 1));
-  EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), false, 2));
-  EXPECT_EQ(1, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), false, 3));
-
-  EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(1, 1), gfx::Size(1, 1), true, 0));
-  EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(2, 2), gfx::Size(2, 2), true, 0));
-  EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(2, 2), gfx::Size(2, 2), true, 1));
-  EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 0));
-  EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 1));
-  EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 2));
-
-  EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 0));
-  EXPECT_EQ(1, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 1));
-  EXPECT_EQ(1, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 2));
-  EXPECT_EQ(1, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 3));
+TEST_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(TilingDataTest, TileSizeX) {
-  EXPECT_EQ(5, SizeX(gfx::Size(5, 5), gfx::Size(5, 5), false, 0));
-  EXPECT_EQ(5, SizeX(gfx::Size(5, 5), gfx::Size(5, 5), true, 0));
-
-  EXPECT_EQ(5, SizeX(gfx::Size(5, 5), gfx::Size(6, 6), false, 0));
-  EXPECT_EQ(1, SizeX(gfx::Size(5, 5), gfx::Size(6, 6), false, 1));
-  EXPECT_EQ(4, SizeX(gfx::Size(5, 5), gfx::Size(6, 6), true, 0));
-  EXPECT_EQ(2, SizeX(gfx::Size(5, 5), gfx::Size(6, 6), true, 1));
-
-  EXPECT_EQ(5, SizeX(gfx::Size(5, 5), gfx::Size(8, 8), false, 0));
-  EXPECT_EQ(3, SizeX(gfx::Size(5, 5), gfx::Size(8, 8), false, 1));
-  EXPECT_EQ(4, SizeX(gfx::Size(5, 5), gfx::Size(8, 8), true, 0));
-  EXPECT_EQ(4, SizeX(gfx::Size(5, 5), gfx::Size(8, 8), true, 1));
-
-  EXPECT_EQ(5, SizeX(gfx::Size(5, 5), gfx::Size(10, 10), false, 0));
-  EXPECT_EQ(5, SizeX(gfx::Size(5, 5), gfx::Size(10, 10), false, 1));
-  EXPECT_EQ(4, SizeX(gfx::Size(5, 5), gfx::Size(10, 10), true, 0));
-  EXPECT_EQ(3, SizeX(gfx::Size(5, 5), gfx::Size(10, 10), true, 1));
-  EXPECT_EQ(3, SizeX(gfx::Size(5, 5), gfx::Size(10, 10), true, 2));
-
-  EXPECT_EQ(4, SizeX(gfx::Size(5, 5), gfx::Size(11, 11), true, 2));
-  EXPECT_EQ(3, SizeX(gfx::Size(5, 5), gfx::Size(12, 12), true, 2));
-
-  EXPECT_EQ(3, SizeX(gfx::Size(5, 9), gfx::Size(12, 17), true, 2));
+TEST_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(TilingDataTest, TileSizeY) {
-  EXPECT_EQ(5, SizeY(gfx::Size(5, 5), gfx::Size(5, 5), false, 0));
-  EXPECT_EQ(5, SizeY(gfx::Size(5, 5), gfx::Size(5, 5), true, 0));
-
-  EXPECT_EQ(5, SizeY(gfx::Size(5, 5), gfx::Size(6, 6), false, 0));
-  EXPECT_EQ(1, SizeY(gfx::Size(5, 5), gfx::Size(6, 6), false, 1));
-  EXPECT_EQ(4, SizeY(gfx::Size(5, 5), gfx::Size(6, 6), true, 0));
-  EXPECT_EQ(2, SizeY(gfx::Size(5, 5), gfx::Size(6, 6), true, 1));
-
-  EXPECT_EQ(5, SizeY(gfx::Size(5, 5), gfx::Size(8, 8), false, 0));
-  EXPECT_EQ(3, SizeY(gfx::Size(5, 5), gfx::Size(8, 8), false, 1));
-  EXPECT_EQ(4, SizeY(gfx::Size(5, 5), gfx::Size(8, 8), true, 0));
-  EXPECT_EQ(4, SizeY(gfx::Size(5, 5), gfx::Size(8, 8), true, 1));
-
-  EXPECT_EQ(5, SizeY(gfx::Size(5, 5), gfx::Size(10, 10), false, 0));
-  EXPECT_EQ(5, SizeY(gfx::Size(5, 5), gfx::Size(10, 10), false, 1));
-  EXPECT_EQ(4, SizeY(gfx::Size(5, 5), gfx::Size(10, 10), true, 0));
-  EXPECT_EQ(3, SizeY(gfx::Size(5, 5), gfx::Size(10, 10), true, 1));
-  EXPECT_EQ(3, SizeY(gfx::Size(5, 5), gfx::Size(10, 10), true, 2));
-
-  EXPECT_EQ(4, SizeY(gfx::Size(5, 5), gfx::Size(11, 11), true, 2));
-  EXPECT_EQ(3, SizeY(gfx::Size(5, 5), gfx::Size(12, 12), true, 2));
-
-  EXPECT_EQ(3, SizeY(gfx::Size(9, 5), gfx::Size(17, 12), true, 2));
+TEST_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(TilingDataTest, TileSizeX_and_TilePositionX) {
+TEST_P(TilingDataTest, TileSizeX_and_TilePositionX) {
+  gfx::Point origin = GetParam();
+
   // Single tile cases:
-  EXPECT_EQ(1, SizeX(gfx::Size(3, 3), gfx::Size(1, 1), false, 0));
-  EXPECT_EQ(0, PosX(gfx::Size(3, 3), gfx::Size(1, 1), false, 0));
-  EXPECT_EQ(1, SizeX(gfx::Size(3, 3), gfx::Size(1, 100), false, 0));
-  EXPECT_EQ(0, PosX(gfx::Size(3, 3), gfx::Size(1, 100), false, 0));
-  EXPECT_EQ(3, SizeX(gfx::Size(3, 3), gfx::Size(3, 1), false, 0));
-  EXPECT_EQ(0, PosX(gfx::Size(3, 3), gfx::Size(3, 1), false, 0));
-  EXPECT_EQ(3, SizeX(gfx::Size(3, 3), gfx::Size(3, 100), false, 0));
-  EXPECT_EQ(0, PosX(gfx::Size(3, 3), gfx::Size(3, 100), false, 0));
-  EXPECT_EQ(1, SizeX(gfx::Size(3, 3), gfx::Size(1, 1), true, 0));
-  EXPECT_EQ(0, PosX(gfx::Size(3, 3), gfx::Size(1, 1), true, 0));
-  EXPECT_EQ(1, SizeX(gfx::Size(3, 3), gfx::Size(1, 100), true, 0));
-  EXPECT_EQ(0, PosX(gfx::Size(3, 3), gfx::Size(1, 100), true, 0));
-  EXPECT_EQ(3, SizeX(gfx::Size(3, 3), gfx::Size(3, 1), true, 0));
-  EXPECT_EQ(0, PosX(gfx::Size(3, 3), gfx::Size(3, 1), true, 0));
-  EXPECT_EQ(3, SizeX(gfx::Size(3, 3), gfx::Size(3, 100), true, 0));
-  EXPECT_EQ(0, PosX(gfx::Size(3, 3), gfx::Size(3, 100), true, 0));
+  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::Size(6, 1), false));
-  EXPECT_EQ(3, SizeX(gfx::Size(3, 3), gfx::Size(6, 1), false, 0));
-  EXPECT_EQ(3, SizeX(gfx::Size(3, 3), gfx::Size(6, 1), false, 1));
-  EXPECT_EQ(0, PosX(gfx::Size(3, 3), gfx::Size(6, 1), false, 0));
-  EXPECT_EQ(3, PosX(gfx::Size(3, 3), gfx::Size(6, 1), false, 1));
-  EXPECT_EQ(3, SizeX(gfx::Size(3, 3), gfx::Size(6, 100), false, 0));
-  EXPECT_EQ(3, SizeX(gfx::Size(3, 3), gfx::Size(6, 100), false, 1));
-  EXPECT_EQ(0, PosX(gfx::Size(3, 3), gfx::Size(6, 100), false, 0));
-  EXPECT_EQ(3, PosX(gfx::Size(3, 3), gfx::Size(6, 100), false, 1));
+  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::Size(6, 1), true));
-  EXPECT_EQ(2, SizeX(gfx::Size(3, 3), gfx::Size(6, 1), true, 0));
-  EXPECT_EQ(1, SizeX(gfx::Size(3, 3), gfx::Size(6, 1), true, 1));
-  EXPECT_EQ(1, SizeX(gfx::Size(3, 3), gfx::Size(6, 1), true, 2));
-  EXPECT_EQ(2, SizeX(gfx::Size(3, 3), gfx::Size(6, 1), true, 3));
-  EXPECT_EQ(0, PosX(gfx::Size(3, 3), gfx::Size(6, 1), true, 0));
-  EXPECT_EQ(2, PosX(gfx::Size(3, 3), gfx::Size(6, 1), true, 1));
-  EXPECT_EQ(3, PosX(gfx::Size(3, 3), gfx::Size(6, 1), true, 2));
-  EXPECT_EQ(4, PosX(gfx::Size(3, 3), gfx::Size(6, 1), true, 3));
-  EXPECT_EQ(2, SizeX(gfx::Size(3, 7), gfx::Size(6, 100), true, 0));
-  EXPECT_EQ(1, SizeX(gfx::Size(3, 7), gfx::Size(6, 100), true, 1));
-  EXPECT_EQ(1, SizeX(gfx::Size(3, 7), gfx::Size(6, 100), true, 2));
-  EXPECT_EQ(2, SizeX(gfx::Size(3, 7), gfx::Size(6, 100), true, 3));
-  EXPECT_EQ(0, PosX(gfx::Size(3, 7), gfx::Size(6, 100), true, 0));
-  EXPECT_EQ(2, PosX(gfx::Size(3, 7), gfx::Size(6, 100), true, 1));
-  EXPECT_EQ(3, PosX(gfx::Size(3, 7), gfx::Size(6, 100), true, 2));
-  EXPECT_EQ(4, PosX(gfx::Size(3, 7), gfx::Size(6, 100), true, 3));
+  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(TilingDataTest, TileSizeY_and_TilePositionY) {
+TEST_P(TilingDataTest, TileSizeY_and_TilePositionY) {
+  gfx::Point origin = GetParam();
+
   // Single tile cases:
-  EXPECT_EQ(1, SizeY(gfx::Size(3, 3), gfx::Size(1, 1), false, 0));
-  EXPECT_EQ(0, PosY(gfx::Size(3, 3), gfx::Size(1, 1), false, 0));
-  EXPECT_EQ(1, SizeY(gfx::Size(3, 3), gfx::Size(100, 1), false, 0));
-  EXPECT_EQ(0, PosY(gfx::Size(3, 3), gfx::Size(100, 1), false, 0));
-  EXPECT_EQ(3, SizeY(gfx::Size(3, 3), gfx::Size(1, 3), false, 0));
-  EXPECT_EQ(0, PosY(gfx::Size(3, 3), gfx::Size(1, 3), false, 0));
-  EXPECT_EQ(3, SizeY(gfx::Size(3, 3), gfx::Size(100, 3), false, 0));
-  EXPECT_EQ(0, PosY(gfx::Size(3, 3), gfx::Size(100, 3), false, 0));
-  EXPECT_EQ(1, SizeY(gfx::Size(3, 3), gfx::Size(1, 1), true, 0));
-  EXPECT_EQ(0, PosY(gfx::Size(3, 3), gfx::Size(1, 1), true, 0));
-  EXPECT_EQ(1, SizeY(gfx::Size(3, 3), gfx::Size(100, 1), true, 0));
-  EXPECT_EQ(0, PosY(gfx::Size(3, 3), gfx::Size(100, 1), true, 0));
-  EXPECT_EQ(3, SizeY(gfx::Size(3, 3), gfx::Size(1, 3), true, 0));
-  EXPECT_EQ(0, PosY(gfx::Size(3, 3), gfx::Size(1, 3), true, 0));
-  EXPECT_EQ(3, SizeY(gfx::Size(3, 3), gfx::Size(100, 3), true, 0));
-  EXPECT_EQ(0, PosY(gfx::Size(3, 3), gfx::Size(100, 3), true, 0));
+  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::Size(1, 6), false));
-  EXPECT_EQ(3, SizeY(gfx::Size(3, 3), gfx::Size(1, 6), false, 0));
-  EXPECT_EQ(3, SizeY(gfx::Size(3, 3), gfx::Size(1, 6), false, 1));
-  EXPECT_EQ(0, PosY(gfx::Size(3, 3), gfx::Size(1, 6), false, 0));
-  EXPECT_EQ(3, PosY(gfx::Size(3, 3), gfx::Size(1, 6), false, 1));
-  EXPECT_EQ(3, SizeY(gfx::Size(3, 3), gfx::Size(100, 6), false, 0));
-  EXPECT_EQ(3, SizeY(gfx::Size(3, 3), gfx::Size(100, 6), false, 1));
-  EXPECT_EQ(0, PosY(gfx::Size(3, 3), gfx::Size(100, 6), false, 0));
-  EXPECT_EQ(3, PosY(gfx::Size(3, 3), gfx::Size(100, 6), false, 1));
+  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::Size(1, 6), true));
-  EXPECT_EQ(2, SizeY(gfx::Size(3, 3), gfx::Size(1, 6), true, 0));
-  EXPECT_EQ(1, SizeY(gfx::Size(3, 3), gfx::Size(1, 6), true, 1));
-  EXPECT_EQ(1, SizeY(gfx::Size(3, 3), gfx::Size(1, 6), true, 2));
-  EXPECT_EQ(2, SizeY(gfx::Size(3, 3), gfx::Size(1, 6), true, 3));
-  EXPECT_EQ(0, PosY(gfx::Size(3, 3), gfx::Size(1, 6), true, 0));
-  EXPECT_EQ(2, PosY(gfx::Size(3, 3), gfx::Size(1, 6), true, 1));
-  EXPECT_EQ(3, PosY(gfx::Size(3, 3), gfx::Size(1, 6), true, 2));
-  EXPECT_EQ(4, PosY(gfx::Size(3, 3), gfx::Size(1, 6), true, 3));
-  EXPECT_EQ(2, SizeY(gfx::Size(7, 3), gfx::Size(100, 6), true, 0));
-  EXPECT_EQ(1, SizeY(gfx::Size(7, 3), gfx::Size(100, 6), true, 1));
-  EXPECT_EQ(1, SizeY(gfx::Size(7, 3), gfx::Size(100, 6), true, 2));
-  EXPECT_EQ(2, SizeY(gfx::Size(7, 3), gfx::Size(100, 6), true, 3));
-  EXPECT_EQ(0, PosY(gfx::Size(7, 3), gfx::Size(100, 6), true, 0));
-  EXPECT_EQ(2, PosY(gfx::Size(7, 3), gfx::Size(100, 6), true, 1));
-  EXPECT_EQ(3, PosY(gfx::Size(7, 3), gfx::Size(100, 6), true, 2));
-  EXPECT_EQ(4, PosY(gfx::Size(7, 3), gfx::Size(100, 6), true, 3));
+  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(TilingDataTest, SetTotalSize) {
-  TilingData data(gfx::Size(5, 5), gfx::Size(5, 5), false);
-  EXPECT_EQ(5, data.total_size().width());
-  EXPECT_EQ(5, data.total_size().height());
+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.SetTotalSize(gfx::Size(6, 5));
-  EXPECT_EQ(6, data.total_size().width());
-  EXPECT_EQ(5, data.total_size().height());
+  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.SetTotalSize(gfx::Size(5, 12));
-  EXPECT_EQ(5, data.total_size().width());
-  EXPECT_EQ(12, data.total_size().height());
+  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());
@@ -730,8 +2077,10 @@ TEST(TilingDataTest, SetTotalSize) {
   EXPECT_EQ(2, data.TileSizeY(2));
 }
 
-TEST(TilingDataTest, SetMaxTextureSizeNoBorders) {
-  TilingData data(gfx::Size(8, 8), gfx::Size(16, 32), false);
+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());
 
@@ -756,8 +2105,10 @@ TEST(TilingDataTest, SetMaxTextureSizeNoBorders) {
   EXPECT_EQ(7, data.num_tiles_y());
 }
 
-TEST(TilingDataTest, SetMaxTextureSizeBorders) {
-  TilingData data(gfx::Size(8, 8), gfx::Size(16, 32), true);
+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());
 
@@ -782,31 +2133,41 @@ TEST(TilingDataTest, SetMaxTextureSizeBorders) {
   EXPECT_EQ(10, data.num_tiles_y());
 }
 
-TEST(TilingDataTest, Assignment) {
+TEST_P(TilingDataTest, Assignment) {
+  gfx::Point origin = GetParam();
+
   {
-    TilingData source(gfx::Size(8, 8), gfx::Size(16, 32), true);
+    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.total_size().width(), dest.total_size().width());
-    EXPECT_EQ(source.total_size().height(), dest.total_size().height());
+    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::Size(6, 100), false);
+    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.total_size().width(), dest.total_size().width());
-    EXPECT_EQ(source.total_size().height(), dest.total_size().height());
+    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(TilingDataTest, SetBorderTexels) {
-  TilingData data(gfx::Size(8, 8), gfx::Size(16, 32), false);
+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());
 
@@ -814,17 +2175,16 @@ TEST(TilingDataTest, SetBorderTexels) {
   EXPECT_EQ(3, data.num_tiles_x());
   EXPECT_EQ(5, data.num_tiles_y());
 
-  data.SetHasBorderTexels(true);
-  EXPECT_EQ(3, data.num_tiles_x());
-  EXPECT_EQ(5, data.num_tiles_y());
-
   data.SetHasBorderTexels(false);
   EXPECT_EQ(2, data.num_tiles_x());
   EXPECT_EQ(4, data.num_tiles_y());
 }
 
-TEST(TilingDataTest, LargeBorders) {
-  TilingData data(gfx::Size(100, 80), gfx::Size(200, 145), 30);
+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));
@@ -840,77 +2200,87 @@ TEST(TilingDataTest, LargeBorders) {
   EXPECT_EQ(35, data.TileSizeY(4));
   EXPECT_EQ(5, data.num_tiles_y());
 
-  EXPECT_RECT_EQ(gfx::Rect(0, 0, 70, 50), data.TileBounds(0, 0));
-  EXPECT_RECT_EQ(gfx::Rect(70, 50, 40, 20), data.TileBounds(1, 1));
-  EXPECT_RECT_EQ(gfx::Rect(110, 110, 40, 35), data.TileBounds(2, 4));
-  EXPECT_RECT_EQ(gfx::Rect(150, 70, 50, 20), data.TileBounds(3, 2));
-  EXPECT_RECT_EQ(gfx::Rect(150, 110, 50, 35), data.TileBounds(3, 4));
-
-  EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 80), data.TileBoundsWithBorder(0, 0));
-  EXPECT_RECT_EQ(gfx::Rect(40, 20, 100, 80), data.TileBoundsWithBorder(1, 1));
-  EXPECT_RECT_EQ(gfx::Rect(80, 80, 100, 65), data.TileBoundsWithBorder(2, 4));
-  EXPECT_RECT_EQ(gfx::Rect(120, 40, 80, 80), data.TileBoundsWithBorder(3, 2));
-  EXPECT_RECT_EQ(gfx::Rect(120, 80, 80, 65), data.TileBoundsWithBorder(3, 4));
-
-  EXPECT_EQ(0, data.TileXIndexFromSrcCoord(0));
-  EXPECT_EQ(0, data.TileXIndexFromSrcCoord(69));
-  EXPECT_EQ(1, data.TileXIndexFromSrcCoord(70));
-  EXPECT_EQ(1, data.TileXIndexFromSrcCoord(109));
-  EXPECT_EQ(2, data.TileXIndexFromSrcCoord(110));
-  EXPECT_EQ(2, data.TileXIndexFromSrcCoord(149));
-  EXPECT_EQ(3, data.TileXIndexFromSrcCoord(150));
-  EXPECT_EQ(3, data.TileXIndexFromSrcCoord(199));
-
-  EXPECT_EQ(0, data.TileYIndexFromSrcCoord(0));
-  EXPECT_EQ(0, data.TileYIndexFromSrcCoord(49));
-  EXPECT_EQ(1, data.TileYIndexFromSrcCoord(50));
-  EXPECT_EQ(1, data.TileYIndexFromSrcCoord(69));
-  EXPECT_EQ(2, data.TileYIndexFromSrcCoord(70));
-  EXPECT_EQ(2, data.TileYIndexFromSrcCoord(89));
-  EXPECT_EQ(3, data.TileYIndexFromSrcCoord(90));
-  EXPECT_EQ(3, data.TileYIndexFromSrcCoord(109));
-  EXPECT_EQ(4, data.TileYIndexFromSrcCoord(110));
-  EXPECT_EQ(4, data.TileYIndexFromSrcCoord(144));
-
-  EXPECT_EQ(0, data.FirstBorderTileXIndexFromSrcCoord(0));
-  EXPECT_EQ(0, data.FirstBorderTileXIndexFromSrcCoord(99));
-  EXPECT_EQ(1, data.FirstBorderTileXIndexFromSrcCoord(100));
-  EXPECT_EQ(1, data.FirstBorderTileXIndexFromSrcCoord(139));
-  EXPECT_EQ(2, data.FirstBorderTileXIndexFromSrcCoord(140));
-  EXPECT_EQ(2, data.FirstBorderTileXIndexFromSrcCoord(179));
-  EXPECT_EQ(3, data.FirstBorderTileXIndexFromSrcCoord(180));
-  EXPECT_EQ(3, data.FirstBorderTileXIndexFromSrcCoord(199));
-
-  EXPECT_EQ(0, data.FirstBorderTileYIndexFromSrcCoord(0));
-  EXPECT_EQ(0, data.FirstBorderTileYIndexFromSrcCoord(79));
-  EXPECT_EQ(1, data.FirstBorderTileYIndexFromSrcCoord(80));
-  EXPECT_EQ(1, data.FirstBorderTileYIndexFromSrcCoord(99));
-  EXPECT_EQ(2, data.FirstBorderTileYIndexFromSrcCoord(100));
-  EXPECT_EQ(2, data.FirstBorderTileYIndexFromSrcCoord(119));
-  EXPECT_EQ(3, data.FirstBorderTileYIndexFromSrcCoord(120));
-  EXPECT_EQ(3, data.FirstBorderTileYIndexFromSrcCoord(139));
-  EXPECT_EQ(4, data.FirstBorderTileYIndexFromSrcCoord(140));
-  EXPECT_EQ(4, data.FirstBorderTileYIndexFromSrcCoord(144));
-
-  EXPECT_EQ(0, data.LastBorderTileXIndexFromSrcCoord(0));
-  EXPECT_EQ(0, data.LastBorderTileXIndexFromSrcCoord(39));
-  EXPECT_EQ(1, data.LastBorderTileXIndexFromSrcCoord(40));
-  EXPECT_EQ(1, data.LastBorderTileXIndexFromSrcCoord(79));
-  EXPECT_EQ(2, data.LastBorderTileXIndexFromSrcCoord(80));
-  EXPECT_EQ(2, data.LastBorderTileXIndexFromSrcCoord(119));
-  EXPECT_EQ(3, data.LastBorderTileXIndexFromSrcCoord(120));
-  EXPECT_EQ(3, data.LastBorderTileXIndexFromSrcCoord(199));
-
-  EXPECT_EQ(0, data.LastBorderTileYIndexFromSrcCoord(0));
-  EXPECT_EQ(0, data.LastBorderTileYIndexFromSrcCoord(19));
-  EXPECT_EQ(1, data.LastBorderTileYIndexFromSrcCoord(20));
-  EXPECT_EQ(1, data.LastBorderTileYIndexFromSrcCoord(39));
-  EXPECT_EQ(2, data.LastBorderTileYIndexFromSrcCoord(40));
-  EXPECT_EQ(2, data.LastBorderTileYIndexFromSrcCoord(59));
-  EXPECT_EQ(3, data.LastBorderTileYIndexFromSrcCoord(60));
-  EXPECT_EQ(3, data.LastBorderTileYIndexFromSrcCoord(79));
-  EXPECT_EQ(4, data.LastBorderTileYIndexFromSrcCoord(80));
-  EXPECT_EQ(4, data.LastBorderTileYIndexFromSrcCoord(144));
+  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,
@@ -1027,103 +2397,237 @@ void TestIterateAll(const TilingData& data,
       data, rect, expect_left, expect_top, expect_right, expect_bottom);
 }
 
-TEST(TilingDataTest, IteratorNoBorderTexels) {
-  TilingData data(gfx::Size(10, 10), gfx::Size(40, 25), false);
+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(0, 0, 40, 25), 0, 0, 3, 2);
-  TestIterateAll(data, gfx::Rect(15, 15, 8, 8), 1, 1, 2, 2);
+  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(-100, -100, 1000, 1000), 0, 0, 3, 2);
-  TestIterateAll(data, gfx::Rect(-100, 20, 1000, 1), 0, 2, 3, 2);
-  TestIterateAll(data, gfx::Rect(29, -100, 31, 1000), 2, 0, 3, 2);
+  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(60, 80, 100, 100), 0, 0, -1, -1);
+  TestIterateAll(data,
+                 gfx::Rect(origin.x() + 60, origin.y() + 80, 100, 100),
+                 0,
+                 0,
+                 -1,
+                 -1);
 }
 
-TEST(TilingDataTest, BordersIteratorOneBorderTexel) {
-  TilingData data(gfx::Size(10, 20), gfx::Size(25, 45), true);
+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(0, 0, 25, 45), 0, 0, 2, 2);
-  TestIterateBorders(data, gfx::Rect(18, 19, 3, 17), 2, 0, 2, 1);
-  TestIterateBorders(data, gfx::Rect(10, 20, 6, 16), 1, 1, 1, 1);
-  TestIterateBorders(data, gfx::Rect(9, 19, 8, 18), 0, 0, 2, 2);
+  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(-100, -100, 1000, 1000), 0, 0, 2, 2);
-  TestIterateBorders(data, gfx::Rect(-100, 20, 1000, 1), 0, 1, 2, 1);
-  TestIterateBorders(data, gfx::Rect(18, -100, 6, 1000), 2, 0, 2, 2);
+  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(60, 80, 100, 100), 0, 0, -1, -1);
+  TestIterateBorders(data,
+                     gfx::Rect(origin.x() + 60, origin.y() + 80, 100, 100),
+                     0,
+                     0,
+                     -1,
+                     -1);
 }
 
-TEST(TilingDataTest, NoBordersIteratorOneBorderTexel) {
-  TilingData data(gfx::Size(10, 20), gfx::Size(25, 45), true);
+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(0, 0, 25, 45), 0, 0, 2, 2);
-  TestIterateNoBorders(data, gfx::Rect(17, 19, 3, 18), 2, 1, 2, 1);
-  TestIterateNoBorders(data, gfx::Rect(17, 19, 3, 19), 2, 1, 2, 2);
-  TestIterateNoBorders(data, gfx::Rect(8, 18, 9, 19), 0, 0, 1, 1);
-  TestIterateNoBorders(data, gfx::Rect(9, 19, 9, 19), 1, 1, 2, 2);
+  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(-100, -100, 1000, 1000), 0, 0, 2, 2);
-  TestIterateNoBorders(data, gfx::Rect(-100, 20, 1000, 1), 0, 1, 2, 1);
-  TestIterateNoBorders(data, gfx::Rect(18, -100, 6, 1000), 2, 0, 2, 2);
+  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(60, 80, 100, 100), 0, 0, -1, -1);
+  TestIterateNoBorders(data,
+                       gfx::Rect(origin.x() + 60, origin.y() + 80, 100, 100),
+                       0,
+                       0,
+                       -1,
+                       -1);
 }
 
-TEST(TilingDataTest, BordersIteratorManyBorderTexels) {
-  TilingData data(gfx::Size(50, 60), gfx::Size(65, 110), 20);
+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(0, 0, 65, 110), 0, 0, 2, 3);
-  TestIterateBorders(data, gfx::Rect(50, 60, 15, 65), 1, 1, 2, 3);
-  TestIterateBorders(data, gfx::Rect(60, 30, 2, 10), 2, 0, 2, 1);
+  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(-100, -100, 1000, 1000), 0, 0, 2, 3);
-  TestIterateBorders(data, gfx::Rect(-100, 10, 1000, 10), 0, 0, 2, 0);
-  TestIterateBorders(data, gfx::Rect(10, -100, 10, 1000), 0, 0, 1, 3);
+  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(65, 110, 100, 100), 0, 0, -1, -1);
+  TestIterateBorders(data,
+                     gfx::Rect(origin.x() + 65, origin.y() + 110, 100, 100),
+                     0,
+                     0,
+                     -1,
+                     -1);
 }
 
-TEST(TilingDataTest, NoBordersIteratorManyBorderTexels) {
-  TilingData data(gfx::Size(50, 60), gfx::Size(65, 110), 20);
+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(0, 0, 65, 110), 0, 0, 2, 3);
-  TestIterateNoBorders(data, gfx::Rect(30, 40, 15, 65), 1, 1, 2, 3);
-  TestIterateNoBorders(data, gfx::Rect(60, 20, 2, 21), 2, 0, 2, 1);
+  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(-100, -100, 1000, 1000), 0, 0, 2, 3);
-  TestIterateNoBorders(data, gfx::Rect(-100, 10, 1000, 10), 0, 0, 2, 0);
-  TestIterateNoBorders(data, gfx::Rect(10, -100, 10, 1000), 0, 0, 0, 3);
+  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(65, 110, 100, 100), 0, 0, -1, -1);
+  TestIterateNoBorders(data,
+                       gfx::Rect(origin.x() + 65, origin.y() + 110, 100, 100),
+                       0,
+                       0,
+                       -1,
+                       -1);
 }
 
-TEST(TilingDataTest, IteratorOneTile) {
-  TilingData no_border(gfx::Size(1000, 1000), gfx::Size(30, 40), false);
-  TestIterateAll(no_border, gfx::Rect(0, 0, 30, 40), 0, 0, 0, 0);
-  TestIterateAll(no_border, gfx::Rect(10, 10, 20, 20), 0, 0, 0, 0);
-  TestIterateAll(no_border, gfx::Rect(30, 40, 100, 100), 0, 0, -1, -1);
-
-  TilingData one_border(gfx::Size(1000, 1000), gfx::Size(30, 40), true);
-  TestIterateAll(one_border, gfx::Rect(0, 0, 30, 40), 0, 0, 0, 0);
-  TestIterateAll(one_border, gfx::Rect(10, 10, 20, 20), 0, 0, 0, 0);
-  TestIterateAll(one_border, gfx::Rect(30, 40, 100, 100), 0, 0, -1, -1);
-
-  TilingData big_border(gfx::Size(1000, 1000), gfx::Size(30, 40), 50);
-  TestIterateAll(big_border, gfx::Rect(0, 0, 30, 40), 0, 0, 0, 0);
-  TestIterateAll(big_border, gfx::Rect(10, 10, 20, 20), 0, 0, 0, 0);
-  TestIterateAll(big_border, gfx::Rect(30, 40, 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::Size(), false);
+  TilingData data(gfx::Size(100, 100), gfx::Rect(), false);
   TestIterateAll(data, gfx::Rect(0, 0, 100, 100), 0, 0, -1, -1);
 }
 
@@ -1161,89 +2665,176 @@ void TestDiff(
   EXPECT_EQ(0u, expected.size());
 }
 
-TEST(TilingDataTest, DifferenceIteratorIgnoreGeometry) {
+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::Size(40, 25), false);
+  TilingData data(
+      gfx::Size(10, 10), gfx::Rect(origin, gfx::Size(40, 25)), false);
 
   // Fully ignored
-  TestDiff(data, gfx::Rect(0, 0, 40, 25), gfx::Rect(0, 0, 40, 25), 0);
-  TestDiff(data, gfx::Rect(0, 0, 40, 25), gfx::Rect(-100, -100, 200, 200), 0);
-  TestDiff(data, gfx::Rect(0, 0, 40, 25), gfx::Rect(9, 9, 30, 15), 0);
-  TestDiff(data, gfx::Rect(15, 15, 8, 8), gfx::Rect(15, 15, 8, 8), 0);
+  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(0, 0, 40, 25), gfx::Rect(-30, -20, 8, 8), 12);
-  TestDiff(data, gfx::Rect(0, 0, 40, 25), gfx::Rect(), 12);
+  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(0, 0, 40, 25), gfx::Rect(0, 0, 20, 19), 8);
+  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(0, 0, 40, 25), gfx::Rect(20, 15, 20, 6), 8);
+  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(0, 0, 40, 25), gfx::Rect(0, 15, 20, 6), 8);
+  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(0, 0, 40, 25), gfx::Rect(20, 0, 20, 19), 8);
+  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(0, 0, 40, 25), gfx::Rect(10, 10, 5, 5), 11);
+  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(0, 0, 40, 25), gfx::Rect(0, 0, 11, 25), 6);
+  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(0, 0, 40, 25), gfx::Rect(11, 0, 11, 25), 6);
+  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(0, 0, 40, 25), gfx::Rect(30, 0, 2, 25), 9);
+  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(0, 0, 40, 25), gfx::Rect(0, 5, 40, 5), 8);
+  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(0, 0, 40, 25), gfx::Rect(0, 13, 40, 5), 8);
+  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(0, 0, 40, 25), gfx::Rect(0, 13, 40, 12), 4);
+  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(8, 0, 32, 25), gfx::Rect(0, 12, 5, 12), 10);
+  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(5, 2, 20, 10), gfx::Rect(25, 15, 5, 10), 5);
+  TestDiff(data,
+           gfx::Rect(origin.x() + 5, origin.y() + 2, 20, 10),
+           gfx::Rect(origin.x() + 25, origin.y() + 15, 5, 10),
+           5);
 }
 
-TEST(TilingDataTest, DifferenceIteratorManyBorderTexels) {
+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::Size(65, 110), 20);
+  TilingData data(gfx::Size(50, 60), gfx::Rect(origin, gfx::Size(65, 110)), 20);
 
   // Ignore one column, three rows
-  TestDiff(data, gfx::Rect(0, 30, 55, 80), gfx::Rect(5, 30, 5, 15), 9);
+  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(10, 30, 55, 80), gfx::Rect(30, 59, 20, 1), 3);
+  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(0, 0, 65, 110), gfx::Rect(30, 59, 1, 2), 0);
+  TestDiff(data,
+           gfx::Rect(origin.x(), origin.y(), 65, 110),
+           gfx::Rect(origin.x() + 30, origin.y() + 59, 1, 2),
+           0);
 }
 
-TEST(TilingDataTest, DifferenceIteratorOneTile) {
-  TilingData no_border(gfx::Size(1000, 1000), gfx::Size(30, 40), false);
-  TestDiff(no_border, gfx::Rect(0, 0, 30, 40), gfx::Rect(), 1);
-  TestDiff(no_border, gfx::Rect(5, 5, 100, 100), gfx::Rect(5, 5, 1, 1), 0);
-
-  TilingData one_border(gfx::Size(1000, 1000), gfx::Size(30, 40), true);
-  TestDiff(one_border, gfx::Rect(0, 0, 30, 40), gfx::Rect(), 1);
-  TestDiff(one_border, gfx::Rect(5, 5, 100, 100), gfx::Rect(5, 5, 1, 1), 0);
-
-  TilingData big_border(gfx::Size(1000, 1000), gfx::Size(30, 40), 50);
-  TestDiff(big_border, gfx::Rect(0, 0, 30, 40), gfx::Rect(), 1);
-  TestDiff(big_border, gfx::Rect(5, 5, 100, 100), gfx::Rect(5, 5, 1, 1), 0);
+TEST_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::Size(), false);
+  TilingData data(gfx::Size(100, 100), gfx::Rect(), false);
   TestDiff(data, gfx::Rect(0, 0, 100, 100), gfx::Rect(0, 0, 5, 5), 0);
 }
 
@@ -1271,14 +2862,16 @@ void TestSpiralIterate(int source_line_number,
   }
 }
 
-TEST(TilingDataTest, SpiralDifferenceIteratorNoIgnoreFullConsider) {
-  TilingData tiling_data(gfx::Size(10, 10), gfx::Size(30, 30), false);
-  gfx::Rect consider(0, 0, 30, 30);
+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(15, 15, 1, 1);
+  gfx::Rect center(origin.x() + 15, origin.y() + 15, 1, 1);
 
   // Layout of the tiling data, and expected return order:
   //   x 0 1 2
@@ -1298,7 +2891,7 @@ TEST(TilingDataTest, SpiralDifferenceIteratorNoIgnoreFullConsider) {
   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
 
   // Center is off to the right side of the tiling (and far away).
-  center = gfx::Rect(100, 15, 1, 1);
+  center = gfx::Rect(origin.x() + 100, origin.y() + 15, 1, 1);
 
   // Layout of the tiling data, and expected return order:
   //   x 0 1 2
@@ -1320,7 +2913,7 @@ TEST(TilingDataTest, SpiralDifferenceIteratorNoIgnoreFullConsider) {
   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
 
   // Center is the bottom right corner of the tiling.
-  center = gfx::Rect(25, 25, 1, 1);
+  center = gfx::Rect(origin.x() + 25, origin.y() + 25, 1, 1);
 
   // Layout of the tiling data, and expected return order:
   //   x 0 1 2
@@ -1341,7 +2934,7 @@ TEST(TilingDataTest, SpiralDifferenceIteratorNoIgnoreFullConsider) {
   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
 
   // Center is off the top left side of the tiling.
-  center = gfx::Rect(-60, -50, 1, 1);
+  center = gfx::Rect(origin.x() - 60, origin.y() - 50, 1, 1);
 
   // Layout of the tiling data, and expected return order:
   // * x 0 1 2
@@ -1363,7 +2956,7 @@ TEST(TilingDataTest, SpiralDifferenceIteratorNoIgnoreFullConsider) {
   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
 
   // Two tile center.
-  center = gfx::Rect(15, 15, 1, 10);
+  center = gfx::Rect(origin.x() + 15, origin.y() + 15, 1, 10);
 
   // Layout of the tiling data, and expected return order:
   //   x 0 1 2
@@ -1383,14 +2976,16 @@ TEST(TilingDataTest, SpiralDifferenceIteratorNoIgnoreFullConsider) {
   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
 }
 
-TEST(TilingDataTest, SpiralDifferenceIteratorSmallConsider) {
-  TilingData tiling_data(gfx::Size(10, 10), gfx::Size(50, 50), false);
+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(15, 15, 1, 1);
+  gfx::Rect center(origin.x() + 15, origin.y() + 15, 1, 1);
 
   // Consider is one cell.
-  gfx::Rect consider(0, 0, 1, 1);
+  gfx::Rect consider(origin.x(), origin.y(), 1, 1);
 
   // Layout of the tiling data, and expected return order:
   //   x 0 1 2 3 4
@@ -1405,7 +3000,7 @@ TEST(TilingDataTest, SpiralDifferenceIteratorSmallConsider) {
   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
 
   // Consider is bottom right corner.
-  consider = gfx::Rect(25, 25, 10, 10);
+  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
@@ -1424,7 +3019,7 @@ TEST(TilingDataTest, SpiralDifferenceIteratorSmallConsider) {
   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
 
   // Consider is one column.
-  consider = gfx::Rect(11, 0, 1, 100);
+  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
@@ -1443,14 +3038,16 @@ TEST(TilingDataTest, SpiralDifferenceIteratorSmallConsider) {
   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
 }
 
-TEST(TilingDataTest, SpiralDifferenceIteratorHasIgnore) {
-  TilingData tiling_data(gfx::Size(10, 10), gfx::Size(50, 50), false);
-  gfx::Rect consider(0, 0, 50, 50);
+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(15, 15, 1, 1);
+  gfx::Rect center(origin.x() + 15, origin.y() + 15, 1, 1);
 
   // Full ignore.
-  gfx::Rect ignore(0, 0, 50, 50);
+  gfx::Rect ignore(origin.x(), origin.y(), 50, 50);
 
   // Layout of the tiling data, and expected return order:
   //   x 0 1 2 3 4
@@ -1465,7 +3062,7 @@ TEST(TilingDataTest, SpiralDifferenceIteratorHasIgnore) {
   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
 
   // 3 column ignore.
-  ignore = gfx::Rect(15, 0, 20, 100);
+  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
@@ -1491,7 +3088,7 @@ TEST(TilingDataTest, SpiralDifferenceIteratorHasIgnore) {
   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
 
   // Ignore covers the top half.
-  ignore = gfx::Rect(0, 0, 50, 25);
+  ignore = gfx::Rect(origin.x(), origin.y(), 50, 25);
 
   // Layout of the tiling data, and expected return order:
   //   x 0 1 2 3 4
@@ -1517,14 +3114,16 @@ TEST(TilingDataTest, SpiralDifferenceIteratorHasIgnore) {
   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
 }
 
-TEST(TilingDataTest, SpiralDifferenceIteratorRectangleCenter) {
-  TilingData tiling_data(gfx::Size(10, 10), gfx::Size(50, 50), false);
-  gfx::Rect consider(0, 0, 50, 50);
+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(25, 25, 1, 10);
+  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
@@ -1563,7 +3162,7 @@ TEST(TilingDataTest, SpiralDifferenceIteratorRectangleCenter) {
   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
 
   // Three by two center.
-  center = gfx::Rect(15, 25, 20, 10);
+  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
@@ -1598,7 +3197,7 @@ TEST(TilingDataTest, SpiralDifferenceIteratorRectangleCenter) {
   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
 
   // Column center off the left side.
-  center = gfx::Rect(-50, 0, 30, 50);
+  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
@@ -1639,17 +3238,19 @@ TEST(TilingDataTest, SpiralDifferenceIteratorRectangleCenter) {
   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
 }
 
-TEST(TilingDataTest, SpiralDifferenceIteratorEdgeCases) {
-  TilingData tiling_data(gfx::Size(10, 10), gfx::Size(30, 30), false);
+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(15, 0, 20, 30);
-  consider = gfx::Rect(20, 10, 10, 20);
-  center = gfx::Rect(25, 0, 5, 5);
+  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
@@ -1663,8 +3264,8 @@ TEST(TilingDataTest, SpiralDifferenceIteratorEdgeCases) {
 
   // Center intersects with consider.
   ignore = gfx::Rect();
-  center = gfx::Rect(0, 15, 30, 15);
-  consider = gfx::Rect(0, 0, 15, 30);
+  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
@@ -1680,9 +3281,9 @@ TEST(TilingDataTest, SpiralDifferenceIteratorEdgeCases) {
   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
 
   // Consider and ignore are non-intersecting.
-  ignore = gfx::Rect(0, 0, 5, 30);
-  consider = gfx::Rect(25, 0, 5, 30);
-  center = gfx::Rect(15, 0, 1, 1);
+  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
@@ -1699,9 +3300,9 @@ TEST(TilingDataTest, SpiralDifferenceIteratorEdgeCases) {
   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
 
   // Center intersects with ignore.
-  consider = gfx::Rect(0, 0, 30, 30);
-  center = gfx::Rect(15, 0, 1, 30);
-  ignore = gfx::Rect(0, 15, 30, 1);
+  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
@@ -1719,8 +3320,8 @@ TEST(TilingDataTest, SpiralDifferenceIteratorEdgeCases) {
   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
 
   // Center and ignore are the same.
-  consider = gfx::Rect(0, 0, 30, 30);
-  center = gfx::Rect(15, 0, 1, 30);
+  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:
@@ -1741,7 +3342,7 @@ TEST(TilingDataTest, SpiralDifferenceIteratorEdgeCases) {
   TestSpiralIterate(__LINE__, tiling_data, consider, ignore, center, expected);
 
   // Empty tiling data.
-  TilingData empty_data(gfx::Size(0, 0), gfx::Size(0, 0), false);
+  TilingData empty_data(gfx::Size(0, 0), gfx::Rect(0, 0, 0, 0), false);
 
   expected.clear();
   TestSpiralIterate(__LINE__, empty_data, consider, ignore, center, expected);
@@ -1756,7 +3357,7 @@ TEST(TilingDataTest, SpiralDifferenceIteratorEdgeCases) {
 
   // Empty center. Note: This arbitrarily puts the center to be off the top-left
   // corner.
-  consider = gfx::Rect(0, 0, 30, 30);
+  consider = gfx::Rect(origin.x(), origin.y(), 30, 30);
   ignore = gfx::Rect();
   center = gfx::Rect();
 
@@ -1789,9 +3390,9 @@ TEST(TilingDataTest, SpiralDifferenceIteratorEdgeCases) {
   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(0, 0, 30, 30);
+  consider = gfx::Rect(origin.x(), origin.y(), 30, 30);
   ignore = gfx::Rect();
-  center = gfx::Rect(-20, 0, 19, 30);
+  center = gfx::Rect(origin.x() - 20, origin.y(), 19, 30);
 
   // Layout of the tiling data, and expected return order:
   //   x 0 1 2
@@ -1813,6 +3414,15 @@ TEST(TilingDataTest, SpiralDifferenceIteratorEdgeCases) {
 
   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