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: 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 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. 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. 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. 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 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 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. 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. 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 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 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 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 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. 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 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 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 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 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 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 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 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) 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) 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 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 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 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 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 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 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 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 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. 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