Add support for adding 256x256 pngs to Windows .ico files.

ui/gfx/icon_util.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/gfx/icon_util.h"
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/win/scoped_gdi_object.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/scoped_hdc.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/gdi_util.h"
+#include "ui/gfx/image/image.h"
 #include "ui/gfx/size.h"
 
 namespace {
 struct ScopedICONINFO : ICONINFO {
   ScopedICONINFO() {
     hbmColor = NULL;
     hbmMask = NULL;
   }
 
   ~ScopedICONINFO() {
@@ skipping 249 matching lines @@
   }
 
   ::SelectObject(dib_dc, old_obj);
   ::DeleteObject(dib);
   ::DeleteDC(dib_dc);
 
   return bitmap;
 }
 
 bool IconUtil::CreateIconFileFromSkBitmap(const SkBitmap& bitmap,
+                                          const SkBitmap& large_bitmap,
                                           const FilePath& icon_path) {
   // Only 32 bit ARGB bitmaps are supported. We also make sure the bitmap has
   // been properly initialized.
   SkAutoLockPixels bitmap_lock(bitmap);
   if ((bitmap.config() != SkBitmap::kARGB_8888_Config) ||
       (bitmap.height() <= 0) || (bitmap.width() <= 0) ||
-      (bitmap.getPixels() == NULL))
+      (bitmap.getPixels() == NULL)) {
     return false;
+  }
+
+  // If |large_bitmap| was specified, validate its dimension and convert to PNG.
+  scoped_refptr<base::RefCountedMemory> png_bytes;
+  if (!large_bitmap.empty()) {
+    CHECK_EQ(256, large_bitmap.width());

[sky, 2013/01/07 17:05:24]

Why CHECK and not DCHECK?

[Alexei Svitkine (slow), 2013/01/07 17:51:28]

I could do a DCHECK. I guess I wanted to make sure that this never runs with
|large_bitmap| non-being 256x, since that would create an invalid .ico file.
Another alternative would be to return "false" in that case.

Let me know what you prefer.

[sky, 2013/01/07 22:18:56]

See
http://dev.chromium.org/developers/coding-style#TOC-CHECK-DCHECK-and-NOTREACHED-
. I think this should be a DCHECK.

[Alexei Svitkine (slow), 2013/01/07 22:25:23]

Ah, I didn't realise CHECKs had to meet those criteria. Thanks for pointing me
to the guidelines there! Done.

+    CHECK_EQ(256, large_bitmap.height());
+    png_bytes = gfx::Image(large_bitmap).As1xPNGBytes();
+  }
 
   // We start by creating the file.
   base::win::ScopedHandle icon_file(::CreateFile(icon_path.value().c_str(),
        GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL));
 
   if (!icon_file.IsValid())
     return false;
 
   // Creating a set of bitmaps corresponding to the icon images we'll end up
   // storing in the icon file. Each bitmap is created by resizing the given
   // bitmap to the desired size.
   std::vector<SkBitmap> bitmaps;
   CreateResizedBitmapSet(bitmap, &bitmaps);
   DCHECK(!bitmaps.empty());

[sky, 2013/01/07 17:05:24]

Is there a reason we can't add large_bitmap to bitmaps here?

[Alexei Svitkine (slow), 2013/01/07 17:51:28]

Yes, because it has to be special-cased. Non-256x ones are stored in BMP format
in the icon file while the 256x one has be stored as a PNG.

We could add it to the list and then do some additional tracking so that it can
be special-treated later. The problem with that is that
ComputeIconFileBufferSize() has to know about it, so that it doesn't compute
size as if it was a BMP and also the for loop that calls
SetSingleIconImageInformation() shouldn't run on that bitmap either and we'd
still need the special case after that loop to add it.

   size_t bitmap_count = bitmaps.size();
 
   // Computing the total size of the buffer we need in order to store the
   // images in the desired icon format.
   size_t buffer_size = ComputeIconFileBufferSize(bitmaps);
-  unsigned char* buffer = new unsigned char[buffer_size];
-  DCHECK(buffer != NULL);
-  memset(buffer, 0, buffer_size);
+  // Account for the bytes needed for the PNG entry.
+  if (png_bytes.get())
+    buffer_size += sizeof(ICONDIRENTRY) + png_bytes->size();
 
   // Setting the information in the structures residing within the buffer.
   // First, we set the information which doesn't require iterating through the
   // bitmap set and then we set the bitmap specific structures. In the latter
   // step we also copy the actual bits.
-  ICONDIR* icon_dir = reinterpret_cast<ICONDIR*>(buffer);
+  std::vector<uint8> buffer(buffer_size);
+  ICONDIR* icon_dir = reinterpret_cast<ICONDIR*>(&buffer[0]);
   icon_dir->idType = kResourceTypeIcon;
   icon_dir->idCount = bitmap_count;
   size_t icon_dir_count = bitmap_count - 1;  // Note DCHECK(!bitmaps.empty())!
+
+  // Increment counts if a PNG entry will be added.
+  if (png_bytes.get()) {
+    icon_dir->idCount++;
+    icon_dir_count++;
+  }
+
   size_t offset = sizeof(ICONDIR) + (sizeof(ICONDIRENTRY) * icon_dir_count);
   for (size_t i = 0; i < bitmap_count; i++) {
-    ICONIMAGE* image = reinterpret_cast<ICONIMAGE*>(buffer + offset);
+    ICONIMAGE* image = reinterpret_cast<ICONIMAGE*>(&buffer[offset]);
     DCHECK_LT(offset, buffer_size);
     size_t icon_image_size = 0;
     SetSingleIconImageInformation(bitmaps[i], i, icon_dir, image, offset,
                                   &icon_image_size);
     DCHECK_GT(icon_image_size, 0U);
     offset += icon_image_size;
   }
+
+  // Add the PNG entry, if necessary.
+  if (png_bytes.get()) {
+    ICONDIRENTRY* entry = &icon_dir->idEntries[bitmap_count];
+    entry->bWidth = 0;
+    entry->bHeight = 0;
+    entry->wPlanes = 1;
+    entry->wBitCount = 32;
+    entry->dwBytesInRes = png_bytes->size();
+    entry->dwImageOffset = offset;
+    memcpy(&buffer[offset], png_bytes->front(), png_bytes->size());
+    offset += png_bytes->size();
+  }
+
   DCHECK_EQ(offset, buffer_size);
 
-  // Finally, writing the data info the file.
+  // Finally, write the data to the file.
   DWORD bytes_written;
   bool delete_file = false;
-  if (!WriteFile(icon_file.Get(), buffer, buffer_size, &bytes_written, NULL) ||
-      bytes_written != buffer_size)
+  if (!WriteFile(icon_file.Get(), &buffer[0], buffer_size, &bytes_written,
+                 NULL) ||
+      bytes_written != buffer_size) {
     delete_file = true;
+  }
 
   ::CloseHandle(icon_file.Take());
-  delete [] buffer;
   if (delete_file) {
     bool success = file_util::Delete(icon_path, false);
     DCHECK(success);
   }
 
   return !delete_file;
 }
 
 bool IconUtil::PixelsHaveAlpha(const uint32* pixels, size_t num_pixels) {
   for (const uint32* end = pixels + num_pixels; pixels != end; ++pixels) {
@@ skipping 188 matching lines @@
   // Once we compute the size for a singe AND mask scan line, we multiply that
   // number by the image height in order to get the total number of bytes for
   // the AND mask. Thus, for a 15X15 image, we need 15 * 4 which is 60 bytes
   // for the monochrome bitmap representing the AND mask.
   size_t and_line_length = (bitmap.width() + 7) >> 3;
   and_line_length = (and_line_length + 3) & ~3;
   size_t and_mask_size = and_line_length * bitmap.height();
   size_t masks_size = *xor_mask_size + and_mask_size;
   *bytes_in_resource = masks_size + sizeof(BITMAPINFOHEADER);
 }