Some easy linked_ptr removal from extensions/common/

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>
 #include <string>
 #include <vector>
 
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/logging.h"
-#include "base/memory/linked_ptr.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/file_util.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/message_bundle.h"
 #include "third_party/icu/source/common/unicode/uloc.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace errors = extensions::manifest_errors;
 namespace keys = extensions::manifest_keys;
 
 namespace {
 
 // 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) {
+std::unique_ptr<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);
   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()),
           *error);
     }
   }
 
-  return dictionary.release();
+  return dictionary;
 }
 
 // Localizes manifest value of string type for a given key.
 bool LocalizeManifestValue(const std::string& key,
                            const extensions::MessageBundle& messages,
                            base::DictionaryValue* manifest,
                            std::string* error) {
   std::string result;
   if (!manifest->GetString(key, &result))
     return true;
@@ skipping 296 matching lines @@
 
 extensions::MessageBundle* LoadMessageCatalogs(
     const base::FilePath& locale_path,
     const std::string& default_locale,
     const std::string& application_locale,
     std::string* error) {
   std::vector<std::string> all_fallback_locales;
   GetAllFallbackLocales(
       application_locale, default_locale, &all_fallback_locales);
 
-  std::vector<linked_ptr<base::DictionaryValue> > catalogs;
+  std::vector<std::unique_ptr<base::DictionaryValue>> catalogs;
   for (size_t i = 0; i < all_fallback_locales.size(); ++i) {
     // Skip all parent locales that are not supplied.
     base::FilePath this_locale_path =
         locale_path.AppendASCII(all_fallback_locales[i]);
     if (!base::PathExists(this_locale_path))
       continue;
-    linked_ptr<base::DictionaryValue> catalog(
-        LoadMessageFile(locale_path, all_fallback_locales[i], error));
+    std::unique_ptr<base::DictionaryValue> catalog =
+        LoadMessageFile(locale_path, all_fallback_locales[i], error);
     if (!catalog.get()) {
       // If locale is valid, but messages.json is corrupted or missing, return
       // an error.
-      return NULL;
+      return nullptr;
     } else {
-      catalogs.push_back(catalog);
+      catalogs.push_back(std::move(catalog));
     }
   }
 
   return extensions::MessageBundle::Create(catalogs, error);
 }
 
 bool ValidateExtensionLocales(const base::FilePath& extension_path,
                               const base::DictionaryValue* manifest,
                               std::string* error) {
   std::string default_locale = GetDefaultLocaleFromManifest(*manifest, error);
 
   if (default_locale.empty())
     return true;
 
   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;
-    std::unique_ptr<base::DictionaryValue> catalog(
-        LoadMessageFile(locale_path, *locale, &locale_error));
+    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 28 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