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

chrome/browser/extensions/api/language_settings_private/language_settings_private_api.cc

 // Copyright 2015 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/api/language_settings_private/language_settings_private_api.h"
 
 #include <map>
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
 #include "base/i18n/rtl.h"
 #include "base/memory/linked_ptr.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/api/language_settings_private/language_settings_private_delegate.h"
 #include "chrome/browser/extensions/api/language_settings_private/language_settings_private_delegate_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/spellchecker/spellcheck_factory.h"
 #include "chrome/browser/spellchecker/spellcheck_service.h"
@@ skipping 38 matching lines @@
   std::vector<std::string> language_codes;
   l10n_util::GetAcceptLanguagesForLocale(app_locale, &language_codes);
 
   // Map of display name -> {language code, native display name}.
   typedef std::pair<std::string, base::string16> LanguagePair;
   typedef std::map<base::string16, LanguagePair,
       l10n_util::StringComparator<base::string16>> LanguageMap;
 
   // Collator used to sort display names in the current locale.
   UErrorCode error = U_ZERO_ERROR;
-  scoped_ptr<icu::Collator> collator(icu::Collator::createInstance(
-      icu::Locale(app_locale.c_str()), error));
+  std::unique_ptr<icu::Collator> collator(
+      icu::Collator::createInstance(icu::Locale(app_locale.c_str()), error));
   if (U_FAILURE(error))
     collator.reset();
   LanguageMap language_map(
       l10n_util::StringComparator<base::string16>(collator.get()));
 
   // Build the list of display names and the language map.
   for (const auto& code : language_codes) {
     base::string16 display_name = l10n_util::GetDisplayNameForLocale(
         code, app_locale, false);
     base::string16 native_display_name = l10n_util::GetDisplayNameForLocale(
@@ skipping 13 matching lines @@
       spellcheck_languages.begin(), spellcheck_languages.end());
 
   // Get the list of translatable languages and convert to a set.
   std::vector<std::string> translate_languages;
   translate::TranslateDownloadManager::GetSupportedLanguages(
       &translate_languages);
   const base::hash_set<std::string> translate_language_set(
       translate_languages.begin(), translate_languages.end());
 
   // Build the language list from the language map.
-  scoped_ptr<base::ListValue> language_list(new base::ListValue);
+  std::unique_ptr<base::ListValue> language_list(new base::ListValue);
   for (const auto& entry : language_map) {
     const base::string16& display_name = entry.first;
     const LanguagePair& pair = entry.second;
 
     language_settings_private::Language language;
     language.code = pair.first;
 
     base::string16 adjusted_display_name(display_name);
     base::i18n::AdjustStringForLocaleDirection(&adjusted_display_name);
     language.display_name = base::UTF16ToUTF8(adjusted_display_name);
@@ skipping 22 matching lines @@
     LanguageSettingsPrivateSetLanguageListFunction()
     : chrome_details_(this) {
 }
 
 LanguageSettingsPrivateSetLanguageListFunction::
     ~LanguageSettingsPrivateSetLanguageListFunction() {
 }
 
 ExtensionFunction::ResponseAction
 LanguageSettingsPrivateSetLanguageListFunction::Run() {
-  scoped_ptr<language_settings_private::SetLanguageList::Params> parameters =
-      language_settings_private::SetLanguageList::Params::Create(*args_);
+  std::unique_ptr<language_settings_private::SetLanguageList::Params>
+      parameters =
+          language_settings_private::SetLanguageList::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(parameters.get());
 
-  scoped_ptr<translate::TranslatePrefs> translate_prefs =
+  std::unique_ptr<translate::TranslatePrefs> translate_prefs =
       ChromeTranslateClient::CreateTranslatePrefs(
           chrome_details_.GetProfile()->GetPrefs());
   translate_prefs->UpdateLanguageList(parameters->language_codes);
 
   return RespondNow(NoArguments());
 }
 
 LanguageSettingsPrivateGetSpellcheckDictionaryStatusesFunction::
     LanguageSettingsPrivateGetSpellcheckDictionaryStatusesFunction() {
 }
@@ skipping 45 matching lines @@
 }
 
 void
 LanguageSettingsPrivateGetSpellcheckWordsFunction::OnCustomDictionaryChanged(
     const SpellcheckCustomDictionary::Change& dictionary_change) {
   NOTREACHED() << "SpellcheckCustomDictionary::Observer: "
                   "OnCustomDictionaryChanged() called before "
                   "OnCustomDictionaryLoaded()";
 }
 
-scoped_ptr<base::ListValue>
+std::unique_ptr<base::ListValue>
 LanguageSettingsPrivateGetSpellcheckWordsFunction::GetSpellcheckWords() const {
   SpellcheckService* service =
       SpellcheckServiceFactory::GetForContext(browser_context());
   SpellcheckCustomDictionary* dictionary = service->GetCustomDictionary();
   DCHECK(dictionary->IsLoaded());
 
   // TODO(michaelpg): Sort using app locale.
-  scoped_ptr<base::ListValue> word_list(new base::ListValue());
+  std::unique_ptr<base::ListValue> word_list(new base::ListValue());
   const std::set<std::string>& words = dictionary->GetWords();
   for (const std::string& word : words)
     word_list->AppendString(word);
   return word_list;
 }
 
 LanguageSettingsPrivateAddSpellcheckWordFunction::
     LanguageSettingsPrivateAddSpellcheckWordFunction() {
 }
 
 LanguageSettingsPrivateAddSpellcheckWordFunction::
     ~LanguageSettingsPrivateAddSpellcheckWordFunction() {
 }
 
 ExtensionFunction::ResponseAction
 LanguageSettingsPrivateAddSpellcheckWordFunction::Run() {
-  scoped_ptr<language_settings_private::AddSpellcheckWord::Params> params =
+  std::unique_ptr<language_settings_private::AddSpellcheckWord::Params> params =
       language_settings_private::AddSpellcheckWord::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   SpellcheckService* service =
       SpellcheckServiceFactory::GetForContext(browser_context());
   bool success = service->GetCustomDictionary()->AddWord(params->word);
 
   return RespondNow(OneArgument(new base::FundamentalValue(success)));
 }
 
 LanguageSettingsPrivateRemoveSpellcheckWordFunction::
     LanguageSettingsPrivateRemoveSpellcheckWordFunction() {
 }
 
 LanguageSettingsPrivateRemoveSpellcheckWordFunction::
     ~LanguageSettingsPrivateRemoveSpellcheckWordFunction() {
 }
 
 ExtensionFunction::ResponseAction
 LanguageSettingsPrivateRemoveSpellcheckWordFunction::Run() {
-  scoped_ptr<language_settings_private::RemoveSpellcheckWord::Params> params =
-      language_settings_private::RemoveSpellcheckWord::Params::Create(*args_);
+  std::unique_ptr<language_settings_private::RemoveSpellcheckWord::Params>
+      params = language_settings_private::RemoveSpellcheckWord::Params::Create(
+          *args_);
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   SpellcheckService* service =
       SpellcheckServiceFactory::GetForContext(browser_context());
   bool success = service->GetCustomDictionary()->RemoveWord(params->word);
 
   return RespondNow(OneArgument(new base::FundamentalValue(success)));
 }
 
 LanguageSettingsPrivateGetTranslateTargetLanguageFunction::
@@ skipping 103 matching lines @@
 LanguageSettingsPrivateRemoveInputMethodFunction::
     ~LanguageSettingsPrivateRemoveInputMethodFunction() {
 }
 
 ExtensionFunction::ResponseAction
 LanguageSettingsPrivateRemoveInputMethodFunction::Run() {
   return RespondNow(OneArgument(new base::FundamentalValue(true)));
 }
 
 }  // namespace extensions