Rewrite simple uses of base::ListValue::Append(base::Value*) on CrOS.

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>
+#include <memory>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/i18n/rtl.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/sequenced_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 36 matching lines @@
   const std::pair<std::set<std::string>::iterator, bool> result =
       to->insert(str);
   return result.second;
 }
 
 void AddOptgroupOtherLayouts(base::ListValue* input_methods_list) {
   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());
+  input_methods_list->Append(std::move(optgroup));
 }
 
 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);
@@ skipping 175 matching lines @@
             display_names.end(),
             std::back_inserter(out_display_names));
 
   // Build the language list from the language map.
   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();
+      auto dictionary = base::MakeUnique<base::DictionaryValue>();
       dictionary->SetString("code", kMostRelevantLanguagesDivider);
-      language_list->Append(dictionary);
+      language_list->Append(std::move(dictionary));
       continue;
     }
 
     const LanguagePair& pair = language_map[out_display_names[i]];
     language_list->Append(
         CreateLanguageEntry(pair.first, out_display_names[i], pair.second));
   }
 
   return language_list;
 }
@@ skipping 32 matching lines @@
                                       &layouts);
 
   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());
+    input_methods_list->Append(CreateInputMethodsEntry(*ime, selected));
   }
 
   callback.Run(std::move(input_methods_list));
 }
 
 // For "UI Language" drop-down menu at OOBE screen we need to decide which
 // entry to mark "selected". If user has just selected "requested_locale",
 // but "loaded_locale" was actually loaded, we mark original user choice
 // "selected" only if loaded_locale is a backup for "requested_locale".
 std::string CalculateSelectedLanguage(const std::string& requested_locale,
@@ skipping 191 matching lines @@
 
   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.
     if (ime) {
       input_methods_added.insert(*i);
-      input_methods_list->Append(
-          CreateInputMethodsEntry(*ime, selected).release());
+      input_methods_list->Append(CreateInputMethodsEntry(*ime, selected));
     } else {
       NOTREACHED();
     }
   }
 
   bool optgroup_added = false;
   for (size_t i = 0; i < input_methods->size(); ++i) {
     // Makes sure the id is in legacy xkb id format.
     const std::string& ime_id = (*input_methods)[i].id();
     if (!InsertString(ime_id, &input_methods_added))
       continue;
     if (!optgroup_added) {
       optgroup_added = true;
       AddOptgroupOtherLayouts(input_methods_list.get());
     }
-    input_methods_list->Append(CreateInputMethodsEntry((*input_methods)[i],
-                                                       selected).release());
+    input_methods_list->Append(
+        CreateInputMethodsEntry((*input_methods)[i], selected));
   }
 
   // "xkb:us::eng" should always be in the list of available layouts.
   const std::string us_keyboard_id =
       util->GetFallbackInputMethodDescriptor().id();
   if (input_methods_added.find(us_keyboard_id) == input_methods_added.end()) {
     const input_method::InputMethodDescriptor* us_eng_descriptor =
         util->GetInputMethodDescriptorFromId(us_keyboard_id);
     DCHECK(us_eng_descriptor);
     if (!optgroup_added) {
       optgroup_added = true;
       AddOptgroupOtherLayouts(input_methods_list.get());
     }
-    input_methods_list->Append(CreateInputMethodsEntry(*us_eng_descriptor,
-                                                       selected).release());
+    input_methods_list->Append(
+        CreateInputMethodsEntry(*us_eng_descriptor, selected));
     manager->GetActiveIMEState()->EnableInputMethod(us_keyboard_id);
   }
   return input_methods_list;
 }
 
 void GetKeyboardLayoutsForLocale(
     const GetKeyboardLayoutsForLocaleCallback& callback,
     const std::string& locale) {
   base::SequencedWorkerPool* worker_pool =
       content::BrowserThread::GetBlockingPool();
@@ skipping 15 matching lines @@
 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