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