Change uses of base::JoinString to pass StringPieces where possible.

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>
 
 #include "base/bind.h"
+#include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/task_runner.h"
 #include "base/task_scheduler/post_task.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/sync_preferences/pref_service_syncable.h"
 #include "content/public/browser/browser_thread.h"
 #include "ui/base/ime/chromeos/component_extension_ime_manager.h"
@@ skipping 66 matching lines @@
         continue;
       }
     }
     value_iter = values.erase(value_iter);
   }
 
   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) {
+void MergeLists(std::vector<base::StringPiece>* dest,
+                const std::vector<base::StringPiece>& src) {
   // Keep track of already-added tokens.
-  std::set<std::string> unique_tokens(dest->begin(), dest->end());
+  std::set<base::StringPiece> unique_tokens(dest->begin(), dest->end());
 
-  for (const std::string& token : src) {
+  for (const auto& token : src) {
     // Skip token if it's already in |dest|.
     if (binary_search(unique_tokens.begin(), unique_tokens.end(), token))
       continue;
     dest->push_back(token);
     unique_tokens.insert(token);
   }
 }
 
 }  // anonymous namespace
 
@@ skipping 57 matching lines @@
     MergeSyncedPrefs();
   }
 }
 
 void InputMethodSyncer::MergeSyncedPrefs() {
   // This should only be done after the first ever sync.
   DCHECK(prefs_->GetBoolean(prefs::kLanguageShouldMergeInputMethods));
   prefs_->SetBoolean(prefs::kLanguageShouldMergeInputMethods, false);
   merging_ = true;
 
+  std::vector<base::StringPiece> synced_tokens;
+  std::vector<base::StringPiece> new_tokens;
+
+  // First, set the syncable prefs to the union of the local and synced prefs.
   std::string preferred_languages_syncable =
       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.
   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);
+      base::SplitStringPiece(preferred_languages_syncable, ",",
+                             base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+  std::string preferred_languages = preferred_languages_.GetValue();
+  new_tokens = base::SplitStringPiece(
+      preferred_languages, ",", 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, ","));
 
+  std::string enabled_extension_imes_syncable =
+      enabled_extension_imes_syncable_.GetValue();
   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);
+      base::SplitStringPiece(enabled_extension_imes_syncable, ",",
+                             base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+  std::string enabled_extension_imes = enabled_extension_imes_.GetValue();
+  new_tokens = base::SplitStringPiece(
+      enabled_extension_imes, ",", 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.
-  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(),
+  std::string preload_engines = preload_engines_.GetValue();
+  std::vector<std::string> new_token_values;
+  new_token_values = base::SplitString(
+      preload_engines, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+  std::transform(new_token_values.begin(), new_token_values.end(),
+                 new_token_values.begin(),
                  extension_ime_util::GetComponentIDByInputMethodID);
+  std::string preload_engines_syncable = preload_engines_syncable_.GetValue();
   synced_tokens =
-      base::SplitString(preload_engines_syncable_.GetValue(), ",",
-                        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+      base::SplitStringPiece(preload_engines_syncable, ",",
+                             base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
+  new_tokens = std::vector<base::StringPiece>(new_token_values.begin(),
+                                              new_token_values.end());
   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(
       AddSupportedInputMethodValues(enabled_extension_imes_.GetValue(),
                                     enabled_extension_imes_syncable,
                                     prefs::kLanguageEnabledExtensionImes));
 
   // Remove unsupported locales before updating the local languages preference.
   std::string languages(
       AddSupportedInputMethodValues(preferred_languages_.GetValue(),
                                     preferred_languages_syncable,
                                     prefs::kLanguagePreferredLanguages));
   base::PostTaskWithTraitsAndReplyWithResult(
       FROM_HERE, base::TaskTraits().MayBlock().WithPriority(
                      base::TaskPriority::BACKGROUND),
       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 =
-      base::SplitString(pref, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
-  std::vector<std::string> new_tokens = base::SplitString(
+  std::vector<base::StringPiece> old_tokens = base::SplitStringPiece(
+      pref, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+  std::vector<std::string> new_token_values = 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();
     std::unique_ptr<input_method::InputMethodDescriptors> supported_descriptors;
 
     if (pref_name == prefs::kLanguagePreloadEngines) {
       // Set the known input methods.
       supported_descriptors = manager->GetSupportedInputMethods();
       // Add the available component extension IMEs.
       ComponentExtensionIMEManager* component_extension_manager =
           manager->GetComponentExtensionIMEManager();
       input_method::InputMethodDescriptors component_descriptors =
           component_extension_manager->GetAllIMEAsInputMethodDescriptor();
       supported_descriptors->insert(supported_descriptors->end(),
                                     component_descriptors.begin(),
                                     component_descriptors.end());
     } else {
       supported_descriptors.reset(new input_method::InputMethodDescriptors);
       ime_state_->GetInputMethodExtensions(supported_descriptors.get());
     }
-    CheckAndResolveInputMethodIDs(*supported_descriptors, &new_tokens);
+    CheckAndResolveInputMethodIDs(*supported_descriptors, &new_token_values);
   } else if (pref_name != prefs::kLanguagePreferredLanguages) {
     NOTREACHED() << "Attempting to merge an invalid preference.";
     // kLanguagePreferredLanguages is checked in CheckAndResolveLocales().
   }
 
   // Do the actual merging.
+  std::vector<base::StringPiece> new_tokens(new_token_values.begin(),
+                                            new_token_values.end());
   MergeLists(&old_tokens, new_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);
@@ skipping 27 matching lines @@
 
 void InputMethodSyncer::OnIsSyncingChanged() {
   if (prefs_->GetBoolean(prefs::kLanguageShouldMergeInputMethods) &&
       prefs_->IsSyncing()) {
     MergeSyncedPrefs();
   }
 }
 
 }  // namespace input_method
 }  // namespace chromeos