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

chrome/browser/extensions/test_extension_environment.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 "chrome/browser/extensions/test_extension_environment.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
@@ skipping 19 matching lines @@
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/device_settings_service.h"
 #endif
 
 namespace extensions {
 
 using content::BrowserThread;
 
 namespace {
 
-scoped_ptr<base::DictionaryValue> MakeExtensionManifest(
+std::unique_ptr<base::DictionaryValue> MakeExtensionManifest(
     const base::Value& manifest_extra) {
-  scoped_ptr<base::DictionaryValue> manifest = DictionaryBuilder()
-                                                   .Set("name", "Extension")
-                                                   .Set("version", "1.0")
-                                                   .Set("manifest_version", 2)
-                                                   .Build();
+  std::unique_ptr<base::DictionaryValue> manifest =
+      DictionaryBuilder()
+          .Set("name", "Extension")
+          .Set("version", "1.0")
+          .Set("manifest_version", 2)
+          .Build();
   const base::DictionaryValue* manifest_extra_dict;
   if (manifest_extra.GetAsDictionary(&manifest_extra_dict)) {
     manifest->MergeDictionary(manifest_extra_dict);
   } else {
     std::string manifest_json;
     base::JSONWriter::Write(manifest_extra, &manifest_json);
     ADD_FAILURE() << "Expected dictionary; got \"" << manifest_json << "\"";
   }
   return manifest;
 }
 
-scoped_ptr<base::DictionaryValue> MakePackagedAppManifest() {
+std::unique_ptr<base::DictionaryValue> MakePackagedAppManifest() {
   return extensions::DictionaryBuilder()
       .Set("name", "Test App Name")
       .Set("version", "2.0")
       .Set("manifest_version", 2)
       .Set("app", extensions::DictionaryBuilder()
                       .Set("background",
                            extensions::DictionaryBuilder()
                                .Set("scripts", extensions::ListBuilder()
                                                    .Append("background.js")
                                                    .Build())
@@ skipping 64 matching lines @@
     extension_service_ = CreateExtensionServiceForProfile(profile());
   return extension_service_;
 }
 
 ExtensionPrefs* TestExtensionEnvironment::GetExtensionPrefs() {
   return ExtensionPrefs::Get(profile_.get());
 }
 
 const Extension* TestExtensionEnvironment::MakeExtension(
     const base::Value& manifest_extra) {
-  scoped_ptr<base::DictionaryValue> manifest =
+  std::unique_ptr<base::DictionaryValue> manifest =
       MakeExtensionManifest(manifest_extra);
   scoped_refptr<Extension> result =
       ExtensionBuilder().SetManifest(std::move(manifest)).Build();
   GetExtensionService()->AddExtension(result.get());
   return result.get();
 }
 
 const Extension* TestExtensionEnvironment::MakeExtension(
     const base::Value& manifest_extra,
     const std::string& id) {
-  scoped_ptr<base::DictionaryValue> manifest =
+  std::unique_ptr<base::DictionaryValue> manifest =
       MakeExtensionManifest(manifest_extra);
   scoped_refptr<Extension> result =
       ExtensionBuilder().SetManifest(std::move(manifest)).SetID(id).Build();
   GetExtensionService()->AddExtension(result.get());
   return result.get();
 }
 
 scoped_refptr<Extension> TestExtensionEnvironment::MakePackagedApp(
     const std::string& id,
     bool install) {
   scoped_refptr<Extension> result = ExtensionBuilder()
                                         .SetManifest(MakePackagedAppManifest())
                                         .AddFlags(Extension::FROM_WEBSTORE)
                                         .SetID(id)
                                         .Build();
   if (install)
     GetExtensionService()->AddExtension(result.get());
   return result;
 }
 
-scoped_ptr<content::WebContents> TestExtensionEnvironment::MakeTab() const {
-  scoped_ptr<content::WebContents> contents(
+std::unique_ptr<content::WebContents> TestExtensionEnvironment::MakeTab()
+    const {
+  std::unique_ptr<content::WebContents> contents(
       content::WebContentsTester::CreateTestWebContents(profile(), NULL));
   // Create a tab id.
   SessionTabHelper::CreateForWebContents(contents.get());
   return contents;
 }
 
 void TestExtensionEnvironment::DeleteProfile() {
   profile_.reset();
   extension_service_ = nullptr;
 }
 
 }  // namespace extensions