Convert //extensions/browser from scoped_ptr to std::unique_ptr

extensions/browser/extension_icon_image_unittest.cc

 // Copyright 2014 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 "extensions/browser/extension_icon_image.h"
 
 #include <vector>
 
 #include "base/json/json_file_value_serializer.h"
 #include "base/macros.h"
@@ skipping 87 matching lines @@
     base::FilePath test_file;
     if (!PathService::Get(DIR_TEST_DATA, &test_file)) {
       EXPECT_FALSE(true);
       return NULL;
     }
     test_file = test_file.AppendASCII(name);
     int error_code = 0;
     std::string error;
     JSONFileValueDeserializer deserializer(
         test_file.AppendASCII("manifest.json"));
-    scoped_ptr<base::DictionaryValue> valid_value = base::DictionaryValue::From(
-        deserializer.Deserialize(&error_code, &error));
+    std::unique_ptr<base::DictionaryValue> valid_value =
+        base::DictionaryValue::From(
+            deserializer.Deserialize(&error_code, &error));
     EXPECT_EQ(0, error_code) << error;
     if (error_code != 0)
       return NULL;
 
     EXPECT_TRUE(valid_value.get());
     if (!valid_value)
       return NULL;
 
     return Extension::Create(test_file, location, *valid_value,
                              Extension::NO_FLAGS, &error);
@@ skipping 16 matching lines @@
     return gfx::ImageSkia(gfx::ImageSkiaRep(gfx::Size(16, 16), 1.0f));
   }
 
  private:
   int image_loaded_count_;
   bool quit_in_image_loaded_;
   base::MessageLoop ui_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
   content::TestBrowserThread io_thread_;
-  scoped_ptr<content::NotificationService> notification_service_;
+  std::unique_ptr<content::NotificationService> notification_service_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionIconImageTest);
 };
 
 }  // namespace
 
 TEST_F(ExtensionIconImageTest, Basic) {
   std::vector<ui::ScaleFactor> supported_factors;
   supported_factors.push_back(ui::SCALE_FACTOR_100P);
   supported_factors.push_back(ui::SCALE_FACTOR_200P);
@@ skipping 308 matching lines @@
   ASSERT_TRUE(extension.get() != NULL);
 
   gfx::ImageSkia default_icon = GetDefaultIcon();
 
   // Load images we expect to find as representations in icon_image, so we
   // can later use them to validate icon_image.
   SkBitmap bitmap_16 =
       TestImageLoader::LoadAndGetExtensionBitmap(extension.get(), "16.png", 16);
   ASSERT_FALSE(bitmap_16.empty());
 
-  scoped_ptr<IconImage> image(
-      new IconImage(browser_context(),
-                    extension.get(),
-                    IconsInfo::GetIcons(extension.get()),
-                    16,
-                    default_icon,
-                    this));
+  std::unique_ptr<IconImage> image(new IconImage(
+      browser_context(), extension.get(), IconsInfo::GetIcons(extension.get()),
+      16, default_icon, this));
 
   // Load an image representation.
   gfx::ImageSkiaRep representation =
       image->image_skia().GetRepresentation(1.0f);
 
   WaitForImageLoad();
   EXPECT_EQ(1, ImageLoadedCount());
   ASSERT_EQ(1u, image->image_skia().image_reps().size());
 
   // Stash loaded image skia, and destroy |image|.
@@ skipping 19 matching lines @@
 }
 
 // Test that new representations added to the image of an IconImage are cached
 // for future use.
 TEST_F(ExtensionIconImageTest, ImageCachesNewRepresentations) {
   // Load up an extension and create an icon image.
   scoped_refptr<Extension> extension(
       CreateExtension("extension_icon_image", Manifest::INVALID_LOCATION));
   ASSERT_TRUE(extension.get() != NULL);
   gfx::ImageSkia default_icon = GetDefaultIcon();
-  scoped_ptr<IconImage> icon_image(
-      new IconImage(browser_context(),
-                    extension.get(),
-                    IconsInfo::GetIcons(extension.get()),
-                    16,
-                    default_icon,
-                    this));
+  std::unique_ptr<IconImage> icon_image(new IconImage(
+      browser_context(), extension.get(), IconsInfo::GetIcons(extension.get()),
+      16, default_icon, this));
 
   // Load an image representation.
   gfx::ImageSkiaRep representation =
       icon_image->image_skia().GetRepresentation(1.0f);
   WaitForImageLoad();
 
   // Cache for later use.
   gfx::Image prior_image = icon_image->image();
 
   // Now the fun part: access the image from the IconImage, and create a png
   // representation of it.
   gfx::Image image = icon_image->image();
   scoped_refptr<base::RefCountedMemory> image_as_png = image.As1xPNGBytes();
 
   // Access the image from the IconImage again, and get a png representation.
   // The two png representations should be exactly equal (the same object),
   // because image storage is shared, so when we created one from the first
   // image, all other images should also have that representation...
   gfx::Image image2 = icon_image->image();
   EXPECT_EQ(image_as_png.get(), image2.As1xPNGBytes().get());
 
   // ...even images that were copied before the representation was constructed.
   EXPECT_EQ(image_as_png.get(), prior_image.As1xPNGBytes().get());
 }
 
 }  // namespace extensions