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

extensions/common/file_util.cc

 // Copyright 2013 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/file_util.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
+#include <memory>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_icon_set.h"
 #include "extensions/common/extension_l10n_util.h"
@@ skipping 166 matching lines @@
                                        int flags,
                                        std::string* error) {
   return LoadExtension(extension_path, std::string(), location, flags, error);
 }
 
 scoped_refptr<Extension> LoadExtension(const base::FilePath& extension_path,
                                        const std::string& extension_id,
                                        Manifest::Location location,
                                        int flags,
                                        std::string* error) {
-  scoped_ptr<base::DictionaryValue> manifest =
+  std::unique_ptr<base::DictionaryValue> manifest =
       LoadManifest(extension_path, error);
   if (!manifest.get())
     return NULL;
   if (!extension_l10n_util::LocalizeExtension(
           extension_path, manifest.get(), error)) {
     return NULL;
   }
 
   scoped_refptr<Extension> extension(Extension::Create(
       extension_path, location, *manifest, flags, extension_id, error));
   if (!extension.get())
     return NULL;
 
   std::vector<InstallWarning> warnings;
   if (!ValidateExtension(extension.get(), error, &warnings))
     return NULL;
   extension->AddInstallWarnings(warnings);
 
   return extension;
 }
 
-scoped_ptr<base::DictionaryValue> LoadManifest(
+std::unique_ptr<base::DictionaryValue> LoadManifest(
     const base::FilePath& extension_path,
     std::string* error) {
   return LoadManifest(extension_path, kManifestFilename, error);
 }
 
-scoped_ptr<base::DictionaryValue> LoadManifest(
+std::unique_ptr<base::DictionaryValue> LoadManifest(
     const base::FilePath& extension_path,
     const base::FilePath::CharType* manifest_filename,
     std::string* error) {
   base::FilePath manifest_path = extension_path.Append(manifest_filename);
   if (!base::PathExists(manifest_path)) {
     *error = l10n_util::GetStringUTF8(IDS_EXTENSION_MANIFEST_UNREADABLE);
     return NULL;
   }
 
   JSONFileValueDeserializer deserializer(manifest_path);
-  scoped_ptr<base::Value> root(deserializer.Deserialize(NULL, error));
+  std::unique_ptr<base::Value> root(deserializer.Deserialize(NULL, error));
   if (!root.get()) {
     if (error->empty()) {
       // If |error| is empty, than the file could not be read.
       // It would be cleaner to have the JSON reader give a specific error
       // in this case, but other code tests for a file error with
       // error->empty().  For now, be consistent.
       *error = l10n_util::GetStringUTF8(IDS_EXTENSION_MANIFEST_UNREADABLE);
     } else {
       *error = base::StringPrintf(
           "%s  %s", manifest_errors::kManifestParseError, error->c_str());
@@ skipping 274 matching lines @@
 
 MessageBundle::SubstitutionMap* LoadMessageBundleSubstitutionMap(
     const base::FilePath& extension_path,
     const std::string& extension_id,
     const std::string& default_locale) {
   MessageBundle::SubstitutionMap* return_value =
       new MessageBundle::SubstitutionMap();
   if (!default_locale.empty()) {
     // Touch disk only if extension is localized.
     std::string error;
-    scoped_ptr<MessageBundle> bundle(
+    std::unique_ptr<MessageBundle> bundle(
         LoadMessageBundle(extension_path, default_locale, &error));
 
     if (bundle.get())
       *return_value = *bundle->dictionary();
   }
 
   // Add @@extension_id reserved message here, so it's available to
   // non-localized extensions too.
   return_value->insert(
       std::make_pair(MessageBundle::kExtensionIdKey, extension_id));
@@ skipping 20 matching lines @@
     return return_value;
   }
 
   // Touch disk only if extension is localized.
   default_locale = LocaleInfo::GetDefaultLocale(extension);
   if (default_locale.empty()) {
     return return_value;
   }
 
   std::string error;
-  scoped_ptr<MessageBundle> bundle(
+  std::unique_ptr<MessageBundle> bundle(
       LoadMessageBundle(extension->path(), default_locale, &error));
 
   if (bundle.get()) {
     for (auto iter : *bundle->dictionary()) {
       return_value->insert(std::make_pair(iter.first, iter.second));
     }
   }
 
   auto imports = extensions::SharedModuleInfo::GetImports(extension);
   // Iterate through the imports in reverse.  This will allow later imported
   // modules to override earlier imported modules, as the list order is
   // maintained from the definition in manifest.json of the imports.
   for (auto it = imports.rbegin(); it != imports.rend(); ++it) {
     const extensions::Extension* imported_extension =
         extension_set.GetByID(it->extension_id);
     if (!imported_extension) {
       NOTREACHED() << "Missing shared module " << it->extension_id;
       continue;
     }
-    scoped_ptr<MessageBundle> imported_bundle(
+    std::unique_ptr<MessageBundle> imported_bundle(
         LoadMessageBundle(imported_extension->path(), default_locale, &error));
 
     if (imported_bundle.get()) {
       for (auto iter : *imported_bundle->dictionary()) {
         // |insert| only adds new entries, and does not replace entries in
         // the main extension or previously processed imports.
         return_value->insert(std::make_pair(iter.first, iter.second));
       }
     }
   }
 
   return return_value;
 }
 
 base::FilePath GetVerifiedContentsPath(const base::FilePath& extension_path) {
   return extension_path.Append(kMetadataFolder)
       .Append(kVerifiedContentsFilename);
 }
 base::FilePath GetComputedHashesPath(const base::FilePath& extension_path) {
   return extension_path.Append(kMetadataFolder).Append(kComputedHashesFilename);
 }
 
 }  // namespace file_util
 }  // namespace extensions