Eliminate HICON leaks caused by creating icons from bitmap image.

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 143 matching lines @@
   48,   // Alt+Tab icon size.
   64,   // Recommended by the MSDN as a nice to have icon size.
   96,   // Recommended by the MSDN as a nice to have icon size.
   128,  // Used by the Shell (e.g. for shortcuts).
   256   // Used by Vista onwards for large icons.
 };
 
 const size_t IconUtil::kNumIconDimensions = arraysize(kIconDimensions);
 const size_t IconUtil::kNumIconDimensionsUpToMediumSize = 9;
 
-HICON IconUtil::CreateHICONFromSkBitmap(const SkBitmap& bitmap) {
+base::win::ScopedHICON IconUtil::CreateHICONFromSkBitmap(
+    const SkBitmap& bitmap) {
   // Only 32 bit ARGB bitmaps are supported. We also try to perform as many
   // validations as we can on the bitmap.
   SkAutoLockPixels bitmap_lock(bitmap);
   if ((bitmap.colorType() != kN32_SkColorType) ||
       (bitmap.width() <= 0) || (bitmap.height() <= 0) ||
       (bitmap.getPixels() == NULL))
-    return NULL;
+    return base::win::ScopedHICON();
 
   // We start by creating a DIB which we'll use later on in order to create
   // the HICON. We use BITMAPV5HEADER since the bitmap we are about to convert
   // may contain an alpha channel and the V5 header allows us to specify the
   // alpha mask for the DIB.
   BITMAPV5HEADER bitmap_header;
   InitializeBitmapHeader(&bitmap_header, bitmap.width(), bitmap.height());
 
   void* bits = NULL;
   HBITMAP dib;
 
   {
     base::win::ScopedGetDC hdc(NULL);
     dib = ::CreateDIBSection(hdc, reinterpret_cast<BITMAPINFO*>(&bitmap_header),
                              DIB_RGB_COLORS, &bits, NULL, 0);
   }
   if (!dib || !bits)
-    return NULL;
+    return base::win::ScopedHICON();
 
   memcpy(bits, bitmap.getPixels(), bitmap.width() * bitmap.height() * 4);
 
   // Icons are generally created using an AND and XOR masks where the AND
   // specifies boolean transparency (the pixel is either opaque or
   // transparent) and the XOR mask contains the actual image pixels. If the XOR
   // mask bitmap has an alpha channel, the AND monochrome bitmap won't
   // actually be used for computing the pixel transparency. Even though all our
   // bitmap has an alpha channel, Windows might not agree when all alpha values
   // are zero. So the monochrome bitmap is created with all pixels transparent
@@ skipping 18 matching lines @@
   HBITMAP mono_bitmap = ::CreateBitmap(bitmap.width(), bitmap.height(), 1, 1,
       reinterpret_cast<LPVOID>(mask_bits.get()));
   DCHECK(mono_bitmap);
 
   ICONINFO icon_info;
   icon_info.fIcon = TRUE;
   icon_info.xHotspot = 0;
   icon_info.yHotspot = 0;
   icon_info.hbmMask = mono_bitmap;
   icon_info.hbmColor = dib;
-  HICON icon = ::CreateIconIndirect(&icon_info);
+  base::win::ScopedHICON icon(CreateIconIndirect(&icon_info));
   ::DeleteObject(dib);
   ::DeleteObject(mono_bitmap);
   return icon;
 }
 
 SkBitmap* IconUtil::CreateSkBitmapFromHICON(HICON icon, const gfx::Size& s) {
   // We start with validating parameters.
   if (!icon || s.IsEmpty())
     return NULL;
   ScopedICONINFO icon_info;
@@ skipping 23 matching lines @@
       reinterpret_cast<const GRPICONDIR*>(icon_dir_data);
   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];
     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(
+      base::win::ScopedHICON icon_handle(static_cast<HICON>(LoadImage(
           module, MAKEINTRESOURCE(resource_id), IMAGE_ICON, entry->bWidth,
-          entry->bHeight, LR_DEFAULTCOLOR | LR_DEFAULTSIZE));
+          entry->bHeight, LR_DEFAULTCOLOR | LR_DEFAULTSIZE)));
       scoped_ptr<SkBitmap> bitmap(
-          IconUtil::CreateSkBitmapFromHICON(icon_handle));
-      DestroyIcon(icon_handle);
+          IconUtil::CreateSkBitmapFromHICON(icon_handle.get()));
       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;
       }
@@ skipping 18 matching lines @@
   if (!::GetIconInfo(icon, &icon_info))
     return NULL;
 
   if (!::GetObject(icon_info.hbmMask, sizeof(bitmap_info), &bitmap_info))
     return NULL;
 
   gfx::Size icon_size(bitmap_info.bmWidth, bitmap_info.bmHeight);
   return new SkBitmap(CreateSkBitmapFromHICONHelper(icon, icon_size));
 }
 
-HICON IconUtil::CreateCursorFromDIB(const gfx::Size& icon_size,
-                                    const gfx::Point& hotspot,
-                                    const void* dib_bits,
-                                    size_t dib_size) {
+base::win::ScopedHICON IconUtil::CreateCursorFromDIB(const gfx::Size& icon_size,
+                                                     const gfx::Point& hotspot,
+                                                     const void* dib_bits,
+                                                     size_t dib_size) {
   BITMAPINFO icon_bitmap_info = {};
   gfx::CreateBitmapHeader(
       icon_size.width(),
       icon_size.height(),
       reinterpret_cast<BITMAPINFOHEADER*>(&icon_bitmap_info));
 
   base::win::ScopedGetDC dc(NULL);
   base::win::ScopedCreateDC working_dc(CreateCompatibleDC(dc));
   base::win::ScopedGDIObject<HBITMAP> bitmap_handle(
       CreateDIBSection(dc,
                        &icon_bitmap_info,
                        DIB_RGB_COLORS,
                        0,
                        0,
                        0));
   if (dib_size > 0) {
     SetDIBits(0,
-              bitmap_handle,
+              bitmap_handle.get(),
               0,
               icon_size.height(),
               dib_bits,
               &icon_bitmap_info,
               DIB_RGB_COLORS);
   }
 
   HBITMAP old_bitmap = reinterpret_cast<HBITMAP>(
-      SelectObject(working_dc.Get(), bitmap_handle));
+      SelectObject(working_dc.Get(), bitmap_handle.get()));
   SetBkMode(working_dc.Get(), TRANSPARENT);
   SelectObject(working_dc.Get(), old_bitmap);
 
   base::win::ScopedGDIObject<HBITMAP> mask(
       CreateBitmap(icon_size.width(),
                    icon_size.height(),
                    1,
                    1,
                    NULL));
   ICONINFO ii = {0};
   ii.fIcon = FALSE;
   ii.xHotspot = hotspot.x();
   ii.yHotspot = hotspot.y();
-  ii.hbmMask = mask;
-  ii.hbmColor = bitmap_handle;
+  ii.hbmMask = mask.get();
+  ii.hbmColor = bitmap_handle.get();
 
-  return CreateIconIndirect(&ii);
+  return base::win::ScopedHICON(CreateIconIndirect(&ii));
 }
 
 SkBitmap IconUtil::CreateSkBitmapFromHICONHelper(HICON icon,
                                                  const gfx::Size& s) {
   DCHECK(icon);
   DCHECK(!s.IsEmpty());
 
   // Allocating memory for the SkBitmap object. We are going to create an ARGB
   // bitmap so we should set the configuration appropriately.
   SkBitmap bitmap;
@@ skipping 314 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);
 }