Move JoinString to the base namespace

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 74 matching lines @@
                         accept_language_codes.end(),
                         resolved_locale)) {
         *value_iter = resolved_locale;
         ++value_iter;
         continue;
       }
     }
     value_iter = values.erase(value_iter);
   }
 
-  return JoinString(values, ',');
+  return base::JoinString(values, ",");
 }
 
 // Appends tokens from |src| that are not in |dest| to |dest|.
 void MergeLists(std::vector<std::string>* dest,
                 const std::vector<std::string>& src) {
   // Keep track of already-added tokens.
   std::set<std::string> unique_tokens(dest->begin(), dest->end());
 
   for (const std::string& token : src) {
     // Skip token if it's already in |dest|.
@@ skipping 84 matching lines @@
   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);
 
   // Append the synced values to the current values.
   MergeLists(&new_tokens, synced_tokens);
-  preferred_languages_syncable_.SetValue(JoinString(new_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);
 
   MergeLists(&new_tokens, synced_tokens);
-  enabled_extension_imes_syncable_.SetValue(JoinString(new_tokens, ','));
+  enabled_extension_imes_syncable_.SetValue(base::JoinString(new_tokens, ","));
 
   // Revert preload engines to legacy component IDs.
   base::SplitString(preload_engines_.GetValue(), ',', &new_tokens);
   std::transform(new_tokens.begin(), new_tokens.end(), new_tokens.begin(),
                  extension_ime_util::GetComponentIDByInputMethodID);
   base::SplitString(
       preload_engines_syncable_.GetValue(), ',', &synced_tokens);
 
   MergeLists(&new_tokens, synced_tokens);
-  preload_engines_syncable_.SetValue(JoinString(new_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(
       AddSupportedInputMethodValues(enabled_extension_imes_.GetValue(),
                                     enabled_extension_imes_syncable,
                                     prefs::kLanguageEnabledExtensionImes));
@@ skipping 43 matching lines @@
       ime_state_->GetInputMethodExtensions(supported_descriptors.get());
     }
     CheckAndResolveInputMethodIDs(*supported_descriptors, &new_tokens);
   } else if (pref_name != prefs::kLanguagePreferredLanguages) {
     NOTREACHED() << "Attempting to merge an invalid preference.";
     // kLanguagePreferredLanguages is checked in CheckAndResolveLocales().
   }
 
   // Do the actual merging.
   MergeLists(&old_tokens, new_tokens);
-  return JoinString(old_tokens, ',');
+  return base::JoinString(old_tokens, ",");
 }
 
 void InputMethodSyncer::FinishMerge(const std::string& languages) {
   // Since the merge only removed locales that are unsupported on this system,
   // we don't need to update the syncable prefs. If the local preference changes
   // later, the sync server will lose the values we dropped. That's okay since
   // the values from this device should then become the new defaults anyway.
   preferred_languages_.SetValue(languages);
 
   // We've finished merging.
@@ skipping 12 matching lines @@
   // 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::transform(engines.begin(), engines.end(), engines.begin(),
                  extension_ime_util::GetComponentIDByInputMethodID);
-  preload_engines_syncable_.SetValue(JoinString(engines, ','));
+  preload_engines_syncable_.SetValue(base::JoinString(engines, ","));
 }
 
 void InputMethodSyncer::OnIsSyncingChanged() {
   if (prefs_->GetBoolean(prefs::kLanguageShouldMergeInputMethods) &&
       prefs_->IsSyncing()) {
     MergeSyncedPrefs();
   }
 }
 
 }  // namespace input_method
 }  // namespace chromeos