Add support for getting the 256x256 app icon on Windows.

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/resource_util.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() {
     if (hbmColor)
       ::DeleteObject(hbmColor);
     if (hbmMask)
       ::DeleteObject(hbmMask);
   }
 };
-}
+
+}  // namespace
 
 // Defining the dimensions for the icon images. We store only one value because
 // we always resize to a square image; that is, the value 48 means that we are
 // going to resize the given bitmap to a 48 by 48 pixels bitmap.
 //
 // The icon images appear in the icon file in same order in which their
 // corresponding dimensions appear in the |icon_dimensions_| array, so it is
 // important to keep this array sorted. Also note that the maximum icon image
 // size we can handle is 255 by 255.
 const int IconUtil::icon_dimensions_[] = {
@@ skipping 81 matching lines @@
   if (!icon || s.IsEmpty())
     return NULL;
   ScopedICONINFO icon_info;
   if (!::GetIconInfo(icon, &icon_info))
     return NULL;
   if (!icon_info.fIcon)
     return NULL;
   return new SkBitmap(CreateSkBitmapFromHICONHelper(icon, s));
 }
 
+scoped_ptr<SkBitmap> IconUtil::CreateSkBitmapFromIconResource(HMODULE module,
+                                                              int resource_id,
+                                                              int size) {
+  DCHECK_LE(size, 256);
+
+  // For everything except the Vista+ 256x256 icons, use |LoadImage()|.
+  if (size != 256) {
+    HICON icon_handle =
+        static_cast<HICON>(LoadImage(module, MAKEINTRESOURCE(resource_id),
+                                     IMAGE_ICON, size, size,
+                                     LR_DEFAULTCOLOR | LR_DEFAULTSIZE));
+    scoped_ptr<SkBitmap> bitmap(IconUtil::CreateSkBitmapFromHICON(icon_handle));
+    DestroyIcon(icon_handle);
+    return bitmap.Pass();
+  }
+
+  // For Vista+ 256x256 PNG icons, read the resource directly and find
+  // the corresponding icon entry to get its PNG bytes.
+  void* icon_dir_data = NULL;
+  size_t icon_dir_size = 0;
+  if (!base::win::GetResourceFromModule(module, resource_id, RT_GROUP_ICON,
+                                        &icon_dir_data, &icon_dir_size)) {
+    return scoped_ptr<SkBitmap>();
+  }
+  DCHECK(icon_dir_data);
+  DCHECK_GE(icon_dir_size, sizeof(GRPICONDIR));
+
+  const GRPICONDIR* icon_dir =
+      reinterpret_cast<const GRPICONDIR*>(icon_dir_data);
+  const GRPICONDIRENTRY* large_icon_entry = NULL;
+  for (size_t i = 0; i < icon_dir->idCount; ++i) {
+    const GRPICONDIRENTRY* entry = &icon_dir->idEntries[i];
+    // 256x256 icons are stored with width and height set to 0.
+    // See: http://en.wikipedia.org/wiki/ICO_(file_format)
+    if (entry->bWidth == 0 && entry->bHeight == 0) {
+      large_icon_entry = entry;
+      break;
+    }
+  }
+  if (!large_icon_entry)
+    return scoped_ptr<SkBitmap>();
+
+  void* png_data = NULL;
+  size_t png_size = 0;
+  if (!base::win::GetResourceFromModule(module, large_icon_entry->nID, RT_ICON,
+                                        &png_data, &png_size)) {
+    return scoped_ptr<SkBitmap>();
+  }
+  DCHECK(png_data);
+  DCHECK_EQ(png_size, large_icon_entry->dwBytesInRes);
+
+  const unsigned char* png_bytes =
+      reinterpret_cast<const unsigned char*>(png_data);
+  gfx::Image image = gfx::Image::CreateFrom1xPNGBytes(png_bytes, png_size);
+  return scoped_ptr<SkBitmap>(new SkBitmap(image.AsBitmap()));
+}
+
 SkBitmap* IconUtil::CreateSkBitmapFromHICON(HICON icon) {
   // We start with validating parameters.
   if (!icon)
     return NULL;
 
   ScopedICONINFO icon_info;
   BITMAP bitmap_info = { 0 };
 
   if (!::GetIconInfo(icon, &icon_info))
     return NULL;
@@ skipping 432 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);
 }