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

chrome/browser/extensions/component_loader.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/component_loader.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
@@ skipping 74 matching lines @@
                        const base::FilePath& path) {
   std::string raw_key;
   std::string id_input;
   CHECK(manifest->GetString(manifest_keys::kPublicKey, &raw_key));
   CHECK(Extension::ParsePEMKeyBytes(raw_key, &id_input));
   std::string id = crx_file::id_util::GenerateId(id_input);
   return id;
 }
 
 #if defined(OS_CHROMEOS)
-scoped_ptr<base::DictionaryValue>
-LoadManifestOnFileThread(
+std::unique_ptr<base::DictionaryValue> LoadManifestOnFileThread(
     const base::FilePath& root_directory,
     const base::FilePath::CharType* manifest_filename) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
   std::string error;
-  scoped_ptr<base::DictionaryValue> manifest(
+  std::unique_ptr<base::DictionaryValue> manifest(
       file_util::LoadManifest(root_directory, manifest_filename, &error));
   if (!manifest) {
     LOG(ERROR) << "Can't load "
                << root_directory.Append(manifest_filename).AsUTF8Unsafe()
                << ": " << error;
     return nullptr;
   }
   bool localized = extension_l10n_util::LocalizeExtension(
       root_directory, manifest.get(), &error);
   CHECK(localized) << error;
@@ skipping 44 matching lines @@
   for (RegisteredComponentExtensions::iterator it =
           component_extensions_.begin();
       it != component_extensions_.end(); ++it) {
     Load(*it);
   }
 }
 
 base::DictionaryValue* ComponentLoader::ParseManifest(
     const std::string& manifest_contents) const {
   JSONStringValueDeserializer deserializer(manifest_contents);
-  scoped_ptr<base::Value> manifest = deserializer.Deserialize(NULL, NULL);
+  std::unique_ptr<base::Value> manifest = deserializer.Deserialize(NULL, NULL);
 
   if (!manifest.get() || !manifest->IsType(base::Value::TYPE_DICTIONARY)) {
     LOG(ERROR) << "Failed to parse extension manifest.";
     return NULL;
   }
   // Transfer ownership to the caller.
   return static_cast<base::DictionaryValue*>(manifest.release());
 }
 
 void ComponentLoader::ClearAllRegistered() {
@@ skipping 58 matching lines @@
 
   component_extensions_.push_back(info);
   if (extension_service_->is_ready())
     Load(info);
   return info.extension_id;
 }
 
 std::string ComponentLoader::AddOrReplace(const base::FilePath& path) {
   base::FilePath absolute_path = base::MakeAbsoluteFilePath(path);
   std::string error;
-  scoped_ptr<base::DictionaryValue> manifest(
+  std::unique_ptr<base::DictionaryValue> manifest(
       file_util::LoadManifest(absolute_path, &error));
   if (!manifest) {
     LOG(ERROR) << "Could not load extension from '" <<
                   absolute_path.value() << "'. " << error;
     return std::string();
   }
   Remove(GenerateId(manifest.get(), absolute_path));
 
   // We don't check component extensions loaded by path because this is only
   // used by developers for testing.
@@ skipping 521 matching lines @@
                  weak_factory_.GetWeakPtr(),
                  root_directory,
                  extension_id,
                  done_cb));
 }
 
 void ComponentLoader::FinishAddWithManifestFile(
     const base::FilePath& root_directory,
     const char* extension_id,
     const base::Closure& done_cb,
-    scoped_ptr<base::DictionaryValue> manifest) {
+    std::unique_ptr<base::DictionaryValue> manifest) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (!manifest)
     return;  // Error already logged.
   std::string actual_extension_id = Add(
       manifest.release(),
       root_directory,
       false);
   CHECK_EQ(extension_id, actual_extension_id);
   if (!done_cb.is_null())
     done_cb.Run();
 }
 #endif
 
 }  // namespace extensions