Update SplitString calls in chrome.

chrome/browser/chromeos/input_method/input_method_syncer.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/chromeos/input_method/input_method_syncer.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
@@ skipping 40 matching lines @@
     }
   }
 }
 
 // Checks whether each language is supported, replacing locales with variants
 // if they are available. Must be called on a thread that allows IO.
 std::string CheckAndResolveLocales(const std::string& languages) {
   DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
   if (languages.empty())
     return languages;
-  std::vector<std::string> values;
-  base::SplitString(languages, ',', &values);
+  std::vector<std::string> values = base::SplitString(
+      languages, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   const std::string app_locale = g_browser_process->GetApplicationLocale();
 
   std::vector<std::string> accept_language_codes;
   l10n_util::GetAcceptLanguagesForLocale(app_locale, &accept_language_codes);
   std::sort(accept_language_codes.begin(), accept_language_codes.end());
 
   // Remove unsupported language values.
   std::vector<std::string>::iterator value_iter = values.begin();
   while (value_iter != values.end()) {
@@ skipping 111 matching lines @@
       preferred_languages_syncable_.GetValue();
   std::string preload_engines_syncable =
       preload_engines_syncable_.GetValue();
   std::string enabled_extension_imes_syncable =
       enabled_extension_imes_syncable_.GetValue();
 
   std::vector<std::string> synced_tokens;
   std::vector<std::string> new_tokens;
 
   // First, set the syncable prefs to the union of the local and synced prefs.
-  base::SplitString(
-      preferred_languages_syncable_.GetValue(), ',', &synced_tokens);
-  base::SplitString(preferred_languages_.GetValue(), ',', &new_tokens);
+  synced_tokens =
+      base::SplitString(preferred_languages_syncable_.GetValue(), ",",
+                        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+  new_tokens = base::SplitString(preferred_languages_.GetValue(), ",",
+                                 base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   // Append the synced values to the current values.
   MergeLists(&new_tokens, synced_tokens);
   preferred_languages_syncable_.SetValue(base::JoinString(new_tokens, ","));
 
-  base::SplitString(
-      enabled_extension_imes_syncable_.GetValue(), ',', &synced_tokens);
-  base::SplitString(enabled_extension_imes_.GetValue(), ',', &new_tokens);
+  synced_tokens =
+      base::SplitString(enabled_extension_imes_syncable_.GetValue(), ",",
+                        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+  new_tokens = base::SplitString(enabled_extension_imes_.GetValue(), ",",
+                                 base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   MergeLists(&new_tokens, synced_tokens);
   enabled_extension_imes_syncable_.SetValue(base::JoinString(new_tokens, ","));
 
   // Revert preload engines to legacy component IDs.
-  base::SplitString(preload_engines_.GetValue(), ',', &new_tokens);
+  new_tokens = base::SplitString(preload_engines_.GetValue(), ",",
+                                 base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   std::transform(new_tokens.begin(), new_tokens.end(), new_tokens.begin(),
                  extension_ime_util::GetComponentIDByInputMethodID);
-  base::SplitString(
-      preload_engines_syncable_.GetValue(), ',', &synced_tokens);
+  synced_tokens =
+      base::SplitString(preload_engines_syncable_.GetValue(), ",",
+                        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   MergeLists(&new_tokens, synced_tokens);
   preload_engines_syncable_.SetValue(base::JoinString(new_tokens, ","));
 
   // Second, set the local prefs, incorporating new values from the sync server.
   preload_engines_.SetValue(
       AddSupportedInputMethodValues(preload_engines_.GetValue(),
                                     preload_engines_syncable,
                                     prefs::kLanguagePreloadEngines));
   enabled_extension_imes_.SetValue(
@@ skipping 11 matching lines @@
       FROM_HERE,
       base::Bind(&CheckAndResolveLocales, languages),
       base::Bind(&InputMethodSyncer::FinishMerge,
                  weak_factory_.GetWeakPtr()));
 }
 
 std::string InputMethodSyncer::AddSupportedInputMethodValues(
     const std::string& pref,
     const std::string& synced_pref,
     const char* pref_name) {
-  std::vector<std::string> old_tokens;
-  std::vector<std::string> new_tokens;
-  base::SplitString(pref, ',', &old_tokens);
-  base::SplitString(synced_pref, ',', &new_tokens);
+  std::vector<std::string> old_tokens =
+      base::SplitString(pref, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+  std::vector<std::string> new_tokens = base::SplitString(
+      synced_pref, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   // Check and convert the new tokens.
   if (pref_name == prefs::kLanguagePreloadEngines ||
       pref_name == prefs::kLanguageEnabledExtensionImes) {
     input_method::InputMethodManager* manager =
         input_method::InputMethodManager::Get();
     scoped_ptr<input_method::InputMethodDescriptors> supported_descriptors;
 
     if (pref_name == prefs::kLanguagePreloadEngines) {
       // Set the known input methods.
@@ skipping 40 matching lines @@
   if (merging_ || prefs_->GetBoolean(prefs::kLanguageShouldMergeInputMethods))
     return;
 
   // Set the language and input prefs at the same time. Otherwise we may,
   // e.g., use a stale languages setting but push a new preload engines setting.
   preferred_languages_syncable_.SetValue(preferred_languages_.GetValue());
   enabled_extension_imes_syncable_.SetValue(enabled_extension_imes_.GetValue());
 
   // For preload engines, use legacy xkb IDs so the preference can sync
   // across Chrome OS and Chromium OS.
-  std::vector<std::string> engines;
-  base::SplitString(preload_engines_.GetValue(), ',', &engines);
+  std::vector<std::string> engines =
+      base::SplitString(preload_engines_.GetValue(), ",", base::TRIM_WHITESPACE,
+                        base::SPLIT_WANT_ALL);
   std::transform(engines.begin(), engines.end(), engines.begin(),
                  extension_ime_util::GetComponentIDByInputMethodID);
   preload_engines_syncable_.SetValue(base::JoinString(engines, ","));
 }
 
 void InputMethodSyncer::OnIsSyncingChanged() {
   if (prefs_->GetBoolean(prefs::kLanguageShouldMergeInputMethods) &&
       prefs_->IsSyncing()) {
     MergeSyncedPrefs();
   }
 }
 
 }  // namespace input_method
 }  // namespace chromeos