cc/base/tiling_data_unittest.cc - Issue 235753002: cc: Give TilingData a Rect instead of a Size

Side by Side Diff: cc/base/tiling_data_unittest.cc

Issue 235753002: cc: Give TilingData a Rect instead of a Size (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src

Patch Set: Git cl format Created 6 years, 8 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch | Annotate | Revision Log

OLD	NEW
1 // Copyright 2013 The Chromium Authors. All rights reserved.	1 // Copyright 2013 The Chromium Authors. All rights reserved.

2 // Use of this source code is governed by a BSD-style license that can be	2 // Use of this source code is governed by a BSD-style license that can be

3 // found in the LICENSE file.	3 // found in the LICENSE file.

4	4

5 #include "cc/base/tiling_data.h"	5 #include "cc/base/tiling_data.h"

6	6

7 #include <algorithm>	7 #include <algorithm>

8 #include <vector>	8 #include <vector>

9	9

10 #include "cc/test/geometry_test_utils.h"	10 #include "cc/test/geometry_test_utils.h"

11 #include "testing/gtest/include/gtest/gtest.h"	11 #include "testing/gtest/include/gtest/gtest.h"

12	12

13 namespace cc {	13 namespace cc {

14 namespace {	14 namespace {

15	15

16 int NumTiles(	16 int NumTiles(const gfx::Size& max_texture_size,

17 const gfx::Size& max_texture_size,	17 const gfx::Rect& tiling_rect,

18 const gfx::Size& total_size,	18 bool has_border_texels) {

19 bool has_border_texels) {	19 TilingData tiling(max_texture_size, tiling_rect, has_border_texels);

20 TilingData tiling(max_texture_size, total_size, has_border_texels);

21 int num_tiles = tiling.num_tiles_x() * tiling.num_tiles_y();	20 int num_tiles = tiling.num_tiles_x() * tiling.num_tiles_y();

22	21

23 // Assert no overflow.	22 // Assert no overflow.

24 EXPECT_GE(num_tiles, 0);	23 EXPECT_GE(num_tiles, 0);

25 if (num_tiles > 0)	24 if (num_tiles > 0)

26 EXPECT_EQ(num_tiles / tiling.num_tiles_x(), tiling.num_tiles_y());	25 EXPECT_EQ(num_tiles / tiling.num_tiles_x(), tiling.num_tiles_y());

27	26

28 return num_tiles;	27 return num_tiles;

29 }	28 }

30	29

31 int XIndex(	30 int XIndex(const gfx::Size& max_texture_size,

32 const gfx::Size& max_texture_size,	31 const gfx::Rect& tiling_rect,

33 const gfx::Size& total_size,	32 bool has_border_texels,

34 bool has_border_texels,	33 int x_coord) {

35 int x_coord) {	34 TilingData tiling(max_texture_size, tiling_rect, has_border_texels);

36 TilingData tiling(max_texture_size, total_size, has_border_texels);

37 return tiling.TileXIndexFromSrcCoord(x_coord);	35 return tiling.TileXIndexFromSrcCoord(x_coord);

38 }	36 }

39	37

40 int YIndex(	38 int YIndex(const gfx::Size& max_texture_size,

41 const gfx::Size& max_texture_size,	39 const gfx::Rect& tiling_rect,

42 const gfx::Size& total_size,	40 bool has_border_texels,

43 bool has_border_texels,	41 int y_coord) {

44 int y_coord) {	42 TilingData tiling(max_texture_size, tiling_rect, has_border_texels);

45 TilingData tiling(max_texture_size, total_size, has_border_texels);

46 return tiling.TileYIndexFromSrcCoord(y_coord);	43 return tiling.TileYIndexFromSrcCoord(y_coord);

47 }	44 }

48	45

49 int MinBorderXIndex(	46 int MinBorderXIndex(const gfx::Size& max_texture_size,

50 const gfx::Size& max_texture_size,	47 const gfx::Rect& tiling_rect,

51 const gfx::Size& total_size,	48 bool has_border_texels,

52 bool has_border_texels,	49 int x_coord) {

53 int x_coord) {	50 TilingData tiling(max_texture_size, tiling_rect, has_border_texels);

54 TilingData tiling(max_texture_size, total_size, has_border_texels);

55 return tiling.FirstBorderTileXIndexFromSrcCoord(x_coord);	51 return tiling.FirstBorderTileXIndexFromSrcCoord(x_coord);

56 }	52 }

57	53

58 int MinBorderYIndex(	54 int MinBorderYIndex(const gfx::Size& max_texture_size,

59 const gfx::Size& max_texture_size,	55 const gfx::Rect& tiling_rect,

60 const gfx::Size& total_size,	56 bool has_border_texels,

61 bool has_border_texels,	57 int y_coord) {

62 int y_coord) {	58 TilingData tiling(max_texture_size, tiling_rect, has_border_texels);

63 TilingData tiling(max_texture_size, total_size, has_border_texels);

64 return tiling.FirstBorderTileYIndexFromSrcCoord(y_coord);	59 return tiling.FirstBorderTileYIndexFromSrcCoord(y_coord);

65 }	60 }

66	61

67 int MaxBorderXIndex(	62 int MaxBorderXIndex(const gfx::Size& max_texture_size,

68 const gfx::Size& max_texture_size,	63 const gfx::Rect& tiling_rect,

69 const gfx::Size& total_size,	64 bool has_border_texels,

70 bool has_border_texels,	65 int x_coord) {

71 int x_coord) {	66 TilingData tiling(max_texture_size, tiling_rect, has_border_texels);

72 TilingData tiling(max_texture_size, total_size, has_border_texels);

73 return tiling.LastBorderTileXIndexFromSrcCoord(x_coord);	67 return tiling.LastBorderTileXIndexFromSrcCoord(x_coord);

74 }	68 }

75	69

76 int MaxBorderYIndex(	70 int MaxBorderYIndex(const gfx::Size& max_texture_size,

77 const gfx::Size& max_texture_size,	71 const gfx::Rect& tiling_rect,

78 const gfx::Size& total_size,	72 bool has_border_texels,

79 bool has_border_texels,	73 int y_coord) {

80 int y_coord) {	74 TilingData tiling(max_texture_size, tiling_rect, has_border_texels);

81 TilingData tiling(max_texture_size, total_size, has_border_texels);

82 return tiling.LastBorderTileYIndexFromSrcCoord(y_coord);	75 return tiling.LastBorderTileYIndexFromSrcCoord(y_coord);

83 }	76 }

84	77

85 int PosX(	78 int PosX(const gfx::Size& max_texture_size,

86 const gfx::Size& max_texture_size,	79 const gfx::Rect& tiling_rect,

87 const gfx::Size& total_size,	80 bool has_border_texels,

88 bool has_border_texels,	81 int x_index) {

89 int x_index) {	82 TilingData tiling(max_texture_size, tiling_rect, has_border_texels);

90 TilingData tiling(max_texture_size, total_size, has_border_texels);

91 return tiling.TilePositionX(x_index);	83 return tiling.TilePositionX(x_index);

92 }	84 }

93	85

94 int PosY(	86 int PosY(const gfx::Size& max_texture_size,

95 const gfx::Size& max_texture_size,	87 const gfx::Rect& tiling_rect,

96 const gfx::Size& total_size,	88 bool has_border_texels,

97 bool has_border_texels,	89 int y_index) {

98 int y_index) {	90 TilingData tiling(max_texture_size, tiling_rect, has_border_texels);

99 TilingData tiling(max_texture_size, total_size, has_border_texels);

100 return tiling.TilePositionY(y_index);	91 return tiling.TilePositionY(y_index);

101 }	92 }

102	93

103 int SizeX(	94 int SizeX(const gfx::Size& max_texture_size,

104 const gfx::Size& max_texture_size,	95 const gfx::Rect& tiling_rect,

105 const gfx::Size& total_size,	96 bool has_border_texels,

106 bool has_border_texels,	97 int x_index) {

107 int x_index) {	98 TilingData tiling(max_texture_size, tiling_rect, has_border_texels);

108 TilingData tiling(max_texture_size, total_size, has_border_texels);

109 return tiling.TileSizeX(x_index);	99 return tiling.TileSizeX(x_index);

110 }	100 }

111	101

112 int SizeY(	102 int SizeY(const gfx::Size& max_texture_size,

113 const gfx::Size& max_texture_size,	103 const gfx::Rect& tiling_rect,

114 const gfx::Size& total_size,	104 bool has_border_texels,

115 bool has_border_texels,	105 int y_index) {

116 int y_index) {	106 TilingData tiling(max_texture_size, tiling_rect, has_border_texels);

117 TilingData tiling(max_texture_size, total_size, has_border_texels);

118 return tiling.TileSizeY(y_index);	107 return tiling.TileSizeY(y_index);

119 }	108 }

120	109

121 TEST(TilingDataTest, NumTiles_NoTiling) {	110 class TilingDataTest : public ::testing::TestWithParam<gfx::Point> {};

122 EXPECT_EQ(1, NumTiles(gfx::Size(16, 16), gfx::Size(16, 16), false));	111

123 EXPECT_EQ(1, NumTiles(gfx::Size(16, 16), gfx::Size(15, 15), true));	112 TEST_P(TilingDataTest, NumTiles_NoTiling) {

124 EXPECT_EQ(1, NumTiles(gfx::Size(16, 16), gfx::Size(16, 16), true));	113 gfx::Point origin = GetParam();

125 EXPECT_EQ(1, NumTiles(gfx::Size(16, 16), gfx::Size(1, 16), false));	114

126 EXPECT_EQ(1, NumTiles(gfx::Size(15, 15), gfx::Size(15, 15), true));	115 EXPECT_EQ(

127 EXPECT_EQ(1, NumTiles(gfx::Size(32, 16), gfx::Size(32, 16), false));	116 1,

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

129 }	118 EXPECT_EQ(

130	119 1,

131 TEST(TilingDataTest, NumTiles_TilingNoBorders) {	120 NumTiles(gfx::Size(16, 16), gfx::Rect(origin, gfx::Size(15, 15)), true));

132 EXPECT_EQ(0, NumTiles(gfx::Size(0, 0), gfx::Size(0, 0), false));	121 EXPECT_EQ(

133 EXPECT_EQ(0, NumTiles(gfx::Size(0, 0), gfx::Size(4, 0), false));	122 1,

134 EXPECT_EQ(0, NumTiles(gfx::Size(0, 0), gfx::Size(0, 4), false));	123 NumTiles(gfx::Size(16, 16), gfx::Rect(origin, gfx::Size(16, 16)), true));

135 EXPECT_EQ(0, NumTiles(gfx::Size(4, 4), gfx::Size(4, 0), false));	124 EXPECT_EQ(

136 EXPECT_EQ(0, NumTiles(gfx::Size(4, 4), gfx::Size(0, 4), false));	125 1,

137 EXPECT_EQ(0, NumTiles(gfx::Size(0, 0), gfx::Size(1, 1), false));	126 NumTiles(gfx::Size(16, 16), gfx::Rect(origin, gfx::Size(1, 16)), false));

138	127 EXPECT_EQ(

139 EXPECT_EQ(1, NumTiles(gfx::Size(1, 1), gfx::Size(1, 1), false));	128 1,

140 EXPECT_EQ(2, NumTiles(gfx::Size(1, 1), gfx::Size(1, 2), false));	129 NumTiles(gfx::Size(15, 15), gfx::Rect(origin, gfx::Size(15, 15)), true));

141 EXPECT_EQ(2, NumTiles(gfx::Size(1, 1), gfx::Size(2, 1), false));	130 EXPECT_EQ(

142 EXPECT_EQ(1, NumTiles(gfx::Size(2, 2), gfx::Size(1, 1), false));	131 1,

143 EXPECT_EQ(1, NumTiles(gfx::Size(2, 2), gfx::Size(1, 2), false));	132 NumTiles(gfx::Size(32, 16), gfx::Rect(origin, gfx::Size(32, 16)), false));

144 EXPECT_EQ(1, NumTiles(gfx::Size(2, 2), gfx::Size(2, 1), false));	133 EXPECT_EQ(

145 EXPECT_EQ(1, NumTiles(gfx::Size(2, 2), gfx::Size(2, 2), false));	134 1,

146 EXPECT_EQ(1, NumTiles(gfx::Size(3, 3), gfx::Size(3, 3), false));	135 NumTiles(gfx::Size(32, 16), gfx::Rect(origin, gfx::Size(32, 16)), true));

147	136 }

148 EXPECT_EQ(1, NumTiles(gfx::Size(4, 4), gfx::Size(1, 4), false));	137

149 EXPECT_EQ(1, NumTiles(gfx::Size(4, 4), gfx::Size(2, 4), false));	138 TEST_P(TilingDataTest, NumTiles_TilingNoBorders) {

150 EXPECT_EQ(1, NumTiles(gfx::Size(4, 4), gfx::Size(3, 4), false));	139 gfx::Point origin = GetParam();

151 EXPECT_EQ(1, NumTiles(gfx::Size(4, 4), gfx::Size(4, 4), false));	140

152 EXPECT_EQ(2, NumTiles(gfx::Size(4, 4), gfx::Size(5, 4), false));	141 EXPECT_EQ(

153 EXPECT_EQ(2, NumTiles(gfx::Size(4, 4), gfx::Size(6, 4), false));	142 0, NumTiles(gfx::Size(0, 0), gfx::Rect(origin, gfx::Size(0, 0)), false));

154 EXPECT_EQ(2, NumTiles(gfx::Size(4, 4), gfx::Size(7, 4), false));	143 EXPECT_EQ(

155 EXPECT_EQ(2, NumTiles(gfx::Size(4, 4), gfx::Size(8, 4), false));	144 0, NumTiles(gfx::Size(0, 0), gfx::Rect(origin, gfx::Size(4, 0)), false));

156 EXPECT_EQ(3, NumTiles(gfx::Size(4, 4), gfx::Size(9, 4), false));	145 EXPECT_EQ(

157 EXPECT_EQ(3, NumTiles(gfx::Size(4, 4), gfx::Size(10, 4), false));	146 0, NumTiles(gfx::Size(0, 0), gfx::Rect(origin, gfx::Size(0, 4)), false));

158 EXPECT_EQ(3, NumTiles(gfx::Size(4, 4), gfx::Size(11, 4), false));	147 EXPECT_EQ(

159	148 0, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(4, 0)), false));

160 EXPECT_EQ(1, NumTiles(gfx::Size(5, 5), gfx::Size(1, 5), false));	149 EXPECT_EQ(

161 EXPECT_EQ(1, NumTiles(gfx::Size(5, 5), gfx::Size(2, 5), false));	150 0, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(0, 4)), false));

162 EXPECT_EQ(1, NumTiles(gfx::Size(5, 5), gfx::Size(3, 5), false));	151 EXPECT_EQ(

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

164 EXPECT_EQ(1, NumTiles(gfx::Size(5, 5), gfx::Size(5, 5), false));	153

165 EXPECT_EQ(2, NumTiles(gfx::Size(5, 5), gfx::Size(6, 5), false));	154 EXPECT_EQ(

166 EXPECT_EQ(2, NumTiles(gfx::Size(5, 5), gfx::Size(7, 5), false));	155 1, NumTiles(gfx::Size(1, 1), gfx::Rect(origin, gfx::Size(1, 1)), false));

167 EXPECT_EQ(2, NumTiles(gfx::Size(5, 5), gfx::Size(8, 5), false));	156 EXPECT_EQ(

168 EXPECT_EQ(2, NumTiles(gfx::Size(5, 5), gfx::Size(9, 5), false));	157 2, NumTiles(gfx::Size(1, 1), gfx::Rect(origin, gfx::Size(1, 2)), false));

169 EXPECT_EQ(2, NumTiles(gfx::Size(5, 5), gfx::Size(10, 5), false));	158 EXPECT_EQ(

170 EXPECT_EQ(3, NumTiles(gfx::Size(5, 5), gfx::Size(11, 5), false));	159 2, NumTiles(gfx::Size(1, 1), gfx::Rect(origin, gfx::Size(2, 1)), false));

171	160 EXPECT_EQ(

172 EXPECT_EQ(1, NumTiles(gfx::Size(16, 16), gfx::Size(16, 16), false));	161 1, NumTiles(gfx::Size(2, 2), gfx::Rect(origin, gfx::Size(1, 1)), false));

173 EXPECT_EQ(1, NumTiles(gfx::Size(17, 17), gfx::Size(16, 16), false));	162 EXPECT_EQ(

174 EXPECT_EQ(4, NumTiles(gfx::Size(15, 15), gfx::Size(16, 16), false));	163 1, NumTiles(gfx::Size(2, 2), gfx::Rect(origin, gfx::Size(1, 2)), false));

175 EXPECT_EQ(4, NumTiles(gfx::Size(8, 8), gfx::Size(16, 16), false));	164 EXPECT_EQ(

176 EXPECT_EQ(6, NumTiles(gfx::Size(8, 8), gfx::Size(17, 16), false));	165 1, NumTiles(gfx::Size(2, 2), gfx::Rect(origin, gfx::Size(2, 1)), false));

177	166 EXPECT_EQ(

178 EXPECT_EQ(8, NumTiles(gfx::Size(5, 8), gfx::Size(17, 16), false));	167 1, NumTiles(gfx::Size(2, 2), gfx::Rect(origin, gfx::Size(2, 2)), false));

179 }	168 EXPECT_EQ(

180	169 1, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 3)), false));

181 TEST(TilingDataTest, NumTiles_TilingWithBorders) {	170

182 EXPECT_EQ(0, NumTiles(gfx::Size(0, 0), gfx::Size(0, 0), true));	171 EXPECT_EQ(

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

184 EXPECT_EQ(0, NumTiles(gfx::Size(0, 0), gfx::Size(0, 4), true));	173 EXPECT_EQ(

185 EXPECT_EQ(0, NumTiles(gfx::Size(4, 4), gfx::Size(4, 0), true));	174 1, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(2, 4)), false));

186 EXPECT_EQ(0, NumTiles(gfx::Size(4, 4), gfx::Size(0, 4), true));	175 EXPECT_EQ(

187 EXPECT_EQ(0, NumTiles(gfx::Size(0, 0), gfx::Size(1, 1), true));	176 1, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(3, 4)), false));

188	177 EXPECT_EQ(

189 EXPECT_EQ(1, NumTiles(gfx::Size(1, 1), gfx::Size(1, 1), true));	178 1, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(4, 4)), false));

190 EXPECT_EQ(0, NumTiles(gfx::Size(1, 1), gfx::Size(1, 2), true));	179 EXPECT_EQ(

191 EXPECT_EQ(0, NumTiles(gfx::Size(1, 1), gfx::Size(2, 1), true));	180 2, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(5, 4)), false));

192 EXPECT_EQ(1, NumTiles(gfx::Size(2, 2), gfx::Size(1, 1), true));	181 EXPECT_EQ(

193 EXPECT_EQ(1, NumTiles(gfx::Size(2, 2), gfx::Size(1, 2), true));	182 2, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(6, 4)), false));

194 EXPECT_EQ(1, NumTiles(gfx::Size(2, 2), gfx::Size(2, 1), true));	183 EXPECT_EQ(

195 EXPECT_EQ(1, NumTiles(gfx::Size(2, 2), gfx::Size(2, 2), true));	184 2, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(7, 4)), false));

196	185 EXPECT_EQ(

197 EXPECT_EQ(1, NumTiles(gfx::Size(3, 3), gfx::Size(1, 3), true));	186 2, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(8, 4)), false));

198 EXPECT_EQ(1, NumTiles(gfx::Size(3, 3), gfx::Size(2, 3), true));	187 EXPECT_EQ(

199 EXPECT_EQ(1, NumTiles(gfx::Size(3, 3), gfx::Size(3, 3), true));	188 3, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(9, 4)), false));

200 EXPECT_EQ(2, NumTiles(gfx::Size(3, 3), gfx::Size(4, 3), true));	189 EXPECT_EQ(

201 EXPECT_EQ(3, NumTiles(gfx::Size(3, 3), gfx::Size(5, 3), true));	190 3, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(10, 4)), false));

202 EXPECT_EQ(4, NumTiles(gfx::Size(3, 3), gfx::Size(6, 3), true));	191 EXPECT_EQ(

203 EXPECT_EQ(5, NumTiles(gfx::Size(3, 3), gfx::Size(7, 3), true));	192 3, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(11, 4)), false));

204	193

205 EXPECT_EQ(1, NumTiles(gfx::Size(4, 4), gfx::Size(1, 4), true));	194 EXPECT_EQ(

206 EXPECT_EQ(1, NumTiles(gfx::Size(4, 4), gfx::Size(2, 4), true));	195 1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(1, 5)), false));

207 EXPECT_EQ(1, NumTiles(gfx::Size(4, 4), gfx::Size(3, 4), true));	196 EXPECT_EQ(

208 EXPECT_EQ(1, NumTiles(gfx::Size(4, 4), gfx::Size(4, 4), true));	197 1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(2, 5)), false));

209 EXPECT_EQ(2, NumTiles(gfx::Size(4, 4), gfx::Size(5, 4), true));	198 EXPECT_EQ(

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

211 EXPECT_EQ(3, NumTiles(gfx::Size(4, 4), gfx::Size(7, 4), true));	200 EXPECT_EQ(

212 EXPECT_EQ(3, NumTiles(gfx::Size(4, 4), gfx::Size(8, 4), true));	201 1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(4, 5)), false));

213 EXPECT_EQ(4, NumTiles(gfx::Size(4, 4), gfx::Size(9, 4), true));	202 EXPECT_EQ(

214 EXPECT_EQ(4, NumTiles(gfx::Size(4, 4), gfx::Size(10, 4), true));	203 1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(5, 5)), false));

215 EXPECT_EQ(5, NumTiles(gfx::Size(4, 4), gfx::Size(11, 4), true));	204 EXPECT_EQ(

216	205 2, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 5)), false));

217 EXPECT_EQ(1, NumTiles(gfx::Size(5, 5), gfx::Size(1, 5), true));	206 EXPECT_EQ(

218 EXPECT_EQ(1, NumTiles(gfx::Size(5, 5), gfx::Size(2, 5), true));	207 2, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(7, 5)), false));

219 EXPECT_EQ(1, NumTiles(gfx::Size(5, 5), gfx::Size(3, 5), true));	208 EXPECT_EQ(

220 EXPECT_EQ(1, NumTiles(gfx::Size(5, 5), gfx::Size(4, 5), true));	209 2, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 5)), false));

221 EXPECT_EQ(1, NumTiles(gfx::Size(5, 5), gfx::Size(5, 5), true));	210 EXPECT_EQ(

222 EXPECT_EQ(2, NumTiles(gfx::Size(5, 5), gfx::Size(6, 5), true));	211 2, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(9, 5)), false));

223 EXPECT_EQ(2, NumTiles(gfx::Size(5, 5), gfx::Size(7, 5), true));	212 EXPECT_EQ(

224 EXPECT_EQ(2, NumTiles(gfx::Size(5, 5), gfx::Size(8, 5), true));	213 2, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 5)), false));

225 EXPECT_EQ(3, NumTiles(gfx::Size(5, 5), gfx::Size(9, 5), true));	214 EXPECT_EQ(

226 EXPECT_EQ(3, NumTiles(gfx::Size(5, 5), gfx::Size(10, 5), true));	215 3, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(11, 5)), false));

227 EXPECT_EQ(3, NumTiles(gfx::Size(5, 5), gfx::Size(11, 5), true));	216

228	217 EXPECT_EQ(

229 EXPECT_EQ(30, NumTiles(gfx::Size(8, 5), gfx::Size(16, 32), true));	218 1,

230 }	219 NumTiles(gfx::Size(16, 16), gfx::Rect(origin, gfx::Size(16, 16)), false));

231	220 EXPECT_EQ(

232 TEST(TilingDataTest, TileXIndexFromSrcCoord) {	221 1,

233 EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 0));	222 NumTiles(gfx::Size(17, 17), gfx::Rect(origin, gfx::Size(16, 16)), false));

234 EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 1));	223 EXPECT_EQ(

235 EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 2));	224 4,

236 EXPECT_EQ(1, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 3));	225 NumTiles(gfx::Size(15, 15), gfx::Rect(origin, gfx::Size(16, 16)), false));

237 EXPECT_EQ(1, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 4));	226 EXPECT_EQ(

238 EXPECT_EQ(1, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 5));	227 4,

239 EXPECT_EQ(2, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 6));	228 NumTiles(gfx::Size(8, 8), gfx::Rect(origin, gfx::Size(16, 16)), false));

240 EXPECT_EQ(2, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 7));	229 EXPECT_EQ(

241 EXPECT_EQ(2, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 8));	230 6,

242 EXPECT_EQ(3, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 9));	231 NumTiles(gfx::Size(8, 8), gfx::Rect(origin, gfx::Size(17, 16)), false));

243 EXPECT_EQ(3, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 10));	232

244 EXPECT_EQ(3, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 11));	233 EXPECT_EQ(

245	234 8,

246 EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 0));	235 NumTiles(gfx::Size(5, 8), gfx::Rect(origin, gfx::Size(17, 16)), false));

247 EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 1));	236 }

248 EXPECT_EQ(1, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 2));	237

249 EXPECT_EQ(2, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 3));	238 TEST_P(TilingDataTest, NumTiles_TilingWithBorders) {

250 EXPECT_EQ(3, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 4));	239 gfx::Point origin = GetParam();

251 EXPECT_EQ(4, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 5));	240

252 EXPECT_EQ(5, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 6));	241 EXPECT_EQ(

253 EXPECT_EQ(6, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 7));	242 0, NumTiles(gfx::Size(0, 0), gfx::Rect(origin, gfx::Size(0, 0)), true));

254 EXPECT_EQ(7, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 8));	243 EXPECT_EQ(

255 EXPECT_EQ(7, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 9));	244 0, NumTiles(gfx::Size(0, 0), gfx::Rect(origin, gfx::Size(4, 0)), true));

256 EXPECT_EQ(7, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 10));	245 EXPECT_EQ(

257 EXPECT_EQ(7, XIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 11));	246 0, NumTiles(gfx::Size(0, 0), gfx::Rect(origin, gfx::Size(0, 4)), true));

258	247 EXPECT_EQ(

259 EXPECT_EQ(0, XIndex(gfx::Size(1, 1), gfx::Size(1, 1), false, 0));	248 0, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(4, 0)), true));

260 EXPECT_EQ(0, XIndex(gfx::Size(2, 2), gfx::Size(2, 2), false, 0));	249 EXPECT_EQ(

261 EXPECT_EQ(0, XIndex(gfx::Size(2, 2), gfx::Size(2, 2), false, 1));	250 0, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(0, 4)), true));

262 EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 0));	251 EXPECT_EQ(

263 EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 1));	252 0, NumTiles(gfx::Size(0, 0), gfx::Rect(origin, gfx::Size(1, 1)), true));

264 EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 2));	253

265	254 EXPECT_EQ(

266 EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(4, 3), false, 0));	255 1, NumTiles(gfx::Size(1, 1), gfx::Rect(origin, gfx::Size(1, 1)), true));

267 EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(4, 3), false, 1));	256 EXPECT_EQ(

268 EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(4, 3), false, 2));	257 0, NumTiles(gfx::Size(1, 1), gfx::Rect(origin, gfx::Size(1, 2)), true));

269 EXPECT_EQ(1, XIndex(gfx::Size(3, 3), gfx::Size(4, 3), false, 3));	258 EXPECT_EQ(

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

271 EXPECT_EQ(0, XIndex(gfx::Size(1, 1), gfx::Size(1, 1), true, 0));	260 EXPECT_EQ(

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

273 EXPECT_EQ(0, XIndex(gfx::Size(2, 2), gfx::Size(2, 2), true, 1));	262 EXPECT_EQ(

274 EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 0));	263 1, NumTiles(gfx::Size(2, 2), gfx::Rect(origin, gfx::Size(1, 2)), true));

275 EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 1));	264 EXPECT_EQ(

276 EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 2));	265 1, NumTiles(gfx::Size(2, 2), gfx::Rect(origin, gfx::Size(2, 1)), true));

277	266 EXPECT_EQ(

278 EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 0));	267 1, NumTiles(gfx::Size(2, 2), gfx::Rect(origin, gfx::Size(2, 2)), true));

279 EXPECT_EQ(0, XIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 1));	268

280 EXPECT_EQ(1, XIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 2));	269 EXPECT_EQ(

281 EXPECT_EQ(1, XIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 3));	270 1, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 3)), true));

282 }	271 EXPECT_EQ(

283	272 1, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(2, 3)), true));

284 TEST(TilingDataTest, FirstBorderTileXIndexFromSrcCoord) {	273 EXPECT_EQ(

285 EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 0));	274 1, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 3)), true));

286 EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 1));	275 EXPECT_EQ(

287 EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 2));	276 2, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(4, 3)), true));

288 EXPECT_EQ(1, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 3));	277 EXPECT_EQ(

289 EXPECT_EQ(1, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 4));	278 3, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(5, 3)), true));

290 EXPECT_EQ(1, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 5));	279 EXPECT_EQ(

291 EXPECT_EQ(2, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 6));	280 4, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 3)), true));

292 EXPECT_EQ(2, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 7));	281 EXPECT_EQ(

293 EXPECT_EQ(2, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 8));	282 5, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(7, 3)), true));

294 EXPECT_EQ(3, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 9));	283

295 EXPECT_EQ(3, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 10));	284 EXPECT_EQ(

296 EXPECT_EQ(3, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 11));	285 1, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(1, 4)), true));

297	286 EXPECT_EQ(

298 EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 0));	287 1, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(2, 4)), true));

299 EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 1));	288 EXPECT_EQ(

300 EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 2));	289 1, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(3, 4)), true));

301 EXPECT_EQ(1, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 3));	290 EXPECT_EQ(

302 EXPECT_EQ(2, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 4));	291 1, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(4, 4)), true));

303 EXPECT_EQ(3, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 5));	292 EXPECT_EQ(

304 EXPECT_EQ(4, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 6));	293 2, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(5, 4)), true));

305 EXPECT_EQ(5, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 7));	294 EXPECT_EQ(

306 EXPECT_EQ(6, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 8));	295 2, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(6, 4)), true));

307 EXPECT_EQ(7, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 9));	296 EXPECT_EQ(

308 EXPECT_EQ(7, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 10));	297 3, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(7, 4)), true));

309 EXPECT_EQ(7, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 11));	298 EXPECT_EQ(

310	299 3, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(8, 4)), true));

311 EXPECT_EQ(0, MinBorderXIndex(gfx::Size(1, 1), gfx::Size(1, 1), false, 0));	300 EXPECT_EQ(

312 EXPECT_EQ(0, MinBorderXIndex(gfx::Size(2, 2), gfx::Size(2, 2), false, 0));	301 4, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(9, 4)), true));

313 EXPECT_EQ(0, MinBorderXIndex(gfx::Size(2, 2), gfx::Size(2, 2), false, 1));	302 EXPECT_EQ(

314 EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 0));	303 4, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(10, 4)), true));

315 EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 1));	304 EXPECT_EQ(

316 EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 2));	305 5, NumTiles(gfx::Size(4, 4), gfx::Rect(origin, gfx::Size(11, 4)), true));

317	306

318 EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), false, 0));	307 EXPECT_EQ(

319 EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), false, 1));	308 1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(1, 5)), true));

320 EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), false, 2));	309 EXPECT_EQ(

321 EXPECT_EQ(1, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), false, 3));	310 1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(2, 5)), true));

322	311 EXPECT_EQ(

323 EXPECT_EQ(0, MinBorderXIndex(gfx::Size(1, 1), gfx::Size(1, 1), true, 0));	312 1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(3, 5)), true));

324 EXPECT_EQ(0, MinBorderXIndex(gfx::Size(2, 2), gfx::Size(2, 2), true, 0));	313 EXPECT_EQ(

325 EXPECT_EQ(0, MinBorderXIndex(gfx::Size(2, 2), gfx::Size(2, 2), true, 1));	314 1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(4, 5)), true));

326 EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 0));	315 EXPECT_EQ(

327 EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 1));	316 1, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(5, 5)), true));

328 EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 2));	317 EXPECT_EQ(

329	318 2, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 5)), true));

330 EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 0));	319 EXPECT_EQ(

331 EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 1));	320 2, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(7, 5)), true));

332 EXPECT_EQ(0, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 2));	321 EXPECT_EQ(

333 EXPECT_EQ(1, MinBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 3));	322 2, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 5)), true));

334 }	323 EXPECT_EQ(

335	324 3, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(9, 5)), true));

336 TEST(TilingDataTest, LastBorderTileXIndexFromSrcCoord) {	325 EXPECT_EQ(

337 EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 0));	326 3, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 5)), true));

338 EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 1));	327 EXPECT_EQ(

339 EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 2));	328 3, NumTiles(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(11, 5)), true));

340 EXPECT_EQ(1, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 3));	329

341 EXPECT_EQ(1, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 4));	330 EXPECT_EQ(

342 EXPECT_EQ(1, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 5));	331 30,

343 EXPECT_EQ(2, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 6));	332 NumTiles(gfx::Size(8, 5), gfx::Rect(origin, gfx::Size(16, 32)), true));

344 EXPECT_EQ(2, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 7));	333 }

345 EXPECT_EQ(2, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 8));	334

346 EXPECT_EQ(3, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 9));	335 TEST_P(TilingDataTest, TileXIndexFromSrcCoord) {

347 EXPECT_EQ(3, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 10));	336 gfx::Point origin = GetParam();

348 EXPECT_EQ(3, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 11));	337

349	338 EXPECT_EQ(0,

350 EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 0));	339 XIndex(gfx::Size(3, 3),

351 EXPECT_EQ(1, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 1));	340 gfx::Rect(origin, gfx::Size(10, 10)),

352 EXPECT_EQ(2, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 2));	341 false,

353 EXPECT_EQ(3, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 3));	342 origin.x() + 0));

354 EXPECT_EQ(4, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 4));	343 EXPECT_EQ(0,

355 EXPECT_EQ(5, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 5));	344 XIndex(gfx::Size(3, 3),

356 EXPECT_EQ(6, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 6));	345 gfx::Rect(origin, gfx::Size(10, 10)),

357 EXPECT_EQ(7, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 7));	346 false,

358 EXPECT_EQ(7, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 8));	347 origin.x() + 1));

359 EXPECT_EQ(7, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 9));	348 EXPECT_EQ(0,

360 EXPECT_EQ(7, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 10));	349 XIndex(gfx::Size(3, 3),

361 EXPECT_EQ(7, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 11));	350 gfx::Rect(origin, gfx::Size(10, 10)),

362	351 false,

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

364 EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(2, 2), gfx::Size(2, 2), false, 0));	353 EXPECT_EQ(1,

365 EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(2, 2), gfx::Size(2, 2), false, 1));	354 XIndex(gfx::Size(3, 3),

366 EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 0));	355 gfx::Rect(origin, gfx::Size(10, 10)),

367 EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 1));	356 false,

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

369	358 EXPECT_EQ(1,

370 EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), false, 0));	359 XIndex(gfx::Size(3, 3),

371 EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), false, 1));	360 gfx::Rect(origin, gfx::Size(10, 10)),

372 EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), false, 2));	361 false,

373 EXPECT_EQ(1, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), false, 3));	362 origin.x() + 4));

374	363 EXPECT_EQ(1,

375 EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(1, 1), gfx::Size(1, 1), true, 0));	364 XIndex(gfx::Size(3, 3),

376 EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(2, 2), gfx::Size(2, 2), true, 0));	365 gfx::Rect(origin, gfx::Size(10, 10)),

377 EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(2, 2), gfx::Size(2, 2), true, 1));	366 false,

378 EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 0));	367 origin.x() + 5));

379 EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 1));	368 EXPECT_EQ(2,

380 EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 2));	369 XIndex(gfx::Size(3, 3),

381	370 gfx::Rect(origin, gfx::Size(10, 10)),

382 EXPECT_EQ(0, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 0));	371 false,

383 EXPECT_EQ(1, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 1));	372 origin.x() + 6));

384 EXPECT_EQ(1, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 2));	373 EXPECT_EQ(2,

385 EXPECT_EQ(1, MaxBorderXIndex(gfx::Size(3, 3), gfx::Size(4, 3), true, 3));	374 XIndex(gfx::Size(3, 3),

386 }	375 gfx::Rect(origin, gfx::Size(10, 10)),

387	376 false,

388 TEST(TilingDataTest, TileYIndexFromSrcCoord) {	377 origin.x() + 7));

389 EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 0));	378 EXPECT_EQ(2,

390 EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 1));	379 XIndex(gfx::Size(3, 3),

391 EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 2));	380 gfx::Rect(origin, gfx::Size(10, 10)),

392 EXPECT_EQ(1, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 3));	381 false,

393 EXPECT_EQ(1, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 4));	382 origin.x() + 8));

394 EXPECT_EQ(1, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 5));	383 EXPECT_EQ(3,

395 EXPECT_EQ(2, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 6));	384 XIndex(gfx::Size(3, 3),

396 EXPECT_EQ(2, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 7));	385 gfx::Rect(origin, gfx::Size(10, 10)),

397 EXPECT_EQ(2, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 8));	386 false,

398 EXPECT_EQ(3, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 9));	387 origin.x() + 9));

399 EXPECT_EQ(3, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 10));	388 EXPECT_EQ(3,

400 EXPECT_EQ(3, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 11));	389 XIndex(gfx::Size(3, 3),

401	390 gfx::Rect(origin, gfx::Size(10, 10)),

402 EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 0));	391 false,

403 EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 1));	392 origin.x() + 10));

404 EXPECT_EQ(1, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 2));	393 EXPECT_EQ(3,

405 EXPECT_EQ(2, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 3));	394 XIndex(gfx::Size(3, 3),

406 EXPECT_EQ(3, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 4));	395 gfx::Rect(origin, gfx::Size(10, 10)),

407 EXPECT_EQ(4, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 5));	396 false,

408 EXPECT_EQ(5, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 6));	397 origin.x() + 11));

409 EXPECT_EQ(6, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 7));	398

410 EXPECT_EQ(7, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 8));	399 EXPECT_EQ(0,

411 EXPECT_EQ(7, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 9));	400 XIndex(gfx::Size(3, 3),

412 EXPECT_EQ(7, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 10));	401 gfx::Rect(origin, gfx::Size(10, 10)),

413 EXPECT_EQ(7, YIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 11));	402 true,

414	403 origin.x()));

415 EXPECT_EQ(0, YIndex(gfx::Size(1, 1), gfx::Size(1, 1), false, 0));	404 EXPECT_EQ(0,

416 EXPECT_EQ(0, YIndex(gfx::Size(2, 2), gfx::Size(2, 2), false, 0));	405 XIndex(gfx::Size(3, 3),

417 EXPECT_EQ(0, YIndex(gfx::Size(2, 2), gfx::Size(2, 2), false, 1));	406 gfx::Rect(origin, gfx::Size(10, 10)),

418 EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 0));	407 true,

419 EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 1));	408 origin.x() + 1));

420 EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 2));	409 EXPECT_EQ(1,

421	410 XIndex(gfx::Size(3, 3),

422 EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(3, 4), false, 0));	411 gfx::Rect(origin, gfx::Size(10, 10)),

423 EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(3, 4), false, 1));	412 true,

424 EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(3, 4), false, 2));	413 origin.x() + 2));

425 EXPECT_EQ(1, YIndex(gfx::Size(3, 3), gfx::Size(3, 4), false, 3));	414 EXPECT_EQ(2,

426	415 XIndex(gfx::Size(3, 3),

427 EXPECT_EQ(0, YIndex(gfx::Size(1, 1), gfx::Size(1, 1), true, 0));	416 gfx::Rect(origin, gfx::Size(10, 10)),

428 EXPECT_EQ(0, YIndex(gfx::Size(2, 2), gfx::Size(2, 2), true, 0));	417 true,

429 EXPECT_EQ(0, YIndex(gfx::Size(2, 2), gfx::Size(2, 2), true, 1));	418 origin.x() + 3));

430 EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 0));	419 EXPECT_EQ(3,

431 EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 1));	420 XIndex(gfx::Size(3, 3),

432 EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 2));	421 gfx::Rect(origin, gfx::Size(10, 10)),

433	422 true,

434 EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 0));	423 origin.x() + 4));

435 EXPECT_EQ(0, YIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 1));	424 EXPECT_EQ(4,

436 EXPECT_EQ(1, YIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 2));	425 XIndex(gfx::Size(3, 3),

437 EXPECT_EQ(1, YIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 3));	426 gfx::Rect(origin, gfx::Size(10, 10)),

438 }	427 true,

439	428 origin.x() + 5));

440 TEST(TilingDataTest, FirstBorderTileYIndexFromSrcCoord) {	429 EXPECT_EQ(5,

441 EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 0));	430 XIndex(gfx::Size(3, 3),

442 EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 1));	431 gfx::Rect(origin, gfx::Size(10, 10)),

443 EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 2));	432 true,

444 EXPECT_EQ(1, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 3));	433 origin.x() + 6));

445 EXPECT_EQ(1, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 4));	434 EXPECT_EQ(6,

446 EXPECT_EQ(1, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 5));	435 XIndex(gfx::Size(3, 3),

447 EXPECT_EQ(2, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 6));	436 gfx::Rect(origin, gfx::Size(10, 10)),

448 EXPECT_EQ(2, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 7));	437 true,

449 EXPECT_EQ(2, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 8));	438 origin.x() + 7));

450 EXPECT_EQ(3, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 9));	439 EXPECT_EQ(7,

451 EXPECT_EQ(3, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 10));	440 XIndex(gfx::Size(3, 3),

452 EXPECT_EQ(3, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 11));	441 gfx::Rect(origin, gfx::Size(10, 10)),

453	442 true,

454 EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 0));	443 origin.x() + 8));

455 EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 1));	444 EXPECT_EQ(7,

456 EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 2));	445 XIndex(gfx::Size(3, 3),

457 EXPECT_EQ(1, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 3));	446 gfx::Rect(origin, gfx::Size(10, 10)),

458 EXPECT_EQ(2, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 4));	447 true,

459 EXPECT_EQ(3, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 5));	448 origin.x() + 9));

460 EXPECT_EQ(4, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 6));	449 EXPECT_EQ(7,

461 EXPECT_EQ(5, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 7));	450 XIndex(gfx::Size(3, 3),

462 EXPECT_EQ(6, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 8));	451 gfx::Rect(origin, gfx::Size(10, 10)),

463 EXPECT_EQ(7, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 9));	452 true,

464 EXPECT_EQ(7, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 10));	453 origin.x() + 10));

465 EXPECT_EQ(7, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 11));	454 EXPECT_EQ(7,

466	455 XIndex(gfx::Size(3, 3),

467 EXPECT_EQ(0, MinBorderYIndex(gfx::Size(1, 1), gfx::Size(1, 1), false, 0));	456 gfx::Rect(origin, gfx::Size(10, 10)),

468 EXPECT_EQ(0, MinBorderYIndex(gfx::Size(2, 2), gfx::Size(2, 2), false, 0));	457 true,

469 EXPECT_EQ(0, MinBorderYIndex(gfx::Size(2, 2), gfx::Size(2, 2), false, 1));	458 origin.x() + 11));

470 EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 0));	459

471 EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 1));	460 EXPECT_EQ(0,

472 EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 2));	461 XIndex(gfx::Size(1, 1),

473	462 gfx::Rect(origin, gfx::Size(1, 1)),

474 EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), false, 0));	463 false,

475 EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), false, 1));	464 origin.x() + 0));

476 EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), false, 2));	465 EXPECT_EQ(0,

477 EXPECT_EQ(1, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), false, 3));	466 XIndex(gfx::Size(2, 2),

478	467 gfx::Rect(origin, gfx::Size(2, 2)),

479 EXPECT_EQ(0, MinBorderYIndex(gfx::Size(1, 1), gfx::Size(1, 1), true, 0));	468 false,

480 EXPECT_EQ(0, MinBorderYIndex(gfx::Size(2, 2), gfx::Size(2, 2), true, 0));	469 origin.x() + 0));

481 EXPECT_EQ(0, MinBorderYIndex(gfx::Size(2, 2), gfx::Size(2, 2), true, 1));	470 EXPECT_EQ(0,

482 EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 0));	471 XIndex(gfx::Size(2, 2),

483 EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 1));	472 gfx::Rect(origin, gfx::Size(2, 2)),

484 EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 2));	473 false,

485	474 origin.x() + 1));

486 EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 0));	475 EXPECT_EQ(0,

487 EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 1));	476 XIndex(gfx::Size(3, 3),

488 EXPECT_EQ(0, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 2));	477 gfx::Rect(origin, gfx::Size(3, 3)),

489 EXPECT_EQ(1, MinBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 3));	478 false,

490 }	479 origin.x() + 0));

491	480 EXPECT_EQ(0,

492 TEST(TilingDataTest, LastBorderTileYIndexFromSrcCoord) {	481 XIndex(gfx::Size(3, 3),

493 EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 0));	482 gfx::Rect(origin, gfx::Size(3, 3)),

494 EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 1));	483 false,

495 EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 2));	484 origin.x() + 1));

496 EXPECT_EQ(1, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 3));	485 EXPECT_EQ(0,

497 EXPECT_EQ(1, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 4));	486 XIndex(gfx::Size(3, 3),

498 EXPECT_EQ(1, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 5));	487 gfx::Rect(origin, gfx::Size(3, 3)),

499 EXPECT_EQ(2, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 6));	488 false,

500 EXPECT_EQ(2, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 7));	489 origin.x() + 2));

501 EXPECT_EQ(2, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 8));	490

502 EXPECT_EQ(3, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 9));	491 EXPECT_EQ(0,

503 EXPECT_EQ(3, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 10));	492 XIndex(gfx::Size(3, 3),

504 EXPECT_EQ(3, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), false, 11));	493 gfx::Rect(origin, gfx::Size(4, 3)),

505	494 false,

506 EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 0));	495 origin.x() + 0));

507 EXPECT_EQ(1, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 1));	496 EXPECT_EQ(0,

508 EXPECT_EQ(2, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 2));	497 XIndex(gfx::Size(3, 3),

509 EXPECT_EQ(3, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 3));	498 gfx::Rect(origin, gfx::Size(4, 3)),

510 EXPECT_EQ(4, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 4));	499 false,

511 EXPECT_EQ(5, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 5));	500 origin.x() + 1));

512 EXPECT_EQ(6, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 6));	501 EXPECT_EQ(0,

513 EXPECT_EQ(7, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 7));	502 XIndex(gfx::Size(3, 3),

514 EXPECT_EQ(7, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 8));	503 gfx::Rect(origin, gfx::Size(4, 3)),

515 EXPECT_EQ(7, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 9));	504 false,

516 EXPECT_EQ(7, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 10));	505 origin.x() + 2));

517 EXPECT_EQ(7, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(10, 10), true, 11));	506 EXPECT_EQ(1,

518	507 XIndex(gfx::Size(3, 3),

519 EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(1, 1), gfx::Size(1, 1), false, 0));	508 gfx::Rect(origin, gfx::Size(4, 3)),

520 EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(2, 2), gfx::Size(2, 2), false, 0));	509 false,

521 EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(2, 2), gfx::Size(2, 2), false, 1));	510 origin.x() + 3));

522 EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 0));	511

523 EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 1));	512 EXPECT_EQ(0,

524 EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), false, 2));	513 XIndex(gfx::Size(1, 1),

525	514 gfx::Rect(origin, gfx::Size(1, 1)),

526 EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), false, 0));	515 true,

527 EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), false, 1));	516 origin.x() + 0));

528 EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), false, 2));	517 EXPECT_EQ(0,

529 EXPECT_EQ(1, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), false, 3));	518 XIndex(gfx::Size(2, 2),

530	519 gfx::Rect(origin, gfx::Size(2, 2)),

531 EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(1, 1), gfx::Size(1, 1), true, 0));	520 true,

532 EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(2, 2), gfx::Size(2, 2), true, 0));	521 origin.x() + 0));

533 EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(2, 2), gfx::Size(2, 2), true, 1));	522 EXPECT_EQ(0,

534 EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 0));	523 XIndex(gfx::Size(2, 2),

535 EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 1));	524 gfx::Rect(origin, gfx::Size(2, 2)),

536 EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 3), true, 2));	525 true,

537	526 origin.x() + 1));

538 EXPECT_EQ(0, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 0));	527 EXPECT_EQ(0,

539 EXPECT_EQ(1, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 1));	528 XIndex(gfx::Size(3, 3),

540 EXPECT_EQ(1, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 2));	529 gfx::Rect(origin, gfx::Size(3, 3)),

541 EXPECT_EQ(1, MaxBorderYIndex(gfx::Size(3, 3), gfx::Size(3, 4), true, 3));	530 true,

542 }	531 origin.x() + 0));

543	532 EXPECT_EQ(0,

544 TEST(TilingDataTest, TileSizeX) {	533 XIndex(gfx::Size(3, 3),

545 EXPECT_EQ(5, SizeX(gfx::Size(5, 5), gfx::Size(5, 5), false, 0));	534 gfx::Rect(origin, gfx::Size(3, 3)),

546 EXPECT_EQ(5, SizeX(gfx::Size(5, 5), gfx::Size(5, 5), true, 0));	535 true,

547	536 origin.x() + 1));

548 EXPECT_EQ(5, SizeX(gfx::Size(5, 5), gfx::Size(6, 6), false, 0));	537 EXPECT_EQ(0,

549 EXPECT_EQ(1, SizeX(gfx::Size(5, 5), gfx::Size(6, 6), false, 1));	538 XIndex(gfx::Size(3, 3),

550 EXPECT_EQ(4, SizeX(gfx::Size(5, 5), gfx::Size(6, 6), true, 0));	539 gfx::Rect(origin, gfx::Size(3, 3)),

551 EXPECT_EQ(2, SizeX(gfx::Size(5, 5), gfx::Size(6, 6), true, 1));	540 true,

552	541 origin.x() + 2));

553 EXPECT_EQ(5, SizeX(gfx::Size(5, 5), gfx::Size(8, 8), false, 0));	542

554 EXPECT_EQ(3, SizeX(gfx::Size(5, 5), gfx::Size(8, 8), false, 1));	543 EXPECT_EQ(0,

555 EXPECT_EQ(4, SizeX(gfx::Size(5, 5), gfx::Size(8, 8), true, 0));	544 XIndex(gfx::Size(3, 3),

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

557	546 true,

558 EXPECT_EQ(5, SizeX(gfx::Size(5, 5), gfx::Size(10, 10), false, 0));	547 origin.x() + 0));

559 EXPECT_EQ(5, SizeX(gfx::Size(5, 5), gfx::Size(10, 10), false, 1));	548 EXPECT_EQ(0,

560 EXPECT_EQ(4, SizeX(gfx::Size(5, 5), gfx::Size(10, 10), true, 0));	549 XIndex(gfx::Size(3, 3),

561 EXPECT_EQ(3, SizeX(gfx::Size(5, 5), gfx::Size(10, 10), true, 1));	550 gfx::Rect(origin, gfx::Size(4, 3)),

562 EXPECT_EQ(3, SizeX(gfx::Size(5, 5), gfx::Size(10, 10), true, 2));	551 true,

563	552 origin.x() + 1));

564 EXPECT_EQ(4, SizeX(gfx::Size(5, 5), gfx::Size(11, 11), true, 2));	553 EXPECT_EQ(1,

565 EXPECT_EQ(3, SizeX(gfx::Size(5, 5), gfx::Size(12, 12), true, 2));	554 XIndex(gfx::Size(3, 3),

566	555 gfx::Rect(origin, gfx::Size(4, 3)),

567 EXPECT_EQ(3, SizeX(gfx::Size(5, 9), gfx::Size(12, 17), true, 2));	556 true,

568 }	557 origin.x() + 2));

569	558 EXPECT_EQ(1,

570 TEST(TilingDataTest, TileSizeY) {	559 XIndex(gfx::Size(3, 3),

571 EXPECT_EQ(5, SizeY(gfx::Size(5, 5), gfx::Size(5, 5), false, 0));	560 gfx::Rect(origin, gfx::Size(4, 3)),

572 EXPECT_EQ(5, SizeY(gfx::Size(5, 5), gfx::Size(5, 5), true, 0));	561 true,

573	562 origin.x() + 3));

574 EXPECT_EQ(5, SizeY(gfx::Size(5, 5), gfx::Size(6, 6), false, 0));	563 }

575 EXPECT_EQ(1, SizeY(gfx::Size(5, 5), gfx::Size(6, 6), false, 1));	564

576 EXPECT_EQ(4, SizeY(gfx::Size(5, 5), gfx::Size(6, 6), true, 0));	565 TEST_P(TilingDataTest, FirstBorderTileXIndexFromSrcCoord) {

577 EXPECT_EQ(2, SizeY(gfx::Size(5, 5), gfx::Size(6, 6), true, 1));	566 gfx::Point origin = GetParam();

578	567

579 EXPECT_EQ(5, SizeY(gfx::Size(5, 5), gfx::Size(8, 8), false, 0));	568 EXPECT_EQ(0,

580 EXPECT_EQ(3, SizeY(gfx::Size(5, 5), gfx::Size(8, 8), false, 1));	569 MinBorderXIndex(gfx::Size(3, 3),

581 EXPECT_EQ(4, SizeY(gfx::Size(5, 5), gfx::Size(8, 8), true, 0));	570 gfx::Rect(origin, gfx::Size(10, 10)),

582 EXPECT_EQ(4, SizeY(gfx::Size(5, 5), gfx::Size(8, 8), true, 1));	571 false,

583	572 origin.x() + 0));

584 EXPECT_EQ(5, SizeY(gfx::Size(5, 5), gfx::Size(10, 10), false, 0));	573 EXPECT_EQ(0,

585 EXPECT_EQ(5, SizeY(gfx::Size(5, 5), gfx::Size(10, 10), false, 1));	574 MinBorderXIndex(gfx::Size(3, 3),

586 EXPECT_EQ(4, SizeY(gfx::Size(5, 5), gfx::Size(10, 10), true, 0));	575 gfx::Rect(origin, gfx::Size(10, 10)),

587 EXPECT_EQ(3, SizeY(gfx::Size(5, 5), gfx::Size(10, 10), true, 1));	576 false,

588 EXPECT_EQ(3, SizeY(gfx::Size(5, 5), gfx::Size(10, 10), true, 2));	577 origin.x() + 1));

589	578 EXPECT_EQ(0,

590 EXPECT_EQ(4, SizeY(gfx::Size(5, 5), gfx::Size(11, 11), true, 2));	579 MinBorderXIndex(gfx::Size(3, 3),

591 EXPECT_EQ(3, SizeY(gfx::Size(5, 5), gfx::Size(12, 12), true, 2));	580 gfx::Rect(origin, gfx::Size(10, 10)),

592	581 false,

593 EXPECT_EQ(3, SizeY(gfx::Size(9, 5), gfx::Size(17, 12), true, 2));	582 origin.x() + 2));

594 }	583 EXPECT_EQ(1,

595	584 MinBorderXIndex(gfx::Size(3, 3),

596 TEST(TilingDataTest, TileSizeX_and_TilePositionX) {	585 gfx::Rect(origin, gfx::Size(10, 10)),

	586 false,

	587 origin.x() + 3));

	588 EXPECT_EQ(1,

	589 MinBorderXIndex(gfx::Size(3, 3),

	590 gfx::Rect(origin, gfx::Size(10, 10)),

	591 false,

	592 origin.x() + 4));

	593 EXPECT_EQ(1,

	594 MinBorderXIndex(gfx::Size(3, 3),

	595 gfx::Rect(origin, gfx::Size(10, 10)),

	596 false,

	597 origin.x() + 5));

	598 EXPECT_EQ(2,

	599 MinBorderXIndex(gfx::Size(3, 3),

	600 gfx::Rect(origin, gfx::Size(10, 10)),

	601 false,

	602 origin.x() + 6));

	603 EXPECT_EQ(2,

	604 MinBorderXIndex(gfx::Size(3, 3),

	605 gfx::Rect(origin, gfx::Size(10, 10)),

	606 false,

	607 origin.x() + 7));

	608 EXPECT_EQ(2,

	609 MinBorderXIndex(gfx::Size(3, 3),

	610 gfx::Rect(origin, gfx::Size(10, 10)),

	611 false,

	612 origin.x() + 8));

	613 EXPECT_EQ(3,

	614 MinBorderXIndex(gfx::Size(3, 3),

	615 gfx::Rect(origin, gfx::Size(10, 10)),

	616 false,

	617 origin.x() + 9));

	618 EXPECT_EQ(3,

	619 MinBorderXIndex(gfx::Size(3, 3),

	620 gfx::Rect(origin, gfx::Size(10, 10)),

	621 false,

	622 origin.x() + 10));

	623 EXPECT_EQ(3,

	624 MinBorderXIndex(gfx::Size(3, 3),

	625 gfx::Rect(origin, gfx::Size(10, 10)),

	626 false,

	627 origin.x() + 11));

	628

	629 EXPECT_EQ(0,

	630 MinBorderXIndex(gfx::Size(3, 3),

	631 gfx::Rect(origin, gfx::Size(10, 10)),

	632 true,

	633 origin.x() + 0));

	634 EXPECT_EQ(0,

	635 MinBorderXIndex(gfx::Size(3, 3),

	636 gfx::Rect(origin, gfx::Size(10, 10)),

	637 true,

	638 origin.x() + 1));

	639 EXPECT_EQ(0,

	640 MinBorderXIndex(gfx::Size(3, 3),

	641 gfx::Rect(origin, gfx::Size(10, 10)),

	642 true,

	643 origin.x() + 2));

	644 EXPECT_EQ(1,

	645 MinBorderXIndex(gfx::Size(3, 3),

	646 gfx::Rect(origin, gfx::Size(10, 10)),

	647 true,

	648 origin.x() + 3));

	649 EXPECT_EQ(2,

	650 MinBorderXIndex(gfx::Size(3, 3),

	651 gfx::Rect(origin, gfx::Size(10, 10)),

	652 true,

	653 origin.x() + 4));

	654 EXPECT_EQ(3,

	655 MinBorderXIndex(gfx::Size(3, 3),

	656 gfx::Rect(origin, gfx::Size(10, 10)),

	657 true,

	658 origin.x() + 5));

	659 EXPECT_EQ(4,

	660 MinBorderXIndex(gfx::Size(3, 3),

	661 gfx::Rect(origin, gfx::Size(10, 10)),

	662 true,

	663 origin.x() + 6));

	664 EXPECT_EQ(5,

	665 MinBorderXIndex(gfx::Size(3, 3),

	666 gfx::Rect(origin, gfx::Size(10, 10)),

	667 true,

	668 origin.x() + 7));

	669 EXPECT_EQ(6,

	670 MinBorderXIndex(gfx::Size(3, 3),

	671 gfx::Rect(origin, gfx::Size(10, 10)),

	672 true,

	673 origin.x() + 8));

	674 EXPECT_EQ(7,

	675 MinBorderXIndex(gfx::Size(3, 3),

	676 gfx::Rect(origin, gfx::Size(10, 10)),

	677 true,

	678 origin.x() + 9));

	679 EXPECT_EQ(7,

	680 MinBorderXIndex(gfx::Size(3, 3),

	681 gfx::Rect(origin, gfx::Size(10, 10)),

	682 true,

	683 origin.x() + 10));

	684 EXPECT_EQ(7,

	685 MinBorderXIndex(gfx::Size(3, 3),

	686 gfx::Rect(origin, gfx::Size(10, 10)),

	687 true,

	688 origin.x() + 11));

	689

	690 EXPECT_EQ(0,

	691 MinBorderXIndex(gfx::Size(1, 1),

	692 gfx::Rect(origin, gfx::Size(1, 1)),

	693 false,

	694 origin.x() + 0));

	695 EXPECT_EQ(0,

	696 MinBorderXIndex(gfx::Size(2, 2),

	697 gfx::Rect(origin, gfx::Size(2, 2)),

	698 false,

	699 origin.x() + 0));

	700 EXPECT_EQ(0,

	701 MinBorderXIndex(gfx::Size(2, 2),

	702 gfx::Rect(origin, gfx::Size(2, 2)),

	703 false,

	704 origin.x() + 1));

	705 EXPECT_EQ(0,

	706 MinBorderXIndex(gfx::Size(3, 3),

	707 gfx::Rect(origin, gfx::Size(3, 3)),

	708 false,

	709 origin.x() + 0));

	710 EXPECT_EQ(0,

	711 MinBorderXIndex(gfx::Size(3, 3),

	712 gfx::Rect(origin, gfx::Size(3, 3)),

	713 false,

	714 origin.x() + 1));

	715 EXPECT_EQ(0,

	716 MinBorderXIndex(gfx::Size(3, 3),

	717 gfx::Rect(origin, gfx::Size(3, 3)),

	718 false,

	719 origin.x() + 2));

	720

	721 EXPECT_EQ(0,

	722 MinBorderXIndex(gfx::Size(3, 3),

	723 gfx::Rect(origin, gfx::Size(4, 3)),

	724 false,

	725 origin.x() + 0));

	726 EXPECT_EQ(0,

	727 MinBorderXIndex(gfx::Size(3, 3),

	728 gfx::Rect(origin, gfx::Size(4, 3)),

	729 false,

	730 origin.x() + 1));

	731 EXPECT_EQ(0,

	732 MinBorderXIndex(gfx::Size(3, 3),

	733 gfx::Rect(origin, gfx::Size(4, 3)),

	734 false,

	735 origin.x() + 2));

	736 EXPECT_EQ(1,

	737 MinBorderXIndex(gfx::Size(3, 3),

	738 gfx::Rect(origin, gfx::Size(4, 3)),

	739 false,

	740 origin.x() + 3));

	741

	742 EXPECT_EQ(0,

	743 MinBorderXIndex(gfx::Size(1, 1),

	744 gfx::Rect(origin, gfx::Size(1, 1)),

	745 true,

	746 origin.x() + 0));

	747 EXPECT_EQ(0,

	748 MinBorderXIndex(gfx::Size(2, 2),

	749 gfx::Rect(origin, gfx::Size(2, 2)),

	750 true,

	751 origin.x() + 0));

	752 EXPECT_EQ(0,

	753 MinBorderXIndex(gfx::Size(2, 2),

	754 gfx::Rect(origin, gfx::Size(2, 2)),

	755 true,

	756 origin.x() + 1));

	757 EXPECT_EQ(0,

	758 MinBorderXIndex(gfx::Size(3, 3),

	759 gfx::Rect(origin, gfx::Size(3, 3)),

	760 true,

	761 origin.x() + 0));

	762 EXPECT_EQ(0,

	763 MinBorderXIndex(gfx::Size(3, 3),

	764 gfx::Rect(origin, gfx::Size(3, 3)),

	765 true,

	766 origin.x() + 1));

	767 EXPECT_EQ(0,

	768 MinBorderXIndex(gfx::Size(3, 3),

	769 gfx::Rect(origin, gfx::Size(3, 3)),

	770 true,

	771 origin.x() + 2));

	772

	773 EXPECT_EQ(0,

	774 MinBorderXIndex(gfx::Size(3, 3),

	775 gfx::Rect(origin, gfx::Size(4, 3)),

	776 true,

	777 origin.x() + 0));

	778 EXPECT_EQ(0,

	779 MinBorderXIndex(gfx::Size(3, 3),

	780 gfx::Rect(origin, gfx::Size(4, 3)),

	781 true,

	782 origin.x() + 1));

	783 EXPECT_EQ(0,

	784 MinBorderXIndex(gfx::Size(3, 3),

	785 gfx::Rect(origin, gfx::Size(4, 3)),

	786 true,

	787 origin.x() + 2));

	788 EXPECT_EQ(1,

	789 MinBorderXIndex(gfx::Size(3, 3),

	790 gfx::Rect(origin, gfx::Size(4, 3)),

	791 true,

	792 origin.x() + 3));

	793 }

	794

	795 TEST_P(TilingDataTest, LastBorderTileXIndexFromSrcCoord) {

	796 gfx::Point origin = GetParam();

	797

	798 EXPECT_EQ(0,

	799 MaxBorderXIndex(gfx::Size(3, 3),

	800 gfx::Rect(origin, gfx::Size(10, 10)),

	801 false,

	802 origin.x() + 0));

	803 EXPECT_EQ(0,

	804 MaxBorderXIndex(gfx::Size(3, 3),

	805 gfx::Rect(origin, gfx::Size(10, 10)),

	806 false,

	807 origin.x() + 1));

	808 EXPECT_EQ(0,

	809 MaxBorderXIndex(gfx::Size(3, 3),

	810 gfx::Rect(origin, gfx::Size(10, 10)),

	811 false,

	812 origin.x() + 2));

	813 EXPECT_EQ(1,

	814 MaxBorderXIndex(gfx::Size(3, 3),

	815 gfx::Rect(origin, gfx::Size(10, 10)),

	816 false,

	817 origin.x() + 3));

	818 EXPECT_EQ(1,

	819 MaxBorderXIndex(gfx::Size(3, 3),

	820 gfx::Rect(origin, gfx::Size(10, 10)),

	821 false,

	822 origin.x() + 4));

	823 EXPECT_EQ(1,

	824 MaxBorderXIndex(gfx::Size(3, 3),

	825 gfx::Rect(origin, gfx::Size(10, 10)),

	826 false,

	827 origin.x() + 5));

	828 EXPECT_EQ(2,

	829 MaxBorderXIndex(gfx::Size(3, 3),

	830 gfx::Rect(origin, gfx::Size(10, 10)),

	831 false,

	832 origin.x() + 6));

	833 EXPECT_EQ(2,

	834 MaxBorderXIndex(gfx::Size(3, 3),

	835 gfx::Rect(origin, gfx::Size(10, 10)),

	836 false,

	837 origin.x() + 7));

	838 EXPECT_EQ(2,

	839 MaxBorderXIndex(gfx::Size(3, 3),

	840 gfx::Rect(origin, gfx::Size(10, 10)),

	841 false,

	842 origin.x() + 8));

	843 EXPECT_EQ(3,

	844 MaxBorderXIndex(gfx::Size(3, 3),

	845 gfx::Rect(origin, gfx::Size(10, 10)),

	846 false,

	847 origin.x() + 9));

	848 EXPECT_EQ(3,

	849 MaxBorderXIndex(gfx::Size(3, 3),

	850 gfx::Rect(origin, gfx::Size(10, 10)),

	851 false,

	852 origin.x() + 10));

	853 EXPECT_EQ(3,

	854 MaxBorderXIndex(gfx::Size(3, 3),

	855 gfx::Rect(origin, gfx::Size(10, 10)),

	856 false,

	857 origin.x() + 11));

	858

	859 EXPECT_EQ(0,

	860 MaxBorderXIndex(gfx::Size(3, 3),

	861 gfx::Rect(origin, gfx::Size(10, 10)),

	862 true,

	863 origin.x() + 0));

	864 EXPECT_EQ(1,

	865 MaxBorderXIndex(gfx::Size(3, 3),

	866 gfx::Rect(origin, gfx::Size(10, 10)),

	867 true,

	868 origin.x() + 1));

	869 EXPECT_EQ(2,

	870 MaxBorderXIndex(gfx::Size(3, 3),

	871 gfx::Rect(origin, gfx::Size(10, 10)),

	872 true,

	873 origin.x() + 2));

	874 EXPECT_EQ(3,

	875 MaxBorderXIndex(gfx::Size(3, 3),

	876 gfx::Rect(origin, gfx::Size(10, 10)),

	877 true,

	878 origin.x() + 3));

	879 EXPECT_EQ(4,

	880 MaxBorderXIndex(gfx::Size(3, 3),

	881 gfx::Rect(origin, gfx::Size(10, 10)),

	882 true,

	883 origin.x() + 4));

	884 EXPECT_EQ(5,

	885 MaxBorderXIndex(gfx::Size(3, 3),

	886 gfx::Rect(origin, gfx::Size(10, 10)),

	887 true,

	888 origin.x() + 5));

	889 EXPECT_EQ(6,

	890 MaxBorderXIndex(gfx::Size(3, 3),

	891 gfx::Rect(origin, gfx::Size(10, 10)),

	892 true,

	893 origin.x() + 6));

	894 EXPECT_EQ(7,

	895 MaxBorderXIndex(gfx::Size(3, 3),

	896 gfx::Rect(origin, gfx::Size(10, 10)),

	897 true,

	898 origin.x() + 7));

	899 EXPECT_EQ(7,

	900 MaxBorderXIndex(gfx::Size(3, 3),

	901 gfx::Rect(origin, gfx::Size(10, 10)),

	902 true,

	903 origin.x() + 8));

	904 EXPECT_EQ(7,

	905 MaxBorderXIndex(gfx::Size(3, 3),

	906 gfx::Rect(origin, gfx::Size(10, 10)),

	907 true,

	908 origin.x() + 9));

	909 EXPECT_EQ(7,

	910 MaxBorderXIndex(gfx::Size(3, 3),

	911 gfx::Rect(origin, gfx::Size(10, 10)),

	912 true,

	913 origin.x() + 10));

	914 EXPECT_EQ(7,

	915 MaxBorderXIndex(gfx::Size(3, 3),

	916 gfx::Rect(origin, gfx::Size(10, 10)),

	917 true,

	918 origin.x() + 11));

	919

	920 EXPECT_EQ(0,

	921 MaxBorderXIndex(gfx::Size(1, 1),

	922 gfx::Rect(origin, gfx::Size(1, 1)),

	923 false,

	924 origin.x() + 0));

	925 EXPECT_EQ(0,

	926 MaxBorderXIndex(gfx::Size(2, 2),

	927 gfx::Rect(origin, gfx::Size(2, 2)),

	928 false,

	929 origin.x() + 0));

	930 EXPECT_EQ(0,

	931 MaxBorderXIndex(gfx::Size(2, 2),

	932 gfx::Rect(origin, gfx::Size(2, 2)),

	933 false,

	934 origin.x() + 1));

	935 EXPECT_EQ(0,

	936 MaxBorderXIndex(gfx::Size(3, 3),

	937 gfx::Rect(origin, gfx::Size(3, 3)),

	938 false,

	939 origin.x() + 0));

	940 EXPECT_EQ(0,

	941 MaxBorderXIndex(gfx::Size(3, 3),

	942 gfx::Rect(origin, gfx::Size(3, 3)),

	943 false,

	944 origin.x() + 1));

	945 EXPECT_EQ(0,

	946 MaxBorderXIndex(gfx::Size(3, 3),

	947 gfx::Rect(origin, gfx::Size(3, 3)),

	948 false,

	949 origin.x() + 2));

	950

	951 EXPECT_EQ(0,

	952 MaxBorderXIndex(gfx::Size(3, 3),

	953 gfx::Rect(origin, gfx::Size(4, 3)),

	954 false,

	955 origin.x() + 0));

	956 EXPECT_EQ(0,

	957 MaxBorderXIndex(gfx::Size(3, 3),

	958 gfx::Rect(origin, gfx::Size(4, 3)),

	959 false,

	960 origin.x() + 1));

	961 EXPECT_EQ(0,

	962 MaxBorderXIndex(gfx::Size(3, 3),

	963 gfx::Rect(origin, gfx::Size(4, 3)),

	964 false,

	965 origin.x() + 2));

	966 EXPECT_EQ(1,

	967 MaxBorderXIndex(gfx::Size(3, 3),

	968 gfx::Rect(origin, gfx::Size(4, 3)),

	969 false,

	970 origin.x() + 3));

	971

	972 EXPECT_EQ(0,

	973 MaxBorderXIndex(gfx::Size(1, 1),

	974 gfx::Rect(origin, gfx::Size(1, 1)),

	975 true,

	976 origin.x() + 0));

	977 EXPECT_EQ(0,

	978 MaxBorderXIndex(gfx::Size(2, 2),

	979 gfx::Rect(origin, gfx::Size(2, 2)),

	980 true,

	981 origin.x() + 0));

	982 EXPECT_EQ(0,

	983 MaxBorderXIndex(gfx::Size(2, 2),

	984 gfx::Rect(origin, gfx::Size(2, 2)),

	985 true,

	986 origin.x() + 1));

	987 EXPECT_EQ(0,

	988 MaxBorderXIndex(gfx::Size(3, 3),

	989 gfx::Rect(origin, gfx::Size(3, 3)),

	990 true,

	991 origin.x() + 0));

	992 EXPECT_EQ(0,

	993 MaxBorderXIndex(gfx::Size(3, 3),

	994 gfx::Rect(origin, gfx::Size(3, 3)),

	995 true,

	996 origin.x() + 1));

	997 EXPECT_EQ(0,

	998 MaxBorderXIndex(gfx::Size(3, 3),

	999 gfx::Rect(origin, gfx::Size(3, 3)),

	1000 true,

	1001 origin.x() + 2));

	1002

	1003 EXPECT_EQ(0,

	1004 MaxBorderXIndex(gfx::Size(3, 3),

	1005 gfx::Rect(origin, gfx::Size(4, 3)),

	1006 true,

	1007 origin.x() + 0));

	1008 EXPECT_EQ(1,

	1009 MaxBorderXIndex(gfx::Size(3, 3),

	1010 gfx::Rect(origin, gfx::Size(4, 3)),

	1011 true,

	1012 origin.x() + 1));

	1013 EXPECT_EQ(1,

	1014 MaxBorderXIndex(gfx::Size(3, 3),

	1015 gfx::Rect(origin, gfx::Size(4, 3)),

	1016 true,

	1017 origin.x() + 2));

	1018 EXPECT_EQ(1,

	1019 MaxBorderXIndex(gfx::Size(3, 3),

	1020 gfx::Rect(origin, gfx::Size(4, 3)),

	1021 true,

	1022 origin.x() + 3));

	1023 }

	1024

	1025 TEST_P(TilingDataTest, TileYIndexFromSrcCoord) {

	1026 gfx::Point origin = GetParam();

	1027

	1028 EXPECT_EQ(0,

	1029 YIndex(gfx::Size(3, 3),

	1030 gfx::Rect(origin, gfx::Size(10, 10)),

	1031 false,

	1032 origin.y() + 0));

	1033 EXPECT_EQ(0,

	1034 YIndex(gfx::Size(3, 3),

	1035 gfx::Rect(origin, gfx::Size(10, 10)),

	1036 false,

	1037 origin.y() + 1));

	1038 EXPECT_EQ(0,

	1039 YIndex(gfx::Size(3, 3),

	1040 gfx::Rect(origin, gfx::Size(10, 10)),

	1041 false,

	1042 origin.y() + 2));

	1043 EXPECT_EQ(1,

	1044 YIndex(gfx::Size(3, 3),

	1045 gfx::Rect(origin, gfx::Size(10, 10)),

	1046 false,

	1047 origin.y() + 3));

	1048 EXPECT_EQ(1,

	1049 YIndex(gfx::Size(3, 3),

	1050 gfx::Rect(origin, gfx::Size(10, 10)),

	1051 false,

	1052 origin.y() + 4));

	1053 EXPECT_EQ(1,

	1054 YIndex(gfx::Size(3, 3),

	1055 gfx::Rect(origin, gfx::Size(10, 10)),

	1056 false,

	1057 origin.y() + 5));

	1058 EXPECT_EQ(2,

	1059 YIndex(gfx::Size(3, 3),

	1060 gfx::Rect(origin, gfx::Size(10, 10)),

	1061 false,

	1062 origin.y() + 6));

	1063 EXPECT_EQ(2,

	1064 YIndex(gfx::Size(3, 3),

	1065 gfx::Rect(origin, gfx::Size(10, 10)),

	1066 false,

	1067 origin.y() + 7));

	1068 EXPECT_EQ(2,

	1069 YIndex(gfx::Size(3, 3),

	1070 gfx::Rect(origin, gfx::Size(10, 10)),

	1071 false,

	1072 origin.y() + 8));

	1073 EXPECT_EQ(3,

	1074 YIndex(gfx::Size(3, 3),

	1075 gfx::Rect(origin, gfx::Size(10, 10)),

	1076 false,

	1077 origin.y() + 9));

	1078 EXPECT_EQ(3,

	1079 YIndex(gfx::Size(3, 3),

	1080 gfx::Rect(origin, gfx::Size(10, 10)),

	1081 false,

	1082 origin.y() + 10));

	1083 EXPECT_EQ(3,

	1084 YIndex(gfx::Size(3, 3),

	1085 gfx::Rect(origin, gfx::Size(10, 10)),

	1086 false,

	1087 origin.y() + 11));

	1088

	1089 EXPECT_EQ(0,

	1090 YIndex(gfx::Size(3, 3),

	1091 gfx::Rect(origin, gfx::Size(10, 10)),

	1092 true,

	1093 origin.y() + 0));

	1094 EXPECT_EQ(0,

	1095 YIndex(gfx::Size(3, 3),

	1096 gfx::Rect(origin, gfx::Size(10, 10)),

	1097 true,

	1098 origin.y() + 1));

	1099 EXPECT_EQ(1,

	1100 YIndex(gfx::Size(3, 3),

	1101 gfx::Rect(origin, gfx::Size(10, 10)),

	1102 true,

	1103 origin.y() + 2));

	1104 EXPECT_EQ(2,

	1105 YIndex(gfx::Size(3, 3),

	1106 gfx::Rect(origin, gfx::Size(10, 10)),

	1107 true,

	1108 origin.y() + 3));

	1109 EXPECT_EQ(3,

	1110 YIndex(gfx::Size(3, 3),

	1111 gfx::Rect(origin, gfx::Size(10, 10)),

	1112 true,

	1113 origin.y() + 4));

	1114 EXPECT_EQ(4,

	1115 YIndex(gfx::Size(3, 3),

	1116 gfx::Rect(origin, gfx::Size(10, 10)),

	1117 true,

	1118 origin.y() + 5));

	1119 EXPECT_EQ(5,

	1120 YIndex(gfx::Size(3, 3),

	1121 gfx::Rect(origin, gfx::Size(10, 10)),

	1122 true,

	1123 origin.y() + 6));

	1124 EXPECT_EQ(6,

	1125 YIndex(gfx::Size(3, 3),

	1126 gfx::Rect(origin, gfx::Size(10, 10)),

	1127 true,

	1128 origin.y() + 7));

	1129 EXPECT_EQ(7,

	1130 YIndex(gfx::Size(3, 3),

	1131 gfx::Rect(origin, gfx::Size(10, 10)),

	1132 true,

	1133 origin.y() + 8));

	1134 EXPECT_EQ(7,

	1135 YIndex(gfx::Size(3, 3),

	1136 gfx::Rect(origin, gfx::Size(10, 10)),

	1137 true,

	1138 origin.y() + 9));

	1139 EXPECT_EQ(7,

	1140 YIndex(gfx::Size(3, 3),

	1141 gfx::Rect(origin, gfx::Size(10, 10)),

	1142 true,

	1143 origin.y() + 10));

	1144 EXPECT_EQ(7,

	1145 YIndex(gfx::Size(3, 3),

	1146 gfx::Rect(origin, gfx::Size(10, 10)),

	1147 true,

	1148 origin.y() + 11));

	1149

	1150 EXPECT_EQ(0,

	1151 YIndex(gfx::Size(1, 1),

	1152 gfx::Rect(origin, gfx::Size(1, 1)),

	1153 false,

	1154 origin.y() + 0));

	1155 EXPECT_EQ(0,

	1156 YIndex(gfx::Size(2, 2),

	1157 gfx::Rect(origin, gfx::Size(2, 2)),

	1158 false,

	1159 origin.y() + 0));

	1160 EXPECT_EQ(0,

	1161 YIndex(gfx::Size(2, 2),

	1162 gfx::Rect(origin, gfx::Size(2, 2)),

	1163 false,

	1164 origin.y() + 1));

	1165 EXPECT_EQ(0,

	1166 YIndex(gfx::Size(3, 3),

	1167 gfx::Rect(origin, gfx::Size(3, 3)),

	1168 false,

	1169 origin.y() + 0));

	1170 EXPECT_EQ(0,

	1171 YIndex(gfx::Size(3, 3),

	1172 gfx::Rect(origin, gfx::Size(3, 3)),

	1173 false,

	1174 origin.y() + 1));

	1175 EXPECT_EQ(0,

	1176 YIndex(gfx::Size(3, 3),

	1177 gfx::Rect(origin, gfx::Size(3, 3)),

	1178 false,

	1179 origin.y() + 2));

	1180

	1181 EXPECT_EQ(0,

	1182 YIndex(gfx::Size(3, 3),

	1183 gfx::Rect(origin, gfx::Size(3, 4)),

	1184 false,

	1185 origin.y() + 0));

	1186 EXPECT_EQ(0,

	1187 YIndex(gfx::Size(3, 3),

	1188 gfx::Rect(origin, gfx::Size(3, 4)),

	1189 false,

	1190 origin.y() + 1));

	1191 EXPECT_EQ(0,

	1192 YIndex(gfx::Size(3, 3),

	1193 gfx::Rect(origin, gfx::Size(3, 4)),

	1194 false,

	1195 origin.y() + 2));

	1196 EXPECT_EQ(1,

	1197 YIndex(gfx::Size(3, 3),

	1198 gfx::Rect(origin, gfx::Size(3, 4)),

	1199 false,

	1200 origin.y() + 3));

	1201

	1202 EXPECT_EQ(0,

	1203 YIndex(gfx::Size(1, 1),

	1204 gfx::Rect(origin, gfx::Size(1, 1)),

	1205 true,

	1206 origin.y() + 0));

	1207 EXPECT_EQ(0,

	1208 YIndex(gfx::Size(2, 2),

	1209 gfx::Rect(origin, gfx::Size(2, 2)),

	1210 true,

	1211 origin.y() + 0));

	1212 EXPECT_EQ(0,

	1213 YIndex(gfx::Size(2, 2),

	1214 gfx::Rect(origin, gfx::Size(2, 2)),

	1215 true,

	1216 origin.y() + 1));

	1217 EXPECT_EQ(0,

	1218 YIndex(gfx::Size(3, 3),

	1219 gfx::Rect(origin, gfx::Size(3, 3)),

	1220 true,

	1221 origin.y() + 0));

	1222 EXPECT_EQ(0,

	1223 YIndex(gfx::Size(3, 3),

	1224 gfx::Rect(origin, gfx::Size(3, 3)),

	1225 true,

	1226 origin.y() + 1));

	1227 EXPECT_EQ(0,

	1228 YIndex(gfx::Size(3, 3),

	1229 gfx::Rect(origin, gfx::Size(3, 3)),

	1230 true,

	1231 origin.y() + 2));

	1232

	1233 EXPECT_EQ(0,

	1234 YIndex(gfx::Size(3, 3),

	1235 gfx::Rect(origin, gfx::Size(3, 4)),

	1236 true,

	1237 origin.y() + 0));

	1238 EXPECT_EQ(0,

	1239 YIndex(gfx::Size(3, 3),

	1240 gfx::Rect(origin, gfx::Size(3, 4)),

	1241 true,

	1242 origin.y() + 1));

	1243 EXPECT_EQ(1,

	1244 YIndex(gfx::Size(3, 3),

	1245 gfx::Rect(origin, gfx::Size(3, 4)),

	1246 true,

	1247 origin.y() + 2));

	1248 EXPECT_EQ(1,

	1249 YIndex(gfx::Size(3, 3),

	1250 gfx::Rect(origin, gfx::Size(3, 4)),

	1251 true,

	1252 origin.y() + 3));

	1253 }

	1254

	1255 TEST_P(TilingDataTest, FirstBorderTileYIndexFromSrcCoord) {

	1256 gfx::Point origin = GetParam();

	1257

	1258 EXPECT_EQ(0,

	1259 MinBorderYIndex(gfx::Size(3, 3),

	1260 gfx::Rect(origin, gfx::Size(10, 10)),

	1261 false,

	1262 origin.y() + 0));

	1263 EXPECT_EQ(0,

	1264 MinBorderYIndex(gfx::Size(3, 3),

	1265 gfx::Rect(origin, gfx::Size(10, 10)),

	1266 false,

	1267 origin.y() + 1));

	1268 EXPECT_EQ(0,

	1269 MinBorderYIndex(gfx::Size(3, 3),

	1270 gfx::Rect(origin, gfx::Size(10, 10)),

	1271 false,

	1272 origin.y() + 2));

	1273 EXPECT_EQ(1,

	1274 MinBorderYIndex(gfx::Size(3, 3),

	1275 gfx::Rect(origin, gfx::Size(10, 10)),

	1276 false,

	1277 origin.y() + 3));

	1278 EXPECT_EQ(1,

	1279 MinBorderYIndex(gfx::Size(3, 3),

	1280 gfx::Rect(origin, gfx::Size(10, 10)),

	1281 false,

	1282 origin.y() + 4));

	1283 EXPECT_EQ(1,

	1284 MinBorderYIndex(gfx::Size(3, 3),

	1285 gfx::Rect(origin, gfx::Size(10, 10)),

	1286 false,

	1287 origin.y() + 5));

	1288 EXPECT_EQ(2,

	1289 MinBorderYIndex(gfx::Size(3, 3),

	1290 gfx::Rect(origin, gfx::Size(10, 10)),

	1291 false,

	1292 origin.y() + 6));

	1293 EXPECT_EQ(2,

	1294 MinBorderYIndex(gfx::Size(3, 3),

	1295 gfx::Rect(origin, gfx::Size(10, 10)),

	1296 false,

	1297 origin.y() + 7));

	1298 EXPECT_EQ(2,

	1299 MinBorderYIndex(gfx::Size(3, 3),

	1300 gfx::Rect(origin, gfx::Size(10, 10)),

	1301 false,

	1302 origin.y() + 8));

	1303 EXPECT_EQ(3,

	1304 MinBorderYIndex(gfx::Size(3, 3),

	1305 gfx::Rect(origin, gfx::Size(10, 10)),

	1306 false,

	1307 origin.y() + 9));

	1308 EXPECT_EQ(3,

	1309 MinBorderYIndex(gfx::Size(3, 3),

	1310 gfx::Rect(origin, gfx::Size(10, 10)),

	1311 false,

	1312 origin.y() + 10));

	1313 EXPECT_EQ(3,

	1314 MinBorderYIndex(gfx::Size(3, 3),

	1315 gfx::Rect(origin, gfx::Size(10, 10)),

	1316 false,

	1317 origin.y() + 11));

	1318

	1319 EXPECT_EQ(0,

	1320 MinBorderYIndex(gfx::Size(3, 3),

	1321 gfx::Rect(origin, gfx::Size(10, 10)),

	1322 true,

	1323 origin.y() + 0));

	1324 EXPECT_EQ(0,

	1325 MinBorderYIndex(gfx::Size(3, 3),

	1326 gfx::Rect(origin, gfx::Size(10, 10)),

	1327 true,

	1328 origin.y() + 1));

	1329 EXPECT_EQ(0,

	1330 MinBorderYIndex(gfx::Size(3, 3),

	1331 gfx::Rect(origin, gfx::Size(10, 10)),

	1332 true,

	1333 origin.y() + 2));

	1334 EXPECT_EQ(1,

	1335 MinBorderYIndex(gfx::Size(3, 3),

	1336 gfx::Rect(origin, gfx::Size(10, 10)),

	1337 true,

	1338 origin.y() + 3));

	1339 EXPECT_EQ(2,

	1340 MinBorderYIndex(gfx::Size(3, 3),

	1341 gfx::Rect(origin, gfx::Size(10, 10)),

	1342 true,

	1343 origin.y() + 4));

	1344 EXPECT_EQ(3,

	1345 MinBorderYIndex(gfx::Size(3, 3),

	1346 gfx::Rect(origin, gfx::Size(10, 10)),

	1347 true,

	1348 origin.y() + 5));

	1349 EXPECT_EQ(4,

	1350 MinBorderYIndex(gfx::Size(3, 3),

	1351 gfx::Rect(origin, gfx::Size(10, 10)),

	1352 true,

	1353 origin.y() + 6));

	1354 EXPECT_EQ(5,

	1355 MinBorderYIndex(gfx::Size(3, 3),

	1356 gfx::Rect(origin, gfx::Size(10, 10)),

	1357 true,

	1358 origin.y() + 7));

	1359 EXPECT_EQ(6,

	1360 MinBorderYIndex(gfx::Size(3, 3),

	1361 gfx::Rect(origin, gfx::Size(10, 10)),

	1362 true,

	1363 origin.y() + 8));

	1364 EXPECT_EQ(7,

	1365 MinBorderYIndex(gfx::Size(3, 3),

	1366 gfx::Rect(origin, gfx::Size(10, 10)),

	1367 true,

	1368 origin.y() + 9));

	1369 EXPECT_EQ(7,

	1370 MinBorderYIndex(gfx::Size(3, 3),

	1371 gfx::Rect(origin, gfx::Size(10, 10)),

	1372 true,

	1373 origin.y() + 10));

	1374 EXPECT_EQ(7,

	1375 MinBorderYIndex(gfx::Size(3, 3),

	1376 gfx::Rect(origin, gfx::Size(10, 10)),

	1377 true,

	1378 origin.y() + 11));

	1379

	1380 EXPECT_EQ(0,

	1381 MinBorderYIndex(gfx::Size(1, 1),

	1382 gfx::Rect(origin, gfx::Size(1, 1)),

	1383 false,

	1384 origin.y() + 0));

	1385 EXPECT_EQ(0,

	1386 MinBorderYIndex(gfx::Size(2, 2),

	1387 gfx::Rect(origin, gfx::Size(2, 2)),

	1388 false,

	1389 origin.y() + 0));

	1390 EXPECT_EQ(0,

	1391 MinBorderYIndex(gfx::Size(2, 2),

	1392 gfx::Rect(origin, gfx::Size(2, 2)),

	1393 false,

	1394 origin.y() + 1));

	1395 EXPECT_EQ(0,

	1396 MinBorderYIndex(gfx::Size(3, 3),

	1397 gfx::Rect(origin, gfx::Size(3, 3)),

	1398 false,

	1399 origin.y() + 0));

	1400 EXPECT_EQ(0,

	1401 MinBorderYIndex(gfx::Size(3, 3),

	1402 gfx::Rect(origin, gfx::Size(3, 3)),

	1403 false,

	1404 origin.y() + 1));

	1405 EXPECT_EQ(0,

	1406 MinBorderYIndex(gfx::Size(3, 3),

	1407 gfx::Rect(origin, gfx::Size(3, 3)),

	1408 false,

	1409 origin.y() + 2));

	1410

	1411 EXPECT_EQ(0,

	1412 MinBorderYIndex(gfx::Size(3, 3),

	1413 gfx::Rect(origin, gfx::Size(3, 4)),

	1414 false,

	1415 origin.y() + 0));

	1416 EXPECT_EQ(0,

	1417 MinBorderYIndex(gfx::Size(3, 3),

	1418 gfx::Rect(origin, gfx::Size(3, 4)),

	1419 false,

	1420 origin.y() + 1));

	1421 EXPECT_EQ(0,

	1422 MinBorderYIndex(gfx::Size(3, 3),

	1423 gfx::Rect(origin, gfx::Size(3, 4)),

	1424 false,

	1425 origin.y() + 2));

	1426 EXPECT_EQ(1,

	1427 MinBorderYIndex(gfx::Size(3, 3),

	1428 gfx::Rect(origin, gfx::Size(3, 4)),

	1429 false,

	1430 origin.y() + 3));

	1431

	1432 EXPECT_EQ(0,

	1433 MinBorderYIndex(gfx::Size(1, 1),

	1434 gfx::Rect(origin, gfx::Size(1, 1)),

	1435 true,

	1436 origin.y() + 0));

	1437 EXPECT_EQ(0,

	1438 MinBorderYIndex(gfx::Size(2, 2),

	1439 gfx::Rect(origin, gfx::Size(2, 2)),

	1440 true,

	1441 origin.y() + 0));

	1442 EXPECT_EQ(0,

	1443 MinBorderYIndex(gfx::Size(2, 2),

	1444 gfx::Rect(origin, gfx::Size(2, 2)),

	1445 true,

	1446 origin.y() + 1));

	1447 EXPECT_EQ(0,

	1448 MinBorderYIndex(gfx::Size(3, 3),

	1449 gfx::Rect(origin, gfx::Size(3, 3)),

	1450 true,

	1451 origin.y() + 0));

	1452 EXPECT_EQ(0,

	1453 MinBorderYIndex(gfx::Size(3, 3),

	1454 gfx::Rect(origin, gfx::Size(3, 3)),

	1455 true,

	1456 origin.y() + 1));

	1457 EXPECT_EQ(0,

	1458 MinBorderYIndex(gfx::Size(3, 3),

	1459 gfx::Rect(origin, gfx::Size(3, 3)),

	1460 true,

	1461 origin.y() + 2));

	1462

	1463 EXPECT_EQ(0,

	1464 MinBorderYIndex(gfx::Size(3, 3),

	1465 gfx::Rect(origin, gfx::Size(3, 4)),

	1466 true,

	1467 origin.y() + 0));

	1468 EXPECT_EQ(0,

	1469 MinBorderYIndex(gfx::Size(3, 3),

	1470 gfx::Rect(origin, gfx::Size(3, 4)),

	1471 true,

	1472 origin.y() + 1));

	1473 EXPECT_EQ(0,

	1474 MinBorderYIndex(gfx::Size(3, 3),

	1475 gfx::Rect(origin, gfx::Size(3, 4)),

	1476 true,

	1477 origin.y() + 2));

	1478 EXPECT_EQ(1,

	1479 MinBorderYIndex(gfx::Size(3, 3),

	1480 gfx::Rect(origin, gfx::Size(3, 4)),

	1481 true,

	1482 origin.y() + 3));

	1483 }

	1484

	1485 TEST_P(TilingDataTest, LastBorderTileYIndexFromSrcCoord) {

	1486 gfx::Point origin = GetParam();

	1487

	1488 EXPECT_EQ(0,

	1489 MaxBorderYIndex(gfx::Size(3, 3),

	1490 gfx::Rect(origin, gfx::Size(10, 10)),

	1491 false,

	1492 origin.y() + 0));

	1493 EXPECT_EQ(0,

	1494 MaxBorderYIndex(gfx::Size(3, 3),

	1495 gfx::Rect(origin, gfx::Size(10, 10)),

	1496 false,

	1497 origin.y() + 1));

	1498 EXPECT_EQ(0,

	1499 MaxBorderYIndex(gfx::Size(3, 3),

	1500 gfx::Rect(origin, gfx::Size(10, 10)),

	1501 false,

	1502 origin.y() + 2));

	1503 EXPECT_EQ(1,

	1504 MaxBorderYIndex(gfx::Size(3, 3),

	1505 gfx::Rect(origin, gfx::Size(10, 10)),

	1506 false,

	1507 origin.y() + 3));

	1508 EXPECT_EQ(1,

	1509 MaxBorderYIndex(gfx::Size(3, 3),

	1510 gfx::Rect(origin, gfx::Size(10, 10)),

	1511 false,

	1512 origin.y() + 4));

	1513 EXPECT_EQ(1,

	1514 MaxBorderYIndex(gfx::Size(3, 3),

	1515 gfx::Rect(origin, gfx::Size(10, 10)),

	1516 false,

	1517 origin.y() + 5));

	1518 EXPECT_EQ(2,

	1519 MaxBorderYIndex(gfx::Size(3, 3),

	1520 gfx::Rect(origin, gfx::Size(10, 10)),

	1521 false,

	1522 origin.y() + 6));

	1523 EXPECT_EQ(2,

	1524 MaxBorderYIndex(gfx::Size(3, 3),

	1525 gfx::Rect(origin, gfx::Size(10, 10)),

	1526 false,

	1527 origin.y() + 7));

	1528 EXPECT_EQ(2,

	1529 MaxBorderYIndex(gfx::Size(3, 3),

	1530 gfx::Rect(origin, gfx::Size(10, 10)),

	1531 false,

	1532 origin.y() + 8));

	1533 EXPECT_EQ(3,

	1534 MaxBorderYIndex(gfx::Size(3, 3),

	1535 gfx::Rect(origin, gfx::Size(10, 10)),

	1536 false,

	1537 origin.y() + 9));

	1538 EXPECT_EQ(3,

	1539 MaxBorderYIndex(gfx::Size(3, 3),

	1540 gfx::Rect(origin, gfx::Size(10, 10)),

	1541 false,

	1542 origin.y() + 10));

	1543 EXPECT_EQ(3,

	1544 MaxBorderYIndex(gfx::Size(3, 3),

	1545 gfx::Rect(origin, gfx::Size(10, 10)),

	1546 false,

	1547 origin.y() + 11));

	1548

	1549 EXPECT_EQ(0,

	1550 MaxBorderYIndex(gfx::Size(3, 3),

	1551 gfx::Rect(origin, gfx::Size(10, 10)),

	1552 true,

	1553 origin.y() + 0));

	1554 EXPECT_EQ(1,

	1555 MaxBorderYIndex(gfx::Size(3, 3),

	1556 gfx::Rect(origin, gfx::Size(10, 10)),

	1557 true,

	1558 origin.y() + 1));

	1559 EXPECT_EQ(2,

	1560 MaxBorderYIndex(gfx::Size(3, 3),

	1561 gfx::Rect(origin, gfx::Size(10, 10)),

	1562 true,

	1563 origin.y() + 2));

	1564 EXPECT_EQ(3,

	1565 MaxBorderYIndex(gfx::Size(3, 3),

	1566 gfx::Rect(origin, gfx::Size(10, 10)),

	1567 true,

	1568 origin.y() + 3));

	1569 EXPECT_EQ(4,

	1570 MaxBorderYIndex(gfx::Size(3, 3),

	1571 gfx::Rect(origin, gfx::Size(10, 10)),

	1572 true,

	1573 origin.y() + 4));

	1574 EXPECT_EQ(5,

	1575 MaxBorderYIndex(gfx::Size(3, 3),

	1576 gfx::Rect(origin, gfx::Size(10, 10)),

	1577 true,

	1578 origin.y() + 5));

	1579 EXPECT_EQ(6,

	1580 MaxBorderYIndex(gfx::Size(3, 3),

	1581 gfx::Rect(origin, gfx::Size(10, 10)),

	1582 true,

	1583 origin.y() + 6));

	1584 EXPECT_EQ(7,

	1585 MaxBorderYIndex(gfx::Size(3, 3),

	1586 gfx::Rect(origin, gfx::Size(10, 10)),

	1587 true,

	1588 origin.y() + 7));

	1589 EXPECT_EQ(7,

	1590 MaxBorderYIndex(gfx::Size(3, 3),

	1591 gfx::Rect(origin, gfx::Size(10, 10)),

	1592 true,

	1593 origin.y() + 8));

	1594 EXPECT_EQ(7,

	1595 MaxBorderYIndex(gfx::Size(3, 3),

	1596 gfx::Rect(origin, gfx::Size(10, 10)),

	1597 true,

	1598 origin.y() + 9));

	1599 EXPECT_EQ(7,

	1600 MaxBorderYIndex(gfx::Size(3, 3),

	1601 gfx::Rect(origin, gfx::Size(10, 10)),

	1602 true,

	1603 origin.y() + 10));

	1604 EXPECT_EQ(7,

	1605 MaxBorderYIndex(gfx::Size(3, 3),

	1606 gfx::Rect(origin, gfx::Size(10, 10)),

	1607 true,

	1608 origin.y() + 11));

	1609

	1610 EXPECT_EQ(0,

	1611 MaxBorderYIndex(gfx::Size(1, 1),

	1612 gfx::Rect(origin, gfx::Size(1, 1)),

	1613 false,

	1614 origin.y() + 0));

	1615 EXPECT_EQ(0,

	1616 MaxBorderYIndex(gfx::Size(2, 2),

	1617 gfx::Rect(origin, gfx::Size(2, 2)),

	1618 false,

	1619 origin.y() + 0));

	1620 EXPECT_EQ(0,

	1621 MaxBorderYIndex(gfx::Size(2, 2),

	1622 gfx::Rect(origin, gfx::Size(2, 2)),

	1623 false,

	1624 origin.y() + 1));

	1625 EXPECT_EQ(0,

	1626 MaxBorderYIndex(gfx::Size(3, 3),

	1627 gfx::Rect(origin, gfx::Size(3, 3)),

	1628 false,

	1629 origin.y() + 0));

	1630 EXPECT_EQ(0,

	1631 MaxBorderYIndex(gfx::Size(3, 3),

	1632 gfx::Rect(origin, gfx::Size(3, 3)),

	1633 false,

	1634 origin.y() + 1));

	1635 EXPECT_EQ(0,

	1636 MaxBorderYIndex(gfx::Size(3, 3),

	1637 gfx::Rect(origin, gfx::Size(3, 3)),

	1638 false,

	1639 origin.y() + 2));

	1640

	1641 EXPECT_EQ(0,

	1642 MaxBorderYIndex(gfx::Size(3, 3),

	1643 gfx::Rect(origin, gfx::Size(3, 4)),

	1644 false,

	1645 origin.y() + 0));

	1646 EXPECT_EQ(0,

	1647 MaxBorderYIndex(gfx::Size(3, 3),

	1648 gfx::Rect(origin, gfx::Size(3, 4)),

	1649 false,

	1650 origin.y() + 1));

	1651 EXPECT_EQ(0,

	1652 MaxBorderYIndex(gfx::Size(3, 3),

	1653 gfx::Rect(origin, gfx::Size(3, 4)),

	1654 false,

	1655 origin.y() + 2));

	1656 EXPECT_EQ(1,

	1657 MaxBorderYIndex(gfx::Size(3, 3),

	1658 gfx::Rect(origin, gfx::Size(3, 4)),

	1659 false,

	1660 origin.y() + 3));

	1661

	1662 EXPECT_EQ(0,

	1663 MaxBorderYIndex(gfx::Size(1, 1),

	1664 gfx::Rect(origin, gfx::Size(1, 1)),

	1665 true,

	1666 origin.y() + 0));

	1667 EXPECT_EQ(0,

	1668 MaxBorderYIndex(gfx::Size(2, 2),

	1669 gfx::Rect(origin, gfx::Size(2, 2)),

	1670 true,

	1671 origin.y() + 0));

	1672 EXPECT_EQ(0,

	1673 MaxBorderYIndex(gfx::Size(2, 2),

	1674 gfx::Rect(origin, gfx::Size(2, 2)),

	1675 true,

	1676 origin.y() + 1));

	1677 EXPECT_EQ(0,

	1678 MaxBorderYIndex(gfx::Size(3, 3),

	1679 gfx::Rect(origin, gfx::Size(3, 3)),

	1680 true,

	1681 origin.y() + 0));

	1682 EXPECT_EQ(0,

	1683 MaxBorderYIndex(gfx::Size(3, 3),

	1684 gfx::Rect(origin, gfx::Size(3, 3)),

	1685 true,

	1686 origin.y() + 1));

	1687 EXPECT_EQ(0,

	1688 MaxBorderYIndex(gfx::Size(3, 3),

	1689 gfx::Rect(origin, gfx::Size(3, 3)),

	1690 true,

	1691 origin.y() + 2));

	1692

	1693 EXPECT_EQ(0,

	1694 MaxBorderYIndex(gfx::Size(3, 3),

	1695 gfx::Rect(origin, gfx::Size(3, 4)),

	1696 true,

	1697 origin.y() + 0));

	1698 EXPECT_EQ(1,

	1699 MaxBorderYIndex(gfx::Size(3, 3),

	1700 gfx::Rect(origin, gfx::Size(3, 4)),

	1701 true,

	1702 origin.y() + 1));

	1703 EXPECT_EQ(1,

	1704 MaxBorderYIndex(gfx::Size(3, 3),

	1705 gfx::Rect(origin, gfx::Size(3, 4)),

	1706 true,

	1707 origin.y() + 2));

	1708 EXPECT_EQ(1,

	1709 MaxBorderYIndex(gfx::Size(3, 3),

	1710 gfx::Rect(origin, gfx::Size(3, 4)),

	1711 true,

	1712 origin.y() + 3));

	1713 }

	1714

	1715 TEST_P(TilingDataTest, TileSizeX) {

	1716 gfx::Point origin = GetParam();

	1717

	1718 EXPECT_EQ(

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

	1720 EXPECT_EQ(

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

	1722

	1723 EXPECT_EQ(

	1724 5, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 6)), false, 0));

	1725 EXPECT_EQ(

	1726 1, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 6)), false, 1));

	1727 EXPECT_EQ(

	1728 4, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 6)), true, 0));

	1729 EXPECT_EQ(

	1730 2, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 6)), true, 1));

	1731

	1732 EXPECT_EQ(

	1733 5, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 8)), false, 0));

	1734 EXPECT_EQ(

	1735 3, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 8)), false, 1));

	1736 EXPECT_EQ(

	1737 4, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 8)), true, 0));

	1738 EXPECT_EQ(

	1739 4, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 8)), true, 1));

	1740

	1741 EXPECT_EQ(

	1742 5,

	1743 SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), false, 0));

	1744 EXPECT_EQ(

	1745 5,

	1746 SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), false, 1));

	1747 EXPECT_EQ(

	1748 4, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), true, 0));

	1749 EXPECT_EQ(

	1750 3, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), true, 1));

	1751 EXPECT_EQ(

	1752 3, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), true, 2));

	1753

	1754 EXPECT_EQ(

	1755 4, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(11, 11)), true, 2));

	1756 EXPECT_EQ(

	1757 3, SizeX(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(12, 12)), true, 2));

	1758

	1759 EXPECT_EQ(

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

	1761 }

	1762

	1763 TEST_P(TilingDataTest, TileSizeY) {

	1764 gfx::Point origin = GetParam();

	1765

	1766 EXPECT_EQ(

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

	1768 EXPECT_EQ(

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

	1770

	1771 EXPECT_EQ(

	1772 5, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 6)), false, 0));

	1773 EXPECT_EQ(

	1774 1, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 6)), false, 1));

	1775 EXPECT_EQ(

	1776 4, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 6)), true, 0));

	1777 EXPECT_EQ(

	1778 2, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(6, 6)), true, 1));

	1779

	1780 EXPECT_EQ(

	1781 5, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 8)), false, 0));

	1782 EXPECT_EQ(

	1783 3, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 8)), false, 1));

	1784 EXPECT_EQ(

	1785 4, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 8)), true, 0));

	1786 EXPECT_EQ(

	1787 4, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(8, 8)), true, 1));

	1788

	1789 EXPECT_EQ(

	1790 5,

	1791 SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), false, 0));

	1792 EXPECT_EQ(

	1793 5,

	1794 SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), false, 1));

	1795 EXPECT_EQ(

	1796 4, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), true, 0));

	1797 EXPECT_EQ(

	1798 3, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), true, 1));

	1799 EXPECT_EQ(

	1800 3, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(10, 10)), true, 2));

	1801

	1802 EXPECT_EQ(

	1803 4, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(11, 11)), true, 2));

	1804 EXPECT_EQ(

	1805 3, SizeY(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(12, 12)), true, 2));

	1806

	1807 EXPECT_EQ(

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

	1809 }

	1810

	1811 TEST_P(TilingDataTest, TileSizeX_and_TilePositionX) {

	1812 gfx::Point origin = GetParam();

	1813

597 // Single tile cases:	1814 // Single tile cases:

598 EXPECT_EQ(1, SizeX(gfx::Size(3, 3), gfx::Size(1, 1), false, 0));	1815 EXPECT_EQ(

599 EXPECT_EQ(0, PosX(gfx::Size(3, 3), gfx::Size(1, 1), false, 0));	1816 1, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 1)), false, 0));

600 EXPECT_EQ(1, SizeX(gfx::Size(3, 3), gfx::Size(1, 100), false, 0));	1817 EXPECT_EQ(

601 EXPECT_EQ(0, PosX(gfx::Size(3, 3), gfx::Size(1, 100), false, 0));	1818 origin.x(),

602 EXPECT_EQ(3, SizeX(gfx::Size(3, 3), gfx::Size(3, 1), false, 0));	1819 PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 1)), false, 0));

603 EXPECT_EQ(0, PosX(gfx::Size(3, 3), gfx::Size(3, 1), false, 0));	1820 EXPECT_EQ(

604 EXPECT_EQ(3, SizeX(gfx::Size(3, 3), gfx::Size(3, 100), false, 0));	1821 1,

605 EXPECT_EQ(0, PosX(gfx::Size(3, 3), gfx::Size(3, 100), false, 0));	1822 SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 100)), false, 0));

606 EXPECT_EQ(1, SizeX(gfx::Size(3, 3), gfx::Size(1, 1), true, 0));	1823 EXPECT_EQ(

607 EXPECT_EQ(0, PosX(gfx::Size(3, 3), gfx::Size(1, 1), true, 0));	1824 origin.x(),

608 EXPECT_EQ(1, SizeX(gfx::Size(3, 3), gfx::Size(1, 100), true, 0));	1825 PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 100)), false, 0));

609 EXPECT_EQ(0, PosX(gfx::Size(3, 3), gfx::Size(1, 100), true, 0));	1826 EXPECT_EQ(

610 EXPECT_EQ(3, SizeX(gfx::Size(3, 3), gfx::Size(3, 1), true, 0));	1827 3, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 1)), false, 0));

611 EXPECT_EQ(0, PosX(gfx::Size(3, 3), gfx::Size(3, 1), true, 0));	1828 EXPECT_EQ(

612 EXPECT_EQ(3, SizeX(gfx::Size(3, 3), gfx::Size(3, 100), true, 0));	1829 origin.x(),

613 EXPECT_EQ(0, PosX(gfx::Size(3, 3), gfx::Size(3, 100), true, 0));	1830 PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 1)), false, 0));

	1831 EXPECT_EQ(

	1832 3,

	1833 SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 100)), false, 0));

	1834 EXPECT_EQ(

	1835 origin.x(),

	1836 PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 100)), false, 0));

	1837 EXPECT_EQ(

	1838 1, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 1)), true, 0));

	1839 EXPECT_EQ(origin.x(),

	1840 PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 1)), true, 0));

	1841 EXPECT_EQ(

	1842 1, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 100)), true, 0));

	1843 EXPECT_EQ(

	1844 origin.x(),

	1845 PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 100)), true, 0));

	1846 EXPECT_EQ(

	1847 3, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 1)), true, 0));

	1848 EXPECT_EQ(origin.x(),

	1849 PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 1)), true, 0));

	1850 EXPECT_EQ(

	1851 3, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 100)), true, 0));

	1852 EXPECT_EQ(

	1853 origin.x(),

	1854 PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(3, 100)), true, 0));

614	1855

615 // Multiple tiles:	1856 // Multiple tiles:

616 // no border	1857 // no border

617 // positions 0, 3	1858 // positions 0, 3

618 EXPECT_EQ(2, NumTiles(gfx::Size(3, 3), gfx::Size(6, 1), false));	1859 EXPECT_EQ(

619 EXPECT_EQ(3, SizeX(gfx::Size(3, 3), gfx::Size(6, 1), false, 0));	1860 2, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), false));

620 EXPECT_EQ(3, SizeX(gfx::Size(3, 3), gfx::Size(6, 1), false, 1));	1861 EXPECT_EQ(

621 EXPECT_EQ(0, PosX(gfx::Size(3, 3), gfx::Size(6, 1), false, 0));	1862 3, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), false, 0));

622 EXPECT_EQ(3, PosX(gfx::Size(3, 3), gfx::Size(6, 1), false, 1));	1863 EXPECT_EQ(

623 EXPECT_EQ(3, SizeX(gfx::Size(3, 3), gfx::Size(6, 100), false, 0));	1864 3, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), false, 1));

624 EXPECT_EQ(3, SizeX(gfx::Size(3, 3), gfx::Size(6, 100), false, 1));	1865 EXPECT_EQ(

625 EXPECT_EQ(0, PosX(gfx::Size(3, 3), gfx::Size(6, 100), false, 0));	1866 origin.x() + 0,

626 EXPECT_EQ(3, PosX(gfx::Size(3, 3), gfx::Size(6, 100), false, 1));	1867 PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), false, 0));

	1868 EXPECT_EQ(

	1869 origin.x() + 3,

	1870 PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), false, 1));

	1871 EXPECT_EQ(

	1872 3,

	1873 SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 100)), false, 0));

	1874 EXPECT_EQ(

	1875 3,

	1876 SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 100)), false, 1));

	1877 EXPECT_EQ(

	1878 origin.x() + 0,

	1879 PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 100)), false, 0));

	1880 EXPECT_EQ(

	1881 origin.x() + 3,

	1882 PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 100)), false, 1));

627	1883

628 // Multiple tiles:	1884 // Multiple tiles:

629 // with border	1885 // with border

630 // positions 0, 2, 3, 4	1886 // positions 0, 2, 3, 4

631 EXPECT_EQ(4, NumTiles(gfx::Size(3, 3), gfx::Size(6, 1), true));	1887 EXPECT_EQ(

632 EXPECT_EQ(2, SizeX(gfx::Size(3, 3), gfx::Size(6, 1), true, 0));	1888 4, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), true));

633 EXPECT_EQ(1, SizeX(gfx::Size(3, 3), gfx::Size(6, 1), true, 1));	1889 EXPECT_EQ(

634 EXPECT_EQ(1, SizeX(gfx::Size(3, 3), gfx::Size(6, 1), true, 2));	1890 2, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), true, 0));

635 EXPECT_EQ(2, SizeX(gfx::Size(3, 3), gfx::Size(6, 1), true, 3));	1891 EXPECT_EQ(

636 EXPECT_EQ(0, PosX(gfx::Size(3, 3), gfx::Size(6, 1), true, 0));	1892 1, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), true, 1));

637 EXPECT_EQ(2, PosX(gfx::Size(3, 3), gfx::Size(6, 1), true, 1));	1893 EXPECT_EQ(

638 EXPECT_EQ(3, PosX(gfx::Size(3, 3), gfx::Size(6, 1), true, 2));	1894 1, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), true, 2));

639 EXPECT_EQ(4, PosX(gfx::Size(3, 3), gfx::Size(6, 1), true, 3));	1895 EXPECT_EQ(

640 EXPECT_EQ(2, SizeX(gfx::Size(3, 7), gfx::Size(6, 100), true, 0));	1896 2, SizeX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), true, 3));

641 EXPECT_EQ(1, SizeX(gfx::Size(3, 7), gfx::Size(6, 100), true, 1));	1897 EXPECT_EQ(origin.x() + 0,

642 EXPECT_EQ(1, SizeX(gfx::Size(3, 7), gfx::Size(6, 100), true, 2));	1898 PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), true, 0));

643 EXPECT_EQ(2, SizeX(gfx::Size(3, 7), gfx::Size(6, 100), true, 3));	1899 EXPECT_EQ(origin.x() + 2,

644 EXPECT_EQ(0, PosX(gfx::Size(3, 7), gfx::Size(6, 100), true, 0));	1900 PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), true, 1));

645 EXPECT_EQ(2, PosX(gfx::Size(3, 7), gfx::Size(6, 100), true, 1));	1901 EXPECT_EQ(origin.x() + 3,

646 EXPECT_EQ(3, PosX(gfx::Size(3, 7), gfx::Size(6, 100), true, 2));	1902 PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), true, 2));

647 EXPECT_EQ(4, PosX(gfx::Size(3, 7), gfx::Size(6, 100), true, 3));	1903 EXPECT_EQ(origin.x() + 4,

648 }	1904 PosX(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(6, 1)), true, 3));

649	1905 EXPECT_EQ(

650 TEST(TilingDataTest, TileSizeY_and_TilePositionY) {	1906 2, SizeX(gfx::Size(3, 7), gfx::Rect(origin, gfx::Size(6, 100)), true, 0));

	1907 EXPECT_EQ(

	1908 1, SizeX(gfx::Size(3, 7), gfx::Rect(origin, gfx::Size(6, 100)), true, 1));

	1909 EXPECT_EQ(

	1910 1, SizeX(gfx::Size(3, 7), gfx::Rect(origin, gfx::Size(6, 100)), true, 2));

	1911 EXPECT_EQ(

	1912 2, SizeX(gfx::Size(3, 7), gfx::Rect(origin, gfx::Size(6, 100)), true, 3));

	1913 EXPECT_EQ(

	1914 origin.x() + 0,

	1915 PosX(gfx::Size(3, 7), gfx::Rect(origin, gfx::Size(6, 100)), true, 0));

	1916 EXPECT_EQ(

	1917 origin.x() + 2,

	1918 PosX(gfx::Size(3, 7), gfx::Rect(origin, gfx::Size(6, 100)), true, 1));

	1919 EXPECT_EQ(

	1920 origin.x() + 3,

	1921 PosX(gfx::Size(3, 7), gfx::Rect(origin, gfx::Size(6, 100)), true, 2));

	1922 EXPECT_EQ(

	1923 origin.x() + 4,

	1924 PosX(gfx::Size(3, 7), gfx::Rect(origin, gfx::Size(6, 100)), true, 3));

	1925 }

	1926

	1927 TEST_P(TilingDataTest, TileSizeY_and_TilePositionY) {

	1928 gfx::Point origin = GetParam();

	1929

651 // Single tile cases:	1930 // Single tile cases:

652 EXPECT_EQ(1, SizeY(gfx::Size(3, 3), gfx::Size(1, 1), false, 0));	1931 EXPECT_EQ(

653 EXPECT_EQ(0, PosY(gfx::Size(3, 3), gfx::Size(1, 1), false, 0));	1932 1, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 1)), false, 0));

654 EXPECT_EQ(1, SizeY(gfx::Size(3, 3), gfx::Size(100, 1), false, 0));	1933 EXPECT_EQ(

655 EXPECT_EQ(0, PosY(gfx::Size(3, 3), gfx::Size(100, 1), false, 0));	1934 origin.y(),

656 EXPECT_EQ(3, SizeY(gfx::Size(3, 3), gfx::Size(1, 3), false, 0));	1935 PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 1)), false, 0));

657 EXPECT_EQ(0, PosY(gfx::Size(3, 3), gfx::Size(1, 3), false, 0));	1936 EXPECT_EQ(

658 EXPECT_EQ(3, SizeY(gfx::Size(3, 3), gfx::Size(100, 3), false, 0));	1937 1,

659 EXPECT_EQ(0, PosY(gfx::Size(3, 3), gfx::Size(100, 3), false, 0));	1938 SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 1)), false, 0));

660 EXPECT_EQ(1, SizeY(gfx::Size(3, 3), gfx::Size(1, 1), true, 0));	1939 EXPECT_EQ(

661 EXPECT_EQ(0, PosY(gfx::Size(3, 3), gfx::Size(1, 1), true, 0));	1940 origin.y(),

662 EXPECT_EQ(1, SizeY(gfx::Size(3, 3), gfx::Size(100, 1), true, 0));	1941 PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 1)), false, 0));

663 EXPECT_EQ(0, PosY(gfx::Size(3, 3), gfx::Size(100, 1), true, 0));	1942 EXPECT_EQ(

664 EXPECT_EQ(3, SizeY(gfx::Size(3, 3), gfx::Size(1, 3), true, 0));	1943 3, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 3)), false, 0));

665 EXPECT_EQ(0, PosY(gfx::Size(3, 3), gfx::Size(1, 3), true, 0));	1944 EXPECT_EQ(

666 EXPECT_EQ(3, SizeY(gfx::Size(3, 3), gfx::Size(100, 3), true, 0));	1945 origin.y(),

667 EXPECT_EQ(0, PosY(gfx::Size(3, 3), gfx::Size(100, 3), true, 0));	1946 PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 3)), false, 0));

	1947 EXPECT_EQ(

	1948 3,

	1949 SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 3)), false, 0));

	1950 EXPECT_EQ(

	1951 origin.y(),

	1952 PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 3)), false, 0));

	1953 EXPECT_EQ(

	1954 1, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 1)), true, 0));

	1955 EXPECT_EQ(origin.y(),

	1956 PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 1)), true, 0));

	1957 EXPECT_EQ(

	1958 1, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 1)), true, 0));

	1959 EXPECT_EQ(

	1960 origin.y(),

	1961 PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 1)), true, 0));

	1962 EXPECT_EQ(

	1963 3, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 3)), true, 0));

	1964 EXPECT_EQ(origin.y(),

	1965 PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 3)), true, 0));

	1966 EXPECT_EQ(

	1967 3, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 3)), true, 0));

	1968 EXPECT_EQ(

	1969 origin.y(),

	1970 PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 3)), true, 0));

668	1971

669 // Multiple tiles:	1972 // Multiple tiles:

670 // no border	1973 // no border

671 // positions 0, 3	1974 // positions 0, 3

672 EXPECT_EQ(2, NumTiles(gfx::Size(3, 3), gfx::Size(1, 6), false));	1975 EXPECT_EQ(

673 EXPECT_EQ(3, SizeY(gfx::Size(3, 3), gfx::Size(1, 6), false, 0));	1976 2, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), false));

674 EXPECT_EQ(3, SizeY(gfx::Size(3, 3), gfx::Size(1, 6), false, 1));	1977 EXPECT_EQ(

675 EXPECT_EQ(0, PosY(gfx::Size(3, 3), gfx::Size(1, 6), false, 0));	1978 3, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), false, 0));

676 EXPECT_EQ(3, PosY(gfx::Size(3, 3), gfx::Size(1, 6), false, 1));	1979 EXPECT_EQ(

677 EXPECT_EQ(3, SizeY(gfx::Size(3, 3), gfx::Size(100, 6), false, 0));	1980 3, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), false, 1));

678 EXPECT_EQ(3, SizeY(gfx::Size(3, 3), gfx::Size(100, 6), false, 1));	1981 EXPECT_EQ(

679 EXPECT_EQ(0, PosY(gfx::Size(3, 3), gfx::Size(100, 6), false, 0));	1982 origin.y() + 0,

680 EXPECT_EQ(3, PosY(gfx::Size(3, 3), gfx::Size(100, 6), false, 1));	1983 PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), false, 0));

	1984 EXPECT_EQ(

	1985 origin.y() + 3,

	1986 PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), false, 1));

	1987 EXPECT_EQ(

	1988 3,

	1989 SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 6)), false, 0));

	1990 EXPECT_EQ(

	1991 3,

	1992 SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 6)), false, 1));

	1993 EXPECT_EQ(

	1994 origin.y() + 0,

	1995 PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 6)), false, 0));

	1996 EXPECT_EQ(

	1997 origin.y() + 3,

	1998 PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(100, 6)), false, 1));

681	1999

682 // Multiple tiles:	2000 // Multiple tiles:

683 // with border	2001 // with border

684 // positions 0, 2, 3, 4	2002 // positions 0, 2, 3, 4

685 EXPECT_EQ(4, NumTiles(gfx::Size(3, 3), gfx::Size(1, 6), true));	2003 EXPECT_EQ(

686 EXPECT_EQ(2, SizeY(gfx::Size(3, 3), gfx::Size(1, 6), true, 0));	2004 4, NumTiles(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), true));

687 EXPECT_EQ(1, SizeY(gfx::Size(3, 3), gfx::Size(1, 6), true, 1));	2005 EXPECT_EQ(

688 EXPECT_EQ(1, SizeY(gfx::Size(3, 3), gfx::Size(1, 6), true, 2));	2006 2, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), true, 0));

689 EXPECT_EQ(2, SizeY(gfx::Size(3, 3), gfx::Size(1, 6), true, 3));	2007 EXPECT_EQ(

690 EXPECT_EQ(0, PosY(gfx::Size(3, 3), gfx::Size(1, 6), true, 0));	2008 1, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), true, 1));

691 EXPECT_EQ(2, PosY(gfx::Size(3, 3), gfx::Size(1, 6), true, 1));	2009 EXPECT_EQ(

692 EXPECT_EQ(3, PosY(gfx::Size(3, 3), gfx::Size(1, 6), true, 2));	2010 1, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), true, 2));

693 EXPECT_EQ(4, PosY(gfx::Size(3, 3), gfx::Size(1, 6), true, 3));	2011 EXPECT_EQ(

694 EXPECT_EQ(2, SizeY(gfx::Size(7, 3), gfx::Size(100, 6), true, 0));	2012 2, SizeY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), true, 3));

695 EXPECT_EQ(1, SizeY(gfx::Size(7, 3), gfx::Size(100, 6), true, 1));	2013 EXPECT_EQ(origin.y() + 0,

696 EXPECT_EQ(1, SizeY(gfx::Size(7, 3), gfx::Size(100, 6), true, 2));	2014 PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), true, 0));

697 EXPECT_EQ(2, SizeY(gfx::Size(7, 3), gfx::Size(100, 6), true, 3));	2015 EXPECT_EQ(origin.y() + 2,

698 EXPECT_EQ(0, PosY(gfx::Size(7, 3), gfx::Size(100, 6), true, 0));	2016 PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), true, 1));

699 EXPECT_EQ(2, PosY(gfx::Size(7, 3), gfx::Size(100, 6), true, 1));	2017 EXPECT_EQ(origin.y() + 3,

700 EXPECT_EQ(3, PosY(gfx::Size(7, 3), gfx::Size(100, 6), true, 2));	2018 PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), true, 2));

701 EXPECT_EQ(4, PosY(gfx::Size(7, 3), gfx::Size(100, 6), true, 3));	2019 EXPECT_EQ(origin.y() + 4,

702 }	2020 PosY(gfx::Size(3, 3), gfx::Rect(origin, gfx::Size(1, 6)), true, 3));

703	2021 EXPECT_EQ(

704 TEST(TilingDataTest, SetTotalSize) {	2022 2, SizeY(gfx::Size(7, 3), gfx::Rect(origin, gfx::Size(100, 6)), true, 0));

705 TilingData data(gfx::Size(5, 5), gfx::Size(5, 5), false);	2023 EXPECT_EQ(

706 EXPECT_EQ(5, data.total_size().width());	2024 1, SizeY(gfx::Size(7, 3), gfx::Rect(origin, gfx::Size(100, 6)), true, 1));

707 EXPECT_EQ(5, data.total_size().height());	2025 EXPECT_EQ(

	2026 1, SizeY(gfx::Size(7, 3), gfx::Rect(origin, gfx::Size(100, 6)), true, 2));

	2027 EXPECT_EQ(

	2028 2, SizeY(gfx::Size(7, 3), gfx::Rect(origin, gfx::Size(100, 6)), true, 3));

	2029 EXPECT_EQ(

	2030 origin.y() + 0,

	2031 PosY(gfx::Size(7, 3), gfx::Rect(origin, gfx::Size(100, 6)), true, 0));

	2032 EXPECT_EQ(

	2033 origin.y() + 2,

	2034 PosY(gfx::Size(7, 3), gfx::Rect(origin, gfx::Size(100, 6)), true, 1));

	2035 EXPECT_EQ(

	2036 origin.y() + 3,

	2037 PosY(gfx::Size(7, 3), gfx::Rect(origin, gfx::Size(100, 6)), true, 2));

	2038 EXPECT_EQ(

	2039 origin.y() + 4,

	2040 PosY(gfx::Size(7, 3), gfx::Rect(origin, gfx::Size(100, 6)), true, 3));

	2041 }

	2042

	2043 TEST_P(TilingDataTest, SetTotalSize) {

	2044 gfx::Point origin = GetParam();

	2045

	2046 TilingData data(gfx::Size(5, 5), gfx::Rect(origin, gfx::Size(5, 5)), false);

	2047 EXPECT_EQ(origin.x(), data.tiling_rect().x());

	2048 EXPECT_EQ(origin.y(), data.tiling_rect().y());

	2049 EXPECT_EQ(5, data.tiling_rect().width());

	2050 EXPECT_EQ(5, data.tiling_rect().height());

708 EXPECT_EQ(1, data.num_tiles_x());	2051 EXPECT_EQ(1, data.num_tiles_x());

709 EXPECT_EQ(5, data.TileSizeX(0));	2052 EXPECT_EQ(5, data.TileSizeX(0));

710 EXPECT_EQ(1, data.num_tiles_y());	2053 EXPECT_EQ(1, data.num_tiles_y());

711 EXPECT_EQ(5, data.TileSizeY(0));	2054 EXPECT_EQ(5, data.TileSizeY(0));

712	2055

713 data.SetTotalSize(gfx::Size(6, 5));	2056 data.SetTilingRect(gfx::Rect(36, 82, 6, 5));

714 EXPECT_EQ(6, data.total_size().width());	2057 EXPECT_EQ(36, data.tiling_rect().x());

715 EXPECT_EQ(5, data.total_size().height());	2058 EXPECT_EQ(82, data.tiling_rect().y());

	2059 EXPECT_EQ(6, data.tiling_rect().width());

	2060 EXPECT_EQ(5, data.tiling_rect().height());

716 EXPECT_EQ(2, data.num_tiles_x());	2061 EXPECT_EQ(2, data.num_tiles_x());

717 EXPECT_EQ(5, data.TileSizeX(0));	2062 EXPECT_EQ(5, data.TileSizeX(0));

718 EXPECT_EQ(1, data.TileSizeX(1));	2063 EXPECT_EQ(1, data.TileSizeX(1));

719 EXPECT_EQ(1, data.num_tiles_y());	2064 EXPECT_EQ(1, data.num_tiles_y());

720 EXPECT_EQ(5, data.TileSizeY(0));	2065 EXPECT_EQ(5, data.TileSizeY(0));

721	2066

722 data.SetTotalSize(gfx::Size(5, 12));	2067 data.SetTilingRect(gfx::Rect(4, 22, 5, 12));

723 EXPECT_EQ(5, data.total_size().width());	2068 EXPECT_EQ(4, data.tiling_rect().x());

724 EXPECT_EQ(12, data.total_size().height());	2069 EXPECT_EQ(22, data.tiling_rect().y());

	2070 EXPECT_EQ(5, data.tiling_rect().width());

	2071 EXPECT_EQ(12, data.tiling_rect().height());

725 EXPECT_EQ(1, data.num_tiles_x());	2072 EXPECT_EQ(1, data.num_tiles_x());

726 EXPECT_EQ(5, data.TileSizeX(0));	2073 EXPECT_EQ(5, data.TileSizeX(0));

727 EXPECT_EQ(3, data.num_tiles_y());	2074 EXPECT_EQ(3, data.num_tiles_y());

728 EXPECT_EQ(5, data.TileSizeY(0));	2075 EXPECT_EQ(5, data.TileSizeY(0));

729 EXPECT_EQ(5, data.TileSizeY(1));	2076 EXPECT_EQ(5, data.TileSizeY(1));

730 EXPECT_EQ(2, data.TileSizeY(2));	2077 EXPECT_EQ(2, data.TileSizeY(2));

731 }	2078 }

732	2079

733 TEST(TilingDataTest, SetMaxTextureSizeNoBorders) {	2080 TEST_P(TilingDataTest, SetMaxTextureSizeNoBorders) {

734 TilingData data(gfx::Size(8, 8), gfx::Size(16, 32), false);	2081 gfx::Point origin = GetParam();

	2082

	2083 TilingData data(gfx::Size(8, 8), gfx::Rect(origin, gfx::Size(16, 32)), false);

735 EXPECT_EQ(2, data.num_tiles_x());	2084 EXPECT_EQ(2, data.num_tiles_x());

736 EXPECT_EQ(4, data.num_tiles_y());	2085 EXPECT_EQ(4, data.num_tiles_y());

737	2086

738 data.SetMaxTextureSize(gfx::Size(32, 32));	2087 data.SetMaxTextureSize(gfx::Size(32, 32));

739 EXPECT_EQ(gfx::Size(32, 32), data.max_texture_size());	2088 EXPECT_EQ(gfx::Size(32, 32), data.max_texture_size());

740 EXPECT_EQ(1, data.num_tiles_x());	2089 EXPECT_EQ(1, data.num_tiles_x());

741 EXPECT_EQ(1, data.num_tiles_y());	2090 EXPECT_EQ(1, data.num_tiles_y());

742	2091

743 data.SetMaxTextureSize(gfx::Size(2, 2));	2092 data.SetMaxTextureSize(gfx::Size(2, 2));

744 EXPECT_EQ(gfx::Size(2, 2), data.max_texture_size());	2093 EXPECT_EQ(gfx::Size(2, 2), data.max_texture_size());

745 EXPECT_EQ(8, data.num_tiles_x());	2094 EXPECT_EQ(8, data.num_tiles_x());

746 EXPECT_EQ(16, data.num_tiles_y());	2095 EXPECT_EQ(16, data.num_tiles_y());

747	2096

748 data.SetMaxTextureSize(gfx::Size(5, 5));	2097 data.SetMaxTextureSize(gfx::Size(5, 5));

749 EXPECT_EQ(gfx::Size(5, 5), data.max_texture_size());	2098 EXPECT_EQ(gfx::Size(5, 5), data.max_texture_size());

750 EXPECT_EQ(4, data.num_tiles_x());	2099 EXPECT_EQ(4, data.num_tiles_x());

751 EXPECT_EQ(7, data.num_tiles_y());	2100 EXPECT_EQ(7, data.num_tiles_y());

752	2101

753 data.SetMaxTextureSize(gfx::Size(8, 5));	2102 data.SetMaxTextureSize(gfx::Size(8, 5));

754 EXPECT_EQ(gfx::Size(8, 5), data.max_texture_size());	2103 EXPECT_EQ(gfx::Size(8, 5), data.max_texture_size());

755 EXPECT_EQ(2, data.num_tiles_x());	2104 EXPECT_EQ(2, data.num_tiles_x());

756 EXPECT_EQ(7, data.num_tiles_y());	2105 EXPECT_EQ(7, data.num_tiles_y());

757 }	2106 }

758	2107

759 TEST(TilingDataTest, SetMaxTextureSizeBorders) {	2108 TEST_P(TilingDataTest, SetMaxTextureSizeBorders) {

760 TilingData data(gfx::Size(8, 8), gfx::Size(16, 32), true);	2109 gfx::Point origin = GetParam();

	2110

	2111 TilingData data(gfx::Size(8, 8), gfx::Rect(origin, gfx::Size(16, 32)), true);

761 EXPECT_EQ(3, data.num_tiles_x());	2112 EXPECT_EQ(3, data.num_tiles_x());

762 EXPECT_EQ(5, data.num_tiles_y());	2113 EXPECT_EQ(5, data.num_tiles_y());

763	2114

764 data.SetMaxTextureSize(gfx::Size(32, 32));	2115 data.SetMaxTextureSize(gfx::Size(32, 32));

765 EXPECT_EQ(gfx::Size(32, 32), data.max_texture_size());	2116 EXPECT_EQ(gfx::Size(32, 32), data.max_texture_size());

766 EXPECT_EQ(1, data.num_tiles_x());	2117 EXPECT_EQ(1, data.num_tiles_x());

767 EXPECT_EQ(1, data.num_tiles_y());	2118 EXPECT_EQ(1, data.num_tiles_y());

768	2119

769 data.SetMaxTextureSize(gfx::Size(2, 2));	2120 data.SetMaxTextureSize(gfx::Size(2, 2));

770 EXPECT_EQ(gfx::Size(2, 2), data.max_texture_size());	2121 EXPECT_EQ(gfx::Size(2, 2), data.max_texture_size());

771 EXPECT_EQ(0, data.num_tiles_x());	2122 EXPECT_EQ(0, data.num_tiles_x());

772 EXPECT_EQ(0, data.num_tiles_y());	2123 EXPECT_EQ(0, data.num_tiles_y());

773	2124

774 data.SetMaxTextureSize(gfx::Size(5, 5));	2125 data.SetMaxTextureSize(gfx::Size(5, 5));

775 EXPECT_EQ(gfx::Size(5, 5), data.max_texture_size());	2126 EXPECT_EQ(gfx::Size(5, 5), data.max_texture_size());

776 EXPECT_EQ(5, data.num_tiles_x());	2127 EXPECT_EQ(5, data.num_tiles_x());

777 EXPECT_EQ(10, data.num_tiles_y());	2128 EXPECT_EQ(10, data.num_tiles_y());

778	2129

779 data.SetMaxTextureSize(gfx::Size(8, 5));	2130 data.SetMaxTextureSize(gfx::Size(8, 5));

780 EXPECT_EQ(gfx::Size(8, 5), data.max_texture_size());	2131 EXPECT_EQ(gfx::Size(8, 5), data.max_texture_size());

781 EXPECT_EQ(3, data.num_tiles_x());	2132 EXPECT_EQ(3, data.num_tiles_x());

782 EXPECT_EQ(10, data.num_tiles_y());	2133 EXPECT_EQ(10, data.num_tiles_y());

783 }	2134 }

784	2135

785 TEST(TilingDataTest, Assignment) {	2136 TEST_P(TilingDataTest, Assignment) {

	2137 gfx::Point origin = GetParam();

	2138

786 {	2139 {

787 TilingData source(gfx::Size(8, 8), gfx::Size(16, 32), true);	2140 TilingData source(

	2141 gfx::Size(8, 8), gfx::Rect(origin, gfx::Size(16, 32)), true);

788 TilingData dest = source;	2142 TilingData dest = source;

789 EXPECT_EQ(source.border_texels(), dest.border_texels());	2143 EXPECT_EQ(source.border_texels(), dest.border_texels());

790 EXPECT_EQ(source.max_texture_size(), dest.max_texture_size());	2144 EXPECT_EQ(source.max_texture_size(), dest.max_texture_size());

791 EXPECT_EQ(source.num_tiles_x(), dest.num_tiles_x());	2145 EXPECT_EQ(source.num_tiles_x(), dest.num_tiles_x());

792 EXPECT_EQ(source.num_tiles_y(), dest.num_tiles_y());	2146 EXPECT_EQ(source.num_tiles_y(), dest.num_tiles_y());

793 EXPECT_EQ(source.total_size().width(), dest.total_size().width());	2147 EXPECT_EQ(source.tiling_rect().x(), dest.tiling_rect().x());

794 EXPECT_EQ(source.total_size().height(), dest.total_size().height());	2148 EXPECT_EQ(source.tiling_rect().y(), dest.tiling_rect().y());

	2149 EXPECT_EQ(source.tiling_rect().width(), dest.tiling_rect().width());

	2150 EXPECT_EQ(source.tiling_rect().height(), dest.tiling_rect().height());

795 }	2151 }

796 {	2152 {

797 TilingData source(gfx::Size(7, 3), gfx::Size(6, 100), false);	2153 TilingData source(

	2154 gfx::Size(7, 3), gfx::Rect(origin, gfx::Size(6, 100)), false);

798 TilingData dest(source);	2155 TilingData dest(source);

799 EXPECT_EQ(source.border_texels(), dest.border_texels());	2156 EXPECT_EQ(source.border_texels(), dest.border_texels());

800 EXPECT_EQ(source.max_texture_size(), dest.max_texture_size());	2157 EXPECT_EQ(source.max_texture_size(), dest.max_texture_size());

801 EXPECT_EQ(source.num_tiles_x(), dest.num_tiles_x());	2158 EXPECT_EQ(source.num_tiles_x(), dest.num_tiles_x());

802 EXPECT_EQ(source.num_tiles_y(), dest.num_tiles_y());	2159 EXPECT_EQ(source.num_tiles_y(), dest.num_tiles_y());

803 EXPECT_EQ(source.total_size().width(), dest.total_size().width());	2160 EXPECT_EQ(source.tiling_rect().x(), dest.tiling_rect().x());

804 EXPECT_EQ(source.total_size().height(), dest.total_size().height());	2161 EXPECT_EQ(source.tiling_rect().y(), dest.tiling_rect().y());

	2162 EXPECT_EQ(source.tiling_rect().width(), dest.tiling_rect().width());

	2163 EXPECT_EQ(source.tiling_rect().height(), dest.tiling_rect().height());

805 }	2164 }

806 }	2165 }

807	2166

808 TEST(TilingDataTest, SetBorderTexels) {	2167 TEST_P(TilingDataTest, SetBorderTexels) {

809 TilingData data(gfx::Size(8, 8), gfx::Size(16, 32), false);	2168 gfx::Point origin = GetParam();

	2169

	2170 TilingData data(gfx::Size(8, 8), gfx::Rect(origin, gfx::Size(16, 32)), false);

810 EXPECT_EQ(2, data.num_tiles_x());	2171 EXPECT_EQ(2, data.num_tiles_x());

811 EXPECT_EQ(4, data.num_tiles_y());	2172 EXPECT_EQ(4, data.num_tiles_y());

812	2173

813 data.SetHasBorderTexels(true);	2174 data.SetHasBorderTexels(true);

814 EXPECT_EQ(3, data.num_tiles_x());	2175 EXPECT_EQ(3, data.num_tiles_x());

815 EXPECT_EQ(5, data.num_tiles_y());	2176 EXPECT_EQ(5, data.num_tiles_y());

816	2177

817 data.SetHasBorderTexels(true);

818 EXPECT_EQ(3, data.num_tiles_x());

819 EXPECT_EQ(5, data.num_tiles_y());

820

821 data.SetHasBorderTexels(false);	2178 data.SetHasBorderTexels(false);

822 EXPECT_EQ(2, data.num_tiles_x());	2179 EXPECT_EQ(2, data.num_tiles_x());

823 EXPECT_EQ(4, data.num_tiles_y());	2180 EXPECT_EQ(4, data.num_tiles_y());

824 }	2181 }

825	2182

826 TEST(TilingDataTest, LargeBorders) {	2183 TEST_P(TilingDataTest, LargeBorders) {

827 TilingData data(gfx::Size(100, 80), gfx::Size(200, 145), 30);	2184 gfx::Point origin = GetParam();

	2185

	2186 TilingData data(

	2187 gfx::Size(100, 80), gfx::Rect(origin, gfx::Size(200, 145)), 30);

828 EXPECT_EQ(30, data.border_texels());	2188 EXPECT_EQ(30, data.border_texels());

829	2189

830 EXPECT_EQ(70, data.TileSizeX(0));	2190 EXPECT_EQ(70, data.TileSizeX(0));

831 EXPECT_EQ(40, data.TileSizeX(1));	2191 EXPECT_EQ(40, data.TileSizeX(1));

832 EXPECT_EQ(40, data.TileSizeX(2));	2192 EXPECT_EQ(40, data.TileSizeX(2));

833 EXPECT_EQ(50, data.TileSizeX(3));	2193 EXPECT_EQ(50, data.TileSizeX(3));

834 EXPECT_EQ(4, data.num_tiles_x());	2194 EXPECT_EQ(4, data.num_tiles_x());

835	2195

836 EXPECT_EQ(50, data.TileSizeY(0));	2196 EXPECT_EQ(50, data.TileSizeY(0));

837 EXPECT_EQ(20, data.TileSizeY(1));	2197 EXPECT_EQ(20, data.TileSizeY(1));

838 EXPECT_EQ(20, data.TileSizeY(2));	2198 EXPECT_EQ(20, data.TileSizeY(2));

839 EXPECT_EQ(20, data.TileSizeY(3));	2199 EXPECT_EQ(20, data.TileSizeY(3));

840 EXPECT_EQ(35, data.TileSizeY(4));	2200 EXPECT_EQ(35, data.TileSizeY(4));

841 EXPECT_EQ(5, data.num_tiles_y());	2201 EXPECT_EQ(5, data.num_tiles_y());

842	2202

843 EXPECT_RECT_EQ(gfx::Rect(0, 0, 70, 50), data.TileBounds(0, 0));	2203 EXPECT_RECT_EQ(gfx::Rect(origin.x() + 0, origin.y() + 0, 70, 50),

844 EXPECT_RECT_EQ(gfx::Rect(70, 50, 40, 20), data.TileBounds(1, 1));	2204 data.TileBounds(0, 0));

845 EXPECT_RECT_EQ(gfx::Rect(110, 110, 40, 35), data.TileBounds(2, 4));	2205 EXPECT_RECT_EQ(gfx::Rect(origin.x() + 70, origin.y() + 50, 40, 20),

846 EXPECT_RECT_EQ(gfx::Rect(150, 70, 50, 20), data.TileBounds(3, 2));	2206 data.TileBounds(1, 1));

847 EXPECT_RECT_EQ(gfx::Rect(150, 110, 50, 35), data.TileBounds(3, 4));	2207 EXPECT_RECT_EQ(gfx::Rect(origin.x() + 110, origin.y() + 110, 40, 35),

	2208 data.TileBounds(2, 4));

	2209 EXPECT_RECT_EQ(gfx::Rect(origin.x() + 150, origin.y() + 70, 50, 20),

	2210 data.TileBounds(3, 2));

	2211 EXPECT_RECT_EQ(gfx::Rect(origin.x() + 150, origin.y() + 110, 50, 35),

	2212 data.TileBounds(3, 4));

848	2213

849 EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 80), data.TileBoundsWithBorder(0, 0));	2214 EXPECT_RECT_EQ(gfx::Rect(origin.x() + 0, origin.y() + 0, 100, 80),

850 EXPECT_RECT_EQ(gfx::Rect(40, 20, 100, 80), data.TileBoundsWithBorder(1, 1));	2215 data.TileBoundsWithBorder(0, 0));

851 EXPECT_RECT_EQ(gfx::Rect(80, 80, 100, 65), data.TileBoundsWithBorder(2, 4));	2216 EXPECT_RECT_EQ(gfx::Rect(origin.x() + 40, origin.y() + 20, 100, 80),

852 EXPECT_RECT_EQ(gfx::Rect(120, 40, 80, 80), data.TileBoundsWithBorder(3, 2));	2217 data.TileBoundsWithBorder(1, 1));

853 EXPECT_RECT_EQ(gfx::Rect(120, 80, 80, 65), data.TileBoundsWithBorder(3, 4));	2218 EXPECT_RECT_EQ(gfx::Rect(origin.x() + 80, origin.y() + 80, 100, 65),

	2219 data.TileBoundsWithBorder(2, 4));

	2220 EXPECT_RECT_EQ(gfx::Rect(origin.x() + 120, origin.y() + 40, 80, 80),

	2221 data.TileBoundsWithBorder(3, 2));

	2222 EXPECT_RECT_EQ(gfx::Rect(origin.x() + 120, origin.y() + 80, 80, 65),

	2223 data.TileBoundsWithBorder(3, 4));

854	2224

855 EXPECT_EQ(0, data.TileXIndexFromSrcCoord(0));	2225 EXPECT_EQ(0, data.TileXIndexFromSrcCoord(origin.x() + 0));

856 EXPECT_EQ(0, data.TileXIndexFromSrcCoord(69));	2226 EXPECT_EQ(0, data.TileXIndexFromSrcCoord(origin.x() + 69));

857 EXPECT_EQ(1, data.TileXIndexFromSrcCoord(70));	2227 EXPECT_EQ(1, data.TileXIndexFromSrcCoord(origin.x() + 70));

858 EXPECT_EQ(1, data.TileXIndexFromSrcCoord(109));	2228 EXPECT_EQ(1, data.TileXIndexFromSrcCoord(origin.x() + 109));

859 EXPECT_EQ(2, data.TileXIndexFromSrcCoord(110));	2229 EXPECT_EQ(2, data.TileXIndexFromSrcCoord(origin.x() + 110));

860 EXPECT_EQ(2, data.TileXIndexFromSrcCoord(149));	2230 EXPECT_EQ(2, data.TileXIndexFromSrcCoord(origin.x() + 149));

861 EXPECT_EQ(3, data.TileXIndexFromSrcCoord(150));	2231 EXPECT_EQ(3, data.TileXIndexFromSrcCoord(origin.x() + 150));

862 EXPECT_EQ(3, data.TileXIndexFromSrcCoord(199));	2232 EXPECT_EQ(3, data.TileXIndexFromSrcCoord(origin.x() + 199));

863	2233

864 EXPECT_EQ(0, data.TileYIndexFromSrcCoord(0));	2234 EXPECT_EQ(0, data.TileYIndexFromSrcCoord(origin.y() + 0));

865 EXPECT_EQ(0, data.TileYIndexFromSrcCoord(49));	2235 EXPECT_EQ(0, data.TileYIndexFromSrcCoord(origin.y() + 49));

866 EXPECT_EQ(1, data.TileYIndexFromSrcCoord(50));	2236 EXPECT_EQ(1, data.TileYIndexFromSrcCoord(origin.y() + 50));

867 EXPECT_EQ(1, data.TileYIndexFromSrcCoord(69));	2237 EXPECT_EQ(1, data.TileYIndexFromSrcCoord(origin.y() + 69));

868 EXPECT_EQ(2, data.TileYIndexFromSrcCoord(70));	2238 EXPECT_EQ(2, data.TileYIndexFromSrcCoord(origin.y() + 70));

869 EXPECT_EQ(2, data.TileYIndexFromSrcCoord(89));	2239 EXPECT_EQ(2, data.TileYIndexFromSrcCoord(origin.y() + 89));

870 EXPECT_EQ(3, data.TileYIndexFromSrcCoord(90));	2240 EXPECT_EQ(3, data.TileYIndexFromSrcCoord(origin.y() + 90));

871 EXPECT_EQ(3, data.TileYIndexFromSrcCoord(109));	2241 EXPECT_EQ(3, data.TileYIndexFromSrcCoord(origin.y() + 109));

872 EXPECT_EQ(4, data.TileYIndexFromSrcCoord(110));	2242 EXPECT_EQ(4, data.TileYIndexFromSrcCoord(origin.y() + 110));

873 EXPECT_EQ(4, data.TileYIndexFromSrcCoord(144));	2243 EXPECT_EQ(4, data.TileYIndexFromSrcCoord(origin.y() + 144));

874	2244

875 EXPECT_EQ(0, data.FirstBorderTileXIndexFromSrcCoord(0));	2245 EXPECT_EQ(0, data.FirstBorderTileXIndexFromSrcCoord(origin.x() + 0));

876 EXPECT_EQ(0, data.FirstBorderTileXIndexFromSrcCoord(99));	2246 EXPECT_EQ(0, data.FirstBorderTileXIndexFromSrcCoord(origin.x() + 99));

877 EXPECT_EQ(1, data.FirstBorderTileXIndexFromSrcCoord(100));	2247 EXPECT_EQ(1, data.FirstBorderTileXIndexFromSrcCoord(origin.x() + 100));

878 EXPECT_EQ(1, data.FirstBorderTileXIndexFromSrcCoord(139));	2248 EXPECT_EQ(1, data.FirstBorderTileXIndexFromSrcCoord(origin.x() + 139));

879 EXPECT_EQ(2, data.FirstBorderTileXIndexFromSrcCoord(140));	2249 EXPECT_EQ(2, data.FirstBorderTileXIndexFromSrcCoord(origin.x() + 140));

880 EXPECT_EQ(2, data.FirstBorderTileXIndexFromSrcCoord(179));	2250 EXPECT_EQ(2, data.FirstBorderTileXIndexFromSrcCoord(origin.x() + 179));

881 EXPECT_EQ(3, data.FirstBorderTileXIndexFromSrcCoord(180));	2251 EXPECT_EQ(3, data.FirstBorderTileXIndexFromSrcCoord(origin.x() + 180));

882 EXPECT_EQ(3, data.FirstBorderTileXIndexFromSrcCoord(199));	2252 EXPECT_EQ(3, data.FirstBorderTileXIndexFromSrcCoord(origin.x() + 199));

883	2253

884 EXPECT_EQ(0, data.FirstBorderTileYIndexFromSrcCoord(0));	2254 EXPECT_EQ(0, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 0));

885 EXPECT_EQ(0, data.FirstBorderTileYIndexFromSrcCoord(79));	2255 EXPECT_EQ(0, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 79));

886 EXPECT_EQ(1, data.FirstBorderTileYIndexFromSrcCoord(80));	2256 EXPECT_EQ(1, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 80));

887 EXPECT_EQ(1, data.FirstBorderTileYIndexFromSrcCoord(99));	2257 EXPECT_EQ(1, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 99));

888 EXPECT_EQ(2, data.FirstBorderTileYIndexFromSrcCoord(100));	2258 EXPECT_EQ(2, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 100));

889 EXPECT_EQ(2, data.FirstBorderTileYIndexFromSrcCoord(119));	2259 EXPECT_EQ(2, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 119));

890 EXPECT_EQ(3, data.FirstBorderTileYIndexFromSrcCoord(120));	2260 EXPECT_EQ(3, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 120));

891 EXPECT_EQ(3, data.FirstBorderTileYIndexFromSrcCoord(139));	2261 EXPECT_EQ(3, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 139));

892 EXPECT_EQ(4, data.FirstBorderTileYIndexFromSrcCoord(140));	2262 EXPECT_EQ(4, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 140));

893 EXPECT_EQ(4, data.FirstBorderTileYIndexFromSrcCoord(144));	2263 EXPECT_EQ(4, data.FirstBorderTileYIndexFromSrcCoord(origin.y() + 144));

894	2264

895 EXPECT_EQ(0, data.LastBorderTileXIndexFromSrcCoord(0));	2265 EXPECT_EQ(0, data.LastBorderTileXIndexFromSrcCoord(origin.x() + 0));

896 EXPECT_EQ(0, data.LastBorderTileXIndexFromSrcCoord(39));	2266 EXPECT_EQ(0, data.LastBorderTileXIndexFromSrcCoord(origin.x() + 39));

897 EXPECT_EQ(1, data.LastBorderTileXIndexFromSrcCoord(40));	2267 EXPECT_EQ(1, data.LastBorderTileXIndexFromSrcCoord(origin.x() + 40));

898 EXPECT_EQ(1, data.LastBorderTileXIndexFromSrcCoord(79));	2268 EXPECT_EQ(1, data.LastBorderTileXIndexFromSrcCoord(origin.x() + 79));

899 EXPECT_EQ(2, data.LastBorderTileXIndexFromSrcCoord(80));	2269 EXPECT_EQ(2, data.LastBorderTileXIndexFromSrcCoord(origin.x() + 80));

900 EXPECT_EQ(2, data.LastBorderTileXIndexFromSrcCoord(119));	2270 EXPECT_EQ(2, data.LastBorderTileXIndexFromSrcCoord(origin.x() + 119));

901 EXPECT_EQ(3, data.LastBorderTileXIndexFromSrcCoord(120));	2271 EXPECT_EQ(3, data.LastBorderTileXIndexFromSrcCoord(origin.x() + 120));

902 EXPECT_EQ(3, data.LastBorderTileXIndexFromSrcCoord(199));	2272 EXPECT_EQ(3, data.LastBorderTileXIndexFromSrcCoord(origin.x() + 199));

903	2273

904 EXPECT_EQ(0, data.LastBorderTileYIndexFromSrcCoord(0));	2274 EXPECT_EQ(0, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 0));

905 EXPECT_EQ(0, data.LastBorderTileYIndexFromSrcCoord(19));	2275 EXPECT_EQ(0, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 19));

906 EXPECT_EQ(1, data.LastBorderTileYIndexFromSrcCoord(20));	2276 EXPECT_EQ(1, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 20));

907 EXPECT_EQ(1, data.LastBorderTileYIndexFromSrcCoord(39));	2277 EXPECT_EQ(1, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 39));

908 EXPECT_EQ(2, data.LastBorderTileYIndexFromSrcCoord(40));	2278 EXPECT_EQ(2, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 40));

909 EXPECT_EQ(2, data.LastBorderTileYIndexFromSrcCoord(59));	2279 EXPECT_EQ(2, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 59));

910 EXPECT_EQ(3, data.LastBorderTileYIndexFromSrcCoord(60));	2280 EXPECT_EQ(3, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 60));

911 EXPECT_EQ(3, data.LastBorderTileYIndexFromSrcCoord(79));	2281 EXPECT_EQ(3, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 79));

912 EXPECT_EQ(4, data.LastBorderTileYIndexFromSrcCoord(80));	2282 EXPECT_EQ(4, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 80));

913 EXPECT_EQ(4, data.LastBorderTileYIndexFromSrcCoord(144));	2283 EXPECT_EQ(4, data.LastBorderTileYIndexFromSrcCoord(origin.y() + 144));

914 }	2284 }

915	2285

916 void TestIterate(const TilingData& data,	2286 void TestIterate(const TilingData& data,

917 gfx::Rect rect,	2287 gfx::Rect rect,

918 int expect_left,	2288 int expect_left,

919 int expect_top,	2289 int expect_top,

920 int expect_right,	2290 int expect_right,

921 int expect_bottom,	2291 int expect_bottom,

922 bool include_borders) {	2292 bool include_borders) {

923 EXPECT_GE(expect_left, 0);	2293 EXPECT_GE(expect_left, 0);

(...skipping 96 matching lines...) Expand 10 before \| Expand all \| Expand 10 after Loading...
1020 int expect_left,	2390 int expect_left,

1021 int expect_top,	2391 int expect_top,

1022 int expect_right,	2392 int expect_right,

1023 int expect_bottom) {	2393 int expect_bottom) {

1024 TestIterateBorders(	2394 TestIterateBorders(

1025 data, rect, expect_left, expect_top, expect_right, expect_bottom);	2395 data, rect, expect_left, expect_top, expect_right, expect_bottom);

1026 TestIterateNoBorders(	2396 TestIterateNoBorders(

1027 data, rect, expect_left, expect_top, expect_right, expect_bottom);	2397 data, rect, expect_left, expect_top, expect_right, expect_bottom);

1028 }	2398 }

1029	2399

1030 TEST(TilingDataTest, IteratorNoBorderTexels) {	2400 TEST_P(TilingDataTest, IteratorNoBorderTexels) {

1031 TilingData data(gfx::Size(10, 10), gfx::Size(40, 25), false);	2401 gfx::Point origin = GetParam();

	2402

	2403 TilingData data(

	2404 gfx::Size(10, 10), gfx::Rect(origin, gfx::Size(40, 25)), false);

	2405 // The following Coordinates are relative to the origin.

1032 // X border index by src coord: [0-10), [10-20), [20, 30), [30, 40)	2406 // X border index by src coord: [0-10), [10-20), [20, 30), [30, 40)

1033 // Y border index by src coord: [0-10), [10-20), [20, 25)	2407 // Y border index by src coord: [0-10), [10-20), [20, 25)

1034 TestIterateAll(data, gfx::Rect(0, 0, 40, 25), 0, 0, 3, 2);	2408 TestIterateAll(data, gfx::Rect(origin.x(), origin.y(), 40, 25), 0, 0, 3, 2);

1035 TestIterateAll(data, gfx::Rect(15, 15, 8, 8), 1, 1, 2, 2);	2409 TestIterateAll(

1036	2410 data, gfx::Rect(origin.x() + 15, origin.y() + 15, 8, 8), 1, 1, 2, 2);

1037 // Oversized.	2411

1038 TestIterateAll(data, gfx::Rect(-100, -100, 1000, 1000), 0, 0, 3, 2);	2412 // Oversized.

1039 TestIterateAll(data, gfx::Rect(-100, 20, 1000, 1), 0, 2, 3, 2);	2413 TestIterateAll(data,

1040 TestIterateAll(data, gfx::Rect(29, -100, 31, 1000), 2, 0, 3, 2);	2414 gfx::Rect(origin.x() - 100, origin.y() - 100, 1000, 1000),

1041 // Nonintersecting.	2415 0,

1042 TestIterateAll(data, gfx::Rect(60, 80, 100, 100), 0, 0, -1, -1);	2416 0,

1043 }	2417 3,

1044	2418 2);

1045 TEST(TilingDataTest, BordersIteratorOneBorderTexel) {	2419 TestIterateAll(

1046 TilingData data(gfx::Size(10, 20), gfx::Size(25, 45), true);	2420 data, gfx::Rect(origin.x() - 100, origin.y() + 20, 1000, 1), 0, 2, 3, 2);

	2421 TestIterateAll(

	2422 data, gfx::Rect(origin.x() + 29, origin.y() - 100, 31, 1000), 2, 0, 3, 2);

	2423 // Nonintersecting.

	2424 TestIterateAll(data,

	2425 gfx::Rect(origin.x() + 60, origin.y() + 80, 100, 100),

	2426 0,

	2427 0,

	2428 -1,

	2429 -1);

	2430 }

	2431

	2432 TEST_P(TilingDataTest, BordersIteratorOneBorderTexel) {

	2433 gfx::Point origin = GetParam();

	2434

	2435 TilingData data(

	2436 gfx::Size(10, 20), gfx::Rect(origin, gfx::Size(25, 45)), true);

	2437 // The following Coordinates are relative to the origin.

1047 // X border index by src coord: [0-10), [8-18), [16-25)	2438 // X border index by src coord: [0-10), [8-18), [16-25)

1048 // Y border index by src coord: [0-20), [18-38), [36-45)	2439 // Y border index by src coord: [0-20), [18-38), [36-45)

1049 TestIterateBorders(data, gfx::Rect(0, 0, 25, 45), 0, 0, 2, 2);	2440 TestIterateBorders(

1050 TestIterateBorders(data, gfx::Rect(18, 19, 3, 17), 2, 0, 2, 1);	2441 data, gfx::Rect(origin.x(), origin.y(), 25, 45), 0, 0, 2, 2);

1051 TestIterateBorders(data, gfx::Rect(10, 20, 6, 16), 1, 1, 1, 1);	2442 TestIterateBorders(

1052 TestIterateBorders(data, gfx::Rect(9, 19, 8, 18), 0, 0, 2, 2);	2443 data, gfx::Rect(origin.x() + 18, origin.y() + 19, 3, 17), 2, 0, 2, 1);

1053 // Oversized.	2444 TestIterateBorders(

1054 TestIterateBorders(data, gfx::Rect(-100, -100, 1000, 1000), 0, 0, 2, 2);	2445 data, gfx::Rect(origin.x() + 10, origin.y() + 20, 6, 16), 1, 1, 1, 1);

1055 TestIterateBorders(data, gfx::Rect(-100, 20, 1000, 1), 0, 1, 2, 1);	2446 TestIterateBorders(

1056 TestIterateBorders(data, gfx::Rect(18, -100, 6, 1000), 2, 0, 2, 2);	2447 data, gfx::Rect(origin.x() + 9, origin.y() + 19, 8, 18), 0, 0, 2, 2);

1057 // Nonintersecting.	2448 // Oversized.

1058 TestIterateBorders(data, gfx::Rect(60, 80, 100, 100), 0, 0, -1, -1);	2449 TestIterateBorders(data,

1059 }	2450 gfx::Rect(origin.x() - 100, origin.y() - 100, 1000, 1000),

1060	2451 0,

1061 TEST(TilingDataTest, NoBordersIteratorOneBorderTexel) {	2452 0,

1062 TilingData data(gfx::Size(10, 20), gfx::Size(25, 45), true);	2453 2,

	2454 2);

	2455 TestIterateBorders(

	2456 data, gfx::Rect(origin.x() - 100, origin.y() + 20, 1000, 1), 0, 1, 2, 1);

	2457 TestIterateBorders(

	2458 data, gfx::Rect(origin.x() + 18, origin.y() - 100, 6, 1000), 2, 0, 2, 2);

	2459 // Nonintersecting.

	2460 TestIterateBorders(data,

	2461 gfx::Rect(origin.x() + 60, origin.y() + 80, 100, 100),

	2462 0,

	2463 0,

	2464 -1,

	2465 -1);

	2466 }

	2467

	2468 TEST_P(TilingDataTest, NoBordersIteratorOneBorderTexel) {

	2469 gfx::Point origin = GetParam();

	2470

	2471 TilingData data(

	2472 gfx::Size(10, 20), gfx::Rect(origin, gfx::Size(25, 45)), true);

	2473 // The following Coordinates are relative to the origin.

1063 // X index by src coord: [0-9), [9-17), [17-25)	2474 // X index by src coord: [0-9), [9-17), [17-25)

1064 // Y index by src coord: [0-19), [19-37), [37-45)	2475 // Y index by src coord: [0-19), [19-37), [37-45)

1065 TestIterateNoBorders(data, gfx::Rect(0, 0, 25, 45), 0, 0, 2, 2);	2476 TestIterateNoBorders(

1066 TestIterateNoBorders(data, gfx::Rect(17, 19, 3, 18), 2, 1, 2, 1);	2477 data, gfx::Rect(origin.x(), origin.y(), 25, 45), 0, 0, 2, 2);

1067 TestIterateNoBorders(data, gfx::Rect(17, 19, 3, 19), 2, 1, 2, 2);	2478 TestIterateNoBorders(

1068 TestIterateNoBorders(data, gfx::Rect(8, 18, 9, 19), 0, 0, 1, 1);	2479 data, gfx::Rect(origin.x() + 17, origin.y() + 19, 3, 18), 2, 1, 2, 1);

1069 TestIterateNoBorders(data, gfx::Rect(9, 19, 9, 19), 1, 1, 2, 2);	2480 TestIterateNoBorders(

1070 // Oversized.	2481 data, gfx::Rect(origin.x() + 17, origin.y() + 19, 3, 19), 2, 1, 2, 2);

1071 TestIterateNoBorders(data, gfx::Rect(-100, -100, 1000, 1000), 0, 0, 2, 2);	2482 TestIterateNoBorders(

1072 TestIterateNoBorders(data, gfx::Rect(-100, 20, 1000, 1), 0, 1, 2, 1);	2483 data, gfx::Rect(origin.x() + 8, origin.y() + 18, 9, 19), 0, 0, 1, 1);

1073 TestIterateNoBorders(data, gfx::Rect(18, -100, 6, 1000), 2, 0, 2, 2);	2484 TestIterateNoBorders(

1074 // Nonintersecting.	2485 data, gfx::Rect(origin.x() + 9, origin.y() + 19, 9, 19), 1, 1, 2, 2);

1075 TestIterateNoBorders(data, gfx::Rect(60, 80, 100, 100), 0, 0, -1, -1);	2486 // Oversized.

1076 }	2487 TestIterateNoBorders(

1077	2488 data,

1078 TEST(TilingDataTest, BordersIteratorManyBorderTexels) {	2489 gfx::Rect(origin.x() - 100, origin.y() - 100, 1000, 1000),

1079 TilingData data(gfx::Size(50, 60), gfx::Size(65, 110), 20);	2490 0,

	2491 0,

	2492 2,

	2493 2);

	2494 TestIterateNoBorders(

	2495 data, gfx::Rect(origin.x() - 100, origin.y() + 20, 1000, 1), 0, 1, 2, 1);

	2496 TestIterateNoBorders(

	2497 data, gfx::Rect(origin.x() + 18, origin.y() - 100, 6, 1000), 2, 0, 2, 2);

	2498 // Nonintersecting.

	2499 TestIterateNoBorders(data,

	2500 gfx::Rect(origin.x() + 60, origin.y() + 80, 100, 100),

	2501 0,

	2502 0,

	2503 -1,

	2504 -1);

	2505 }

	2506

	2507 TEST_P(TilingDataTest, BordersIteratorManyBorderTexels) {

	2508 gfx::Point origin = GetParam();

	2509

	2510 TilingData data(gfx::Size(50, 60), gfx::Rect(origin, gfx::Size(65, 110)), 20);

	2511 // The following Coordinates are relative to the origin.

1080 // X border index by src coord: [0-50), [10-60), [20-65)	2512 // X border index by src coord: [0-50), [10-60), [20-65)

1081 // Y border index by src coord: [0-60), [20-80), [40-100), [60-110)	2513 // Y border index by src coord: [0-60), [20-80), [40-100), [60-110)

1082 TestIterateBorders(data, gfx::Rect(0, 0, 65, 110), 0, 0, 2, 3);	2514 TestIterateBorders(

1083 TestIterateBorders(data, gfx::Rect(50, 60, 15, 65), 1, 1, 2, 3);	2515 data, gfx::Rect(origin.x(), origin.y(), 65, 110), 0, 0, 2, 3);

1084 TestIterateBorders(data, gfx::Rect(60, 30, 2, 10), 2, 0, 2, 1);	2516 TestIterateBorders(

1085 // Oversized.	2517 data, gfx::Rect(origin.x() + 50, origin.y() + 60, 15, 65), 1, 1, 2, 3);

1086 TestIterateBorders(data, gfx::Rect(-100, -100, 1000, 1000), 0, 0, 2, 3);	2518 TestIterateBorders(

1087 TestIterateBorders(data, gfx::Rect(-100, 10, 1000, 10), 0, 0, 2, 0);	2519 data, gfx::Rect(origin.x() + 60, origin.y() + 30, 2, 10), 2, 0, 2, 1);

1088 TestIterateBorders(data, gfx::Rect(10, -100, 10, 1000), 0, 0, 1, 3);	2520 // Oversized.

1089 // Nonintersecting.	2521 TestIterateBorders(data,

1090 TestIterateBorders(data, gfx::Rect(65, 110, 100, 100), 0, 0, -1, -1);	2522 gfx::Rect(origin.x() - 100, origin.y() - 100, 1000, 1000),

1091 }	2523 0,

1092	2524 0,

1093 TEST(TilingDataTest, NoBordersIteratorManyBorderTexels) {	2525 2,

1094 TilingData data(gfx::Size(50, 60), gfx::Size(65, 110), 20);	2526 3);

	2527 TestIterateBorders(

	2528 data, gfx::Rect(origin.x() - 100, origin.y() + 10, 1000, 10), 0, 0, 2, 0);

	2529 TestIterateBorders(

	2530 data, gfx::Rect(origin.x() + 10, origin.y() - 100, 10, 1000), 0, 0, 1, 3);

	2531 // Nonintersecting.

	2532 TestIterateBorders(data,

	2533 gfx::Rect(origin.x() + 65, origin.y() + 110, 100, 100),

	2534 0,

	2535 0,

	2536 -1,

	2537 -1);

	2538 }

	2539

	2540 TEST_P(TilingDataTest, NoBordersIteratorManyBorderTexels) {

	2541 gfx::Point origin = GetParam();

	2542

	2543 TilingData data(gfx::Size(50, 60), gfx::Rect(origin, gfx::Size(65, 110)), 20);

	2544 // The following Coordinates are relative to the origin.

1095 // X index by src coord: [0-30), [30-40), [40, 65)	2545 // X index by src coord: [0-30), [30-40), [40, 65)

1096 // Y index by src coord: [0-40), [40-60), [60, 80), [80-110)	2546 // Y index by src coord: [0-40), [40-60), [60, 80), [80-110)

1097 TestIterateNoBorders(data, gfx::Rect(0, 0, 65, 110), 0, 0, 2, 3);	2547 TestIterateNoBorders(

1098 TestIterateNoBorders(data, gfx::Rect(30, 40, 15, 65), 1, 1, 2, 3);	2548 data, gfx::Rect(origin.x(), origin.y(), 65, 110), 0, 0, 2, 3);

1099 TestIterateNoBorders(data, gfx::Rect(60, 20, 2, 21), 2, 0, 2, 1);	2549 TestIterateNoBorders(

1100 // Oversized.	2550 data, gfx::Rect(origin.x() + 30, origin.y() + 40, 15, 65), 1, 1, 2, 3);

1101 TestIterateNoBorders(data, gfx::Rect(-100, -100, 1000, 1000), 0, 0, 2, 3);	2551 TestIterateNoBorders(

1102 TestIterateNoBorders(data, gfx::Rect(-100, 10, 1000, 10), 0, 0, 2, 0);	2552 data, gfx::Rect(origin.x() + 60, origin.y() + 20, 2, 21), 2, 0, 2, 1);

1103 TestIterateNoBorders(data, gfx::Rect(10, -100, 10, 1000), 0, 0, 0, 3);	2553 // Oversized.

1104 // Nonintersecting.	2554 TestIterateNoBorders(

1105 TestIterateNoBorders(data, gfx::Rect(65, 110, 100, 100), 0, 0, -1, -1);	2555 data,

1106 }	2556 gfx::Rect(origin.x() - 100, origin.y() - 100, 1000, 1000),

1107	2557 0,

1108 TEST(TilingDataTest, IteratorOneTile) {	2558 0,

1109 TilingData no_border(gfx::Size(1000, 1000), gfx::Size(30, 40), false);	2559 2,

1110 TestIterateAll(no_border, gfx::Rect(0, 0, 30, 40), 0, 0, 0, 0);	2560 3);

1111 TestIterateAll(no_border, gfx::Rect(10, 10, 20, 20), 0, 0, 0, 0);	2561 TestIterateNoBorders(

1112 TestIterateAll(no_border, gfx::Rect(30, 40, 100, 100), 0, 0, -1, -1);	2562 data, gfx::Rect(origin.x() - 100, origin.y() + 10, 1000, 10), 0, 0, 2, 0);

1113	2563 TestIterateNoBorders(

1114 TilingData one_border(gfx::Size(1000, 1000), gfx::Size(30, 40), true);	2564 data, gfx::Rect(origin.x() + 10, origin.y() - 100, 10, 1000), 0, 0, 0, 3);

1115 TestIterateAll(one_border, gfx::Rect(0, 0, 30, 40), 0, 0, 0, 0);	2565 // Nonintersecting.

1116 TestIterateAll(one_border, gfx::Rect(10, 10, 20, 20), 0, 0, 0, 0);	2566 TestIterateNoBorders(data,

1117 TestIterateAll(one_border, gfx::Rect(30, 40, 100, 100), 0, 0, -1, -1);	2567 gfx::Rect(origin.x() + 65, origin.y() + 110, 100, 100),

1118	2568 0,

1119 TilingData big_border(gfx::Size(1000, 1000), gfx::Size(30, 40), 50);	2569 0,

1120 TestIterateAll(big_border, gfx::Rect(0, 0, 30, 40), 0, 0, 0, 0);	2570 -1,

1121 TestIterateAll(big_border, gfx::Rect(10, 10, 20, 20), 0, 0, 0, 0);	2571 -1);

1122 TestIterateAll(big_border, gfx::Rect(30, 40, 100, 100), 0, 0, -1, -1);	2572 }

	2573

	2574 TEST_P(TilingDataTest, IteratorOneTile) {

	2575 gfx::Point origin = GetParam();

	2576

	2577 TilingData no_border(

	2578 gfx::Size(1000, 1000), gfx::Rect(origin, gfx::Size(30, 40)), false);

	2579 TestIterateAll(

	2580 no_border, gfx::Rect(origin.x(), origin.y(), 30, 40), 0, 0, 0, 0);

	2581 TestIterateAll(no_border,

	2582 gfx::Rect(origin.x() + 10, origin.y() + 10, 20, 20),

	2583 0,

	2584 0,

	2585 0,

	2586 0);

	2587 TestIterateAll(no_border,

	2588 gfx::Rect(origin.x() + 30, origin.y() + 40, 100, 100),

	2589 0,

	2590 0,

	2591 -1,

	2592 -1);

	2593

	2594 TilingData one_border(

	2595 gfx::Size(1000, 1000), gfx::Rect(origin, gfx::Size(30, 40)), true);

	2596 TestIterateAll(

	2597 one_border, gfx::Rect(origin.x(), origin.y(), 30, 40), 0, 0, 0, 0);

	2598 TestIterateAll(one_border,

	2599 gfx::Rect(origin.x() + 10, origin.y() + 10, 20, 20),

	2600 0,

	2601 0,

	2602 0,

	2603 0);

	2604 TestIterateAll(one_border,

	2605 gfx::Rect(origin.x() + 30, origin.y() + 40, 100, 100),

	2606 0,

	2607 0,

	2608 -1,

	2609 -1);

	2610

	2611 TilingData big_border(

	2612 gfx::Size(1000, 1000), gfx::Rect(origin, gfx::Size(30, 40)), 50);

	2613 TestIterateAll(

	2614 big_border, gfx::Rect(origin.x(), origin.y(), 30, 40), 0, 0, 0, 0);

	2615 TestIterateAll(big_border,

	2616 gfx::Rect(origin.x() + 10, origin.y() + 10, 20, 20),

	2617 0,

	2618 0,

	2619 0,

	2620 0);

	2621 TestIterateAll(big_border,

	2622 gfx::Rect(origin.x() + 30, origin.y() + 40, 100, 100),

	2623 0,

	2624 0,

	2625 -1,

	2626 -1);

1123 }	2627 }

1124	2628

1125 TEST(TilingDataTest, IteratorNoTiles) {	2629 TEST(TilingDataTest, IteratorNoTiles) {

1126 TilingData data(gfx::Size(100, 100), gfx::Size(), false);	2630 TilingData data(gfx::Size(100, 100), gfx::Rect(), false);

1127 TestIterateAll(data, gfx::Rect(0, 0, 100, 100), 0, 0, -1, -1);	2631 TestIterateAll(data, gfx::Rect(0, 0, 100, 100), 0, 0, -1, -1);

1128 }	2632 }

1129	2633

1130 void TestDiff(	2634 void TestDiff(

1131 const TilingData& data,	2635 const TilingData& data,

1132 gfx::Rect consider,	2636 gfx::Rect consider,

1133 gfx::Rect ignore,	2637 gfx::Rect ignore,

1134 size_t num_tiles) {	2638 size_t num_tiles) {

1135	2639

1136 std::vector<std::pair<int, int> > expected;	2640 std::vector<std::pair<int, int> > expected;

(...skipping 17 matching lines...) Expand all Loading...
1154 expected.pop_back();	2658 expected.pop_back();

1155 found = true;	2659 found = true;

1156 break;	2660 break;

1157 }	2661 }

1158 }	2662 }

1159 EXPECT_TRUE(found);	2663 EXPECT_TRUE(found);

1160 }	2664 }

1161 EXPECT_EQ(0u, expected.size());	2665 EXPECT_EQ(0u, expected.size());

1162 }	2666 }

1163	2667

1164 TEST(TilingDataTest, DifferenceIteratorIgnoreGeometry) {	2668 TEST_P(TilingDataTest, DifferenceIteratorIgnoreGeometry) {

1165 // This test is checking that the iterator can handle different geometries of	2669 // This test is checking that the iterator can handle different geometries of

1166 // ignore rects relative to the consider rect. The consider rect indices	2670 // ignore rects relative to the consider rect. The consider rect indices

1167 // themselves are mostly tested by the non-difference iterator tests, so the	2671 // themselves are mostly tested by the non-difference iterator tests, so the

1168 // full rect is mostly used here for simplicity.	2672 // full rect is mostly used here for simplicity.

1169	2673

	2674 gfx::Point origin = GetParam();

	2675

	2676 // The following Coordinates are relative to the origin.

1170 // X border index by src coord: [0-10), [10-20), [20, 30), [30, 40)	2677 // X border index by src coord: [0-10), [10-20), [20, 30), [30, 40)

1171 // Y border index by src coord: [0-10), [10-20), [20, 25)	2678 // Y border index by src coord: [0-10), [10-20), [20, 25)

1172 TilingData data(gfx::Size(10, 10), gfx::Size(40, 25), false);	2679 TilingData data(

	2680 gfx::Size(10, 10), gfx::Rect(origin, gfx::Size(40, 25)), false);

1173	2681

1174 // Fully ignored	2682 // Fully ignored

1175 TestDiff(data, gfx::Rect(0, 0, 40, 25), gfx::Rect(0, 0, 40, 25), 0);	2683 TestDiff(data,

1176 TestDiff(data, gfx::Rect(0, 0, 40, 25), gfx::Rect(-100, -100, 200, 200), 0);	2684 gfx::Rect(origin.x(), origin.y(), 40, 25),

1177 TestDiff(data, gfx::Rect(0, 0, 40, 25), gfx::Rect(9, 9, 30, 15), 0);	2685 gfx::Rect(origin.x(), origin.y(), 40, 25),

1178 TestDiff(data, gfx::Rect(15, 15, 8, 8), gfx::Rect(15, 15, 8, 8), 0);	2686 0);

	2687 TestDiff(data,

	2688 gfx::Rect(origin.x(), origin.y(), 40, 25),

	2689 gfx::Rect(origin.x() - 100, origin.y() - 100, 200, 200),

	2690 0);

	2691 TestDiff(data,

	2692 gfx::Rect(origin.x(), origin.y(), 40, 25),

	2693 gfx::Rect(origin.x() + 9, origin.y() + 9, 30, 15),

	2694 0);

	2695 TestDiff(data,

	2696 gfx::Rect(origin.x() + 15, origin.y() + 15, 8, 8),

	2697 gfx::Rect(origin.x() + 15, origin.y() + 15, 8, 8),

	2698 0);

1179	2699

1180 // Fully un-ignored	2700 // Fully un-ignored

1181 TestDiff(data, gfx::Rect(0, 0, 40, 25), gfx::Rect(-30, -20, 8, 8), 12);	2701 TestDiff(data,

1182 TestDiff(data, gfx::Rect(0, 0, 40, 25), gfx::Rect(), 12);	2702 gfx::Rect(origin.x(), origin.y(), 40, 25),

	2703 gfx::Rect(origin.x() - 30, origin.y() - 20, 8, 8),

	2704 12);

	2705 TestDiff(data, gfx::Rect(origin.x(), origin.y(), 40, 25), gfx::Rect(), 12);

1183	2706

1184 // Top left, remove 2x2 tiles	2707 // Top left, remove 2x2 tiles

1185 TestDiff(data, gfx::Rect(0, 0, 40, 25), gfx::Rect(0, 0, 20, 19), 8);	2708 TestDiff(data,

	2709 gfx::Rect(origin.x(), origin.y(), 40, 25),

	2710 gfx::Rect(origin.x(), origin.y(), 20, 19),

	2711 8);

1186 // Bottom right, remove 2x2 tiles	2712 // Bottom right, remove 2x2 tiles

1187 TestDiff(data, gfx::Rect(0, 0, 40, 25), gfx::Rect(20, 15, 20, 6), 8);	2713 TestDiff(data,

	2714 gfx::Rect(origin.x(), origin.y(), 40, 25),

	2715 gfx::Rect(origin.x() + 20, origin.y() + 15, 20, 6),

	2716 8);

1188 // Bottom left, remove 2x2 tiles	2717 // Bottom left, remove 2x2 tiles

1189 TestDiff(data, gfx::Rect(0, 0, 40, 25), gfx::Rect(0, 15, 20, 6), 8);	2718 TestDiff(data,

	2719 gfx::Rect(origin.x(), origin.y(), 40, 25),

	2720 gfx::Rect(origin.x(), origin.y() + 15, 20, 6),

	2721 8);

1190 // Top right, remove 2x2 tiles	2722 // Top right, remove 2x2 tiles

1191 TestDiff(data, gfx::Rect(0, 0, 40, 25), gfx::Rect(20, 0, 20, 19), 8);	2723 TestDiff(data,

	2724 gfx::Rect(origin.x(), origin.y(), 40, 25),

	2725 gfx::Rect(origin.x() + 20, origin.y(), 20, 19),

	2726 8);

1192 // Center, remove only one tile	2727 // Center, remove only one tile

1193 TestDiff(data, gfx::Rect(0, 0, 40, 25), gfx::Rect(10, 10, 5, 5), 11);	2728 TestDiff(data,

	2729 gfx::Rect(origin.x(), origin.y(), 40, 25),

	2730 gfx::Rect(origin.x() + 10, origin.y() + 10, 5, 5),

	2731 11);

1194	2732

1195 // Left column, flush left, removing two columns	2733 // Left column, flush left, removing two columns

1196 TestDiff(data, gfx::Rect(0, 0, 40, 25), gfx::Rect(0, 0, 11, 25), 6);	2734 TestDiff(data,

	2735 gfx::Rect(origin.x(), origin.y(), 40, 25),

	2736 gfx::Rect(origin.x(), origin.y(), 11, 25),

	2737 6);

1197 // Middle column, removing two columns	2738 // Middle column, removing two columns

1198 TestDiff(data, gfx::Rect(0, 0, 40, 25), gfx::Rect(11, 0, 11, 25), 6);	2739 TestDiff(data,

	2740 gfx::Rect(origin.x(), origin.y(), 40, 25),

	2741 gfx::Rect(origin.x() + 11, origin.y(), 11, 25),

	2742 6);

1199 // Right column, flush right, removing one column	2743 // Right column, flush right, removing one column

1200 TestDiff(data, gfx::Rect(0, 0, 40, 25), gfx::Rect(30, 0, 2, 25), 9);	2744 TestDiff(data,

	2745 gfx::Rect(origin.x(), origin.y(), 40, 25),

	2746 gfx::Rect(origin.x() + 30, origin.y(), 2, 25),

	2747 9);

1201	2748

1202 // Top row, flush top, removing one row	2749 // Top row, flush top, removing one row

1203 TestDiff(data, gfx::Rect(0, 0, 40, 25), gfx::Rect(0, 5, 40, 5), 8);	2750 TestDiff(data,

	2751 gfx::Rect(origin.x(), origin.y(), 40, 25),

	2752 gfx::Rect(origin.x(), origin.y() + 5, 40, 5),

	2753 8);

1204 // Middle row, removing one row	2754 // Middle row, removing one row

1205 TestDiff(data, gfx::Rect(0, 0, 40, 25), gfx::Rect(0, 13, 40, 5), 8);	2755 TestDiff(data,

	2756 gfx::Rect(origin.x(), origin.y(), 40, 25),

	2757 gfx::Rect(origin.x(), origin.y() + 13, 40, 5),

	2758 8);

1206 // Bottom row, flush bottom, removing two rows	2759 // Bottom row, flush bottom, removing two rows

1207 TestDiff(data, gfx::Rect(0, 0, 40, 25), gfx::Rect(0, 13, 40, 12), 4);	2760 TestDiff(data,

	2761 gfx::Rect(origin.x(), origin.y(), 40, 25),

	2762 gfx::Rect(origin.x(), origin.y() + 13, 40, 12),

	2763 4);

1208	2764

1209 // Non-intersecting, but still touching two of the same tiles.	2765 // Non-intersecting, but still touching two of the same tiles.

1210 TestDiff(data, gfx::Rect(8, 0, 32, 25), gfx::Rect(0, 12, 5, 12), 10);	2766 TestDiff(data,

	2767 gfx::Rect(origin.x() + 8, origin.y(), 32, 25),

	2768 gfx::Rect(origin.x(), origin.y() + 12, 5, 12),

	2769 10);

1211	2770

1212 // Intersecting, but neither contains the other. 2x3 with one overlap.	2771 // Intersecting, but neither contains the other. 2x3 with one overlap.

1213 TestDiff(data, gfx::Rect(5, 2, 20, 10), gfx::Rect(25, 15, 5, 10), 5);	2772 TestDiff(data,

	2773 gfx::Rect(origin.x() + 5, origin.y() + 2, 20, 10),

	2774 gfx::Rect(origin.x() + 25, origin.y() + 15, 5, 10),

	2775 5);

1214 }	2776 }

1215	2777

1216 TEST(TilingDataTest, DifferenceIteratorManyBorderTexels) {	2778 TEST_P(TilingDataTest, DifferenceIteratorManyBorderTexels) {

	2779 gfx::Point origin = GetParam();

	2780

	2781 // The following Coordinates are relative to the origin.

1217 // X border index by src coord: [0-50), [10-60), [20-65)	2782 // X border index by src coord: [0-50), [10-60), [20-65)

1218 // Y border index by src coord: [0-60), [20-80), [40-100), [60-110)	2783 // Y border index by src coord: [0-60), [20-80), [40-100), [60-110)

1219 TilingData data(gfx::Size(50, 60), gfx::Size(65, 110), 20);	2784 TilingData data(gfx::Size(50, 60), gfx::Rect(origin, gfx::Size(65, 110)), 20);

1220	2785

1221 // Ignore one column, three rows	2786 // Ignore one column, three rows

1222 TestDiff(data, gfx::Rect(0, 30, 55, 80), gfx::Rect(5, 30, 5, 15), 9);	2787 TestDiff(data,

	2788 gfx::Rect(origin.x(), origin.y() + 30, 55, 80),

	2789 gfx::Rect(origin.x() + 5, origin.y() + 30, 5, 15),

	2790 9);

1223	2791

1224 // Knock out three columns, leaving only one.	2792 // Knock out three columns, leaving only one.

1225 TestDiff(data, gfx::Rect(10, 30, 55, 80), gfx::Rect(30, 59, 20, 1), 3);	2793 TestDiff(data,

	2794 gfx::Rect(origin.x() + 10, origin.y() + 30, 55, 80),

	2795 gfx::Rect(origin.x() + 30, origin.y() + 59, 20, 1),

	2796 3);

1226	2797

1227 // Overlap all tiles with ignore rect.	2798 // Overlap all tiles with ignore rect.

1228 TestDiff(data, gfx::Rect(0, 0, 65, 110), gfx::Rect(30, 59, 1, 2), 0);	2799 TestDiff(data,

	2800 gfx::Rect(origin.x(), origin.y(), 65, 110),

	2801 gfx::Rect(origin.x() + 30, origin.y() + 59, 1, 2),

	2802 0);

1229 }	2803 }

1230	2804

1231 TEST(TilingDataTest, DifferenceIteratorOneTile) {	2805 TEST_P(TilingDataTest, DifferenceIteratorOneTile) {

1232 TilingData no_border(gfx::Size(1000, 1000), gfx::Size(30, 40), false);	2806 gfx::Point origin = GetParam();

1233 TestDiff(no_border, gfx::Rect(0, 0, 30, 40), gfx::Rect(), 1);

1234 TestDiff(no_border, gfx::Rect(5, 5, 100, 100), gfx::Rect(5, 5, 1, 1), 0);

1235	2807

1236 TilingData one_border(gfx::Size(1000, 1000), gfx::Size(30, 40), true);	2808 TilingData no_border(

1237 TestDiff(one_border, gfx::Rect(0, 0, 30, 40), gfx::Rect(), 1);	2809 gfx::Size(1000, 1000), gfx::Rect(origin, gfx::Size(30, 40)), false);

1238 TestDiff(one_border, gfx::Rect(5, 5, 100, 100), gfx::Rect(5, 5, 1, 1), 0);	2810 TestDiff(

	2811 no_border, gfx::Rect(origin.x(), origin.y(), 30, 40), gfx::Rect(), 1);

	2812 TestDiff(no_border,

	2813 gfx::Rect(origin.x() + 5, origin.y() + 5, 100, 100),

	2814 gfx::Rect(origin.x() + 5, origin.y() + 5, 1, 1),

	2815 0);

1239	2816

1240 TilingData big_border(gfx::Size(1000, 1000), gfx::Size(30, 40), 50);	2817 TilingData one_border(

1241 TestDiff(big_border, gfx::Rect(0, 0, 30, 40), gfx::Rect(), 1);	2818 gfx::Size(1000, 1000), gfx::Rect(origin, gfx::Size(30, 40)), true);

1242 TestDiff(big_border, gfx::Rect(5, 5, 100, 100), gfx::Rect(5, 5, 1, 1), 0);	2819 TestDiff(

	2820 one_border, gfx::Rect(origin.x(), origin.y(), 30, 40), gfx::Rect(), 1);

	2821 TestDiff(one_border,

	2822 gfx::Rect(origin.x() + 5, origin.y() + 5, 100, 100),

	2823 gfx::Rect(origin.x() + 5, origin.y() + 5, 1, 1),

	2824 0);

	2825

	2826 TilingData big_border(

	2827 gfx::Size(1000, 1000), gfx::Rect(origin, gfx::Size(30, 40)), 50);

	2828 TestDiff(

	2829 big_border, gfx::Rect(origin.x(), origin.y(), 30, 40), gfx::Rect(), 1);

	2830 TestDiff(big_border,

	2831 gfx::Rect(origin.x() + 5, origin.y() + 5, 100, 100),

	2832 gfx::Rect(origin.x() + 5, origin.y() + 5, 1, 1),

	2833 0);

1243 }	2834 }

1244	2835

1245 TEST(TilingDataTest, DifferenceIteratorNoTiles) {	2836 TEST(TilingDataTest, DifferenceIteratorNoTiles) {

1246 TilingData data(gfx::Size(100, 100), gfx::Size(), false);	2837 TilingData data(gfx::Size(100, 100), gfx::Rect(), false);

1247 TestDiff(data, gfx::Rect(0, 0, 100, 100), gfx::Rect(0, 0, 5, 5), 0);	2838 TestDiff(data, gfx::Rect(0, 0, 100, 100), gfx::Rect(0, 0, 5, 5), 0);

1248 }	2839 }

1249	2840

1250 void TestSpiralIterate(int source_line_number,	2841 void TestSpiralIterate(int source_line_number,

1251 const TilingData& tiling_data,	2842 const TilingData& tiling_data,

1252 const gfx::Rect& consider,	2843 const gfx::Rect& consider,

1253 const gfx::Rect& ignore,	2844 const gfx::Rect& ignore,

1254 const gfx::Rect& center,	2845 const gfx::Rect& center,

1255 const std::vector<std::pair<int, int> >& expected) {	2846 const std::vector<std::pair<int, int> >& expected) {

1256 std::vector<std::pair<int, int> > actual;	2847 std::vector<std::pair<int, int> > actual;

1257 for (TilingData::SpiralDifferenceIterator it(	2848 for (TilingData::SpiralDifferenceIterator it(

1258 &tiling_data, consider, ignore, center);	2849 &tiling_data, consider, ignore, center);

1259 it;	2850 it;

1260 ++it) {	2851 ++it) {

1261 actual.push_back(it.index());	2852 actual.push_back(it.index());

1262 }	2853 }

1263	2854

1264 EXPECT_EQ(expected.size(), actual.size()) << "error from line "	2855 EXPECT_EQ(expected.size(), actual.size()) << "error from line "

1265 << source_line_number;	2856 << source_line_number;

1266 for (size_t i = 0; i < std::min(expected.size(), actual.size()); ++i) {	2857 for (size_t i = 0; i < std::min(expected.size(), actual.size()); ++i) {

1267 EXPECT_EQ(expected[i].first, actual[i].first)	2858 EXPECT_EQ(expected[i].first, actual[i].first)

1268 << "i: " << i << " error from line: " << source_line_number;	2859 << "i: " << i << " error from line: " << source_line_number;

1269 EXPECT_EQ(expected[i].second, actual[i].second)	2860 EXPECT_EQ(expected[i].second, actual[i].second)

1270 << "i: " << i << " error from line: " << source_line_number;	2861 << "i: " << i << " error from line: " << source_line_number;

1271 }	2862 }

1272 }	2863 }

1273	2864

1274 TEST(TilingDataTest, SpiralDifferenceIteratorNoIgnoreFullConsider) {	2865 TEST_P(TilingDataTest, SpiralDifferenceIteratorNoIgnoreFullConsider) {

1275 TilingData tiling_data(gfx::Size(10, 10), gfx::Size(30, 30), false);	2866 gfx::Point origin = GetParam();

1276 gfx::Rect consider(0, 0, 30, 30);	2867 TilingData tiling_data(

	2868 gfx::Size(10, 10), gfx::Rect(origin, gfx::Size(30, 30)), false);

	2869 gfx::Rect consider(origin.x(), origin.y(), 30, 30);

1277 gfx::Rect ignore;	2870 gfx::Rect ignore;

1278 std::vector<std::pair<int, int> > expected;	2871 std::vector<std::pair<int, int> > expected;

1279	2872

1280 // Center is in the center of the tiling.	2873 // Center is in the center of the tiling.

1281 gfx::Rect center(15, 15, 1, 1);	2874 gfx::Rect center(origin.x() + 15, origin.y() + 15, 1, 1);

1282	2875

1283 // Layout of the tiling data, and expected return order:	2876 // Layout of the tiling data, and expected return order:

1284 // x 0 1 2	2877 // x 0 1 2

1285 // y.------	2878 // y.------

1286 // 0\| 4 3 2	2879 // 0\| 4 3 2

1287 // 1\| 5 * 1	2880 // 1\| 5 * 1

1288 // 2\| 6 7 8	2881 // 2\| 6 7 8

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

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

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

1292 expected.push_back(std::make_pair(0, 0));	2885 expected.push_back(std::make_pair(0, 0));

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

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

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

1296 expected.push_back(std::make_pair(2, 2));	2889 expected.push_back(std::make_pair(2, 2));

1297	2890

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

1299	2892

1300 // Center is off to the right side of the tiling (and far away).	2893 // Center is off to the right side of the tiling (and far away).

1301 center = gfx::Rect(100, 15, 1, 1);	2894 center = gfx::Rect(origin.x() + 100, origin.y() + 15, 1, 1);

1302	2895

1303 // Layout of the tiling data, and expected return order:	2896 // Layout of the tiling data, and expected return order:

1304 // x 0 1 2	2897 // x 0 1 2

1305 // y.------	2898 // y.------

1306 // 0\| 7 4 1	2899 // 0\| 7 4 1

1307 // 1\| 8 5 2 *	2900 // 1\| 8 5 2 *

1308 // 2\| 9 6 3	2901 // 2\| 9 6 3

1309 expected.clear();	2902 expected.clear();

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

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

1312 expected.push_back(std::make_pair(2, 2));	2905 expected.push_back(std::make_pair(2, 2));

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

1314 expected.push_back(std::make_pair(1, 1));	2907 expected.push_back(std::make_pair(1, 1));

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

1316 expected.push_back(std::make_pair(0, 0));	2909 expected.push_back(std::make_pair(0, 0));

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

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

1319	2912

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

1321	2914

1322 // Center is the bottom right corner of the tiling.	2915 // Center is the bottom right corner of the tiling.

1323 center = gfx::Rect(25, 25, 1, 1);	2916 center = gfx::Rect(origin.x() + 25, origin.y() + 25, 1, 1);

1324	2917

1325 // Layout of the tiling data, and expected return order:	2918 // Layout of the tiling data, and expected return order:

1326 // x 0 1 2	2919 // x 0 1 2

1327 // y.------	2920 // y.------

1328 // 0\| 6 5 4	2921 // 0\| 6 5 4

1329 // 1\| 7 2 1	2922 // 1\| 7 2 1

1330 // 2\| 8 3 *	2923 // 2\| 8 3 *

1331 expected.clear();	2924 expected.clear();

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

1333 expected.push_back(std::make_pair(1, 1));	2926 expected.push_back(std::make_pair(1, 1));

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

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

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

1337 expected.push_back(std::make_pair(0, 0));	2930 expected.push_back(std::make_pair(0, 0));

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

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

1340	2933

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

1342	2935

1343 // Center is off the top left side of the tiling.	2936 // Center is off the top left side of the tiling.

1344 center = gfx::Rect(-60, -50, 1, 1);	2937 center = gfx::Rect(origin.x() - 60, origin.y() - 50, 1, 1);

1345	2938

1346 // Layout of the tiling data, and expected return order:	2939 // Layout of the tiling data, and expected return order:

1347 // * x 0 1 2	2940 // * x 0 1 2

1348 // y.------	2941 // y.------

1349 // 0\| 1 2 6	2942 // 0\| 1 2 6

1350 // 1\| 3 4 5	2943 // 1\| 3 4 5

1351 // 2\| 7 8 9	2944 // 2\| 7 8 9

1352 expected.clear();	2945 expected.clear();

1353 expected.push_back(std::make_pair(0, 0));	2946 expected.push_back(std::make_pair(0, 0));

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

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

1356 expected.push_back(std::make_pair(1, 1));	2949 expected.push_back(std::make_pair(1, 1));

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

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

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

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

1361 expected.push_back(std::make_pair(2, 2));	2954 expected.push_back(std::make_pair(2, 2));

1362	2955

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

1364	2957

1365 // Two tile center.	2958 // Two tile center.

1366 center = gfx::Rect(15, 15, 1, 10);	2959 center = gfx::Rect(origin.x() + 15, origin.y() + 15, 1, 10);

1367	2960

1368 // Layout of the tiling data, and expected return order:	2961 // Layout of the tiling data, and expected return order:

1369 // x 0 1 2	2962 // x 0 1 2

1370 // y.------	2963 // y.------

1371 // 0\| 5 4 3	2964 // 0\| 5 4 3

1372 // 1\| 6 * 2	2965 // 1\| 6 * 2

1373 // 2\| 7 * 1	2966 // 2\| 7 * 1

1374 expected.clear();	2967 expected.clear();

1375 expected.push_back(std::make_pair(2, 2));	2968 expected.push_back(std::make_pair(2, 2));

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

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

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

1379 expected.push_back(std::make_pair(0, 0));	2972 expected.push_back(std::make_pair(0, 0));

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

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

1382	2975

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

1384 }	2977 }

1385	2978

1386 TEST(TilingDataTest, SpiralDifferenceIteratorSmallConsider) {	2979 TEST_P(TilingDataTest, SpiralDifferenceIteratorSmallConsider) {

1387 TilingData tiling_data(gfx::Size(10, 10), gfx::Size(50, 50), false);	2980 gfx::Point origin = GetParam();

	2981 TilingData tiling_data(

	2982 gfx::Size(10, 10), gfx::Rect(origin, gfx::Size(50, 50)), false);

1388 gfx::Rect ignore;	2983 gfx::Rect ignore;

1389 std::vector<std::pair<int, int> > expected;	2984 std::vector<std::pair<int, int> > expected;

1390 gfx::Rect center(15, 15, 1, 1);	2985 gfx::Rect center(origin.x() + 15, origin.y() + 15, 1, 1);

1391	2986

1392 // Consider is one cell.	2987 // Consider is one cell.

1393 gfx::Rect consider(0, 0, 1, 1);	2988 gfx::Rect consider(origin.x(), origin.y(), 1, 1);

1394	2989

1395 // Layout of the tiling data, and expected return order:	2990 // Layout of the tiling data, and expected return order:

1396 // x 0 1 2 3 4	2991 // x 0 1 2 3 4

1397 // y.----------	2992 // y.----------

1398 // 0\| 1	2993 // 0\| 1

1399 // 1\| *	2994 // 1\| *

1400 // 2\|	2995 // 2\|

1401 // 3\|	2996 // 3\|

1402 // 4\|	2997 // 4\|

1403 expected.push_back(std::make_pair(0, 0));	2998 expected.push_back(std::make_pair(0, 0));

1404	2999

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

1406	3001

1407 // Consider is bottom right corner.	3002 // Consider is bottom right corner.

1408 consider = gfx::Rect(25, 25, 10, 10);	3003 consider = gfx::Rect(origin.x() + 25, origin.y() + 25, 10, 10);

1409	3004

1410 // Layout of the tiling data, and expected return order:	3005 // Layout of the tiling data, and expected return order:

1411 // x 0 1 2 3 4	3006 // x 0 1 2 3 4

1412 // y.----------	3007 // y.----------

1413 // 0\|	3008 // 0\|

1414 // 1\| *	3009 // 1\| *

1415 // 2\| 1 2	3010 // 2\| 1 2

1416 // 3\| 3 4	3011 // 3\| 3 4

1417 // 4\|	3012 // 4\|

1418 expected.clear();	3013 expected.clear();

1419 expected.push_back(std::make_pair(2, 2));	3014 expected.push_back(std::make_pair(2, 2));

1420 expected.push_back(std::make_pair(3, 2));	3015 expected.push_back(std::make_pair(3, 2));

1421 expected.push_back(std::make_pair(2, 3));	3016 expected.push_back(std::make_pair(2, 3));

1422 expected.push_back(std::make_pair(3, 3));	3017 expected.push_back(std::make_pair(3, 3));

1423	3018

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

1425	3020

1426 // Consider is one column.	3021 // Consider is one column.

1427 consider = gfx::Rect(11, 0, 1, 100);	3022 consider = gfx::Rect(origin.x() + 11, origin.y(), 1, 100);

1428	3023

1429 // Layout of the tiling data, and expected return order:	3024 // Layout of the tiling data, and expected return order:

1430 // x 0 1 2 3 4	3025 // x 0 1 2 3 4

1431 // y.----------	3026 // y.----------

1432 // 0\| 2	3027 // 0\| 2

1433 // 1\| *	3028 // 1\| *

1434 // 2\| 3	3029 // 2\| 3

1435 // 3\| 4	3030 // 3\| 4

1436 // 4\| 5	3031 // 4\| 5

1437 expected.clear();	3032 expected.clear();

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

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

1440 expected.push_back(std::make_pair(1, 3));	3035 expected.push_back(std::make_pair(1, 3));

1441 expected.push_back(std::make_pair(1, 4));	3036 expected.push_back(std::make_pair(1, 4));

1442	3037

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

1444 }	3039 }

1445	3040

1446 TEST(TilingDataTest, SpiralDifferenceIteratorHasIgnore) {	3041 TEST_P(TilingDataTest, SpiralDifferenceIteratorHasIgnore) {

1447 TilingData tiling_data(gfx::Size(10, 10), gfx::Size(50, 50), false);	3042 gfx::Point origin = GetParam();

1448 gfx::Rect consider(0, 0, 50, 50);	3043 TilingData tiling_data(

	3044 gfx::Size(10, 10), gfx::Rect(origin, gfx::Size(50, 50)), false);

	3045 gfx::Rect consider(origin.x(), origin.y(), 50, 50);

1449 std::vector<std::pair<int, int> > expected;	3046 std::vector<std::pair<int, int> > expected;

1450 gfx::Rect center(15, 15, 1, 1);	3047 gfx::Rect center(origin.x() + 15, origin.y() + 15, 1, 1);

1451	3048

1452 // Full ignore.	3049 // Full ignore.

1453 gfx::Rect ignore(0, 0, 50, 50);	3050 gfx::Rect ignore(origin.x(), origin.y(), 50, 50);

1454	3051

1455 // Layout of the tiling data, and expected return order:	3052 // Layout of the tiling data, and expected return order:

1456 // x 0 1 2 3 4	3053 // x 0 1 2 3 4

1457 // y.----------	3054 // y.----------

1458 // 0\| . . . . .	3055 // 0\| . . . . .

1459 // 1\| . * . . .	3056 // 1\| . * . . .

1460 // 2\| . . . . .	3057 // 2\| . . . . .

1461 // 3\| . . . . .	3058 // 3\| . . . . .

1462 // 4\| . . . . .	3059 // 4\| . . . . .

1463 expected.clear();	3060 expected.clear();

1464	3061

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

1466	3063

1467 // 3 column ignore.	3064 // 3 column ignore.

1468 ignore = gfx::Rect(15, 0, 20, 100);	3065 ignore = gfx::Rect(origin.x() + 15, origin.y(), 20, 100);

1469	3066

1470 // Layout of the tiling data, and expected return order:	3067 // Layout of the tiling data, and expected return order:

1471 // x 0 1 2 3 4	3068 // x 0 1 2 3 4

1472 // y.----------	3069 // y.----------

1473 // 0\| 1 . . . 8	3070 // 0\| 1 . . . 8

1474 // 1\| 2 * . . 7	3071 // 1\| 2 * . . 7

1475 // 2\| 3 . . . 6	3072 // 2\| 3 . . . 6

1476 // 3\| 4 . . . 5	3073 // 3\| 4 . . . 5

1477 // 4\| 9 . . . 10	3074 // 4\| 9 . . . 10

1478 expected.clear();	3075 expected.clear();

1479	3076

1480 expected.push_back(std::make_pair(0, 0));	3077 expected.push_back(std::make_pair(0, 0));

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

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

1483 expected.push_back(std::make_pair(0, 3));	3080 expected.push_back(std::make_pair(0, 3));

1484 expected.push_back(std::make_pair(4, 3));	3081 expected.push_back(std::make_pair(4, 3));

1485 expected.push_back(std::make_pair(4, 2));	3082 expected.push_back(std::make_pair(4, 2));

1486 expected.push_back(std::make_pair(4, 1));	3083 expected.push_back(std::make_pair(4, 1));

1487 expected.push_back(std::make_pair(4, 0));	3084 expected.push_back(std::make_pair(4, 0));

1488 expected.push_back(std::make_pair(0, 4));	3085 expected.push_back(std::make_pair(0, 4));

1489 expected.push_back(std::make_pair(4, 4));	3086 expected.push_back(std::make_pair(4, 4));

1490	3087

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

1492	3089

1493 // Ignore covers the top half.	3090 // Ignore covers the top half.

1494 ignore = gfx::Rect(0, 0, 50, 25);	3091 ignore = gfx::Rect(origin.x(), origin.y(), 50, 25);

1495	3092

1496 // Layout of the tiling data, and expected return order:	3093 // Layout of the tiling data, and expected return order:

1497 // x 0 1 2 3 4	3094 // x 0 1 2 3 4

1498 // y.----------	3095 // y.----------

1499 // 0\| . . . . .	3096 // 0\| . . . . .

1500 // 1\| . * . . .	3097 // 1\| . * . . .

1501 // 2\| . . . . .	3098 // 2\| . . . . .

1502 // 3\| 1 2 3 4 5	3099 // 3\| 1 2 3 4 5

1503 // 4\| 6 7 8 9 10	3100 // 4\| 6 7 8 9 10

1504 expected.clear();	3101 expected.clear();

1505	3102

1506 expected.push_back(std::make_pair(0, 3));	3103 expected.push_back(std::make_pair(0, 3));

1507 expected.push_back(std::make_pair(1, 3));	3104 expected.push_back(std::make_pair(1, 3));

1508 expected.push_back(std::make_pair(2, 3));	3105 expected.push_back(std::make_pair(2, 3));

1509 expected.push_back(std::make_pair(3, 3));	3106 expected.push_back(std::make_pair(3, 3));

1510 expected.push_back(std::make_pair(4, 3));	3107 expected.push_back(std::make_pair(4, 3));

1511 expected.push_back(std::make_pair(0, 4));	3108 expected.push_back(std::make_pair(0, 4));

1512 expected.push_back(std::make_pair(1, 4));	3109 expected.push_back(std::make_pair(1, 4));

1513 expected.push_back(std::make_pair(2, 4));	3110 expected.push_back(std::make_pair(2, 4));

1514 expected.push_back(std::make_pair(3, 4));	3111 expected.push_back(std::make_pair(3, 4));

1515 expected.push_back(std::make_pair(4, 4));	3112 expected.push_back(std::make_pair(4, 4));

1516	3113

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

1518 }	3115 }

1519	3116

1520 TEST(TilingDataTest, SpiralDifferenceIteratorRectangleCenter) {	3117 TEST_P(TilingDataTest, SpiralDifferenceIteratorRectangleCenter) {

1521 TilingData tiling_data(gfx::Size(10, 10), gfx::Size(50, 50), false);	3118 gfx::Point origin = GetParam();

1522 gfx::Rect consider(0, 0, 50, 50);	3119 TilingData tiling_data(

	3120 gfx::Size(10, 10), gfx::Rect(origin, gfx::Size(50, 50)), false);

	3121 gfx::Rect consider(origin.x(), origin.y(), 50, 50);

1523 std::vector<std::pair<int, int> > expected;	3122 std::vector<std::pair<int, int> > expected;

1524 gfx::Rect ignore;	3123 gfx::Rect ignore;

1525	3124

1526 // Two cell center	3125 // Two cell center

1527 gfx::Rect center(25, 25, 1, 10);	3126 gfx::Rect center(origin.x() + 25, origin.y() + 25, 1, 10);

1528	3127

1529 // Layout of the tiling data, and expected return order:	3128 // Layout of the tiling data, and expected return order:

1530 // x 0 1 2 3 4	3129 // x 0 1 2 3 4

1531 // y.----------	3130 // y.----------

1532 // 0\| J I H G F	3131 // 0\| J I H G F

1533 // 1\| K 5 4 3 E	3132 // 1\| K 5 4 3 E

1534 // 2\| L 6 * 2 D	3133 // 2\| L 6 * 2 D

1535 // 3\| M 7 * 1 C	3134 // 3\| M 7 * 1 C

1536 // 4\| N 8 9 A B	3135 // 4\| N 8 9 A B

1537 expected.clear();	3136 expected.clear();

(...skipping 18 matching lines...) Expand all Loading...
1556 expected.push_back(std::make_pair(1, 0));	3155 expected.push_back(std::make_pair(1, 0));

1557 expected.push_back(std::make_pair(0, 0));	3156 expected.push_back(std::make_pair(0, 0));

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

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

1560 expected.push_back(std::make_pair(0, 3));	3159 expected.push_back(std::make_pair(0, 3));

1561 expected.push_back(std::make_pair(0, 4));	3160 expected.push_back(std::make_pair(0, 4));

1562	3161

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

1564	3163

1565 // Three by two center.	3164 // Three by two center.

1566 center = gfx::Rect(15, 25, 20, 10);	3165 center = gfx::Rect(origin.x() + 15, origin.y() + 25, 20, 10);

1567	3166

1568 // Layout of the tiling data, and expected return order:	3167 // Layout of the tiling data, and expected return order:

1569 // x 0 1 2 3 4	3168 // x 0 1 2 3 4

1570 // y.----------	3169 // y.----------

1571 // 0\| J I H G F	3170 // 0\| J I H G F

1572 // 1\| 7 6 5 4 3	3171 // 1\| 7 6 5 4 3

1573 // 2\| 8 * * * 2	3172 // 2\| 8 * * * 2

1574 // 3\| 9 * * * 1	3173 // 3\| 9 * * * 1

1575 // 4\| A B C D E	3174 // 4\| A B C D E

1576 expected.clear();	3175 expected.clear();

(...skipping 14 matching lines...) Expand all Loading...
1591 expected.push_back(std::make_pair(4, 4));	3190 expected.push_back(std::make_pair(4, 4));

1592 expected.push_back(std::make_pair(4, 0));	3191 expected.push_back(std::make_pair(4, 0));

1593 expected.push_back(std::make_pair(3, 0));	3192 expected.push_back(std::make_pair(3, 0));

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

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

1596 expected.push_back(std::make_pair(0, 0));	3195 expected.push_back(std::make_pair(0, 0));

1597	3196

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

1599	3198

1600 // Column center off the left side.	3199 // Column center off the left side.

1601 center = gfx::Rect(-50, 0, 30, 50);	3200 center = gfx::Rect(origin.x() - 50, origin.y(), 30, 50);

1602	3201

1603 // Layout of the tiling data, and expected return order:	3202 // Layout of the tiling data, and expected return order:

1604 // x 0 1 2 3 4	3203 // x 0 1 2 3 4

1605 // y.----------	3204 // y.----------

1606 // * 0\| 5 A F K P	3205 // * 0\| 5 A F K P

1607 // * 1\| 4 9 E J O	3206 // * 1\| 4 9 E J O

1608 // * 2\| 3 8 D I N	3207 // * 2\| 3 8 D I N

1609 // * 3\| 2 7 C H M	3208 // * 3\| 2 7 C H M

1610 // * 4\| 1 6 B G L	3209 // * 4\| 1 6 B G L

1611 expected.clear();	3210 expected.clear();

(...skipping 20 matching lines...) Expand all Loading...
1632 expected.push_back(std::make_pair(3, 0));	3231 expected.push_back(std::make_pair(3, 0));

1633 expected.push_back(std::make_pair(4, 4));	3232 expected.push_back(std::make_pair(4, 4));

1634 expected.push_back(std::make_pair(4, 3));	3233 expected.push_back(std::make_pair(4, 3));

1635 expected.push_back(std::make_pair(4, 2));	3234 expected.push_back(std::make_pair(4, 2));

1636 expected.push_back(std::make_pair(4, 1));	3235 expected.push_back(std::make_pair(4, 1));

1637 expected.push_back(std::make_pair(4, 0));	3236 expected.push_back(std::make_pair(4, 0));

1638	3237

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

1640 }	3239 }

1641	3240

1642 TEST(TilingDataTest, SpiralDifferenceIteratorEdgeCases) {	3241 TEST_P(TilingDataTest, SpiralDifferenceIteratorEdgeCases) {

1643 TilingData tiling_data(gfx::Size(10, 10), gfx::Size(30, 30), false);	3242 gfx::Point origin = GetParam();

	3243 TilingData tiling_data(

	3244 gfx::Size(10, 10), gfx::Rect(origin, gfx::Size(30, 30)), false);

1644 std::vector<std::pair<int, int> > expected;	3245 std::vector<std::pair<int, int> > expected;

1645 gfx::Rect center;	3246 gfx::Rect center;

1646 gfx::Rect consider;	3247 gfx::Rect consider;

1647 gfx::Rect ignore;	3248 gfx::Rect ignore;

1648	3249

1649 // Ignore contains, but is not equal to, consider and center.	3250 // Ignore contains, but is not equal to, consider and center.

1650 ignore = gfx::Rect(15, 0, 20, 30);	3251 ignore = gfx::Rect(origin.x() + 15, origin.y(), 20, 30);

1651 consider = gfx::Rect(20, 10, 10, 20);	3252 consider = gfx::Rect(origin.x() + 20, origin.y() + 10, 10, 20);

1652 center = gfx::Rect(25, 0, 5, 5);	3253 center = gfx::Rect(origin.x() + 25, origin.y(), 5, 5);

1653	3254

1654 // Layout of the tiling data, and expected return order:	3255 // Layout of the tiling data, and expected return order:

1655 // x 0 1 2	3256 // x 0 1 2

1656 // y.------	3257 // y.------

1657 // 0\| . *	3258 // 0\| . *

1658 // 1\| . .	3259 // 1\| . .

1659 // 2\| . .	3260 // 2\| . .

1660 expected.clear();	3261 expected.clear();

1661	3262

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

1663	3264

1664 // Center intersects with consider.	3265 // Center intersects with consider.

1665 ignore = gfx::Rect();	3266 ignore = gfx::Rect();

1666 center = gfx::Rect(0, 15, 30, 15);	3267 center = gfx::Rect(origin.x(), origin.y() + 15, 30, 15);

1667 consider = gfx::Rect(0, 0, 15, 30);	3268 consider = gfx::Rect(origin.x(), origin.y(), 15, 30);

1668	3269

1669 // Layout of the tiling data, and expected return order:	3270 // Layout of the tiling data, and expected return order:

1670 // x 0 1 2	3271 // x 0 1 2

1671 // y.------	3272 // y.------

1672 // 0\| 2 1	3273 // 0\| 2 1

1673 // 1\| * * *	3274 // 1\| * * *

1674 // 2\| * * *	3275 // 2\| * * *

1675 expected.clear();	3276 expected.clear();

1676	3277

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

1678 expected.push_back(std::make_pair(0, 0));	3279 expected.push_back(std::make_pair(0, 0));

1679	3280

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

1681	3282

1682 // Consider and ignore are non-intersecting.	3283 // Consider and ignore are non-intersecting.

1683 ignore = gfx::Rect(0, 0, 5, 30);	3284 ignore = gfx::Rect(origin.x(), origin.y(), 5, 30);

1684 consider = gfx::Rect(25, 0, 5, 30);	3285 consider = gfx::Rect(origin.x() + 25, origin.y(), 5, 30);

1685 center = gfx::Rect(15, 0, 1, 1);	3286 center = gfx::Rect(origin.x() + 15, origin.y(), 1, 1);

1686	3287

1687 // Layout of the tiling data, and expected return order:	3288 // Layout of the tiling data, and expected return order:

1688 // x 0 1 2	3289 // x 0 1 2

1689 // y.------	3290 // y.------

1690 // 0\| . * 1	3291 // 0\| . * 1

1691 // 1\| . 2	3292 // 1\| . 2

1692 // 2\| . 3	3293 // 2\| . 3

1693 expected.clear();	3294 expected.clear();

1694	3295

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

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

1697 expected.push_back(std::make_pair(2, 2));	3298 expected.push_back(std::make_pair(2, 2));

1698	3299

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

1700	3301

1701 // Center intersects with ignore.	3302 // Center intersects with ignore.

1702 consider = gfx::Rect(0, 0, 30, 30);	3303 consider = gfx::Rect(origin.x(), origin.y(), 30, 30);

1703 center = gfx::Rect(15, 0, 1, 30);	3304 center = gfx::Rect(origin.x() + 15, origin.y(), 1, 30);

1704 ignore = gfx::Rect(0, 15, 30, 1);	3305 ignore = gfx::Rect(origin.x(), origin.y() + 15, 30, 1);

1705	3306

1706 // Layout of the tiling data, and expected return order:	3307 // Layout of the tiling data, and expected return order:

1707 // x 0 1 2	3308 // x 0 1 2

1708 // y.------	3309 // y.------

1709 // 0\| 3 * 2	3310 // 0\| 3 * 2

1710 // 1\| . * .	3311 // 1\| . * .

1711 // 2\| 4 * 1	3312 // 2\| 4 * 1

1712 expected.clear();	3313 expected.clear();

1713	3314

1714 expected.push_back(std::make_pair(2, 2));	3315 expected.push_back(std::make_pair(2, 2));

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

1716 expected.push_back(std::make_pair(0, 0));	3317 expected.push_back(std::make_pair(0, 0));

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

1718	3319

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

1720	3321

1721 // Center and ignore are the same.	3322 // Center and ignore are the same.

1722 consider = gfx::Rect(0, 0, 30, 30);	3323 consider = gfx::Rect(origin.x(), origin.y(), 30, 30);

1723 center = gfx::Rect(15, 0, 1, 30);	3324 center = gfx::Rect(origin.x() + 15, origin.y(), 1, 30);

1724 ignore = center;	3325 ignore = center;

1725	3326

1726 // Layout of the tiling data, and expected return order:	3327 // Layout of the tiling data, and expected return order:

1727 // x 0 1 2	3328 // x 0 1 2

1728 // y.------	3329 // y.------

1729 // 0\| 4 * 3	3330 // 0\| 4 * 3

1730 // 1\| 5 * 2	3331 // 1\| 5 * 2

1731 // 2\| 6 * 1	3332 // 2\| 6 * 1

1732 expected.clear();	3333 expected.clear();

1733	3334

1734 expected.push_back(std::make_pair(2, 2));	3335 expected.push_back(std::make_pair(2, 2));

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

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

1737 expected.push_back(std::make_pair(0, 0));	3338 expected.push_back(std::make_pair(0, 0));

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

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

1740	3341

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

1742	3343

1743 // Empty tiling data.	3344 // Empty tiling data.

1744 TilingData empty_data(gfx::Size(0, 0), gfx::Size(0, 0), false);	3345 TilingData empty_data(gfx::Size(0, 0), gfx::Rect(0, 0, 0, 0), false);

1745	3346

1746 expected.clear();	3347 expected.clear();

1747 TestSpiralIterate(__LINE__, empty_data, consider, ignore, center, expected);	3348 TestSpiralIterate(__LINE__, empty_data, consider, ignore, center, expected);

1748	3349

1749 // Empty consider.	3350 // Empty consider.

1750 ignore = gfx::Rect();	3351 ignore = gfx::Rect();

1751 center = gfx::Rect(1, 1, 1, 1);	3352 center = gfx::Rect(1, 1, 1, 1);

1752 consider = gfx::Rect();	3353 consider = gfx::Rect();

1753	3354

1754 expected.clear();	3355 expected.clear();

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

1756	3357

1757 // Empty center. Note: This arbitrarily puts the center to be off the top-left	3358 // Empty center. Note: This arbitrarily puts the center to be off the top-left

1758 // corner.	3359 // corner.

1759 consider = gfx::Rect(0, 0, 30, 30);	3360 consider = gfx::Rect(origin.x(), origin.y(), 30, 30);

1760 ignore = gfx::Rect();	3361 ignore = gfx::Rect();

1761 center = gfx::Rect();	3362 center = gfx::Rect();

1762	3363

1763 // Layout of the tiling data, and expected return order:	3364 // Layout of the tiling data, and expected return order:

1764 // * x 0 1 2	3365 // * x 0 1 2

1765 // y.------	3366 // y.------

1766 // 0\| 1 2 6	3367 // 0\| 1 2 6

1767 // 1\| 3 4 5	3368 // 1\| 3 4 5

1768 // 2\| 7 8 9	3369 // 2\| 7 8 9

1769 expected.clear();	3370 expected.clear();

(...skipping 12 matching lines...) Expand all Loading...
1782	3383

1783 // Every rect is empty.	3384 // Every rect is empty.

1784 ignore = gfx::Rect();	3385 ignore = gfx::Rect();

1785 center = gfx::Rect();	3386 center = gfx::Rect();

1786 consider = gfx::Rect();	3387 consider = gfx::Rect();

1787	3388

1788 expected.clear();	3389 expected.clear();

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

1790	3391

1791 // Center is just to the left of cover, and off of the tiling's left side.	3392 // Center is just to the left of cover, and off of the tiling's left side.

1792 consider = gfx::Rect(0, 0, 30, 30);	3393 consider = gfx::Rect(origin.x(), origin.y(), 30, 30);

1793 ignore = gfx::Rect();	3394 ignore = gfx::Rect();

1794 center = gfx::Rect(-20, 0, 19, 30);	3395 center = gfx::Rect(origin.x() - 20, origin.y(), 19, 30);

1795	3396

1796 // Layout of the tiling data, and expected return order:	3397 // Layout of the tiling data, and expected return order:

1797 // x 0 1 2	3398 // x 0 1 2

1798 // y.------	3399 // y.------

1799 // *0\| 3 6 9	3400 // *0\| 3 6 9

1800 // *1\| 2 5 8	3401 // *1\| 2 5 8

1801 // *2\| 1 4 7	3402 // *2\| 1 4 7

1802 expected.clear();	3403 expected.clear();

1803	3404

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

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

1806 expected.push_back(std::make_pair(0, 0));	3407 expected.push_back(std::make_pair(0, 0));

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

1808 expected.push_back(std::make_pair(1, 1));	3409 expected.push_back(std::make_pair(1, 1));

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

1810 expected.push_back(std::make_pair(2, 2));	3411 expected.push_back(std::make_pair(2, 2));

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

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

1813	3414

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

1815 }	3416 }

	3417

	3418 INSTANTIATE_TEST_CASE_P(TilingData,

	3419 TilingDataTest,

	3420 ::testing::Values(gfx::Point(42, 17),

	3421 gfx::Point(0, 0),

	3422 gfx::Point(-8, 15),

	3423 gfx::Point(-12, 4),

	3424 gfx::Point(-16, -35),

	3425 gfx::Point(-10000, -15000)));

1816 } // namespace	3426 } // namespace

1817	3427

1818 } // namespace cc	3428 } // namespace cc

OLD	NEW

« no previous file with comments | « cc/base/tiling_data.cc ('k') | cc/layers/picture_layer.cc » ('j') | no next file with comments »