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

chrome/browser/ui/webui/chromeos/login/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 "chrome/browser/ui/webui/chromeos/login/l10n_util.h"
 
 #include <stddef.h>
 
 #include <iterator>
 #include <map>
@@ skipping 26 matching lines @@
 #include "ui/base/l10n/l10n_util.h"
 
 namespace chromeos {
 
 const char kMostRelevantLanguagesDivider[] = "MOST_RELEVANT_LANGUAGES_DIVIDER";
 
 namespace {
 
 const char kSequenceToken[] = "chromeos_login_l10n_util";
 
-scoped_ptr<base::DictionaryValue> CreateInputMethodsEntry(
+std::unique_ptr<base::DictionaryValue> CreateInputMethodsEntry(
     const input_method::InputMethodDescriptor& method,
     const std::string selected) {
   input_method::InputMethodUtil* util =
       input_method::InputMethodManager::Get()->GetInputMethodUtil();
   const std::string& ime_id = method.id();
-  scoped_ptr<base::DictionaryValue> input_method(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> input_method(
+      new base::DictionaryValue);
   input_method->SetString("value", ime_id);
   input_method->SetString(
       "title", util->GetInputMethodLongNameStripped(method));
   input_method->SetBoolean("selected", ime_id == selected);
   return input_method;
 }
 
 // Returns true if element was inserted.
 bool InsertString(const std::string& str, std::set<std::string>* to) {
   const std::pair<std::set<std::string>::iterator, bool> result =
       to->insert(str);
   return result.second;
 }
 
 void AddOptgroupOtherLayouts(base::ListValue* input_methods_list) {
-  scoped_ptr<base::DictionaryValue> optgroup(new base::DictionaryValue);
+  std::unique_ptr<base::DictionaryValue> optgroup(new base::DictionaryValue);
   optgroup->SetString(
       "optionGroupName",
       l10n_util::GetStringUTF16(IDS_OOBE_OTHER_KEYBOARD_LAYOUTS));
   input_methods_list->Append(optgroup.release());
 }
 
 base::DictionaryValue* CreateLanguageEntry(
     const std::string& language_code,
     const base::string16& language_display_name,
     const base::string16& language_native_display_name) {
   base::string16 display_name = language_display_name;
   const bool markup_removal =
       base::i18n::UnadjustStringForLocaleDirection(&display_name);
   DCHECK(markup_removal);
 
   const bool has_rtl_chars =
       base::i18n::StringContainsStrongRTLChars(display_name);
   const std::string directionality = has_rtl_chars ? "rtl" : "ltr";
 
-  scoped_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> dictionary(
+      new base::DictionaryValue());
   dictionary->SetString("code", language_code);
   dictionary->SetString("displayName", language_display_name);
   dictionary->SetString("textDirection", directionality);
   dictionary->SetString("nativeDisplayName", language_native_display_name);
   return dictionary.release();
 }
 
 // Gets the list of languages with |descriptors| based on |base_language_codes|.
 // The |most_relevant_language_codes| will be first in the list. If
 // |insert_divider| is true, an entry with its "code" attribute set to
 // kMostRelevantLanguagesDivider is placed between the most relevant languages
 // and all others.
-scoped_ptr<base::ListValue> GetLanguageList(
+std::unique_ptr<base::ListValue> GetLanguageList(
     const input_method::InputMethodDescriptors& descriptors,
     const std::vector<std::string>& base_language_codes,
     const std::vector<std::string>& most_relevant_language_codes,
     bool insert_divider) {
   const std::string app_locale = g_browser_process->GetApplicationLocale();
 
   std::set<std::string> language_codes;
   // Collect the language codes from the supported input methods.
   for (size_t i = 0; i < descriptors.size(); ++i) {
     const input_method::InputMethodDescriptor& descriptor = descriptors[i];
@@ skipping 140 matching lines @@
     // |most_relevant_locales_display_names| is not empty.
     divider16 = base::ASCIIToUTF16(kMostRelevantLanguagesDivider);
     out_display_names.push_back(divider16);
   }
 
   std::copy(display_names.begin(),
             display_names.end(),
             std::back_inserter(out_display_names));
 
   // 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 (size_t i = 0; i < out_display_names.size(); ++i) {
     // Sets the directionality of the display language name.
     base::string16 display_name(out_display_names[i]);
     if (insert_divider && display_name == divider16) {
       // Insert divider.
       base::DictionaryValue* dictionary = new base::DictionaryValue();
       dictionary->SetString("code", kMostRelevantLanguagesDivider);
       language_list->Append(dictionary);
       continue;
     }
@@ skipping 21 matching lines @@
       &layouts_from_locale);
   layouts.insert(layouts.end(), layouts_from_locale.begin(),
                  layouts_from_locale.end());
 
   std::string selected;
   if (!layouts_from_locale.empty()) {
     selected =
         util->GetInputMethodDescriptorFromId(layouts_from_locale[0])->id();
   }
 
-  scoped_ptr<base::ListValue> input_methods_list(new base::ListValue);
+  std::unique_ptr<base::ListValue> input_methods_list(new base::ListValue);
   std::set<std::string> input_methods_added;
   for (std::vector<std::string>::const_iterator it = layouts.begin();
        it != layouts.end(); ++it) {
     const input_method::InputMethodDescriptor* ime =
         util->GetInputMethodDescriptorFromId(*it);
     if (!InsertString(ime->id(), &input_methods_added))
       continue;
     input_methods_list->Append(
         CreateInputMethodsEntry(*ime, selected).release());
   }
@@ skipping 11 matching lines @@
   if (!l10n_util::CheckAndResolveLocale(requested_locale, &resolved_locale))
     return loaded_locale;
 
   if (resolved_locale == loaded_locale)
     return requested_locale;
 
   return loaded_locale;
 }
 
 void ResolveLanguageListOnBlockingPool(
-    scoped_ptr<chromeos::locale_util::LanguageSwitchResult>
+    std::unique_ptr<chromeos::locale_util::LanguageSwitchResult>
         language_switch_result,
     const scoped_refptr<base::TaskRunner> task_runner,
     const UILanguageListResolvedCallback& resolved_callback) {
   DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
 
   std::string selected_language;
   if (!language_switch_result) {
     selected_language =
         StartupCustomizationDocument::GetInstance()->initial_locale_default();
   } else {
@@ skipping 10 matching lines @@
       selected_language = language_switch_result->loaded_locale;
     }
   }
   const std::string selected_code =
       selected_language.empty() ? g_browser_process->GetApplicationLocale()
                                 : selected_language;
 
   const std::string list_locale =
       language_switch_result ? language_switch_result->loaded_locale
                              : g_browser_process->GetApplicationLocale();
-  scoped_ptr<base::ListValue> language_list(
+  std::unique_ptr<base::ListValue> language_list(
       chromeos::GetUILanguageList(nullptr, selected_code));
 
   task_runner->PostTask(
       FROM_HERE, base::Bind(resolved_callback, base::Passed(&language_list),
                             list_locale, selected_language));
 }
 
 void AdjustUILanguageList(const std::string& selected,
                           base::ListValue* languages_list) {
   for (size_t i = 0; i < languages_list->GetSize(); ++i) {
@@ skipping 23 matching lines @@
     language_info->SetString("value", value);
     language_info->SetString("title", display_name);
     if (value == selected)
       language_info->SetBoolean("selected", true);
   }
 }
 
 }  // namespace
 
 void ResolveUILanguageList(
-    scoped_ptr<chromeos::locale_util::LanguageSwitchResult>
+    std::unique_ptr<chromeos::locale_util::LanguageSwitchResult>
         language_switch_result,
     const UILanguageListResolvedCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   content::BrowserThread::GetBlockingPool()->PostTask(
       FROM_HERE, base::Bind(&ResolveLanguageListOnBlockingPool,
                             base::Passed(&language_switch_result),
                             base::ThreadTaskRunnerHandle::Get(), callback));
 }
 
-scoped_ptr<base::ListValue> GetMinimalUILanguageList() {
+std::unique_ptr<base::ListValue> GetMinimalUILanguageList() {
   const std::string application_locale =
       g_browser_process->GetApplicationLocale();
   base::string16 language_native_display_name =
       l10n_util::GetDisplayNameForLocale(
           application_locale, application_locale, true);
 
-  scoped_ptr<base::ListValue> language_list(new base::ListValue());
+  std::unique_ptr<base::ListValue> language_list(new base::ListValue());
   language_list->Append(CreateLanguageEntry(application_locale,
                                             language_native_display_name,
                                             language_native_display_name));
   AdjustUILanguageList(std::string(), language_list.get());
   return language_list;
 }
 
-scoped_ptr<base::ListValue> GetUILanguageList(
+std::unique_ptr<base::ListValue> GetUILanguageList(
     const std::vector<std::string>* most_relevant_language_codes,
     const std::string& selected) {
   ComponentExtensionIMEManager* manager =
       input_method::InputMethodManager::Get()
           ->GetComponentExtensionIMEManager();
   input_method::InputMethodDescriptors descriptors =
       manager->GetXkbIMEAsInputMethodDescriptor();
-  scoped_ptr<base::ListValue> languages_list(GetLanguageList(
-      descriptors,
-      l10n_util::GetAvailableLocales(),
+  std::unique_ptr<base::ListValue> languages_list(GetLanguageList(
+      descriptors, l10n_util::GetAvailableLocales(),
       most_relevant_language_codes
           ? *most_relevant_language_codes
           : StartupCustomizationDocument::GetInstance()->configured_locales(),
       true));
   AdjustUILanguageList(selected, languages_list.get());
   return languages_list;
 }
 
 std::string FindMostRelevantLocale(
     const std::vector<std::string>& most_relevant_language_codes,
@@ skipping 14 matching lines @@
         continue;
       }
       if (available_locale == *most_relevant_it)
         return *most_relevant_it;
     }
   }
 
   return fallback_locale;
 }
 
-scoped_ptr<base::ListValue> GetAcceptLanguageList() {
+std::unique_ptr<base::ListValue> GetAcceptLanguageList() {
   // Collect the language codes from the supported accept-languages.
   const std::string app_locale = g_browser_process->GetApplicationLocale();
   std::vector<std::string> accept_language_codes;
   l10n_util::GetAcceptLanguagesForLocale(app_locale, &accept_language_codes);
   return GetLanguageList(
       *input_method::InputMethodManager::Get()->GetSupportedInputMethods(),
       accept_language_codes,
       StartupCustomizationDocument::GetInstance()->configured_locales(),
       false);
 }
 
-scoped_ptr<base::ListValue> GetAndActivateLoginKeyboardLayouts(
+std::unique_ptr<base::ListValue> GetAndActivateLoginKeyboardLayouts(
     const std::string& locale,
     const std::string& selected,
     bool activate_keyboards) {
-  scoped_ptr<base::ListValue> input_methods_list(new base::ListValue);
+  std::unique_ptr<base::ListValue> input_methods_list(new base::ListValue);
   input_method::InputMethodManager* manager =
       input_method::InputMethodManager::Get();
   input_method::InputMethodUtil* util = manager->GetInputMethodUtil();
 
   const std::vector<std::string>& hardware_login_input_methods =
       util->GetHardwareLoginInputMethodIds();
 
   if (activate_keyboards) {
     DCHECK(
         ProfileHelper::IsSigninProfile(ProfileManager::GetActiveUserProfile()));
     manager->GetActiveIMEState()->EnableLoginLayouts(
         locale, hardware_login_input_methods);
   }
 
-  scoped_ptr<input_method::InputMethodDescriptors> input_methods(
+  std::unique_ptr<input_method::InputMethodDescriptors> input_methods(
       manager->GetActiveIMEState()->GetActiveInputMethods());
   std::set<std::string> input_methods_added;
 
   for (std::vector<std::string>::const_iterator i =
            hardware_login_input_methods.begin();
        i != hardware_login_input_methods.end();
        ++i) {
     const input_method::InputMethodDescriptor* ime =
         util->GetInputMethodDescriptorFromId(*i);
     // Do not crash in case of misconfiguration.
@@ skipping 52 matching lines @@
   // thread.
   std::string (*get_application_locale)(const std::string&, bool) =
       &l10n_util::GetApplicationLocale;
   base::PostTaskAndReplyWithResult(
       background_task_runner.get(),
       FROM_HERE,
       base::Bind(get_application_locale, locale, false /* set_icu_locale */),
       base::Bind(&GetKeyboardLayoutsForResolvedLocale, callback));
 }
 
-scoped_ptr<base::DictionaryValue> GetCurrentKeyboardLayout() {
+std::unique_ptr<base::DictionaryValue> GetCurrentKeyboardLayout() {
   const input_method::InputMethodDescriptor current_input_method =
       input_method::InputMethodManager::Get()
           ->GetActiveIMEState()
           ->GetCurrentInputMethod();
   return CreateInputMethodsEntry(current_input_method,
                                  current_input_method.id());
 }
 
 }  // namespace chromeos