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

extensions/common/extension_l10n_util.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/common/extension_l10n_util.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <set>
@@ skipping 23 matching lines @@
 
 // Loads contents of the messages file for given locale. If file is not found,
 // or there was parsing error we return NULL and set |error|.
 // Caller owns the returned object.
 base::DictionaryValue* LoadMessageFile(const base::FilePath& locale_path,
                                        const std::string& locale,
                                        std::string* error) {
   base::FilePath file =
       locale_path.AppendASCII(locale).Append(extensions::kMessagesFilename);
   JSONFileValueDeserializer messages_deserializer(file);
-  scoped_ptr<base::DictionaryValue> dictionary = base::DictionaryValue::From(
-      messages_deserializer.Deserialize(NULL, error));
+  std::unique_ptr<base::DictionaryValue> dictionary =
+      base::DictionaryValue::From(
+          messages_deserializer.Deserialize(NULL, error));
   if (!dictionary) {
     if (error->empty()) {
       // JSONFileValueSerializer just returns NULL if file cannot be found. It
       // doesn't set the error, so we have to do it.
       *error = base::StringPrintf("Catalog file is missing for locale %s.",
                                   locale.c_str());
     } else {
       *error = extensions::ErrorUtils::FormatErrorMessage(
           errors::kLocalesInvalidLocale,
           base::UTF16ToUTF8(file.LossyDisplayName()),
@@ skipping 202 matching lines @@
   return true;
 }
 
 bool LocalizeExtension(const base::FilePath& extension_path,
                        base::DictionaryValue* manifest,
                        std::string* error) {
   DCHECK(manifest);
 
   std::string default_locale = GetDefaultLocaleFromManifest(*manifest, error);
 
-  scoped_ptr<extensions::MessageBundle> message_bundle(
-      extensions::file_util::LoadMessageBundle(
-          extension_path, default_locale, error));
+  std::unique_ptr<extensions::MessageBundle> message_bundle(
+      extensions::file_util::LoadMessageBundle(extension_path, default_locale,
+                                               error));
 
   if (!message_bundle.get() && !error->empty())
     return false;
 
   if (message_bundle.get() &&
       !LocalizeManifest(*message_bundle, manifest, error))
     return false;
 
   return true;
 }
@@ skipping 127 matching lines @@
   base::FilePath locale_path = extension_path.Append(extensions::kLocaleFolder);
 
   std::set<std::string> valid_locales;
   if (!GetValidLocales(locale_path, &valid_locales, error))
     return false;
 
   for (std::set<std::string>::const_iterator locale = valid_locales.begin();
        locale != valid_locales.end();
        ++locale) {
     std::string locale_error;
-    scoped_ptr<base::DictionaryValue> catalog(
+    std::unique_ptr<base::DictionaryValue> catalog(
         LoadMessageFile(locale_path, *locale, &locale_error));
 
     if (!locale_error.empty()) {
       if (!error->empty())
         error->append(" ");
       error->append(locale_error);
     }
   }
 
   return error->empty();
@@ skipping 29 matching lines @@
 ScopedLocaleForTest::ScopedLocaleForTest(const std::string& locale)
     : locale_(extension_l10n_util::CurrentLocaleOrDefault()) {
   extension_l10n_util::SetProcessLocale(locale);
 }
 
 ScopedLocaleForTest::~ScopedLocaleForTest() {
   extension_l10n_util::SetProcessLocale(locale_);
 }
 
 }  // namespace extension_l10n_util