?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove WebKitTestRunner::setClientWindowRect.
[chromium-blink-merge.git] / ui / gfx / skbitmap_operations_unittest.cc
blob4e488aa2c451c09b16a0e9c856ab1078c5d9b412
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "ui/gfx/skbitmap_operations.h"
6
7 #include "testing/gtest/include/gtest/gtest.h"
8 #include "third_party/skia/include/core/SkBitmap.h"
9 #include "third_party/skia/include/core/SkCanvas.h"
10 #include "third_party/skia/include/core/SkColorPriv.h"
11 #include "third_party/skia/include/core/SkRect.h"
12 #include "third_party/skia/include/core/SkRegion.h"
13 #include "third_party/skia/include/core/SkUnPreMultiply.h"
14
15 namespace {
16
17 // Returns true if each channel of the given two colors are "close." This is
18 // used for comparing colors where rounding errors may cause off-by-one.
19 inline bool ColorsClose(uint32_t a, uint32_t b) {
20 return abs(static_cast<int>(SkColorGetB(a) - SkColorGetB(b))) <= 2 &&
21 abs(static_cast<int>(SkColorGetG(a) - SkColorGetG(b))) <= 2 &&
22 abs(static_cast<int>(SkColorGetR(a) - SkColorGetR(b))) <= 2 &&
23 abs(static_cast<int>(SkColorGetA(a) - SkColorGetA(b))) <= 2;
24 }
25
26 inline bool MultipliedColorsClose(uint32_t a, uint32_t b) {
27 return ColorsClose(SkUnPreMultiply::PMColorToColor(a),
28 SkUnPreMultiply::PMColorToColor(b));
29 }
30
31 bool BitmapsClose(const SkBitmap& a, const SkBitmap& b) {
32 SkAutoLockPixels a_lock(a);
33 SkAutoLockPixels b_lock(b);
34
35 for (int y = 0; y < a.height(); y++) {
36 for (int x = 0; x < a.width(); x++) {
37 SkColor a_pixel = *a.getAddr32(x, y);
38 SkColor b_pixel = *b.getAddr32(x, y);
39 if (!ColorsClose(a_pixel, b_pixel))
40 return false;
41 }
42 }
43 return true;
44 }
45
46 void FillDataToBitmap(int w, int h, SkBitmap* bmp) {
47 bmp->setConfig(SkBitmap::kARGB_8888_Config, w, h);
48 bmp->allocPixels();
49
50 unsigned char* src_data =
51 reinterpret_cast<unsigned char*>(bmp->getAddr32(0, 0));
52 for (int i = 0; i < w * h; i++) {
53 src_data[i * 4 + 0] = static_cast<unsigned char>(i % 255);
54 src_data[i * 4 + 1] = static_cast<unsigned char>(i % 255);
55 src_data[i * 4 + 2] = static_cast<unsigned char>(i % 255);
56 src_data[i * 4 + 3] = static_cast<unsigned char>(i % 255);
57 }
58 }
59
60 // The reference (i.e., old) implementation of |CreateHSLShiftedBitmap()|.
61 SkBitmap ReferenceCreateHSLShiftedBitmap(
62 const SkBitmap& bitmap,
63 color_utils::HSL hsl_shift) {
64 SkBitmap shifted;
65 shifted.setConfig(SkBitmap::kARGB_8888_Config, bitmap.width(),
66 bitmap.height());
67 shifted.allocPixels();
68 shifted.eraseARGB(0, 0, 0, 0);
69
70 SkAutoLockPixels lock_bitmap(bitmap);
71 SkAutoLockPixels lock_shifted(shifted);
72
73 // Loop through the pixels of the original bitmap.
74 for (int y = 0; y < bitmap.height(); ++y) {
75 SkPMColor* pixels = bitmap.getAddr32(0, y);
76 SkPMColor* tinted_pixels = shifted.getAddr32(0, y);
77
78 for (int x = 0; x < bitmap.width(); ++x) {
79 tinted_pixels[x] = SkPreMultiplyColor(color_utils::HSLShift(
80 SkUnPreMultiply::PMColorToColor(pixels[x]), hsl_shift));
81 }
82 }
83
84 return shifted;
85 }
86
87 } // namespace
88
89 // Invert bitmap and verify the each pixel is inverted and the alpha value is
90 // not changed.
91 TEST(SkBitmapOperationsTest, CreateInvertedBitmap) {
92 int src_w = 16, src_h = 16;
93 SkBitmap src;
94 src.setConfig(SkBitmap::kARGB_8888_Config, src_w, src_h);
95 src.allocPixels();
96
97 for (int y = 0; y < src_h; y++) {
98 for (int x = 0; x < src_w; x++) {
99 int i = y * src_w + x;
100 *src.getAddr32(x, y) =
101 SkColorSetARGB((255 - i) % 255, i % 255, i * 4 % 255, 0);
102 }
103 }
104
105 SkBitmap inverted = SkBitmapOperations::CreateInvertedBitmap(src);
106 SkAutoLockPixels src_lock(src);
107 SkAutoLockPixels inverted_lock(inverted);
108
109 for (int y = 0; y < src_h; y++) {
110 for (int x = 0; x < src_w; x++) {
111 int i = y * src_w + x;
112 EXPECT_EQ(static_cast<unsigned int>((255 - i) % 255),
113 SkColorGetA(*inverted.getAddr32(x, y)));
114 EXPECT_EQ(static_cast<unsigned int>(255 - (i % 255)),
115 SkColorGetR(*inverted.getAddr32(x, y)));
116 EXPECT_EQ(static_cast<unsigned int>(255 - (i * 4 % 255)),
117 SkColorGetG(*inverted.getAddr32(x, y)));
118 EXPECT_EQ(static_cast<unsigned int>(255),
119 SkColorGetB(*inverted.getAddr32(x, y)));
120 }
121 }
122 }
123
124 // Blend two bitmaps together at 50% alpha and verify that the result
125 // is the middle-blend of the two.
126 TEST(SkBitmapOperationsTest, CreateBlendedBitmap) {
127 int src_w = 16, src_h = 16;
128 SkBitmap src_a;
129 src_a.setConfig(SkBitmap::kARGB_8888_Config, src_w, src_h);
130 src_a.allocPixels();
131
132 SkBitmap src_b;
133 src_b.setConfig(SkBitmap::kARGB_8888_Config, src_w, src_h);
134 src_b.allocPixels();
135
136 for (int y = 0, i = 0; y < src_h; y++) {
137 for (int x = 0; x < src_w; x++) {
138 *src_a.getAddr32(x, y) = SkColorSetARGB(255, 0, i * 2 % 255, i % 255);
139 *src_b.getAddr32(x, y) =
140 SkColorSetARGB((255 - i) % 255, i % 255, i * 4 % 255, 0);
141 i++;
142 }
143 }
144
145 // Shift to red.
146 SkBitmap blended = SkBitmapOperations::CreateBlendedBitmap(
147 src_a, src_b, 0.5);
148 SkAutoLockPixels srca_lock(src_a);
149 SkAutoLockPixels srcb_lock(src_b);
150 SkAutoLockPixels blended_lock(blended);
151
152 for (int y = 0; y < src_h; y++) {
153 for (int x = 0; x < src_w; x++) {
154 int i = y * src_w + x;
155 EXPECT_EQ(static_cast<unsigned int>((255 + ((255 - i) % 255)) / 2),
156 SkColorGetA(*blended.getAddr32(x, y)));
157 EXPECT_EQ(static_cast<unsigned int>(i % 255 / 2),
158 SkColorGetR(*blended.getAddr32(x, y)));
159 EXPECT_EQ((static_cast<unsigned int>((i * 2) % 255 + (i * 4) % 255) / 2),
160 SkColorGetG(*blended.getAddr32(x, y)));
161 EXPECT_EQ(static_cast<unsigned int>(i % 255 / 2),
162 SkColorGetB(*blended.getAddr32(x, y)));
163 }
164 }
165 }
166
167 // Test our masking functions.
168 TEST(SkBitmapOperationsTest, CreateMaskedBitmap) {
169 int src_w = 16, src_h = 16;
170
171 SkBitmap src;
172 FillDataToBitmap(src_w, src_h, &src);
173
174 // Generate alpha mask
175 SkBitmap alpha;
176 alpha.setConfig(SkBitmap::kARGB_8888_Config, src_w, src_h);
177 alpha.allocPixels();
178 for (int y = 0, i = 0; y < src_h; y++) {
179 for (int x = 0; x < src_w; x++) {
180 *alpha.getAddr32(x, y) = SkColorSetARGB((i + 128) % 255,
181 (i + 128) % 255,
182 (i + 64) % 255,
183 (i + 0) % 255);
184 i++;
185 }
186 }
187
188 SkBitmap masked = SkBitmapOperations::CreateMaskedBitmap(src, alpha);
189
190 SkAutoLockPixels src_lock(src);
191 SkAutoLockPixels alpha_lock(alpha);
192 SkAutoLockPixels masked_lock(masked);
193 for (int y = 0; y < src_h; y++) {
194 for (int x = 0; x < src_w; x++) {
195 // Test that the alpha is equal.
196 SkColor src_pixel = SkUnPreMultiply::PMColorToColor(*src.getAddr32(x, y));
197 SkColor alpha_pixel =
198 SkUnPreMultiply::PMColorToColor(*alpha.getAddr32(x, y));
199 SkColor masked_pixel = *masked.getAddr32(x, y);
200
201 int alpha_value = SkAlphaMul(SkColorGetA(src_pixel),
202 SkAlpha255To256(SkColorGetA(alpha_pixel)));
203 int alpha_value_256 = SkAlpha255To256(alpha_value);
204 SkColor expected_pixel = SkColorSetARGB(
205 alpha_value,
206 SkAlphaMul(SkColorGetR(src_pixel), alpha_value_256),
207 SkAlphaMul(SkColorGetG(src_pixel), alpha_value_256),
208 SkAlphaMul(SkColorGetB(src_pixel), alpha_value_256));
209
210 EXPECT_EQ(expected_pixel, masked_pixel);
211 }
212 }
213 }
214
215 // Make sure that when shifting a bitmap without any shift parameters,
216 // the end result is close enough to the original (rounding errors
217 // notwithstanding).
218 TEST(SkBitmapOperationsTest, CreateHSLShiftedBitmapToSame) {
219 int src_w = 16, src_h = 16;
220 SkBitmap src;
221 src.setConfig(SkBitmap::kARGB_8888_Config, src_w, src_h);
222 src.allocPixels();
223
224 for (int y = 0, i = 0; y < src_h; y++) {
225 for (int x = 0; x < src_w; x++) {
226 *src.getAddr32(x, y) = SkPreMultiplyColor(SkColorSetARGB((i + 128) % 255,
227 (i + 128) % 255, (i + 64) % 255, (i + 0) % 255));
228 i++;
229 }
230 }
231
232 color_utils::HSL hsl = { -1, -1, -1 };
233 SkBitmap shifted = ReferenceCreateHSLShiftedBitmap(src, hsl);
234
235 SkAutoLockPixels src_lock(src);
236 SkAutoLockPixels shifted_lock(shifted);
237
238 for (int y = 0; y < src_h; y++) {
239 for (int x = 0; x < src_w; x++) {
240 SkColor src_pixel = *src.getAddr32(x, y);
241 SkColor shifted_pixel = *shifted.getAddr32(x, y);
242 EXPECT_TRUE(MultipliedColorsClose(src_pixel, shifted_pixel)) <<
243 "source: (a,r,g,b) = (" << SkColorGetA(src_pixel) << "," <<
244 SkColorGetR(src_pixel) << "," <<
245 SkColorGetG(src_pixel) << "," <<
246 SkColorGetB(src_pixel) << "); " <<
247 "shifted: (a,r,g,b) = (" << SkColorGetA(shifted_pixel) << "," <<
248 SkColorGetR(shifted_pixel) << "," <<
249 SkColorGetG(shifted_pixel) << "," <<
250 SkColorGetB(shifted_pixel) << ")";
251 }
252 }
253 }
254
255 // Shift a blue bitmap to red.
256 TEST(SkBitmapOperationsTest, CreateHSLShiftedBitmapHueOnly) {
257 int src_w = 16, src_h = 16;
258 SkBitmap src;
259 src.setConfig(SkBitmap::kARGB_8888_Config, src_w, src_h);
260 src.allocPixels();
261
262 for (int y = 0, i = 0; y < src_h; y++) {
263 for (int x = 0; x < src_w; x++) {
264 *src.getAddr32(x, y) = SkColorSetARGB(255, 0, 0, i % 255);
265 i++;
266 }
267 }
268
269 // Shift to red.
270 color_utils::HSL hsl = { 0, -1, -1 };
271
272 SkBitmap shifted = SkBitmapOperations::CreateHSLShiftedBitmap(src, hsl);
273
274 SkAutoLockPixels src_lock(src);
275 SkAutoLockPixels shifted_lock(shifted);
276
277 for (int y = 0, i = 0; y < src_h; y++) {
278 for (int x = 0; x < src_w; x++) {
279 EXPECT_TRUE(ColorsClose(shifted.getColor(x, y),
280 SkColorSetARGB(255, i % 255, 0, 0)));
281 i++;
282 }
283 }
284 }
285
286 // Validate HSL shift.
287 TEST(SkBitmapOperationsTest, ValidateHSLShift) {
288 // Note: 255/51 = 5 (exactly) => 6 including 0!
289 const int inc = 51;
290 const int dim = 255 / inc + 1;
291 SkBitmap src;
292 src.setConfig(SkBitmap::kARGB_8888_Config, dim*dim, dim*dim);
293 src.allocPixels();
294
295 for (int a = 0, y = 0; a <= 255; a += inc) {
296 for (int r = 0; r <= 255; r += inc, y++) {
297 for (int g = 0, x = 0; g <= 255; g += inc) {
298 for (int b = 0; b <= 255; b+= inc, x++) {
299 *src.getAddr32(x, y) =
300 SkPreMultiplyColor(SkColorSetARGB(a, r, g, b));
301 }
302 }
303 }
304 }
305
306 // Shhhh. The spec says I should set things to -1 for "no change", but
307 // actually -0.1 will do. Don't tell anyone I did this.
308 for (double h = -0.1; h <= 1.0001; h += 0.1) {
309 for (double s = -0.1; s <= 1.0001; s += 0.1) {
310 for (double l = -0.1; l <= 1.0001; l += 0.1) {
311 color_utils::HSL hsl = { h, s, l };
312 SkBitmap ref_shifted = ReferenceCreateHSLShiftedBitmap(src, hsl);
313 SkBitmap shifted = SkBitmapOperations::CreateHSLShiftedBitmap(src, hsl);
314 EXPECT_TRUE(BitmapsClose(ref_shifted, shifted))
315 << "h = " << h << ", s = " << s << ", l = " << l;
316 }
317 }
318 }
319 }
320
321 // Test our cropping.
322 TEST(SkBitmapOperationsTest, CreateCroppedBitmap) {
323 int src_w = 16, src_h = 16;
324 SkBitmap src;
325 FillDataToBitmap(src_w, src_h, &src);
326
327 SkBitmap cropped = SkBitmapOperations::CreateTiledBitmap(src, 4, 4,
328 8, 8);
329 ASSERT_EQ(8, cropped.width());
330 ASSERT_EQ(8, cropped.height());
331
332 SkAutoLockPixels src_lock(src);
333 SkAutoLockPixels cropped_lock(cropped);
334 for (int y = 4; y < 12; y++) {
335 for (int x = 4; x < 12; x++) {
336 EXPECT_EQ(*src.getAddr32(x, y),
337 *cropped.getAddr32(x - 4, y - 4));
338 }
339 }
340 }
341
342 // Test whether our cropping correctly wraps across image boundaries.
343 TEST(SkBitmapOperationsTest, CreateCroppedBitmapWrapping) {
344 int src_w = 16, src_h = 16;
345 SkBitmap src;
346 FillDataToBitmap(src_w, src_h, &src);
347
348 SkBitmap cropped = SkBitmapOperations::CreateTiledBitmap(
349 src, src_w / 2, src_h / 2, src_w, src_h);
350 ASSERT_EQ(src_w, cropped.width());
351 ASSERT_EQ(src_h, cropped.height());
352
353 SkAutoLockPixels src_lock(src);
354 SkAutoLockPixels cropped_lock(cropped);
355 for (int y = 0; y < src_h; y++) {
356 for (int x = 0; x < src_w; x++) {
357 EXPECT_EQ(*src.getAddr32(x, y),
358 *cropped.getAddr32((x + src_w / 2) % src_w,
359 (y + src_h / 2) % src_h));
360 }
361 }
362 }
363
364 TEST(SkBitmapOperationsTest, DownsampleByTwo) {
365 // Use an odd-sized bitmap to make sure the edge cases where there isn't a
366 // 2x2 block of pixels is handled correctly.
367 // Here's the ARGB example
368 //
369 // 50% transparent green opaque 50% blue white
370 // 80008000 FF000080 FFFFFFFF
371 //
372 // 50% transparent red opaque 50% gray black
373 // 80800000 80808080 FF000000
374 //
375 // black white 50% gray
376 // FF000000 FFFFFFFF FF808080
377 //
378 // The result of this computation should be:
379 // A0404040 FF808080
380 // FF808080 FF808080
381 SkBitmap input;
382 input.setConfig(SkBitmap::kARGB_8888_Config, 3, 3);
383 input.allocPixels();
384
385 // The color order may be different, but we don't care (the channels are
386 // trated the same).
387 *input.getAddr32(0, 0) = 0x80008000;
388 *input.getAddr32(1, 0) = 0xFF000080;
389 *input.getAddr32(2, 0) = 0xFFFFFFFF;
390 *input.getAddr32(0, 1) = 0x80800000;
391 *input.getAddr32(1, 1) = 0x80808080;
392 *input.getAddr32(2, 1) = 0xFF000000;
393 *input.getAddr32(0, 2) = 0xFF000000;
394 *input.getAddr32(1, 2) = 0xFFFFFFFF;
395 *input.getAddr32(2, 2) = 0xFF808080;
396
397 SkBitmap result = SkBitmapOperations::DownsampleByTwo(input);
398 EXPECT_EQ(2, result.width());
399 EXPECT_EQ(2, result.height());
400
401 // Some of the values are off-by-one due to rounding.
402 SkAutoLockPixels lock(result);
403 EXPECT_EQ(0x9f404040, *result.getAddr32(0, 0));
404 EXPECT_EQ(0xFF7f7f7f, *result.getAddr32(1, 0));
405 EXPECT_EQ(0xFF7f7f7f, *result.getAddr32(0, 1));
406 EXPECT_EQ(0xFF808080, *result.getAddr32(1, 1));
407 }
408
409 // Test edge cases for DownsampleByTwo.
410 TEST(SkBitmapOperationsTest, DownsampleByTwoSmall) {
411 SkPMColor reference = 0xFF4080FF;
412
413 // Test a 1x1 bitmap.
414 SkBitmap one_by_one;
415 one_by_one.setConfig(SkBitmap::kARGB_8888_Config, 1, 1);
416 one_by_one.allocPixels();
417 *one_by_one.getAddr32(0, 0) = reference;
418 SkBitmap result = SkBitmapOperations::DownsampleByTwo(one_by_one);
419 SkAutoLockPixels lock1(result);
420 EXPECT_EQ(1, result.width());
421 EXPECT_EQ(1, result.height());
422 EXPECT_EQ(reference, *result.getAddr32(0, 0));
423
424 // Test an n by 1 bitmap.
425 SkBitmap one_by_n;
426 one_by_n.setConfig(SkBitmap::kARGB_8888_Config, 300, 1);
427 one_by_n.allocPixels();
428 result = SkBitmapOperations::DownsampleByTwo(one_by_n);
429 SkAutoLockPixels lock2(result);
430 EXPECT_EQ(300, result.width());
431 EXPECT_EQ(1, result.height());
432
433 // Test a 1 by n bitmap.
434 SkBitmap n_by_one;
435 n_by_one.setConfig(SkBitmap::kARGB_8888_Config, 1, 300);
436 n_by_one.allocPixels();
437 result = SkBitmapOperations::DownsampleByTwo(n_by_one);
438 SkAutoLockPixels lock3(result);
439 EXPECT_EQ(1, result.width());
440 EXPECT_EQ(300, result.height());
441
442 // Test an empty bitmap
443 SkBitmap empty;
444 result = SkBitmapOperations::DownsampleByTwo(empty);
445 EXPECT_TRUE(result.isNull());
446 EXPECT_EQ(0, result.width());
447 EXPECT_EQ(0, result.height());
448 }
449
450 // Here we assume DownsampleByTwo works correctly (it's tested above) and
451 // just make sure that the wrapper function does the right thing.
452 TEST(SkBitmapOperationsTest, DownsampleByTwoUntilSize) {
453 // First make sure a "too small" bitmap doesn't get modified at all.
454 SkBitmap too_small;
455 too_small.setConfig(SkBitmap::kARGB_8888_Config, 10, 10);
456 too_small.allocPixels();
457 SkBitmap result = SkBitmapOperations::DownsampleByTwoUntilSize(
458 too_small, 16, 16);
459 EXPECT_EQ(10, result.width());
460 EXPECT_EQ(10, result.height());
461
462 // Now make sure giving it a 0x0 target returns something reasonable.
463 result = SkBitmapOperations::DownsampleByTwoUntilSize(too_small, 0, 0);
464 EXPECT_EQ(1, result.width());
465 EXPECT_EQ(1, result.height());
466
467 // Test multiple steps of downsampling.
468 SkBitmap large;
469 large.setConfig(SkBitmap::kARGB_8888_Config, 100, 43);
470 large.allocPixels();
471 result = SkBitmapOperations::DownsampleByTwoUntilSize(large, 6, 6);
472
473 // The result should be divided in half 100x43 -> 50x22 -> 25x11
474 EXPECT_EQ(25, result.width());
475 EXPECT_EQ(11, result.height());
476 }
477
478 TEST(SkBitmapOperationsTest, UnPreMultiply) {
479 SkBitmap input;
480 input.setConfig(SkBitmap::kARGB_8888_Config, 2, 2);
481 input.allocPixels();
482
483 // Set PMColors into the bitmap
484 *input.getAddr32(0, 0) = SkPackARGB32NoCheck(0x80, 0x00, 0x00, 0x00);
485 *input.getAddr32(1, 0) = SkPackARGB32NoCheck(0x80, 0x80, 0x80, 0x80);
486 *input.getAddr32(0, 1) = SkPackARGB32NoCheck(0xFF, 0x00, 0xCC, 0x88);
487 *input.getAddr32(1, 1) = SkPackARGB32NoCheck(0x00, 0x00, 0xCC, 0x88);
488
489 SkBitmap result = SkBitmapOperations::UnPreMultiply(input);
490 EXPECT_EQ(2, result.width());
491 EXPECT_EQ(2, result.height());
492
493 SkAutoLockPixels lock(result);
494 EXPECT_EQ(0x80000000, *result.getAddr32(0, 0));
495 EXPECT_EQ(0x80FFFFFF, *result.getAddr32(1, 0));
496 EXPECT_EQ(0xFF00CC88, *result.getAddr32(0, 1));
497 EXPECT_EQ(0x00000000u, *result.getAddr32(1, 1)); // "Division by zero".
498 }
499
500 TEST(SkBitmapOperationsTest, CreateTransposedBitmap) {
501 SkBitmap input;
502 input.setConfig(SkBitmap::kARGB_8888_Config, 2, 3);
503 input.allocPixels();
504
505 for (int x = 0; x < input.width(); ++x) {
506 for (int y = 0; y < input.height(); ++y) {
507 *input.getAddr32(x, y) = x * input.width() + y;
508 }
509 }
510
511 SkBitmap result = SkBitmapOperations::CreateTransposedBitmap(input);
512 EXPECT_EQ(3, result.width());
513 EXPECT_EQ(2, result.height());
514
515 SkAutoLockPixels lock(result);
516 for (int x = 0; x < input.width(); ++x) {
517 for (int y = 0; y < input.height(); ++y) {
518 EXPECT_EQ(*input.getAddr32(x, y), *result.getAddr32(y, x));
519 }
520 }
521 }
522
523 // Check that Rotate provides the desired results
524 TEST(SkBitmapOperationsTest, RotateImage) {
525 const int src_w = 6, src_h = 4;
526 SkBitmap src;
527 // Create a simple 4 color bitmap:
528 // RRRBBB
529 // RRRBBB
530 // GGGYYY
531 // GGGYYY
532 src.setConfig(SkBitmap::kARGB_8888_Config, src_w, src_h);
533 src.allocPixels();
534
535 SkCanvas canvas(src);
536 src.eraseARGB(0, 0, 0, 0);
537 SkRegion region;
538
539 region.setRect(0, 0, src_w / 2, src_h / 2);
540 canvas.setClipRegion(region);
541 // This region is a semi-transparent red to test non-opaque pixels.
542 canvas.drawColor(0x1FFF0000, SkXfermode::kSrc_Mode);
543 region.setRect(src_w / 2, 0, src_w, src_h / 2);
544 canvas.setClipRegion(region);
545 canvas.drawColor(SK_ColorBLUE, SkXfermode::kSrc_Mode);
546 region.setRect(0, src_h / 2, src_w / 2, src_h);
547 canvas.setClipRegion(region);
548 canvas.drawColor(SK_ColorGREEN, SkXfermode::kSrc_Mode);
549 region.setRect(src_w / 2, src_h / 2, src_w, src_h);
550 canvas.setClipRegion(region);
551 canvas.drawColor(SK_ColorYELLOW, SkXfermode::kSrc_Mode);
552 canvas.flush();
553
554 SkBitmap rotate90, rotate180, rotate270;
555 rotate90 = SkBitmapOperations::Rotate(src,
556 SkBitmapOperations::ROTATION_90_CW);
557 rotate180 = SkBitmapOperations::Rotate(src,
558 SkBitmapOperations::ROTATION_180_CW);
559 rotate270 = SkBitmapOperations::Rotate(src,
560 SkBitmapOperations::ROTATION_270_CW);
561
562 ASSERT_EQ(rotate90.width(), src.height());
563 ASSERT_EQ(rotate90.height(), src.width());
564 ASSERT_EQ(rotate180.width(), src.width());
565 ASSERT_EQ(rotate180.height(), src.height());
566 ASSERT_EQ(rotate270.width(), src.height());
567 ASSERT_EQ(rotate270.height(), src.width());
568
569 SkAutoLockPixels lock_src(src);
570 SkAutoLockPixels lock_90(rotate90);
571 SkAutoLockPixels lock_180(rotate180);
572 SkAutoLockPixels lock_270(rotate270);
573
574 for (int x=0; x < src_w; ++x) {
575 for (int y=0; y < src_h; ++y) {
576 ASSERT_EQ(*src.getAddr32(x,y), *rotate90.getAddr32(src_h - (y+1),x));
577 ASSERT_EQ(*src.getAddr32(x,y), *rotate270.getAddr32(y, src_w - (x+1)));
578 ASSERT_EQ(*src.getAddr32(x,y),
579 *rotate180.getAddr32(src_w - (x+1), src_h - (y+1)));
580 }
581 }
582 }