Replace scoped_ptr with std::unique_ptr in //ui

ui/gfx/icon_util_unittest.cc

 // Copyright (c) 2011 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 <stddef.h>
 
+#include <memory>
 #include <vector>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/gfx_paths.h"
 #include "ui/gfx/icon_util_unittests_resource.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_family.h"
 
 namespace {
@@ skipping 130 matching lines @@
   // Invalid size parameter.
   gfx::Size invalid_icon_size(kSmallIconHeight, 0);
   EXPECT_EQ(IconUtil::CreateSkBitmapFromHICON(icon.get(), invalid_icon_size),
             static_cast<SkBitmap*>(NULL));
 
   // Invalid icon.
   EXPECT_EQ(IconUtil::CreateSkBitmapFromHICON(NULL, icon_size),
             static_cast<SkBitmap*>(NULL));
 
   // The following code should succeed.
-  scoped_ptr<SkBitmap> bitmap;
+  std::unique_ptr<SkBitmap> bitmap;
   bitmap.reset(IconUtil::CreateSkBitmapFromHICON(icon.get(), icon_size));
   EXPECT_NE(bitmap.get(), static_cast<SkBitmap*>(NULL));
 }
 
 // The following test case makes sure IconUtil::CreateHICONFromSkBitmap fails
 // gracefully when called with invalid input parameters.
 TEST_F(IconUtilTest, TestBitmapToIconInvalidParameters) {
   ScopedHICON icon;
-  scoped_ptr<SkBitmap> bitmap;
+  std::unique_ptr<SkBitmap> bitmap;
 
   // Wrong bitmap format.
   bitmap.reset(new SkBitmap);
   ASSERT_NE(bitmap.get(), static_cast<SkBitmap*>(NULL));
   bitmap->setInfo(SkImageInfo::MakeA8(kSmallIconWidth, kSmallIconHeight));
   icon = IconUtil::CreateHICONFromSkBitmap(*bitmap);
   EXPECT_FALSE(icon.is_valid());
 
   // Invalid bitmap size.
   bitmap.reset(new SkBitmap);
   ASSERT_NE(bitmap.get(), static_cast<SkBitmap*>(NULL));
   bitmap->setInfo(SkImageInfo::MakeN32Premul(0, 0));
   icon = IconUtil::CreateHICONFromSkBitmap(*bitmap);
   EXPECT_FALSE(icon.is_valid());
 
   // Valid bitmap configuration but no pixels allocated.
   bitmap.reset(new SkBitmap);
   ASSERT_NE(bitmap.get(), static_cast<SkBitmap*>(NULL));
   bitmap->setInfo(SkImageInfo::MakeN32Premul(kSmallIconWidth,
                                              kSmallIconHeight));
   icon = IconUtil::CreateHICONFromSkBitmap(*bitmap);
   EXPECT_FALSE(icon.is_valid());
 }
 
 // The following test case makes sure IconUtil::CreateIconFileFromImageFamily
 // fails gracefully when called with invalid input parameters.
 TEST_F(IconUtilTest, TestCreateIconFileInvalidParameters) {
-  scoped_ptr<SkBitmap> bitmap;
+  std::unique_ptr<SkBitmap> bitmap;
   gfx::ImageFamily image_family;
   base::FilePath valid_icon_filename = temp_directory_.path().AppendASCII(
       kTempIconFilename);
   base::FilePath invalid_icon_filename = temp_directory_.path().AppendASCII(
       "<>?.ico");
 
   // Wrong bitmap format.
   bitmap.reset(new SkBitmap);
   ASSERT_NE(bitmap.get(), static_cast<SkBitmap*>(NULL));
   // Must allocate pixels or else ImageSkia will ignore the bitmap and just
@@ skipping 52 matching lines @@
   gfx::ImageFamily image_family;
   image_family.Add(gfx::Image());
   EXPECT_FALSE(IconUtil::CreateIconFileFromImageFamily(image_family,
                                                        icon_filename));
   EXPECT_FALSE(base::PathExists(icon_filename));
 }
 
 // This test case makes sure that when we load an icon from disk and convert
 // the HICON into a bitmap, the bitmap has the expected format and dimensions.
 TEST_F(IconUtilTest, TestCreateSkBitmapFromHICON) {
-  scoped_ptr<SkBitmap> bitmap;
+  std::unique_ptr<SkBitmap> bitmap;
   base::FilePath small_icon_filename = test_data_directory_.AppendASCII(
       kSmallIconName);
   gfx::Size small_icon_size(kSmallIconWidth, kSmallIconHeight);
   ScopedHICON small_icon(LoadIconFromFile(
       small_icon_filename, small_icon_size.width(), small_icon_size.height()));
   ASSERT_TRUE(small_icon.is_valid());
   bitmap.reset(
       IconUtil::CreateSkBitmapFromHICON(small_icon.get(), small_icon_size));
   ASSERT_NE(bitmap.get(), static_cast<SkBitmap*>(NULL));
   EXPECT_EQ(bitmap->width(), small_icon_size.width());
@@ skipping 113 matching lines @@
   image_family.clear();
   image_family.Add(gfx::Image());
   image_family.Add(gfx::Image::CreateFrom1xBitmap(CreateBlackSkBitmap(16, 16)));
   ASSERT_TRUE(IconUtil::CreateIconFileFromImageFamily(image_family,
                                                        icon_filename));
   CheckAllIconSizes(icon_filename, 48);
 }
 
 TEST_F(IconUtilTest, TestCreateImageFamilyFromIconResource) {
   HMODULE module = GetModuleHandle(NULL);
-  scoped_ptr<gfx::ImageFamily> family(
+  std::unique_ptr<gfx::ImageFamily> family(
       IconUtil::CreateImageFamilyFromIconResource(module, IDR_MAINFRAME));
   ASSERT_TRUE(family.get());
   EXPECT_FALSE(family->empty());
   std::vector<gfx::Image> images;
   for (const auto& image : *family)
     images.push_back(image);
 
   // Assert that the family contains all of the images from the icon resource.
   EXPECT_EQ(5u, images.size());
   EXPECT_EQ(16, images[0].Width());
   EXPECT_EQ(24, images[1].Width());
   EXPECT_EQ(32, images[2].Width());
   EXPECT_EQ(48, images[3].Width());
   EXPECT_EQ(256, images[4].Width());
 }
 
 // This tests that kNumIconDimensionsUpToMediumSize has the correct value.
 TEST_F(IconUtilTest, TestNumIconDimensionsUpToMediumSize) {
   ASSERT_LE(IconUtil::kNumIconDimensionsUpToMediumSize,
             IconUtil::kNumIconDimensions);
   EXPECT_EQ(IconUtil::kMediumIconSize,
             IconUtil::kIconDimensions[
                 IconUtil::kNumIconDimensionsUpToMediumSize - 1]);
 }