Home | History | Annotate | Download | only in gfx
      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 "ui/gfx/icon_util.h"
      6 
      7 #include "base/files/file_util.h"
      8 #include "base/files/important_file_writer.h"
      9 #include "base/logging.h"
     10 #include "base/memory/scoped_ptr.h"
     11 #include "base/win/resource_util.h"
     12 #include "base/win/scoped_gdi_object.h"
     13 #include "base/win/scoped_handle.h"
     14 #include "base/win/scoped_hdc.h"
     15 #include "skia/ext/image_operations.h"
     16 #include "third_party/skia/include/core/SkBitmap.h"
     17 #include "ui/gfx/gdi_util.h"
     18 #include "ui/gfx/image/image.h"
     19 #include "ui/gfx/image/image_family.h"
     20 #include "ui/gfx/size.h"
     21 
     22 namespace {
     23 
     24 struct ScopedICONINFO : ICONINFO {
     25   ScopedICONINFO() {
     26     hbmColor = NULL;
     27     hbmMask = NULL;
     28   }
     29 
     30   ~ScopedICONINFO() {
     31     if (hbmColor)
     32       ::DeleteObject(hbmColor);
     33     if (hbmMask)
     34       ::DeleteObject(hbmMask);
     35   }
     36 };
     37 
     38 // Creates a new ImageFamily, |resized_image_family|, based on the images in
     39 // |image_family|, but containing images of specific dimensions desirable for
     40 // Windows icons. For each desired image dimension, it chooses the most
     41 // appropriate image for that size, and resizes it to the desired size.
     42 // Returns true on success, false on failure. Failure can occur if
     43 // |image_family| is empty, all images in the family have size 0x0, or an image
     44 // has no allocated pixel data.
     45 // |resized_image_family| must be empty.
     46 bool BuildResizedImageFamily(const gfx::ImageFamily& image_family,
     47                              gfx::ImageFamily* resized_image_family) {
     48   DCHECK(resized_image_family);
     49   DCHECK(resized_image_family->empty());
     50 
     51   for (size_t i = 0; i < IconUtil::kNumIconDimensions; ++i) {
     52     int dimension = IconUtil::kIconDimensions[i];
     53     gfx::Size size(dimension, dimension);
     54     const gfx::Image* best = image_family.GetBest(size);
     55     if (!best || best->IsEmpty()) {
     56       // Either |image_family| is empty, or all images have size 0x0.
     57       return false;
     58     }
     59 
     60     // Optimize for the "Large icons" view in Windows Vista+. This view displays
     61     // icons at full size if only if there is a 256x256 (kLargeIconSize) image
     62     // in the .ico file. Otherwise, it shrinks icons to 48x48 (kMediumIconSize).
     63     if (dimension > IconUtil::kMediumIconSize &&
     64         best->Width() <= IconUtil::kMediumIconSize &&
     65         best->Height() <= IconUtil::kMediumIconSize) {
     66       // There is no source icon larger than 48x48, so do not create any
     67       // images larger than 48x48. kIconDimensions is sorted in ascending
     68       // order, so it is safe to break here.
     69       break;
     70     }
     71 
     72     if (best->Size() == size) {
     73       resized_image_family->Add(*best);
     74     } else {
     75       // There is no |dimension|x|dimension| source image.
     76       // Resize this one to the desired size, and insert it.
     77       SkBitmap best_bitmap = best->AsBitmap();
     78       // Only kARGB_8888 images are supported.
     79       // This will also filter out images with no pixels.
     80       if (best_bitmap.colorType() != kN32_SkColorType)
     81         return false;
     82       SkBitmap resized_bitmap = skia::ImageOperations::Resize(
     83           best_bitmap, skia::ImageOperations::RESIZE_LANCZOS3,
     84           dimension, dimension);
     85       resized_image_family->Add(gfx::Image::CreateFrom1xBitmap(resized_bitmap));
     86     }
     87   }
     88   return true;
     89 }
     90 
     91 // Creates a set of bitmaps from an image family.
     92 // All images smaller than 256x256 are converted to SkBitmaps, and inserted into
     93 // |bitmaps| in order of aspect ratio (thinnest to widest), and then ascending
     94 // size order. If an image of exactly 256x256 is specified, it is converted into
     95 // PNG format and stored in |png_bytes|. Images with width or height larger than
     96 // 256 are ignored.
     97 // |bitmaps| must be an empty vector, and not NULL.
     98 // Returns true on success, false on failure. This fails if any image in
     99 // |image_family| is not a 32-bit ARGB image, or is otherwise invalid.
    100 bool ConvertImageFamilyToBitmaps(
    101     const gfx::ImageFamily& image_family,
    102     std::vector<SkBitmap>* bitmaps,
    103     scoped_refptr<base::RefCountedMemory>* png_bytes) {
    104   DCHECK(bitmaps != NULL);
    105   DCHECK(bitmaps->empty());
    106 
    107   for (gfx::ImageFamily::const_iterator it = image_family.begin();
    108        it != image_family.end(); ++it) {
    109     const gfx::Image& image = *it;
    110 
    111     // All images should have one of the kIconDimensions sizes.
    112     DCHECK_GT(image.Width(), 0);
    113     DCHECK_LE(image.Width(), IconUtil::kLargeIconSize);
    114     DCHECK_GT(image.Height(), 0);
    115     DCHECK_LE(image.Height(), IconUtil::kLargeIconSize);
    116 
    117     SkBitmap bitmap = image.AsBitmap();
    118 
    119     // Only 32 bit ARGB bitmaps are supported. We also make sure the bitmap has
    120     // been properly initialized.
    121     SkAutoLockPixels bitmap_lock(bitmap);
    122     if ((bitmap.colorType() != kN32_SkColorType) ||
    123         (bitmap.getPixels() == NULL)) {
    124       return false;
    125     }
    126 
    127     // Special case: Icons exactly 256x256 are stored in PNG format.
    128     if (image.Width() == IconUtil::kLargeIconSize &&
    129         image.Height() == IconUtil::kLargeIconSize) {
    130       *png_bytes = image.As1xPNGBytes();
    131     } else {
    132       bitmaps->push_back(bitmap);
    133     }
    134   }
    135 
    136   return true;
    137 }
    138 
    139 }  // namespace
    140 
    141 // The icon images appear in the icon file in same order in which their
    142 // corresponding dimensions appear in this array, so it is important to keep
    143 // this array sorted. Also note that the maximum icon image size we can handle
    144 // is 256 by 256. See:
    145 // http://msdn.microsoft.com/en-us/library/windows/desktop/aa511280.aspx#size
    146 const int IconUtil::kIconDimensions[] = {
    147   8,    // Recommended by the MSDN as a nice to have icon size.
    148   10,   // Used by the Shell (e.g. for shortcuts).
    149   14,   // Recommended by the MSDN as a nice to have icon size.
    150   16,   // Toolbar, Application and Shell icon sizes.
    151   22,   // Recommended by the MSDN as a nice to have icon size.
    152   24,   // Used by the Shell (e.g. for shortcuts).
    153   32,   // Toolbar, Dialog and Wizard icon size.
    154   40,   // Quick Launch.
    155   48,   // Alt+Tab icon size.
    156   64,   // Recommended by the MSDN as a nice to have icon size.
    157   96,   // Recommended by the MSDN as a nice to have icon size.
    158   128,  // Used by the Shell (e.g. for shortcuts).
    159   256   // Used by Vista onwards for large icons.
    160 };
    161 
    162 const size_t IconUtil::kNumIconDimensions = arraysize(kIconDimensions);
    163 const size_t IconUtil::kNumIconDimensionsUpToMediumSize = 9;
    164 
    165 HICON IconUtil::CreateHICONFromSkBitmap(const SkBitmap& bitmap) {
    166   // Only 32 bit ARGB bitmaps are supported. We also try to perform as many
    167   // validations as we can on the bitmap.
    168   SkAutoLockPixels bitmap_lock(bitmap);
    169   if ((bitmap.colorType() != kN32_SkColorType) ||
    170       (bitmap.width() <= 0) || (bitmap.height() <= 0) ||
    171       (bitmap.getPixels() == NULL))
    172     return NULL;
    173 
    174   // We start by creating a DIB which we'll use later on in order to create
    175   // the HICON. We use BITMAPV5HEADER since the bitmap we are about to convert
    176   // may contain an alpha channel and the V5 header allows us to specify the
    177   // alpha mask for the DIB.
    178   BITMAPV5HEADER bitmap_header;
    179   InitializeBitmapHeader(&bitmap_header, bitmap.width(), bitmap.height());
    180 
    181   void* bits = NULL;
    182   HBITMAP dib;
    183 
    184   {
    185     base::win::ScopedGetDC hdc(NULL);
    186     dib = ::CreateDIBSection(hdc, reinterpret_cast<BITMAPINFO*>(&bitmap_header),
    187                              DIB_RGB_COLORS, &bits, NULL, 0);
    188   }
    189   if (!dib || !bits)
    190     return NULL;
    191 
    192   memcpy(bits, bitmap.getPixels(), bitmap.width() * bitmap.height() * 4);
    193 
    194   // Icons are generally created using an AND and XOR masks where the AND
    195   // specifies boolean transparency (the pixel is either opaque or
    196   // transparent) and the XOR mask contains the actual image pixels. If the XOR
    197   // mask bitmap has an alpha channel, the AND monochrome bitmap won't
    198   // actually be used for computing the pixel transparency. Even though all our
    199   // bitmap has an alpha channel, Windows might not agree when all alpha values
    200   // are zero. So the monochrome bitmap is created with all pixels transparent
    201   // for this case. Otherwise, it is created with all pixels opaque.
    202   bool bitmap_has_alpha_channel = PixelsHaveAlpha(
    203       static_cast<const uint32*>(bitmap.getPixels()),
    204       bitmap.width() * bitmap.height());
    205 
    206   scoped_ptr<uint8[]> mask_bits;
    207   if (!bitmap_has_alpha_channel) {
    208     // Bytes per line with paddings to make it word alignment.
    209     size_t bytes_per_line = (bitmap.width() + 0xF) / 16 * 2;
    210     size_t mask_bits_size = bytes_per_line * bitmap.height();
    211 
    212     mask_bits.reset(new uint8[mask_bits_size]);
    213     DCHECK(mask_bits.get());
    214 
    215     // Make all pixels transparent.
    216     memset(mask_bits.get(), 0xFF, mask_bits_size);
    217   }
    218 
    219   HBITMAP mono_bitmap = ::CreateBitmap(bitmap.width(), bitmap.height(), 1, 1,
    220       reinterpret_cast<LPVOID>(mask_bits.get()));
    221   DCHECK(mono_bitmap);
    222 
    223   ICONINFO icon_info;
    224   icon_info.fIcon = TRUE;
    225   icon_info.xHotspot = 0;
    226   icon_info.yHotspot = 0;
    227   icon_info.hbmMask = mono_bitmap;
    228   icon_info.hbmColor = dib;
    229   HICON icon = ::CreateIconIndirect(&icon_info);
    230   ::DeleteObject(dib);
    231   ::DeleteObject(mono_bitmap);
    232   return icon;
    233 }
    234 
    235 SkBitmap* IconUtil::CreateSkBitmapFromHICON(HICON icon, const gfx::Size& s) {
    236   // We start with validating parameters.
    237   if (!icon || s.IsEmpty())
    238     return NULL;
    239   ScopedICONINFO icon_info;
    240   if (!::GetIconInfo(icon, &icon_info))
    241     return NULL;
    242   if (!icon_info.fIcon)
    243     return NULL;
    244   return new SkBitmap(CreateSkBitmapFromHICONHelper(icon, s));
    245 }
    246 
    247 scoped_ptr<SkBitmap> IconUtil::CreateSkBitmapFromIconResource(HMODULE module,
    248                                                               int resource_id,
    249                                                               int size) {
    250   DCHECK_LE(size, kLargeIconSize);
    251 
    252   // For everything except the Vista+ 256x256 icons, use |LoadImage()|.
    253   if (size != kLargeIconSize) {
    254     HICON icon_handle =
    255         static_cast<HICON>(LoadImage(module, MAKEINTRESOURCE(resource_id),
    256                                      IMAGE_ICON, size, size,
    257                                      LR_DEFAULTCOLOR | LR_DEFAULTSIZE));
    258     scoped_ptr<SkBitmap> bitmap(IconUtil::CreateSkBitmapFromHICON(icon_handle));
    259     DestroyIcon(icon_handle);
    260     return bitmap.Pass();
    261   }
    262 
    263   // For Vista+ 256x256 PNG icons, read the resource directly and find
    264   // the corresponding icon entry to get its PNG bytes.
    265   void* icon_dir_data = NULL;
    266   size_t icon_dir_size = 0;
    267   if (!base::win::GetResourceFromModule(module, resource_id, RT_GROUP_ICON,
    268                                         &icon_dir_data, &icon_dir_size)) {
    269     return scoped_ptr<SkBitmap>();
    270   }
    271   DCHECK(icon_dir_data);
    272   DCHECK_GE(icon_dir_size, sizeof(GRPICONDIR));
    273 
    274   const GRPICONDIR* icon_dir =
    275       reinterpret_cast<const GRPICONDIR*>(icon_dir_data);
    276   const GRPICONDIRENTRY* large_icon_entry = NULL;
    277   for (size_t i = 0; i < icon_dir->idCount; ++i) {
    278     const GRPICONDIRENTRY* entry = &icon_dir->idEntries[i];
    279     // 256x256 icons are stored with width and height set to 0.
    280     // See: http://en.wikipedia.org/wiki/ICO_(file_format)
    281     if (entry->bWidth == 0 && entry->bHeight == 0) {
    282       large_icon_entry = entry;
    283       break;
    284     }
    285   }
    286   if (!large_icon_entry)
    287     return scoped_ptr<SkBitmap>();
    288 
    289   void* png_data = NULL;
    290   size_t png_size = 0;
    291   if (!base::win::GetResourceFromModule(module, large_icon_entry->nID, RT_ICON,
    292                                         &png_data, &png_size)) {
    293     return scoped_ptr<SkBitmap>();
    294   }
    295   DCHECK(png_data);
    296   DCHECK_EQ(png_size, large_icon_entry->dwBytesInRes);
    297 
    298   gfx::Image image = gfx::Image::CreateFrom1xPNGBytes(
    299       new base::RefCountedStaticMemory(png_data, png_size));
    300   return scoped_ptr<SkBitmap>(new SkBitmap(image.AsBitmap()));
    301 }
    302 
    303 SkBitmap* IconUtil::CreateSkBitmapFromHICON(HICON icon) {
    304   // We start with validating parameters.
    305   if (!icon)
    306     return NULL;
    307 
    308   ScopedICONINFO icon_info;
    309   BITMAP bitmap_info = { 0 };
    310 
    311   if (!::GetIconInfo(icon, &icon_info))
    312     return NULL;
    313 
    314   if (!::GetObject(icon_info.hbmMask, sizeof(bitmap_info), &bitmap_info))
    315     return NULL;
    316 
    317   gfx::Size icon_size(bitmap_info.bmWidth, bitmap_info.bmHeight);
    318   return new SkBitmap(CreateSkBitmapFromHICONHelper(icon, icon_size));
    319 }
    320 
    321 HICON IconUtil::CreateCursorFromDIB(const gfx::Size& icon_size,
    322                                     const gfx::Point& hotspot,
    323                                     const void* dib_bits,
    324                                     size_t dib_size) {
    325   BITMAPINFO icon_bitmap_info = {0};
    326   gfx::CreateBitmapHeader(
    327       icon_size.width(),
    328       icon_size.height(),
    329       reinterpret_cast<BITMAPINFOHEADER*>(&icon_bitmap_info));
    330 
    331   base::win::ScopedGetDC dc(NULL);
    332   base::win::ScopedCreateDC working_dc(CreateCompatibleDC(dc));
    333   base::win::ScopedGDIObject<HBITMAP> bitmap_handle(
    334       CreateDIBSection(dc,
    335                        &icon_bitmap_info,
    336                        DIB_RGB_COLORS,
    337                        0,
    338                        0,
    339                        0));
    340   if (dib_size > 0) {
    341     SetDIBits(0,
    342               bitmap_handle,
    343               0,
    344               icon_size.height(),
    345               dib_bits,
    346               &icon_bitmap_info,
    347               DIB_RGB_COLORS);
    348   }
    349 
    350   HBITMAP old_bitmap = reinterpret_cast<HBITMAP>(
    351       SelectObject(working_dc.Get(), bitmap_handle));
    352   SetBkMode(working_dc.Get(), TRANSPARENT);
    353   SelectObject(working_dc.Get(), old_bitmap);
    354 
    355   base::win::ScopedGDIObject<HBITMAP> mask(
    356       CreateBitmap(icon_size.width(),
    357                    icon_size.height(),
    358                    1,
    359                    1,
    360                    NULL));
    361   ICONINFO ii = {0};
    362   ii.fIcon = FALSE;
    363   ii.xHotspot = hotspot.x();
    364   ii.yHotspot = hotspot.y();
    365   ii.hbmMask = mask;
    366   ii.hbmColor = bitmap_handle;
    367 
    368   return CreateIconIndirect(&ii);
    369 }
    370 
    371 SkBitmap IconUtil::CreateSkBitmapFromHICONHelper(HICON icon,
    372                                                  const gfx::Size& s) {
    373   DCHECK(icon);
    374   DCHECK(!s.IsEmpty());
    375 
    376   // Allocating memory for the SkBitmap object. We are going to create an ARGB
    377   // bitmap so we should set the configuration appropriately.
    378   SkBitmap bitmap;
    379   bitmap.allocN32Pixels(s.width(), s.height());
    380   bitmap.eraseARGB(0, 0, 0, 0);
    381   SkAutoLockPixels bitmap_lock(bitmap);
    382 
    383   // Now we should create a DIB so that we can use ::DrawIconEx in order to
    384   // obtain the icon's image.
    385   BITMAPV5HEADER h;
    386   InitializeBitmapHeader(&h, s.width(), s.height());
    387   HDC hdc = ::GetDC(NULL);
    388   uint32* bits;
    389   HBITMAP dib = ::CreateDIBSection(hdc, reinterpret_cast<BITMAPINFO*>(&h),
    390       DIB_RGB_COLORS, reinterpret_cast<void**>(&bits), NULL, 0);
    391   DCHECK(dib);
    392   HDC dib_dc = CreateCompatibleDC(hdc);
    393   ::ReleaseDC(NULL, hdc);
    394   DCHECK(dib_dc);
    395   HGDIOBJ old_obj = ::SelectObject(dib_dc, dib);
    396 
    397   // Windows icons are defined using two different masks. The XOR mask, which
    398   // represents the icon image and an AND mask which is a monochrome bitmap
    399   // which indicates the transparency of each pixel.
    400   //
    401   // To make things more complex, the icon image itself can be an ARGB bitmap
    402   // and therefore contain an alpha channel which specifies the transparency
    403   // for each pixel. Unfortunately, there is no easy way to determine whether
    404   // or not a bitmap has an alpha channel and therefore constructing the bitmap
    405   // for the icon is nothing but straightforward.
    406   //
    407   // The idea is to read the AND mask but use it only if we know for sure that
    408   // the icon image does not have an alpha channel. The only way to tell if the
    409   // bitmap has an alpha channel is by looking through the pixels and checking
    410   // whether there are non-zero alpha bytes.
    411   //
    412   // We start by drawing the AND mask into our DIB.
    413   size_t num_pixels = s.GetArea();
    414   memset(bits, 0, num_pixels * 4);
    415   ::DrawIconEx(dib_dc, 0, 0, icon, s.width(), s.height(), 0, NULL, DI_MASK);
    416 
    417   // Capture boolean opacity. We may not use it if we find out the bitmap has
    418   // an alpha channel.
    419   scoped_ptr<bool[]> opaque(new bool[num_pixels]);
    420   for (size_t i = 0; i < num_pixels; ++i)
    421     opaque[i] = !bits[i];
    422 
    423   // Then draw the image itself which is really the XOR mask.
    424   memset(bits, 0, num_pixels * 4);
    425   ::DrawIconEx(dib_dc, 0, 0, icon, s.width(), s.height(), 0, NULL, DI_NORMAL);
    426   memcpy(bitmap.getPixels(), static_cast<void*>(bits), num_pixels * 4);
    427 
    428   // Finding out whether the bitmap has an alpha channel.
    429   bool bitmap_has_alpha_channel = PixelsHaveAlpha(
    430       static_cast<const uint32*>(bitmap.getPixels()), num_pixels);
    431 
    432   // If the bitmap does not have an alpha channel, we need to build it using
    433   // the previously captured AND mask. Otherwise, we are done.
    434   if (!bitmap_has_alpha_channel) {
    435     uint32* p = static_cast<uint32*>(bitmap.getPixels());
    436     for (size_t i = 0; i < num_pixels; ++p, ++i) {
    437       DCHECK_EQ((*p & 0xff000000), 0u);
    438       if (opaque[i])
    439         *p |= 0xff000000;
    440       else
    441         *p &= 0x00ffffff;
    442     }
    443   }
    444 
    445   ::SelectObject(dib_dc, old_obj);
    446   ::DeleteObject(dib);
    447   ::DeleteDC(dib_dc);
    448 
    449   return bitmap;
    450 }
    451 
    452 // static
    453 bool IconUtil::CreateIconFileFromImageFamily(
    454     const gfx::ImageFamily& image_family,
    455     const base::FilePath& icon_path) {
    456   // Creating a set of bitmaps corresponding to the icon images we'll end up
    457   // storing in the icon file. Each bitmap is created by resizing the most
    458   // appropriate image from |image_family| to the desired size.
    459   gfx::ImageFamily resized_image_family;
    460   if (!BuildResizedImageFamily(image_family, &resized_image_family))
    461     return false;
    462 
    463   std::vector<SkBitmap> bitmaps;
    464   scoped_refptr<base::RefCountedMemory> png_bytes;
    465   if (!ConvertImageFamilyToBitmaps(resized_image_family, &bitmaps, &png_bytes))
    466     return false;
    467 
    468   // Guaranteed true because BuildResizedImageFamily will provide at least one
    469   // image < 256x256.
    470   DCHECK(!bitmaps.empty());
    471   size_t bitmap_count = bitmaps.size();  // Not including PNG image.
    472   // Including PNG image, if any.
    473   size_t image_count = bitmap_count + (png_bytes.get() ? 1 : 0);
    474 
    475   // Computing the total size of the buffer we need in order to store the
    476   // images in the desired icon format.
    477   size_t buffer_size = ComputeIconFileBufferSize(bitmaps);
    478   // Account for the bytes needed for the PNG entry.
    479   if (png_bytes.get())
    480     buffer_size += sizeof(ICONDIRENTRY) + png_bytes->size();
    481 
    482   // Setting the information in the structures residing within the buffer.
    483   // First, we set the information which doesn't require iterating through the
    484   // bitmap set and then we set the bitmap specific structures. In the latter
    485   // step we also copy the actual bits.
    486   std::vector<uint8> buffer(buffer_size);
    487   ICONDIR* icon_dir = reinterpret_cast<ICONDIR*>(&buffer[0]);
    488   icon_dir->idType = kResourceTypeIcon;
    489   icon_dir->idCount = static_cast<WORD>(image_count);
    490   // - 1 because there is already one ICONDIRENTRY in ICONDIR.
    491   size_t icon_dir_count = image_count - 1;
    492 
    493   size_t offset = sizeof(ICONDIR) + (sizeof(ICONDIRENTRY) * icon_dir_count);
    494   for (size_t i = 0; i < bitmap_count; i++) {
    495     ICONIMAGE* image = reinterpret_cast<ICONIMAGE*>(&buffer[offset]);
    496     DCHECK_LT(offset, buffer_size);
    497     size_t icon_image_size = 0;
    498     SetSingleIconImageInformation(bitmaps[i], i, icon_dir, image, offset,
    499                                   &icon_image_size);
    500     DCHECK_GT(icon_image_size, 0U);
    501     offset += icon_image_size;
    502   }
    503 
    504   // Add the PNG entry, if necessary.
    505   if (png_bytes.get()) {
    506     ICONDIRENTRY* entry = &icon_dir->idEntries[bitmap_count];
    507     entry->bWidth = 0;
    508     entry->bHeight = 0;
    509     entry->wPlanes = 1;
    510     entry->wBitCount = 32;
    511     entry->dwBytesInRes = static_cast<DWORD>(png_bytes->size());
    512     entry->dwImageOffset = static_cast<DWORD>(offset);
    513     memcpy(&buffer[offset], png_bytes->front(), png_bytes->size());
    514     offset += png_bytes->size();
    515   }
    516 
    517   DCHECK_EQ(offset, buffer_size);
    518 
    519   std::string data(buffer.begin(), buffer.end());
    520   return base::ImportantFileWriter::WriteFileAtomically(icon_path, data);
    521 }
    522 
    523 bool IconUtil::PixelsHaveAlpha(const uint32* pixels, size_t num_pixels) {
    524   for (const uint32* end = pixels + num_pixels; pixels != end; ++pixels) {
    525     if ((*pixels & 0xff000000) != 0)
    526       return true;
    527   }
    528 
    529   return false;
    530 }
    531 
    532 void IconUtil::InitializeBitmapHeader(BITMAPV5HEADER* header, int width,
    533                                       int height) {
    534   DCHECK(header);
    535   memset(header, 0, sizeof(BITMAPV5HEADER));
    536   header->bV5Size = sizeof(BITMAPV5HEADER);
    537 
    538   // Note that icons are created using top-down DIBs so we must negate the
    539   // value used for the icon's height.
    540   header->bV5Width = width;
    541   header->bV5Height = -height;
    542   header->bV5Planes = 1;
    543   header->bV5Compression = BI_RGB;
    544 
    545   // Initializing the bitmap format to 32 bit ARGB.
    546   header->bV5BitCount = 32;
    547   header->bV5RedMask = 0x00FF0000;
    548   header->bV5GreenMask = 0x0000FF00;
    549   header->bV5BlueMask = 0x000000FF;
    550   header->bV5AlphaMask = 0xFF000000;
    551 
    552   // Use the system color space.  The default value is LCS_CALIBRATED_RGB, which
    553   // causes us to crash if we don't specify the approprite gammas, etc.  See
    554   // <http://msdn.microsoft.com/en-us/library/ms536531(VS.85).aspx> and
    555   // <http://b/1283121>.
    556   header->bV5CSType = LCS_WINDOWS_COLOR_SPACE;
    557 
    558   // Use a valid value for bV5Intent as 0 is not a valid one.
    559   // <http://msdn.microsoft.com/en-us/library/dd183381(VS.85).aspx>
    560   header->bV5Intent = LCS_GM_IMAGES;
    561 }
    562 
    563 void IconUtil::SetSingleIconImageInformation(const SkBitmap& bitmap,
    564                                              size_t index,
    565                                              ICONDIR* icon_dir,
    566                                              ICONIMAGE* icon_image,
    567                                              size_t image_offset,
    568                                              size_t* image_byte_count) {
    569   DCHECK(icon_dir != NULL);
    570   DCHECK(icon_image != NULL);
    571   DCHECK_GT(image_offset, 0U);
    572   DCHECK(image_byte_count != NULL);
    573   DCHECK_LT(bitmap.width(), kLargeIconSize);
    574   DCHECK_LT(bitmap.height(), kLargeIconSize);
    575 
    576   // We start by computing certain image values we'll use later on.
    577   size_t xor_mask_size, bytes_in_resource;
    578   ComputeBitmapSizeComponents(bitmap,
    579                               &xor_mask_size,
    580                               &bytes_in_resource);
    581 
    582   icon_dir->idEntries[index].bWidth = static_cast<BYTE>(bitmap.width());
    583   icon_dir->idEntries[index].bHeight = static_cast<BYTE>(bitmap.height());
    584   icon_dir->idEntries[index].wPlanes = 1;
    585   icon_dir->idEntries[index].wBitCount = 32;
    586   icon_dir->idEntries[index].dwBytesInRes = bytes_in_resource;
    587   icon_dir->idEntries[index].dwImageOffset = image_offset;
    588   icon_image->icHeader.biSize = sizeof(BITMAPINFOHEADER);
    589 
    590   // The width field in the BITMAPINFOHEADER structure accounts for the height
    591   // of both the AND mask and the XOR mask so we need to multiply the bitmap's
    592   // height by 2. The same does NOT apply to the width field.
    593   icon_image->icHeader.biHeight = bitmap.height() * 2;
    594   icon_image->icHeader.biWidth = bitmap.width();
    595   icon_image->icHeader.biPlanes = 1;
    596   icon_image->icHeader.biBitCount = 32;
    597 
    598   // We use a helper function for copying to actual bits from the SkBitmap
    599   // object into the appropriate space in the buffer. We use a helper function
    600   // (rather than just copying the bits) because there is no way to specify the
    601   // orientation (bottom-up vs. top-down) of a bitmap residing in a .ico file.
    602   // Thus, if we just copy the bits, we'll end up with a bottom up bitmap in
    603   // the .ico file which will result in the icon being displayed upside down.
    604   // The helper function copies the image into the buffer one scanline at a
    605   // time.
    606   //
    607   // Note that we don't need to initialize the AND mask since the memory
    608   // allocated for the icon data buffer was initialized to zero. The icon we
    609   // create will therefore use an AND mask containing only zeros, which is OK
    610   // because the underlying image has an alpha channel. An AND mask containing
    611   // only zeros essentially means we'll initially treat all the pixels as
    612   // opaque.
    613   unsigned char* image_addr = reinterpret_cast<unsigned char*>(icon_image);
    614   unsigned char* xor_mask_addr = image_addr + sizeof(BITMAPINFOHEADER);
    615   CopySkBitmapBitsIntoIconBuffer(bitmap, xor_mask_addr, xor_mask_size);
    616   *image_byte_count = bytes_in_resource;
    617 }
    618 
    619 void IconUtil::CopySkBitmapBitsIntoIconBuffer(const SkBitmap& bitmap,
    620                                               unsigned char* buffer,
    621                                               size_t buffer_size) {
    622   SkAutoLockPixels bitmap_lock(bitmap);
    623   unsigned char* bitmap_ptr = static_cast<unsigned char*>(bitmap.getPixels());
    624   size_t bitmap_size = bitmap.height() * bitmap.width() * 4;
    625   DCHECK_EQ(buffer_size, bitmap_size);
    626   for (size_t i = 0; i < bitmap_size; i += bitmap.width() * 4) {
    627     memcpy(buffer + bitmap_size - bitmap.width() * 4 - i,
    628            bitmap_ptr + i,
    629            bitmap.width() * 4);
    630   }
    631 }
    632 
    633 size_t IconUtil::ComputeIconFileBufferSize(const std::vector<SkBitmap>& set) {
    634   DCHECK(!set.empty());
    635 
    636   // We start by counting the bytes for the structures that don't depend on the
    637   // number of icon images. Note that sizeof(ICONDIR) already accounts for a
    638   // single ICONDIRENTRY structure, which is why we subtract one from the
    639   // number of bitmaps.
    640   size_t total_buffer_size = sizeof(ICONDIR);
    641   size_t bitmap_count = set.size();
    642   total_buffer_size += sizeof(ICONDIRENTRY) * (bitmap_count - 1);
    643   // May not have all icon sizes, but must have at least up to medium icon size.
    644   DCHECK_GE(bitmap_count, kNumIconDimensionsUpToMediumSize);
    645 
    646   // Add the bitmap specific structure sizes.
    647   for (size_t i = 0; i < bitmap_count; i++) {
    648     size_t xor_mask_size, bytes_in_resource;
    649     ComputeBitmapSizeComponents(set[i],
    650                                 &xor_mask_size,
    651                                 &bytes_in_resource);
    652     total_buffer_size += bytes_in_resource;
    653   }
    654   return total_buffer_size;
    655 }
    656 
    657 void IconUtil::ComputeBitmapSizeComponents(const SkBitmap& bitmap,
    658                                            size_t* xor_mask_size,
    659                                            size_t* bytes_in_resource) {
    660   // The XOR mask size is easy to calculate since we only deal with 32bpp
    661   // images.
    662   *xor_mask_size = bitmap.width() * bitmap.height() * 4;
    663 
    664   // Computing the AND mask is a little trickier since it is a monochrome
    665   // bitmap (regardless of the number of bits per pixels used in the XOR mask).
    666   // There are two things we must make sure we do when computing the AND mask
    667   // size:
    668   //
    669   // 1. Make sure the right number of bytes is allocated for each AND mask
    670   //    scan line in case the number of pixels in the image is not divisible by
    671   //    8. For example, in a 15X15 image, 15 / 8 is one byte short of
    672   //    containing the number of bits we need in order to describe a single
    673   //    image scan line so we need to add a byte. Thus, we need 2 bytes instead
    674   //    of 1 for each scan line.
    675   //
    676   // 2. Make sure each scan line in the AND mask is 4 byte aligned (so that the
    677   //    total icon image has a 4 byte alignment). In the 15X15 image example
    678   //    above, we can not use 2 bytes so we increase it to the next multiple of
    679   //    4 which is 4.
    680   //
    681   // Once we compute the size for a singe AND mask scan line, we multiply that
    682   // number by the image height in order to get the total number of bytes for
    683   // the AND mask. Thus, for a 15X15 image, we need 15 * 4 which is 60 bytes
    684   // for the monochrome bitmap representing the AND mask.
    685   size_t and_line_length = (bitmap.width() + 7) >> 3;
    686   and_line_length = (and_line_length + 3) & ~3;
    687   size_t and_mask_size = and_line_length * bitmap.height();
    688   size_t masks_size = *xor_mask_size + and_mask_size;
    689   *bytes_in_resource = masks_size + sizeof(BITMAPINFOHEADER);
    690 }
    691