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