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