Convert //extensions/{common,shell} from scoped_ptr to std::unique_ptr

extensions/common/manifest_test.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 "extensions/common/manifest_test.h"
 
 #include <utility>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/path_service.h"
 #include "base/strings/pattern.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "extensions/common/extension_l10n_util.h"
 #include "extensions/common/extension_paths.h"
 #include "extensions/common/test_util.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace extensions {
 namespace {
 
 // |manifest_path| is an absolute path to a manifest file.
-scoped_ptr<base::DictionaryValue> LoadManifestFile(
+std::unique_ptr<base::DictionaryValue> LoadManifestFile(
     const base::FilePath& manifest_path,
     std::string* error) {
   base::FilePath extension_path = manifest_path.DirName();
 
   EXPECT_TRUE(base::PathExists(manifest_path)) <<
       "Couldn't find " << manifest_path.value();
 
   JSONFileValueDeserializer deserializer(manifest_path);
-  scoped_ptr<base::DictionaryValue> manifest =
+  std::unique_ptr<base::DictionaryValue> manifest =
       base::DictionaryValue::From(deserializer.Deserialize(NULL, error));
 
   // Most unit tests don't need localization, and they'll fail if we try to
   // localize them, since their manifests don't have a default_locale key.
   // Only localize manifests that indicate they want to be localized.
   // Calling LocalizeExtension at this point mirrors file_util::LoadExtension.
   if (manifest &&
       manifest_path.value().find(FILE_PATH_LITERAL("localized")) !=
       std::string::npos)
     extension_l10n_util::LocalizeExtension(extension_path, manifest.get(),
@@ skipping 17 matching lines @@
     : name_(name), manifest_(nullptr) {}
 
 // This does not take ownership of |manifest|.
 ManifestTest::ManifestData::ManifestData(base::DictionaryValue* manifest,
                                           const char* name)
     : name_(name), manifest_(manifest) {
   CHECK(manifest_) << "Manifest NULL";
 }
 
 ManifestTest::ManifestData::ManifestData(
-    scoped_ptr<base::DictionaryValue> manifest)
+    std::unique_ptr<base::DictionaryValue> manifest)
     : manifest_(manifest.get()), manifest_holder_(std::move(manifest)) {
   CHECK(manifest_) << "Manifest NULL";
 }
 
 ManifestTest::ManifestData::ManifestData(
-    scoped_ptr<base::DictionaryValue> manifest,
+    std::unique_ptr<base::DictionaryValue> manifest,
     const char* name)
     : name_(name),
       manifest_(manifest.get()),
       manifest_holder_(std::move(manifest)) {
   CHECK(manifest_) << "Manifest NULL";
 }
 
 ManifestTest::ManifestData::ManifestData(const ManifestData& m) {
   NOTREACHED();
 }
@@ skipping 15 matching lines @@
 std::string ManifestTest::GetTestExtensionID() const {
   return std::string();
 }
 
 base::FilePath ManifestTest::GetTestDataDir() {
   base::FilePath path;
   PathService::Get(DIR_TEST_DATA, &path);
   return path.AppendASCII("manifest_tests");
 }
 
-scoped_ptr<base::DictionaryValue> ManifestTest::LoadManifest(
-    char const* manifest_name, std::string* error) {
+std::unique_ptr<base::DictionaryValue> ManifestTest::LoadManifest(
+    char const* manifest_name,
+    std::string* error) {
   base::FilePath manifest_path = GetTestDataDir().AppendASCII(manifest_name);
   return LoadManifestFile(manifest_path, error);
 }
 
 scoped_refptr<Extension> ManifestTest::LoadExtension(
     const ManifestData& manifest,
     std::string* error,
     extensions::Manifest::Location location,
     int flags) {
   base::FilePath test_data_dir = GetTestDataDir();
@@ skipping 139 matching lines @@
       break;
     case EXPECT_TYPE_SUCCESS:
       LoadAndExpectSuccess(testcase.manifest_filename_.c_str(),
                            testcase.location_,
                            testcase.flags_);
       break;
    }
 }
 
 }  // namespace extensions