Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(180)

Issues Search
    My Issues | Starred     Open | Closed | All

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

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

Powered by Google App Engine
This is Rietveld 408576698