Replace scoped_ptr with std::unique_ptr in //ui

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 <memory>
+
 #include "base/files/file_util.h"
 #include "base/files/important_file_writer.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/trace_event/trace_event.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/geometry/size.h"
 #include "ui/gfx/image/image.h"
@@ skipping 175 matching lines @@
   // 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
   // for this case. Otherwise, it is created with all pixels opaque.
   bool bitmap_has_alpha_channel =
       PixelsHaveAlpha(static_cast<const uint32_t*>(bitmap.getPixels()),
                       bitmap.width() * bitmap.height());
 
-  scoped_ptr<uint8_t[]> mask_bits;
+  std::unique_ptr<uint8_t[]> mask_bits;
   if (!bitmap_has_alpha_channel) {
     // Bytes per line with paddings to make it word alignment.
     size_t bytes_per_line = (bitmap.width() + 0xF) / 16 * 2;
     size_t mask_bits_size = bytes_per_line * bitmap.height();
 
     mask_bits.reset(new uint8_t[mask_bits_size]);
     DCHECK(mask_bits.get());
 
     // Make all pixels transparent.
     memset(mask_bits.get(), 0xFF, mask_bits_size);
@@ skipping 21 matching lines @@
     return NULL;
   ScopedICONINFO icon_info;
   if (!::GetIconInfo(icon, &icon_info))
     return NULL;
   if (!icon_info.fIcon)
     return NULL;
   return new SkBitmap(CreateSkBitmapFromHICONHelper(icon, s));
 }
 
 // static
-scoped_ptr<gfx::ImageFamily> IconUtil::CreateImageFamilyFromIconResource(
+std::unique_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);
-  scoped_ptr<gfx::ImageFamily> result(new gfx::ImageFamily);
+  std::unique_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()|.
       base::win::ScopedHICON icon_handle(static_cast<HICON>(LoadImage(
           module, MAKEINTRESOURCE(resource_id), IMAGE_ICON, entry->bWidth,
           entry->bHeight, LR_DEFAULTCOLOR | LR_DEFAULTSIZE)));
-      scoped_ptr<SkBitmap> bitmap(
+      std::unique_ptr<SkBitmap> bitmap(
           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 117 matching lines @@
   // bitmap has an alpha channel is by looking through the pixels and checking
   // whether there are non-zero alpha bytes.
   //
   // We start by drawing the AND mask into our DIB.
   size_t num_pixels = s.GetArea();
   memset(bits, 0, num_pixels * 4);
   ::DrawIconEx(dib_dc, 0, 0, icon, s.width(), s.height(), 0, NULL, DI_MASK);
 
   // Capture boolean opacity. We may not use it if we find out the bitmap has
   // an alpha channel.
-  scoped_ptr<bool[]> opaque(new bool[num_pixels]);
+  std::unique_ptr<bool[]> opaque(new bool[num_pixels]);
   for (size_t i = 0; i < num_pixels; ++i)
     opaque[i] = !bits[i];
 
   // Then draw the image itself which is really the XOR mask.
   memset(bits, 0, num_pixels * 4);
   ::DrawIconEx(dib_dc, 0, 0, icon, s.width(), s.height(), 0, NULL, DI_NORMAL);
   memcpy(bitmap.getPixels(), static_cast<void*>(bits), num_pixels * 4);
 
   // Finding out whether the bitmap has an alpha channel.
   bool bitmap_has_alpha_channel = PixelsHaveAlpha(
@@ skipping 263 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);
 }