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 "testing/gtest/include/gtest/gtest.h"
6 #include "third_party/skia/include/core/SkCanvas.h"
7 #include "third_party/skia/include/core/SkPaint.h"
8 #include "ui/gfx/image/image.h"
9 #include "ui/gfx/image/image_png_rep.h"
10 #include "ui/gfx/image/image_skia.h"
11 #include "ui/gfx/image/image_unittest_util.h"
12
13 #if defined(OS_IOS)
14 #include "base/mac/foundation_util.h"
15 #include "skia/ext/skia_utils_ios.h"
16 #elif defined(OS_MACOSX)
17 #include "base/mac/mac_util.h"
18 #include "skia/ext/skia_utils_mac.h"
19 #endif
20
21 namespace {
22
23 #if defined(TOOLKIT_VIEWS) || defined(OS_ANDROID) || \
24 (defined(OS_LINUX) && !defined(USE_CAIRO))
25 const bool kUsesSkiaNatively = true;
26 #else
27 const bool kUsesSkiaNatively = false;
28 #endif
29
30 class ImageTest : public testing::Test {
31 public:
ImageTest()32 ImageTest() {
33 std::vector<float> scales;
34 scales.push_back(1.0f);
35 #if !defined(OS_IOS)
36 scales.push_back(2.0f);
37 #endif
38 gfx::ImageSkia::SetSupportedScales(scales);
39 }
40 };
41
42 namespace gt = gfx::test;
43
TEST_F(ImageTest,EmptyImage)44 TEST_F(ImageTest, EmptyImage) {
45 // Test the default constructor.
46 gfx::Image image;
47 EXPECT_EQ(0U, image.RepresentationCount());
48 EXPECT_TRUE(image.IsEmpty());
49 EXPECT_EQ(0, image.Width());
50 EXPECT_EQ(0, image.Height());
51
52 // Test the copy constructor.
53 gfx::Image imageCopy(image);
54 EXPECT_TRUE(imageCopy.IsEmpty());
55 EXPECT_EQ(0, imageCopy.Width());
56 EXPECT_EQ(0, imageCopy.Height());
57
58 // Test calling SwapRepresentations() with an empty image.
59 gfx::Image image2(gt::CreateImageSkia(25, 25));
60 EXPECT_FALSE(image2.IsEmpty());
61 EXPECT_EQ(25, image2.Width());
62 EXPECT_EQ(25, image2.Height());
63
64 image.SwapRepresentations(&image2);
65 EXPECT_FALSE(image.IsEmpty());
66 EXPECT_EQ(25, image.Width());
67 EXPECT_EQ(25, image.Height());
68 EXPECT_TRUE(image2.IsEmpty());
69 EXPECT_EQ(0, image2.Width());
70 EXPECT_EQ(0, image2.Height());
71 }
72
73 // Test constructing a gfx::Image from an empty PlatformImage.
TEST_F(ImageTest,EmptyImageFromEmptyPlatformImage)74 TEST_F(ImageTest, EmptyImageFromEmptyPlatformImage) {
75 #if defined(OS_IOS) || defined(OS_MACOSX)
76 gfx::Image image1(NULL);
77 EXPECT_TRUE(image1.IsEmpty());
78 EXPECT_EQ(0, image1.Width());
79 EXPECT_EQ(0, image1.Height());
80 EXPECT_EQ(0U, image1.RepresentationCount());
81 #endif
82
83 // gfx::ImageSkia and gfx::ImagePNGRep are available on all platforms.
84 gfx::ImageSkia image_skia;
85 EXPECT_TRUE(image_skia.isNull());
86 gfx::Image image2(image_skia);
87 EXPECT_TRUE(image2.IsEmpty());
88 EXPECT_EQ(0, image2.Width());
89 EXPECT_EQ(0, image2.Height());
90 EXPECT_EQ(0U, image2.RepresentationCount());
91
92 std::vector<gfx::ImagePNGRep> image_png_reps;
93 gfx::Image image3(image_png_reps);
94 EXPECT_TRUE(image3.IsEmpty());
95 EXPECT_EQ(0, image3.Width());
96 EXPECT_EQ(0, image3.Height());
97 EXPECT_EQ(0U, image3.RepresentationCount());
98 }
99
100 // The resulting Image should be empty when it is created using obviously
101 // invalid data.
TEST_F(ImageTest,EmptyImageFromObviouslyInvalidPNGImage)102 TEST_F(ImageTest, EmptyImageFromObviouslyInvalidPNGImage) {
103 std::vector<gfx::ImagePNGRep> image_png_reps1;
104 image_png_reps1.push_back(gfx::ImagePNGRep(NULL, 1.0f));
105 gfx::Image image1(image_png_reps1);
106 EXPECT_TRUE(image1.IsEmpty());
107 EXPECT_EQ(0U, image1.RepresentationCount());
108
109 std::vector<gfx::ImagePNGRep> image_png_reps2;
110 image_png_reps2.push_back(gfx::ImagePNGRep(
111 new base::RefCountedBytes(), 1.0f));
112 gfx::Image image2(image_png_reps2);
113 EXPECT_TRUE(image2.IsEmpty());
114 EXPECT_EQ(0U, image2.RepresentationCount());
115 }
116
117 // Test the Width, Height and Size of an empty and non-empty image.
TEST_F(ImageTest,ImageSize)118 TEST_F(ImageTest, ImageSize) {
119 gfx::Image image;
120 EXPECT_EQ(0, image.Width());
121 EXPECT_EQ(0, image.Height());
122 EXPECT_EQ(gfx::Size(0, 0), image.Size());
123
124 gfx::Image image2(gt::CreateImageSkia(10, 25));
125 EXPECT_EQ(10, image2.Width());
126 EXPECT_EQ(25, image2.Height());
127 EXPECT_EQ(gfx::Size(10, 25), image2.Size());
128 }
129
TEST_F(ImageTest,SkiaToSkia)130 TEST_F(ImageTest, SkiaToSkia) {
131 gfx::Image image(gt::CreateImageSkia(25, 25));
132 EXPECT_EQ(25, image.Width());
133 EXPECT_EQ(25, image.Height());
134
135 // Test ToImageSkia().
136 const gfx::ImageSkia* image_skia1 = image.ToImageSkia();
137 EXPECT_TRUE(image_skia1);
138 EXPECT_FALSE(image_skia1->isNull());
139 EXPECT_EQ(1U, image.RepresentationCount());
140
141 // Make sure double conversion doesn't happen.
142 const gfx::ImageSkia* image_skia2 = image.ToImageSkia();
143 EXPECT_EQ(1U, image.RepresentationCount());
144
145 // ToImageSkia() should always return the same gfx::ImageSkia.
146 EXPECT_EQ(image_skia1, image_skia2);
147
148 // Test ToSkBitmap().
149 const SkBitmap* bitmap1 = image.ToSkBitmap();
150 const SkBitmap* bitmap2 = image.ToSkBitmap();
151 EXPECT_TRUE(bitmap1);
152 EXPECT_FALSE(bitmap1->isNull());
153 EXPECT_EQ(bitmap1, bitmap2);
154
155 EXPECT_EQ(1U, image.RepresentationCount());
156 EXPECT_TRUE(image.HasRepresentation(gfx::Image::kImageRepSkia));
157 if (!kUsesSkiaNatively)
158 EXPECT_FALSE(image.HasRepresentation(gt::GetPlatformRepresentationType()));
159 }
160
TEST_F(ImageTest,EmptyImageToPNG)161 TEST_F(ImageTest, EmptyImageToPNG) {
162 gfx::Image image;
163 scoped_refptr<base::RefCountedMemory> png_bytes = image.As1xPNGBytes();
164 EXPECT_TRUE(png_bytes.get());
165 EXPECT_FALSE(png_bytes->size());
166 }
167
168 // Check that getting the 1x PNG bytes from images which do not have a 1x
169 // representation returns NULL.
TEST_F(ImageTest,ImageNo1xToPNG)170 TEST_F(ImageTest, ImageNo1xToPNG) {
171 // Image with 2x only.
172 const int kSize2x = 50;
173 gfx::ImageSkia image_skia;
174 image_skia.AddRepresentation(gfx::ImageSkiaRep(gt::CreateBitmap(
175 kSize2x, kSize2x), 2.0f));
176 gfx::Image image1(image_skia);
177 scoped_refptr<base::RefCountedMemory> png_bytes1 = image1.As1xPNGBytes();
178 EXPECT_TRUE(png_bytes1.get());
179 EXPECT_FALSE(png_bytes1->size());
180
181 std::vector<gfx::ImagePNGRep> image_png_reps;
182 image_png_reps.push_back(gfx::ImagePNGRep(
183 gt::CreatePNGBytes(kSize2x), 2.0f));
184 gfx::Image image2(image_png_reps);
185 EXPECT_FALSE(image2.IsEmpty());
186 EXPECT_EQ(0, image2.Width());
187 EXPECT_EQ(0, image2.Height());
188 scoped_refptr<base::RefCountedMemory> png_bytes2 = image2.As1xPNGBytes();
189 EXPECT_TRUE(png_bytes2.get());
190 EXPECT_FALSE(png_bytes2->size());
191 }
192
193 // Check that for an image initialized with multi resolution PNG data,
194 // As1xPNGBytes() returns the 1x bytes.
TEST_F(ImageTest,CreateExtractPNGBytes)195 TEST_F(ImageTest, CreateExtractPNGBytes) {
196 const int kSize1x = 25;
197 const int kSize2x = 50;
198
199 scoped_refptr<base::RefCountedMemory> bytes1x = gt::CreatePNGBytes(kSize1x);
200 std::vector<gfx::ImagePNGRep> image_png_reps;
201 image_png_reps.push_back(gfx::ImagePNGRep(bytes1x, 1.0f));
202 image_png_reps.push_back(gfx::ImagePNGRep(
203 gt::CreatePNGBytes(kSize2x), 2.0f));
204
205 gfx::Image image(image_png_reps);
206 EXPECT_FALSE(image.IsEmpty());
207 EXPECT_EQ(25, image.Width());
208 EXPECT_EQ(25, image.Height());
209
210 EXPECT_TRUE(std::equal(bytes1x->front(), bytes1x->front() + bytes1x->size(),
211 image.As1xPNGBytes()->front()));
212 }
213
TEST_F(ImageTest,MultiResolutionImageSkiaToPNG)214 TEST_F(ImageTest, MultiResolutionImageSkiaToPNG) {
215 const int kSize1x = 25;
216 const int kSize2x = 50;
217
218 SkBitmap bitmap_1x = gt::CreateBitmap(kSize1x, kSize1x);
219 gfx::ImageSkia image_skia;
220 image_skia.AddRepresentation(gfx::ImageSkiaRep(bitmap_1x,
221 1.0f));
222 image_skia.AddRepresentation(gfx::ImageSkiaRep(gt::CreateBitmap(
223 kSize2x, kSize2x), 2.0f));
224 gfx::Image image(image_skia);
225
226 EXPECT_TRUE(gt::IsEqual(image.As1xPNGBytes(), bitmap_1x));
227 EXPECT_TRUE(image.HasRepresentation(gfx::Image::kImageRepPNG));
228 }
229
TEST_F(ImageTest,MultiResolutionPNGToImageSkia)230 TEST_F(ImageTest, MultiResolutionPNGToImageSkia) {
231 const int kSize1x = 25;
232 const int kSize2x = 50;
233
234 scoped_refptr<base::RefCountedMemory> bytes1x = gt::CreatePNGBytes(kSize1x);
235 scoped_refptr<base::RefCountedMemory> bytes2x = gt::CreatePNGBytes(kSize2x);
236
237 std::vector<gfx::ImagePNGRep> image_png_reps;
238 image_png_reps.push_back(gfx::ImagePNGRep(bytes1x, 1.0f));
239 image_png_reps.push_back(gfx::ImagePNGRep(bytes2x, 2.0f));
240 gfx::Image image(image_png_reps);
241
242 std::vector<float> scales;
243 scales.push_back(1.0f);
244 scales.push_back(2.0f);
245 gfx::ImageSkia image_skia = image.AsImageSkia();
246 EXPECT_TRUE(gt::IsEqual(bytes1x,
247 image_skia.GetRepresentation(1.0f).sk_bitmap()));
248 EXPECT_TRUE(gt::IsEqual(bytes2x,
249 image_skia.GetRepresentation(2.0f).sk_bitmap()));
250 EXPECT_TRUE(gt::ImageSkiaStructureMatches(image_skia, kSize1x, kSize1x,
251 scales));
252 #if !defined(OS_IOS)
253 // IOS does not support arbitrary scale factors.
254 gfx::ImageSkiaRep rep_1_6x = image_skia.GetRepresentation(1.6f);
255 ASSERT_FALSE(rep_1_6x.is_null());
256 ASSERT_EQ(1.6f, rep_1_6x.scale());
257 EXPECT_EQ("40x40", rep_1_6x.pixel_size().ToString());
258
259 gfx::ImageSkiaRep rep_0_8x = image_skia.GetRepresentation(0.8f);
260 ASSERT_FALSE(rep_0_8x.is_null());
261 ASSERT_EQ(0.8f, rep_0_8x.scale());
262 EXPECT_EQ("20x20", rep_0_8x.pixel_size().ToString());
263 #endif
264 }
265
TEST_F(ImageTest,MultiResolutionPNGToPlatform)266 TEST_F(ImageTest, MultiResolutionPNGToPlatform) {
267 const int kSize1x = 25;
268 const int kSize2x = 50;
269
270 scoped_refptr<base::RefCountedMemory> bytes1x = gt::CreatePNGBytes(kSize1x);
271 scoped_refptr<base::RefCountedMemory> bytes2x = gt::CreatePNGBytes(kSize2x);
272 std::vector<gfx::ImagePNGRep> image_png_reps;
273 image_png_reps.push_back(gfx::ImagePNGRep(bytes1x, 1.0f));
274 image_png_reps.push_back(gfx::ImagePNGRep(bytes2x, 2.0f));
275
276 gfx::Image from_png(image_png_reps);
277 gfx::Image from_platform(gt::CopyPlatformType(from_png));
278 #if defined(OS_IOS)
279 // On iOS the platform type (UIImage) only supports one resolution.
280 std::vector<float> scales = gfx::ImageSkia::GetSupportedScales();
281 EXPECT_EQ(scales.size(), 1U);
282 if (scales[0] == 1.0f)
283 EXPECT_TRUE(gt::IsEqual(bytes1x, from_platform.AsBitmap()));
284 else if (scales[0] == 2.0f)
285 EXPECT_TRUE(gt::IsEqual(bytes2x, from_platform.AsBitmap()));
286 else
287 ADD_FAILURE() << "Unexpected platform scale factor.";
288 #else
289 EXPECT_TRUE(gt::IsEqual(bytes1x, from_platform.AsBitmap()));
290 #endif // defined(OS_IOS)
291 }
292
293
TEST_F(ImageTest,PlatformToPNGEncodeAndDecode)294 TEST_F(ImageTest, PlatformToPNGEncodeAndDecode) {
295 gfx::Image image(gt::CreatePlatformImage());
296 scoped_refptr<base::RefCountedMemory> png_data = image.As1xPNGBytes();
297 EXPECT_TRUE(png_data.get());
298 EXPECT_TRUE(png_data->size());
299 EXPECT_TRUE(image.HasRepresentation(gfx::Image::kImageRepPNG));
300
301 std::vector<gfx::ImagePNGRep> image_png_reps;
302 image_png_reps.push_back(gfx::ImagePNGRep(png_data, 1.0f));
303 gfx::Image from_png(image_png_reps);
304
305 EXPECT_TRUE(from_png.HasRepresentation(gfx::Image::kImageRepPNG));
306 EXPECT_TRUE(gt::IsPlatformImageValid(gt::ToPlatformType(from_png)));
307 }
308
309 // The platform types use the platform provided encoding/decoding of PNGs. Make
310 // sure these work with the Skia Encode/Decode.
TEST_F(ImageTest,PNGEncodeFromSkiaDecodeToPlatform)311 TEST_F(ImageTest, PNGEncodeFromSkiaDecodeToPlatform) {
312 // Force the conversion sequence skia to png to platform_type.
313 gfx::Image from_bitmap = gfx::Image::CreateFrom1xBitmap(
314 gt::CreateBitmap(25, 25));
315 scoped_refptr<base::RefCountedMemory> png_bytes =
316 from_bitmap.As1xPNGBytes();
317
318 std::vector<gfx::ImagePNGRep> image_png_reps;
319 image_png_reps.push_back(gfx::ImagePNGRep(png_bytes, 1.0f));
320 gfx::Image from_png(image_png_reps);
321
322 gfx::Image from_platform(gt::CopyPlatformType(from_png));
323
324 EXPECT_TRUE(gt::IsPlatformImageValid(gt::ToPlatformType(from_platform)));
325 EXPECT_TRUE(gt::IsEqual(png_bytes, from_platform.AsBitmap()));
326 }
327
TEST_F(ImageTest,PNGEncodeFromPlatformDecodeToSkia)328 TEST_F(ImageTest, PNGEncodeFromPlatformDecodeToSkia) {
329 // Force the conversion sequence platform_type to png to skia.
330 gfx::Image from_platform(gt::CreatePlatformImage());
331 scoped_refptr<base::RefCountedMemory> png_bytes =
332 from_platform.As1xPNGBytes();
333 std::vector<gfx::ImagePNGRep> image_png_reps;
334 image_png_reps.push_back(gfx::ImagePNGRep(png_bytes, 1.0f));
335 gfx::Image from_png(image_png_reps);
336
337 EXPECT_TRUE(gt::IsEqual(from_platform.AsBitmap(), from_png.AsBitmap()));
338 }
339
TEST_F(ImageTest,PNGDecodeToSkiaFailure)340 TEST_F(ImageTest, PNGDecodeToSkiaFailure) {
341 scoped_refptr<base::RefCountedBytes> invalid_bytes(
342 new base::RefCountedBytes());
343 invalid_bytes->data().push_back('0');
344 std::vector<gfx::ImagePNGRep> image_png_reps;
345 image_png_reps.push_back(gfx::ImagePNGRep(
346 invalid_bytes, 1.0f));
347 gfx::Image image(image_png_reps);
348 gt::CheckImageIndicatesPNGDecodeFailure(image);
349 }
350
TEST_F(ImageTest,PNGDecodeToPlatformFailure)351 TEST_F(ImageTest, PNGDecodeToPlatformFailure) {
352 scoped_refptr<base::RefCountedBytes> invalid_bytes(
353 new base::RefCountedBytes());
354 invalid_bytes->data().push_back('0');
355 std::vector<gfx::ImagePNGRep> image_png_reps;
356 image_png_reps.push_back(gfx::ImagePNGRep(
357 invalid_bytes, 1.0f));
358 gfx::Image from_png(image_png_reps);
359 gfx::Image from_platform(gt::CopyPlatformType(from_png));
360 gt::CheckImageIndicatesPNGDecodeFailure(from_platform);
361 }
362
TEST_F(ImageTest,SkiaToPlatform)363 TEST_F(ImageTest, SkiaToPlatform) {
364 gfx::Image image(gt::CreateImageSkia(25, 25));
365 EXPECT_EQ(25, image.Width());
366 EXPECT_EQ(25, image.Height());
367 const size_t kRepCount = kUsesSkiaNatively ? 1U : 2U;
368
369 EXPECT_TRUE(image.HasRepresentation(gfx::Image::kImageRepSkia));
370 if (!kUsesSkiaNatively)
371 EXPECT_FALSE(image.HasRepresentation(gt::GetPlatformRepresentationType()));
372
373 EXPECT_TRUE(gt::IsPlatformImageValid(gt::ToPlatformType(image)));
374 EXPECT_EQ(kRepCount, image.RepresentationCount());
375
376 const SkBitmap* bitmap = image.ToSkBitmap();
377 EXPECT_FALSE(bitmap->isNull());
378 EXPECT_EQ(kRepCount, image.RepresentationCount());
379
380 EXPECT_TRUE(image.HasRepresentation(gfx::Image::kImageRepSkia));
381 EXPECT_TRUE(image.HasRepresentation(gt::GetPlatformRepresentationType()));
382 EXPECT_EQ(25, image.Width());
383 EXPECT_EQ(25, image.Height());
384 }
385
TEST_F(ImageTest,PlatformToSkia)386 TEST_F(ImageTest, PlatformToSkia) {
387 gfx::Image image(gt::CreatePlatformImage());
388 EXPECT_EQ(25, image.Width());
389 EXPECT_EQ(25, image.Height());
390 const size_t kRepCount = kUsesSkiaNatively ? 1U : 2U;
391
392 EXPECT_TRUE(image.HasRepresentation(gt::GetPlatformRepresentationType()));
393 if (!kUsesSkiaNatively)
394 EXPECT_FALSE(image.HasRepresentation(gfx::Image::kImageRepSkia));
395
396 const SkBitmap* bitmap = image.ToSkBitmap();
397 EXPECT_TRUE(bitmap);
398 EXPECT_FALSE(bitmap->isNull());
399 EXPECT_EQ(kRepCount, image.RepresentationCount());
400
401 EXPECT_TRUE(gt::IsPlatformImageValid(gt::ToPlatformType(image)));
402 EXPECT_EQ(kRepCount, image.RepresentationCount());
403
404 EXPECT_TRUE(image.HasRepresentation(gfx::Image::kImageRepSkia));
405 EXPECT_EQ(25, image.Width());
406 EXPECT_EQ(25, image.Height());
407 }
408
TEST_F(ImageTest,PlatformToPlatform)409 TEST_F(ImageTest, PlatformToPlatform) {
410 gfx::Image image(gt::CreatePlatformImage());
411 EXPECT_EQ(25, image.Width());
412 EXPECT_EQ(25, image.Height());
413 EXPECT_TRUE(gt::IsPlatformImageValid(gt::ToPlatformType(image)));
414 EXPECT_EQ(1U, image.RepresentationCount());
415
416 // Make sure double conversion doesn't happen.
417 EXPECT_TRUE(gt::IsPlatformImageValid(gt::ToPlatformType(image)));
418 EXPECT_EQ(1U, image.RepresentationCount());
419
420 EXPECT_TRUE(image.HasRepresentation(gt::GetPlatformRepresentationType()));
421 if (!kUsesSkiaNatively)
422 EXPECT_FALSE(image.HasRepresentation(gfx::Image::kImageRepSkia));
423 EXPECT_EQ(25, image.Width());
424 EXPECT_EQ(25, image.Height());
425 }
426
TEST_F(ImageTest,PlatformToSkiaToCopy)427 TEST_F(ImageTest, PlatformToSkiaToCopy) {
428 const gfx::ImageSkia* image_skia = NULL;
429 {
430 gfx::Image image(gt::CreatePlatformImage());
431 image_skia = image.CopyImageSkia();
432 }
433 EXPECT_TRUE(image_skia);
434 EXPECT_FALSE(image_skia->isNull());
435 delete image_skia;
436
437 const SkBitmap* bitmap = NULL;
438 {
439 gfx::Image image(gt::CreatePlatformImage());
440 bitmap = image.CopySkBitmap();
441 }
442
443 EXPECT_TRUE(bitmap);
444 EXPECT_FALSE(bitmap->isNull());
445 delete bitmap;
446 }
447
448 #if defined(OS_IOS)
TEST_F(ImageTest,SkiaToCocoaTouchCopy)449 TEST_F(ImageTest, SkiaToCocoaTouchCopy) {
450 UIImage* ui_image;
451
452 {
453 gfx::Image image(gt::CreateImageSkia(25, 25));
454 ui_image = image.CopyUIImage();
455 }
456
457 EXPECT_TRUE(ui_image);
458 base::mac::NSObjectRelease(ui_image);
459 }
460 #elif defined(OS_MACOSX)
TEST_F(ImageTest,SkiaToCocoaCopy)461 TEST_F(ImageTest, SkiaToCocoaCopy) {
462 NSImage* ns_image;
463
464 {
465 gfx::Image image(gt::CreateImageSkia(25, 25));
466 ns_image = image.CopyNSImage();
467 }
468
469 EXPECT_TRUE(ns_image);
470 base::mac::NSObjectRelease(ns_image);
471 }
472 #endif
473
TEST_F(ImageTest,CheckSkiaColor)474 TEST_F(ImageTest, CheckSkiaColor) {
475 gfx::Image image(gt::CreatePlatformImage());
476
477 const SkBitmap* bitmap = image.ToSkBitmap();
478 SkAutoLockPixels auto_lock(*bitmap);
479 gt::CheckColors(bitmap->getColor(10, 10), SK_ColorGREEN);
480 }
481
TEST_F(ImageTest,SkBitmapConversionPreservesOrientation)482 TEST_F(ImageTest, SkBitmapConversionPreservesOrientation) {
483 const int width = 50;
484 const int height = 50;
485 SkBitmap bitmap;
486 bitmap.allocN32Pixels(width, height);
487 bitmap.eraseARGB(255, 0, 255, 0);
488
489 // Paint the upper half of the image in red (lower half is in green).
490 SkCanvas canvas(bitmap);
491 SkPaint red;
492 red.setColor(SK_ColorRED);
493 canvas.drawRect(SkRect::MakeWH(width, height / 2), red);
494 {
495 SCOPED_TRACE("Checking color of the initial SkBitmap");
496 gt::CheckColors(bitmap.getColor(10, 10), SK_ColorRED);
497 gt::CheckColors(bitmap.getColor(10, 40), SK_ColorGREEN);
498 }
499
500 // Convert from SkBitmap to a platform representation, then check the upper
501 // half of the platform image to make sure it is red, not green.
502 gfx::Image from_skbitmap = gfx::Image::CreateFrom1xBitmap(bitmap);
503 {
504 SCOPED_TRACE("Checking color of the platform image");
505 gt::CheckColors(
506 gt::GetPlatformImageColor(gt::ToPlatformType(from_skbitmap), 10, 10),
507 SK_ColorRED);
508 gt::CheckColors(
509 gt::GetPlatformImageColor(gt::ToPlatformType(from_skbitmap), 10, 40),
510 SK_ColorGREEN);
511 }
512
513 // Force a conversion back to SkBitmap and check that the upper half is red.
514 gfx::Image from_platform(gt::CopyPlatformType(from_skbitmap));
515 const SkBitmap* bitmap2 = from_platform.ToSkBitmap();
516 SkAutoLockPixels auto_lock(*bitmap2);
517 {
518 SCOPED_TRACE("Checking color after conversion back to SkBitmap");
519 gt::CheckColors(bitmap2->getColor(10, 10), SK_ColorRED);
520 gt::CheckColors(bitmap2->getColor(10, 40), SK_ColorGREEN);
521 }
522 }
523
TEST_F(ImageTest,SkBitmapConversionPreservesTransparency)524 TEST_F(ImageTest, SkBitmapConversionPreservesTransparency) {
525 const int width = 50;
526 const int height = 50;
527 SkBitmap bitmap;
528 bitmap.allocN32Pixels(width, height);
529 bitmap.eraseARGB(0, 0, 255, 0);
530
531 // Paint the upper half of the image in red (lower half is transparent).
532 SkCanvas canvas(bitmap);
533 SkPaint red;
534 red.setColor(SK_ColorRED);
535 canvas.drawRect(SkRect::MakeWH(width, height / 2), red);
536 {
537 SCOPED_TRACE("Checking color of the initial SkBitmap");
538 gt::CheckColors(bitmap.getColor(10, 10), SK_ColorRED);
539 gt::CheckIsTransparent(bitmap.getColor(10, 40));
540 }
541
542 // Convert from SkBitmap to a platform representation, then check the upper
543 // half of the platform image to make sure it is red, not green.
544 gfx::Image from_skbitmap = gfx::Image::CreateFrom1xBitmap(bitmap);
545 {
546 SCOPED_TRACE("Checking color of the platform image");
547 gt::CheckColors(
548 gt::GetPlatformImageColor(gt::ToPlatformType(from_skbitmap), 10, 10),
549 SK_ColorRED);
550 gt::CheckIsTransparent(
551 gt::GetPlatformImageColor(gt::ToPlatformType(from_skbitmap), 10, 40));
552 }
553
554 // Force a conversion back to SkBitmap and check that the upper half is red.
555 gfx::Image from_platform(gt::CopyPlatformType(from_skbitmap));
556 const SkBitmap* bitmap2 = from_platform.ToSkBitmap();
557 SkAutoLockPixels auto_lock(*bitmap2);
558 {
559 SCOPED_TRACE("Checking color after conversion back to SkBitmap");
560 gt::CheckColors(bitmap2->getColor(10, 10), SK_ColorRED);
561 gt::CheckIsTransparent(bitmap.getColor(10, 40));
562 }
563 }
564
TEST_F(ImageTest,SwapRepresentations)565 TEST_F(ImageTest, SwapRepresentations) {
566 const size_t kRepCount = kUsesSkiaNatively ? 1U : 2U;
567
568 gfx::Image image1(gt::CreateImageSkia(25, 25));
569 const gfx::ImageSkia* image_skia1 = image1.ToImageSkia();
570 EXPECT_EQ(1U, image1.RepresentationCount());
571
572 gfx::Image image2(gt::CreatePlatformImage());
573 const gfx::ImageSkia* image_skia2 = image2.ToImageSkia();
574 gt::PlatformImage platform_image = gt::ToPlatformType(image2);
575 EXPECT_EQ(kRepCount, image2.RepresentationCount());
576
577 image1.SwapRepresentations(&image2);
578
579 EXPECT_EQ(image_skia2, image1.ToImageSkia());
580 EXPECT_TRUE(gt::PlatformImagesEqual(platform_image,
581 gt::ToPlatformType(image1)));
582 EXPECT_EQ(image_skia1, image2.ToImageSkia());
583 EXPECT_EQ(kRepCount, image1.RepresentationCount());
584 EXPECT_EQ(1U, image2.RepresentationCount());
585 }
586
TEST_F(ImageTest,Copy)587 TEST_F(ImageTest, Copy) {
588 const size_t kRepCount = kUsesSkiaNatively ? 1U : 2U;
589
590 gfx::Image image1(gt::CreateImageSkia(25, 25));
591 EXPECT_EQ(25, image1.Width());
592 EXPECT_EQ(25, image1.Height());
593 gfx::Image image2(image1);
594 EXPECT_EQ(25, image2.Width());
595 EXPECT_EQ(25, image2.Height());
596
597 EXPECT_EQ(1U, image1.RepresentationCount());
598 EXPECT_EQ(1U, image2.RepresentationCount());
599 EXPECT_EQ(image1.ToImageSkia(), image2.ToImageSkia());
600
601 EXPECT_TRUE(gt::IsPlatformImageValid(gt::ToPlatformType(image2)));
602 EXPECT_EQ(kRepCount, image2.RepresentationCount());
603 EXPECT_EQ(kRepCount, image1.RepresentationCount());
604 }
605
TEST_F(ImageTest,Assign)606 TEST_F(ImageTest, Assign) {
607 gfx::Image image1(gt::CreatePlatformImage());
608 EXPECT_EQ(25, image1.Width());
609 EXPECT_EQ(25, image1.Height());
610 // Assignment must be on a separate line to the declaration in order to test
611 // assignment operator (instead of copy constructor).
612 gfx::Image image2;
613 image2 = image1;
614 EXPECT_EQ(25, image2.Width());
615 EXPECT_EQ(25, image2.Height());
616
617 EXPECT_EQ(1U, image1.RepresentationCount());
618 EXPECT_EQ(1U, image2.RepresentationCount());
619 EXPECT_EQ(image1.ToSkBitmap(), image2.ToSkBitmap());
620 }
621
TEST_F(ImageTest,MultiResolutionImageSkia)622 TEST_F(ImageTest, MultiResolutionImageSkia) {
623 const int kWidth1x = 10;
624 const int kHeight1x = 12;
625 const int kWidth2x = 20;
626 const int kHeight2x = 24;
627
628 gfx::ImageSkia image_skia;
629 image_skia.AddRepresentation(gfx::ImageSkiaRep(
630 gt::CreateBitmap(kWidth1x, kHeight1x),
631 1.0f));
632 image_skia.AddRepresentation(gfx::ImageSkiaRep(
633 gt::CreateBitmap(kWidth2x, kHeight2x),
634 2.0f));
635
636 std::vector<float> scales;
637 scales.push_back(1.0f);
638 scales.push_back(2.0f);
639 EXPECT_TRUE(gt::ImageSkiaStructureMatches(image_skia, kWidth1x, kHeight1x,
640 scales));
641
642 // Check that the image has a single representation.
643 gfx::Image image(image_skia);
644 EXPECT_EQ(1u, image.RepresentationCount());
645 EXPECT_EQ(kWidth1x, image.Width());
646 EXPECT_EQ(kHeight1x, image.Height());
647 }
648
TEST_F(ImageTest,RemoveFromMultiResolutionImageSkia)649 TEST_F(ImageTest, RemoveFromMultiResolutionImageSkia) {
650 const int kWidth2x = 20;
651 const int kHeight2x = 24;
652
653 gfx::ImageSkia image_skia;
654
655 image_skia.AddRepresentation(gfx::ImageSkiaRep(
656 gt::CreateBitmap(kWidth2x, kHeight2x), 2.0f));
657 EXPECT_EQ(1u, image_skia.image_reps().size());
658
659 image_skia.RemoveRepresentation(1.0f);
660 EXPECT_EQ(1u, image_skia.image_reps().size());
661
662 image_skia.RemoveRepresentation(2.0f);
663 EXPECT_EQ(0u, image_skia.image_reps().size());
664 }
665
666 // Tests that gfx::Image does indeed take ownership of the SkBitmap it is
667 // passed.
TEST_F(ImageTest,OwnershipTest)668 TEST_F(ImageTest, OwnershipTest) {
669 gfx::Image image;
670 {
671 SkBitmap bitmap(gt::CreateBitmap(10, 10));
672 EXPECT_TRUE(!bitmap.isNull());
673 image = gfx::Image(gfx::ImageSkia(
674 gfx::ImageSkiaRep(bitmap, 1.0f)));
675 }
676 EXPECT_TRUE(!image.ToSkBitmap()->isNull());
677 }
678
679 // Integration tests with UI toolkit frameworks require linking against the
680 // Views library and cannot be here (ui_unittests doesn't include it). They
681 // instead live in /chrome/browser/ui/tests/ui_gfx_image_unittest.cc.
682
683 } // namespace
684