Replaced GetAppIconForSize with GetAppIconImageFamily.

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/files/file_util.h"
 #include "base/files/important_file_writer.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 221 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, kLargeIconSize);
-
-  // For everything except the Vista+ 256x256 icons, use |LoadImage()|.
-  if (size != kLargeIconSize) {
-    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.
+// static
+scoped_ptr<gfx::ImageFamily> IconUtil::CreateImageFamilyFromIconResource(
+    HMODULE module,
+    int resource_id) {
+  // Read the resource directly so we can get the icon image sizes. This data
+  // will also be used to directly get the PNG bytes for large images.
   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 nullptr;
   }
   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;
+  scoped_ptr<gfx::ImageFamily> result(new gfx::ImageFamily);
   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 (entry->bWidth != 0 || entry->bHeight != 0) {
+      // Ignore the low-bit-depth versions of the icon.
+      if (entry->wBitCount != 32)
+        continue;
+
+      // For everything except the Vista+ 256x256 icons, use |LoadImage()|.
+      HICON icon_handle = static_cast<HICON>(LoadImage(
+          module, MAKEINTRESOURCE(resource_id), IMAGE_ICON, entry->bWidth,
+          entry->bHeight, LR_DEFAULTCOLOR | LR_DEFAULTSIZE));
+      scoped_ptr<SkBitmap> bitmap(
+          IconUtil::CreateSkBitmapFromHICON(icon_handle));
+      DestroyIcon(icon_handle);
+      result->Add(gfx::Image::CreateFrom1xBitmap(*bitmap));
+    } else {
+      // 256x256 icons are stored with width and height set to 0.
+      // See: http://en.wikipedia.org/wiki/ICO_(file_format)
+      void* png_data = NULL;
+      size_t png_size = 0;
+      if (!base::win::GetResourceFromModule(module, entry->nID, RT_ICON,
+                                            &png_data, &png_size)) {
+        return nullptr;
+      }
+      DCHECK(png_data);
+      DCHECK_EQ(png_size, entry->dwBytesInRes);
+
+      result->Add(gfx::Image::CreateFrom1xPNGBytes(
+          new base::RefCountedStaticMemory(png_data, png_size)));
     }
   }
-  if (!large_icon_entry)
-    return nullptr;
-
-  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 nullptr;
-  }
-  DCHECK(png_data);
-  DCHECK_EQ(png_size, large_icon_entry->dwBytesInRes);
-
-  gfx::Image image = gfx::Image::CreateFrom1xPNGBytes(
-      new base::RefCountedStaticMemory(png_data, png_size));
-  return make_scoped_ptr(new SkBitmap(image.AsBitmap()));
+  return result;
 }
 
 SkBitmap* IconUtil::CreateSkBitmapFromHICON(HICON icon) {
   // We start with validating parameters.
   if (!icon)
     return NULL;
 
   ScopedICONINFO icon_info;
   BITMAP bitmap_info = { 0 };
 
@@ skipping 382 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);
 }