Home | History | Annotate | Download | only in gfx 
      1 // Copyright (c) 2011 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 "ui/gfx/icon_util.h"
      6 
      7 #include "base/files/file_util.h"
      8 #include "base/files/scoped_temp_dir.h"
      9 #include "base/memory/scoped_ptr.h"
     10 #include "base/path_service.h"
     11 #include "testing/gtest/include/gtest/gtest.h"
     12 #include "third_party/skia/include/core/SkBitmap.h"
     13 #include "ui/gfx/gfx_paths.h"
     14 #include "ui/gfx/icon_util_unittests_resource.h"
     15 #include "ui/gfx/image/image.h"
     16 #include "ui/gfx/image/image_family.h"
     17 #include "ui/gfx/size.h"
     18 
     19 namespace {
     20 
     21 static const char kSmallIconName[] = "icon_util/16_X_16_icon.ico";
     22 static const char kLargeIconName[] = "icon_util/128_X_128_icon.ico";
     23 static const char kTempIconFilename[] = "temp_test_icon.ico";
     24 
     25 }  // namespace
     26 
     27 class IconUtilTest : public testing::Test {
     28  public:
     29   virtual void SetUp() OVERRIDE {
     30     gfx::RegisterPathProvider();
     31     ASSERT_TRUE(PathService::Get(gfx::DIR_TEST_DATA, &test_data_directory_));
     32     temp_directory_.CreateUniqueTempDir();
     33   }
     34 
     35   static const int kSmallIconWidth = 16;
     36   static const int kSmallIconHeight = 16;
     37   static const int kLargeIconWidth = 128;
     38   static const int kLargeIconHeight = 128;
     39 
     40   // Given a file name for an .ico file and an image dimensions, this
     41   // function loads the icon and returns an HICON handle.
     42   HICON LoadIconFromFile(const base::FilePath& filename,
     43                          int width, int height) {
     44     HICON icon = static_cast<HICON>(LoadImage(NULL,
     45                                     filename.value().c_str(),
     46                                     IMAGE_ICON,
     47                                     width,
     48                                     height,
     49                                     LR_LOADTRANSPARENT | LR_LOADFROMFILE));
     50     return icon;
     51   }
     52 
     53   SkBitmap CreateBlackSkBitmap(int width, int height) {
     54     SkBitmap bitmap;
     55     bitmap.allocN32Pixels(width, height);
     56     // Setting the pixels to transparent-black.
     57     memset(bitmap.getPixels(), 0, width * height * 4);
     58     return bitmap;
     59   }
     60 
     61   // Loads an .ico file from |icon_filename| and asserts that it contains all of
     62   // the expected icon sizes up to and including |max_icon_size|, and no other
     63   // icons. If |max_icon_size| >= 256, this tests for a 256x256 PNG icon entry.
     64   void CheckAllIconSizes(const base::FilePath& icon_filename,
     65                          int max_icon_size);
     66 
     67  protected:
     68   // The root directory for test files. This should be treated as read-only.
     69   base::FilePath test_data_directory_;
     70 
     71   // Directory for creating files by this test.
     72   base::ScopedTempDir temp_directory_;
     73 };
     74 
     75 void IconUtilTest::CheckAllIconSizes(const base::FilePath& icon_filename,
     76                                      int max_icon_size) {
     77   ASSERT_TRUE(base::PathExists(icon_filename));
     78 
     79   // Determine how many icons to expect, based on |max_icon_size|.
     80   int expected_num_icons = 0;
     81   for (size_t i = 0; i < IconUtil::kNumIconDimensions; ++i) {
     82     if (IconUtil::kIconDimensions[i] > max_icon_size)
     83       break;
     84     ++expected_num_icons;
     85   }
     86 
     87   // First, use the Windows API to load the icon, a basic validity test.
     88   HICON icon = LoadIconFromFile(icon_filename, kSmallIconWidth,
     89                                 kSmallIconHeight);
     90   EXPECT_NE(static_cast<HICON>(NULL), icon);
     91   if (icon != NULL)
     92     ::DestroyIcon(icon);
     93 
     94   // Read the file completely into memory.
     95   std::string icon_data;
     96   ASSERT_TRUE(base::ReadFileToString(icon_filename, &icon_data));
     97   ASSERT_GE(icon_data.length(), sizeof(IconUtil::ICONDIR));
     98 
     99   // Ensure that it has exactly the expected number and sizes of icons, in the
    100   // expected order. This matches each entry of the loaded file's icon directory
    101   // with the corresponding element of kIconDimensions.
    102   // Also extracts the 256x256 entry as png_entry.
    103   const IconUtil::ICONDIR* icon_dir =
    104       reinterpret_cast<const IconUtil::ICONDIR*>(icon_data.data());
    105   EXPECT_EQ(expected_num_icons, icon_dir->idCount);
    106   ASSERT_GE(IconUtil::kNumIconDimensions, icon_dir->idCount);
    107   ASSERT_GE(icon_data.length(),
    108             sizeof(IconUtil::ICONDIR) +
    109                 icon_dir->idCount * sizeof(IconUtil::ICONDIRENTRY));
    110   const IconUtil::ICONDIRENTRY* png_entry = NULL;
    111   for (size_t i = 0; i < icon_dir->idCount; ++i) {
    112     const IconUtil::ICONDIRENTRY* entry = &icon_dir->idEntries[i];
    113     // Mod 256 because as a special case in ICONDIRENTRY, the value 0 represents
    114     // a width or height of 256.
    115     int expected_size = IconUtil::kIconDimensions[i] % 256;
    116     EXPECT_EQ(expected_size, static_cast<int>(entry->bWidth));
    117     EXPECT_EQ(expected_size, static_cast<int>(entry->bHeight));
    118     if (entry->bWidth == 0 && entry->bHeight == 0) {
    119       EXPECT_EQ(NULL, png_entry);
    120       png_entry = entry;
    121     }
    122   }
    123 
    124   if (max_icon_size >= 256) {
    125     ASSERT_TRUE(png_entry);
    126 
    127     // Convert the PNG entry data back to a SkBitmap to ensure it's valid.
    128     ASSERT_GE(icon_data.length(),
    129               png_entry->dwImageOffset + png_entry->dwBytesInRes);
    130     const unsigned char* png_bytes = reinterpret_cast<const unsigned char*>(
    131         icon_data.data() + png_entry->dwImageOffset);
    132     gfx::Image image = gfx::Image::CreateFrom1xPNGBytes(
    133         png_bytes, png_entry->dwBytesInRes);
    134     SkBitmap bitmap = image.AsBitmap();
    135     EXPECT_EQ(256, bitmap.width());
    136     EXPECT_EQ(256, bitmap.height());
    137   }
    138 }
    139 
    140 // The following test case makes sure IconUtil::SkBitmapFromHICON fails
    141 // gracefully when called with invalid input parameters.
    142 TEST_F(IconUtilTest, TestIconToBitmapInvalidParameters) {
    143   base::FilePath icon_filename =
    144       test_data_directory_.AppendASCII(kSmallIconName);
    145   gfx::Size icon_size(kSmallIconWidth, kSmallIconHeight);
    146   HICON icon = LoadIconFromFile(icon_filename,
    147                                 icon_size.width(),
    148                                 icon_size.height());
    149   ASSERT_TRUE(icon != NULL);
    150 
    151   // Invalid size parameter.
    152   gfx::Size invalid_icon_size(kSmallIconHeight, 0);
    153   EXPECT_EQ(IconUtil::CreateSkBitmapFromHICON(icon, invalid_icon_size),
    154             static_cast<SkBitmap*>(NULL));
    155 
    156   // Invalid icon.
    157   EXPECT_EQ(IconUtil::CreateSkBitmapFromHICON(NULL, icon_size),
    158             static_cast<SkBitmap*>(NULL));
    159 
    160   // The following code should succeed.
    161   scoped_ptr<SkBitmap> bitmap;
    162   bitmap.reset(IconUtil::CreateSkBitmapFromHICON(icon, icon_size));
    163   EXPECT_NE(bitmap.get(), static_cast<SkBitmap*>(NULL));
    164   ::DestroyIcon(icon);
    165 }
    166 
    167 // The following test case makes sure IconUtil::CreateHICONFromSkBitmap fails
    168 // gracefully when called with invalid input parameters.
    169 TEST_F(IconUtilTest, TestBitmapToIconInvalidParameters) {
    170   HICON icon = NULL;
    171   scoped_ptr<SkBitmap> bitmap;
    172 
    173   // Wrong bitmap format.
    174   bitmap.reset(new SkBitmap);
    175   ASSERT_NE(bitmap.get(), static_cast<SkBitmap*>(NULL));
    176   bitmap->setInfo(SkImageInfo::MakeA8(kSmallIconWidth, kSmallIconHeight));
    177   icon = IconUtil::CreateHICONFromSkBitmap(*bitmap);
    178   EXPECT_EQ(icon, static_cast<HICON>(NULL));
    179 
    180   // Invalid bitmap size.
    181   bitmap.reset(new SkBitmap);
    182   ASSERT_NE(bitmap.get(), static_cast<SkBitmap*>(NULL));
    183   bitmap->setInfo(SkImageInfo::MakeN32Premul(0, 0));
    184   icon = IconUtil::CreateHICONFromSkBitmap(*bitmap);
    185   EXPECT_EQ(icon, static_cast<HICON>(NULL));
    186 
    187   // Valid bitmap configuration but no pixels allocated.
    188   bitmap.reset(new SkBitmap);
    189   ASSERT_NE(bitmap.get(), static_cast<SkBitmap*>(NULL));
    190   bitmap->setInfo(SkImageInfo::MakeN32Premul(kSmallIconWidth,
    191                                              kSmallIconHeight));
    192   icon = IconUtil::CreateHICONFromSkBitmap(*bitmap);
    193   EXPECT_TRUE(icon == NULL);
    194 }
    195 
    196 // The following test case makes sure IconUtil::CreateIconFileFromImageFamily
    197 // fails gracefully when called with invalid input parameters.
    198 TEST_F(IconUtilTest, TestCreateIconFileInvalidParameters) {
    199   scoped_ptr<SkBitmap> bitmap;
    200   gfx::ImageFamily image_family;
    201   base::FilePath valid_icon_filename = temp_directory_.path().AppendASCII(
    202       kTempIconFilename);
    203   base::FilePath invalid_icon_filename = temp_directory_.path().AppendASCII(
    204       "<>?.ico");
    205 
    206   // Wrong bitmap format.
    207   bitmap.reset(new SkBitmap);
    208   ASSERT_NE(bitmap.get(), static_cast<SkBitmap*>(NULL));
    209   // Must allocate pixels or else ImageSkia will ignore the bitmap and just
    210   // return an empty image.
    211   bitmap->allocPixels(SkImageInfo::MakeA8(kSmallIconWidth, kSmallIconHeight));
    212   memset(bitmap->getPixels(), 0, bitmap->width() * bitmap->height());
    213   image_family.Add(gfx::Image::CreateFrom1xBitmap(*bitmap));
    214   EXPECT_FALSE(IconUtil::CreateIconFileFromImageFamily(image_family,
    215                                                        valid_icon_filename));
    216   EXPECT_FALSE(base::PathExists(valid_icon_filename));
    217 
    218   // Invalid bitmap size.
    219   image_family.clear();
    220   bitmap.reset(new SkBitmap);
    221   ASSERT_NE(bitmap.get(), static_cast<SkBitmap*>(NULL));
    222   bitmap->allocPixels(SkImageInfo::MakeN32Premul(0, 0));
    223   image_family.Add(gfx::Image::CreateFrom1xBitmap(*bitmap));
    224   EXPECT_FALSE(IconUtil::CreateIconFileFromImageFamily(image_family,
    225                                                        valid_icon_filename));
    226   EXPECT_FALSE(base::PathExists(valid_icon_filename));
    227 
    228   // Bitmap with no allocated pixels.
    229   image_family.clear();
    230   bitmap.reset(new SkBitmap);
    231   ASSERT_NE(bitmap.get(), static_cast<SkBitmap*>(NULL));
    232   bitmap->setInfo(SkImageInfo::MakeN32Premul(kSmallIconWidth,
    233                                              kSmallIconHeight));
    234   image_family.Add(gfx::Image::CreateFrom1xBitmap(*bitmap));
    235   EXPECT_FALSE(IconUtil::CreateIconFileFromImageFamily(image_family,
    236                                                        valid_icon_filename));
    237   EXPECT_FALSE(base::PathExists(valid_icon_filename));
    238 
    239   // Invalid file name.
    240   image_family.clear();
    241   bitmap->allocPixels();
    242   // Setting the pixels to black.
    243   memset(bitmap->getPixels(), 0, bitmap->width() * bitmap->height() * 4);
    244   image_family.Add(gfx::Image::CreateFrom1xBitmap(*bitmap));
    245   EXPECT_FALSE(IconUtil::CreateIconFileFromImageFamily(image_family,
    246                                                        invalid_icon_filename));
    247   EXPECT_FALSE(base::PathExists(invalid_icon_filename));
    248 }
    249 
    250 // This test case makes sure IconUtil::CreateIconFileFromImageFamily fails if
    251 // the image family is empty or invalid.
    252 TEST_F(IconUtilTest, TestCreateIconFileEmptyImageFamily) {
    253   base::FilePath icon_filename = temp_directory_.path().AppendASCII(
    254       kTempIconFilename);
    255 
    256   // Empty image family.
    257   EXPECT_FALSE(IconUtil::CreateIconFileFromImageFamily(gfx::ImageFamily(),
    258                                                        icon_filename));
    259   EXPECT_FALSE(base::PathExists(icon_filename));
    260 
    261   // Image family with only an empty image.
    262   gfx::ImageFamily image_family;
    263   image_family.Add(gfx::Image());
    264   EXPECT_FALSE(IconUtil::CreateIconFileFromImageFamily(image_family,
    265                                                        icon_filename));
    266   EXPECT_FALSE(base::PathExists(icon_filename));
    267 }
    268 
    269 // This test case makes sure that when we load an icon from disk and convert
    270 // the HICON into a bitmap, the bitmap has the expected format and dimensions.
    271 TEST_F(IconUtilTest, TestCreateSkBitmapFromHICON) {
    272   scoped_ptr<SkBitmap> bitmap;
    273   base::FilePath small_icon_filename = test_data_directory_.AppendASCII(
    274       kSmallIconName);
    275   gfx::Size small_icon_size(kSmallIconWidth, kSmallIconHeight);
    276   HICON small_icon = LoadIconFromFile(small_icon_filename,
    277                                       small_icon_size.width(),
    278                                       small_icon_size.height());
    279   ASSERT_NE(small_icon, static_cast<HICON>(NULL));
    280   bitmap.reset(IconUtil::CreateSkBitmapFromHICON(small_icon, small_icon_size));
    281   ASSERT_NE(bitmap.get(), static_cast<SkBitmap*>(NULL));
    282   EXPECT_EQ(bitmap->width(), small_icon_size.width());
    283   EXPECT_EQ(bitmap->height(), small_icon_size.height());
    284   EXPECT_EQ(bitmap->colorType(), kN32_SkColorType);
    285   ::DestroyIcon(small_icon);
    286 
    287   base::FilePath large_icon_filename = test_data_directory_.AppendASCII(
    288       kLargeIconName);
    289   gfx::Size large_icon_size(kLargeIconWidth, kLargeIconHeight);
    290   HICON large_icon = LoadIconFromFile(large_icon_filename,
    291                                       large_icon_size.width(),
    292                                       large_icon_size.height());
    293   ASSERT_NE(large_icon, static_cast<HICON>(NULL));
    294   bitmap.reset(IconUtil::CreateSkBitmapFromHICON(large_icon, large_icon_size));
    295   ASSERT_NE(bitmap.get(), static_cast<SkBitmap*>(NULL));
    296   EXPECT_EQ(bitmap->width(), large_icon_size.width());
    297   EXPECT_EQ(bitmap->height(), large_icon_size.height());
    298   EXPECT_EQ(bitmap->colorType(), kN32_SkColorType);
    299   ::DestroyIcon(large_icon);
    300 }
    301 
    302 // This test case makes sure that when an HICON is created from an SkBitmap,
    303 // the returned handle is valid and refers to an icon with the expected
    304 // dimensions color depth etc.
    305 TEST_F(IconUtilTest, TestBasicCreateHICONFromSkBitmap) {
    306   SkBitmap bitmap = CreateBlackSkBitmap(kSmallIconWidth, kSmallIconHeight);
    307   HICON icon = IconUtil::CreateHICONFromSkBitmap(bitmap);
    308   EXPECT_NE(icon, static_cast<HICON>(NULL));
    309   ICONINFO icon_info;
    310   ASSERT_TRUE(::GetIconInfo(icon, &icon_info));
    311   EXPECT_TRUE(icon_info.fIcon);
    312 
    313   // Now that have the icon information, we should obtain the specification of
    314   // the icon's bitmap and make sure it matches the specification of the
    315   // SkBitmap we started with.
    316   //
    317   // The bitmap handle contained in the icon information is a handle to a
    318   // compatible bitmap so we need to call ::GetDIBits() in order to retrieve
    319   // the bitmap's header information.
    320   BITMAPINFO bitmap_info;
    321   ::ZeroMemory(&bitmap_info, sizeof(BITMAPINFO));
    322   bitmap_info.bmiHeader.biSize = sizeof(BITMAPINFO);
    323   HDC hdc = ::GetDC(NULL);
    324   int result = ::GetDIBits(hdc,
    325                            icon_info.hbmColor,
    326                            0,
    327                            kSmallIconWidth,
    328                            NULL,
    329                            &bitmap_info,
    330                            DIB_RGB_COLORS);
    331   ASSERT_GT(result, 0);
    332   EXPECT_EQ(bitmap_info.bmiHeader.biWidth, kSmallIconWidth);
    333   EXPECT_EQ(bitmap_info.bmiHeader.biHeight, kSmallIconHeight);
    334   EXPECT_EQ(bitmap_info.bmiHeader.biPlanes, 1);
    335   EXPECT_EQ(bitmap_info.bmiHeader.biBitCount, 32);
    336   ::ReleaseDC(NULL, hdc);
    337   ::DestroyIcon(icon);
    338 }
    339 
    340 // This test case makes sure that CreateIconFileFromImageFamily creates a
    341 // valid .ico file given an ImageFamily, and appropriately creates all icon
    342 // sizes from the given input.
    343 TEST_F(IconUtilTest, TestCreateIconFileFromImageFamily) {
    344   gfx::ImageFamily image_family;
    345   base::FilePath icon_filename =
    346       temp_directory_.path().AppendASCII(kTempIconFilename);
    347 
    348   // Test with only a 16x16 icon. Should only scale up to 48x48.
    349   image_family.Add(gfx::Image::CreateFrom1xBitmap(
    350       CreateBlackSkBitmap(kSmallIconWidth, kSmallIconHeight)));
    351   ASSERT_TRUE(IconUtil::CreateIconFileFromImageFamily(image_family,
    352                                                       icon_filename));
    353   CheckAllIconSizes(icon_filename, 48);
    354 
    355   // Test with a 48x48 icon. Should only scale down.
    356   image_family.Add(gfx::Image::CreateFrom1xBitmap(CreateBlackSkBitmap(48, 48)));
    357   ASSERT_TRUE(IconUtil::CreateIconFileFromImageFamily(image_family,
    358                                                       icon_filename));
    359   CheckAllIconSizes(icon_filename, 48);
    360 
    361   // Test with a 64x64 icon. Should scale up to 256x256.
    362   image_family.Add(gfx::Image::CreateFrom1xBitmap(CreateBlackSkBitmap(64, 64)));
    363   ASSERT_TRUE(IconUtil::CreateIconFileFromImageFamily(image_family,
    364                                                       icon_filename));
    365   CheckAllIconSizes(icon_filename, 256);
    366 
    367   // Test with a 256x256 icon. Should include the 256x256 in the output.
    368   image_family.Add(gfx::Image::CreateFrom1xBitmap(
    369       CreateBlackSkBitmap(256, 256)));
    370   ASSERT_TRUE(IconUtil::CreateIconFileFromImageFamily(image_family,
    371                                                       icon_filename));
    372   CheckAllIconSizes(icon_filename, 256);
    373 
    374   // Test with a 49x49 icon. Should scale up to 256x256, but exclude the
    375   // original 49x49 representation from the output.
    376   image_family.clear();
    377   image_family.Add(gfx::Image::CreateFrom1xBitmap(CreateBlackSkBitmap(49, 49)));
    378   ASSERT_TRUE(IconUtil::CreateIconFileFromImageFamily(image_family,
    379                                                       icon_filename));
    380   CheckAllIconSizes(icon_filename, 256);
    381 
    382   // Test with a non-square 16x32 icon. Should scale up to 48, but exclude the
    383   // original 16x32 representation from the output.
    384   image_family.clear();
    385   image_family.Add(gfx::Image::CreateFrom1xBitmap(CreateBlackSkBitmap(16, 32)));
    386   ASSERT_TRUE(IconUtil::CreateIconFileFromImageFamily(image_family,
    387                                                       icon_filename));
    388   CheckAllIconSizes(icon_filename, 48);
    389 
    390   // Test with a non-square 32x49 icon. Should scale up to 256, but exclude the
    391   // original 32x49 representation from the output.
    392   image_family.Add(gfx::Image::CreateFrom1xBitmap(CreateBlackSkBitmap(32, 49)));
    393   ASSERT_TRUE(IconUtil::CreateIconFileFromImageFamily(image_family,
    394                                                       icon_filename));
    395   CheckAllIconSizes(icon_filename, 256);
    396 
    397   // Test with an empty and non-empty image.
    398   // The empty image should be ignored.
    399   image_family.clear();
    400   image_family.Add(gfx::Image());
    401   image_family.Add(gfx::Image::CreateFrom1xBitmap(CreateBlackSkBitmap(16, 16)));
    402   ASSERT_TRUE(IconUtil::CreateIconFileFromImageFamily(image_family,
    403                                                        icon_filename));
    404   CheckAllIconSizes(icon_filename, 48);
    405 }
    406 
    407 TEST_F(IconUtilTest, TestCreateSkBitmapFromIconResource48x48) {
    408   HMODULE module = GetModuleHandle(NULL);
    409   scoped_ptr<SkBitmap> bitmap(
    410       IconUtil::CreateSkBitmapFromIconResource(module, IDR_MAINFRAME, 48));
    411   ASSERT_TRUE(bitmap.get());
    412   EXPECT_EQ(48, bitmap->width());
    413   EXPECT_EQ(48, bitmap->height());
    414 }
    415 
    416 TEST_F(IconUtilTest, TestCreateSkBitmapFromIconResource256x256) {
    417   HMODULE module = GetModuleHandle(NULL);
    418   scoped_ptr<SkBitmap> bitmap(
    419       IconUtil::CreateSkBitmapFromIconResource(module, IDR_MAINFRAME, 256));
    420   ASSERT_TRUE(bitmap.get());
    421   EXPECT_EQ(256, bitmap->width());
    422   EXPECT_EQ(256, bitmap->height());
    423 }
    424 
    425 // This tests that kNumIconDimensionsUpToMediumSize has the correct value.
    426 TEST_F(IconUtilTest, TestNumIconDimensionsUpToMediumSize) {
    427   ASSERT_LE(IconUtil::kNumIconDimensionsUpToMediumSize,
    428             IconUtil::kNumIconDimensions);
    429   EXPECT_EQ(IconUtil::kMediumIconSize,
    430             IconUtil::kIconDimensions[
    431                 IconUtil::kNumIconDimensionsUpToMediumSize - 1]);
    432 }
    433