ui/gfx/image/image_unittest.cc

   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