Update SplitString calls in chrome.

In many places that iterated over the results, the code was changed to use a range-based for loop over the result of the SplitStirng call.

Review URL: https://codereview.chromium.org/1240183002

Cr-Commit-Position: refs/heads/master@{#339753}

102 files changed, 438 insertions, 463 deletions

diff --git a/chrome/app/chrome_crash_reporter_client.cc b/chrome/app/chrome_crash_reporter_client.cc
index a5474cd..067ab53 100644
--- a/chrome/app/chrome_crash_reporter_client.cc
+++ b/chrome/app/chrome_crash_reporter_client.cc
@@ -135,8 +135,8 @@ bool ChromeCrashReporterClient::ShouldShowRestartDialog(base::string16* title,
   // The CHROME_RESTART var contains the dialog strings separated by '|'.
   // See ChromeBrowserMainPartsWin::PrepareRestartOnCrashEnviroment()
   // for details.
-  std::vector<std::string> dlg_strings;
-  base::SplitString(restart_info, '|', &dlg_strings);
+  std::vector<std::string> dlg_strings = base::SplitString(
+      restart_info, "|", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   if (dlg_strings.size() < 3)
     return false;
diff --git a/chrome/browser/autocomplete/bookmark_provider_unittest.cc b/chrome/browser/autocomplete/bookmark_provider_unittest.cc
index 7a5e5a4..77d2dfb 100644
--- a/chrome/browser/autocomplete/bookmark_provider_unittest.cc
+++ b/chrome/browser/autocomplete/bookmark_provider_unittest.cc
@@ -461,14 +461,14 @@ TEST_F(BookmarkProviderTest, StripHttpAndAdjustOffsets) {
     const AutocompleteMatch& match = matches[0];
     EXPECT_EQ(base::ASCIIToUTF16(query_data[i].expected_contents),
               match.contents) << description;
-    std::vector<std::string> class_strings;
-    base::SplitString(
-        query_data[i].expected_contents_class, ',', &class_strings);
+    std::vector<std::string> class_strings = base::SplitString(
+        query_data[i].expected_contents_class, ",",
+        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     ASSERT_EQ(class_strings.size(), match.contents_class.size())
         << description;
     for (size_t i = 0; i < class_strings.size(); ++i) {
-      std::vector<std::string> chunks;
-      base::SplitString(class_strings[i], ':', &chunks);
+      std::vector<std::string> chunks = base::SplitString(
+          class_strings[i], ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
       ASSERT_EQ(2U, chunks.size()) << description;
       size_t offset;
       EXPECT_TRUE(base::StringToSizeT(chunks[0], &offset)) << description;
diff --git a/chrome/browser/autofill/autofill_browsertest.cc b/chrome/browser/autofill/autofill_browsertest.cc
index 69d6eaf..878027a6 100644
--- a/chrome/browser/autofill/autofill_browsertest.cc
+++ b/chrome/browser/autofill/autofill_browsertest.cc
@@ -242,8 +242,8 @@ class AutofillTest : public InProcessBrowserTest {
         ui_test_utils::GetTestFilePath(base::FilePath().AppendASCII("autofill"),
                                        base::FilePath().AppendASCII(filename));
     CHECK(base::ReadFileToString(data_file, &data));
-    std::vector<std::string> lines;
-    base::SplitString(data, '\n', &lines);
+    std::vector<std::string> lines = base::SplitString(
+        data, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     int parsed_profiles = 0;
     for (size_t i = 0; i < lines.size(); ++i) {
       if (base::StartsWith(lines[i], "#", base::CompareCase::SENSITIVE))
diff --git a/chrome/browser/chromeos/accessibility/accessibility_manager.cc b/chrome/browser/chromeos/accessibility/accessibility_manager.cc
index 993d426..1a47aad 100644
--- a/chrome/browser/chromeos/accessibility/accessibility_manager.cc
+++ b/chrome/browser/chromeos/accessibility/accessibility_manager.cc
@@ -827,10 +827,9 @@ void AccessibilityManager::UpdateBrailleImeState() {
   if (!profile_)
     return;
   PrefService* pref_service = profile_->GetPrefs();
-  std::vector<std::string> preload_engines;
-  base::SplitString(pref_service->GetString(prefs::kLanguagePreloadEngines),
-                    ',',
-                    &preload_engines);
+  std::vector<std::string> preload_engines =
+      base::SplitString(pref_service->GetString(prefs::kLanguagePreloadEngines),
+                        ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   std::vector<std::string>::iterator it =
       std::find(preload_engines.begin(),
                 preload_engines.end(),
diff --git a/chrome/browser/chromeos/camera_detector.cc b/chrome/browser/chromeos/camera_detector.cc
index 8c5deff..918a869 100644
--- a/chrome/browser/chromeos/camera_detector.cc
+++ b/chrome/browser/chromeos/camera_detector.cc
@@ -75,8 +75,9 @@ bool CameraDetector::CheckPresence() {
     std::string v4l_capabilities;
     if (storage_monitor::GetUdevDevicePropertyValueByPath(
             path, kV4LCapabilities, &v4l_capabilities)) {
-      std::vector<std::string> caps;
-      base::SplitString(v4l_capabilities, kV4LCapabilitiesDelim, &caps);
+      std::vector<std::string> caps = base::SplitString(
+          v4l_capabilities, std::string(1, kV4LCapabilitiesDelim),
+          base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
       if (find(caps.begin(), caps.end(), kV4LCaptureCapability) != caps.end()) {
         return true;
       }
diff --git a/chrome/browser/chromeos/customization/customization_document.cc b/chrome/browser/chromeos/customization/customization_document.cc
index 83be1ce..22e19268 100644
--- a/chrome/browser/chromeos/customization/customization_document.cc
+++ b/chrome/browser/chromeos/customization/customization_document.cc
@@ -329,8 +329,8 @@ void StartupCustomizationDocument::Init(
                                            &initial_timezone_);
   statistics_provider->GetMachineStatistic(kKeyboardLayoutAttr,
                                            &keyboard_layout_);
-  configured_locales_.resize(0);
-  base::SplitString(initial_locale_, ',', &configured_locales_);
+  configured_locales_ = base::SplitString(
+      initial_locale_, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   // Convert ICU locale to chrome ("en_US" to "en-US", etc.).
   std::for_each(configured_locales_.begin(), configured_locales_.end(),
diff --git a/chrome/browser/chromeos/customization/customization_document_browsertest.cc b/chrome/browser/chromeos/customization/customization_document_browsertest.cc
index 7ba8243..fc61d5d 100644
--- a/chrome/browser/chromeos/customization/customization_document_browsertest.cc
+++ b/chrome/browser/chromeos/customization/customization_document_browsertest.cc
@@ -215,8 +215,8 @@ class CustomizationVPDTest : public InProcessBrowserTest,
 };
 
 IN_PROC_BROWSER_TEST_P(CustomizationVPDTest, GetUILanguageList) {
-  std::vector<std::string> locales;
-  base::SplitString(GetParam(), ',', &locales);
+  std::vector<std::string> locales = base::SplitString(
+      GetParam(), ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   for (std::string& l : locales) {
     base::TrimString(l, " ", &l);
diff --git a/chrome/browser/chromeos/display/display_preferences.cc b/chrome/browser/chromeos/display/display_preferences.cc
index b046013..8d0dea9 100644
--- a/chrome/browser/chromeos/display/display_preferences.cc
+++ b/chrome/browser/chromeos/display/display_preferences.cc
@@ -121,8 +121,8 @@ void LoadDisplayLayouts() {
     }
 
     if (it.key().find(",") != std::string::npos) {
-      std::vector<std::string> ids;
-      base::SplitString(it.key(), ',', &ids);
+      std::vector<std::string> ids = base::SplitString(
+          it.key(), ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
       int64 id1 = gfx::Display::kInvalidDisplayID;
       int64 id2 = gfx::Display::kInvalidDisplayID;
       if (!base::StringToInt64(ids[0], &id1) ||
diff --git a/chrome/browser/chromeos/input_method/input_method_manager_impl.cc b/chrome/browser/chromeos/input_method/input_method_manager_impl.cc
index 7326e5e..12d114f 100644
--- a/chrome/browser/chromeos/input_method/input_method_manager_impl.cc
+++ b/chrome/browser/chromeos/input_method/input_method_manager_impl.cc
@@ -606,8 +606,8 @@ void InputMethodManagerImpl::StateImpl::SetInputMethodLoginDefaultFromVPD(
   if (layout.empty())
     return;
 
-  std::vector<std::string> layouts;
-  base::SplitString(layout, ',', &layouts);
+  std::vector<std::string> layouts = base::SplitString(
+      layout, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   manager_->MigrateInputMethods(&layouts);
 
   PrefService* prefs = g_browser_process->local_state();
diff --git a/chrome/browser/chromeos/input_method/input_method_syncer.cc b/chrome/browser/chromeos/input_method/input_method_syncer.cc
index 6823f23..7190476 100644
--- a/chrome/browser/chromeos/input_method/input_method_syncer.cc
+++ b/chrome/browser/chromeos/input_method/input_method_syncer.cc
@@ -58,8 +58,8 @@ 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();
 
@@ -191,27 +191,33 @@ void InputMethodSyncer::MergeSyncedPrefs() {
   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, ","));
@@ -243,10 +249,10 @@ 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 ||
@@ -307,8 +313,9 @@ void InputMethodSyncer::OnPreferenceChanged(const std::string& pref_name) {
 
   // 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, ","));
diff --git a/chrome/browser/chromeos/login/chrome_restart_request.cc b/chrome/browser/chromeos/login/chrome_restart_request.cc
index e3cb8c4..c82550e 100644
--- a/chrome/browser/chromeos/login/chrome_restart_request.cc
+++ b/chrome/browser/chromeos/login/chrome_restart_request.cc
@@ -256,10 +256,9 @@ std::string DeriveCommandLine(const GURL& start_url,
 // Simulates a session manager restart by launching give command line
 // and exit current process.
 void ReLaunch(const std::string& command_line) {
-  std::vector<std::string> argv;
-
   // This is not a proper way to get |argv| but it's good enough for debugging.
-  base::SplitString(command_line, ' ', &argv);
+  std::vector<std::string> argv = base::SplitString(
+      command_line, " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   base::LaunchProcess(argv, base::LaunchOptions());
   chrome::AttemptUserExit();
diff --git a/chrome/browser/chromeos/login/language_list.cc b/chrome/browser/chromeos/login/language_list.cc
index f6bf251..9e39539 100644
--- a/chrome/browser/chromeos/login/language_list.cc
+++ b/chrome/browser/chromeos/login/language_list.cc
@@ -78,10 +78,9 @@ int LanguageList::GetIndexFromLocale(const std::string& locale) const {
 
 void LanguageList::CopySpecifiedLanguagesUp(const std::string& locale_codes) {
   DCHECK(!locale_names_.empty());
-  std::vector<std::string> locale_codes_vector;
-  base::SplitString(locale_codes, ',', &locale_codes_vector);
-  for (size_t i = 0; i != locale_codes_vector.size(); ++i) {
-    const int locale_index = GetIndexFromLocale(locale_codes_vector[i]);
+  for (const std::string& code : base::SplitString(
+           locale_codes, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
+    const int locale_index = GetIndexFromLocale(code);
     CHECK_NE(locale_index, -1);
     locale_names_.insert(locale_names_.begin(), locale_names_[locale_index]);
   }
diff --git a/chrome/browser/chromeos/power/cpu_data_collector.cc b/chrome/browser/chromeos/power/cpu_data_collector.cc
index bc43420..a4eb50f 100644
--- a/chrome/browser/chromeos/power/cpu_data_collector.cc
+++ b/chrome/browser/chromeos/power/cpu_data_collector.cc
@@ -232,22 +232,21 @@ void SampleCpuFreqData(
 
       freq_sample.time = now;
 
-      std::vector<std::string> lines;
-      base::SplitString(time_in_state_string, '\n', &lines);
+      std::vector<base::StringPiece> lines =
+          base::SplitStringPiece(time_in_state_string, "\n",
+                                 base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
       // The last line could end with '\n'. Ignore the last empty string in
       // such cases.
       size_t state_count = lines.size();
       if (state_count > 0 && lines.back().empty())
         state_count -= 1;
       for (size_t state = 0; state < state_count; ++state) {
-        std::vector<std::string> pair;
         int freq_in_khz;
         int64 occupancy_time_centisecond;
 
         // Occupancy of each state is in the format "<state> <time>"
-        base::SplitString(lines[state], ' ', &pair);
-        for (size_t s = 0; s < pair.size(); ++s)
-          base::TrimWhitespace(pair[s], base::TRIM_ALL, &pair[s]);
+        std::vector<base::StringPiece> pair = base::SplitStringPiece(
+            lines[state], " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
         if (pair.size() == 2 &&
             base::StringToInt(pair[0], &freq_in_khz) &&
             base::StringToInt64(pair[1], &occupancy_time_centisecond)) {
diff --git a/chrome/browser/chromeos/power/peripheral_battery_observer.cc b/chrome/browser/chromeos/power/peripheral_battery_observer.cc
index 22089fa..1ef701e2 100644
--- a/chrome/browser/chromeos/power/peripheral_battery_observer.cc
+++ b/chrome/browser/chromeos/power/peripheral_battery_observer.cc
@@ -63,8 +63,8 @@ std::string ExtractBluetoothAddress(const std::string& path) {
     return std::string();
   std::string reverse_address = path.substr(header_size, key_len);
   base::StringToLowerASCII(&reverse_address);
-  std::vector<std::string> result;
-  base::SplitString(reverse_address, ':', &result);
+  std::vector<std::string> result = base::SplitString(
+      reverse_address, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   std::reverse(result.begin(), result.end());
   std::string address = base::JoinString(result, ":");
   return address;
diff --git a/chrome/browser/chromeos/preferences.cc b/chrome/browser/chromeos/preferences.cc
index e19c8ff..848c825 100644
--- a/chrome/browser/chromeos/preferences.cc
+++ b/chrome/browser/chromeos/preferences.cc
@@ -553,9 +553,10 @@ void Preferences::ApplyPreferences(ApplyReason reason,
     std::string value(enabled_extension_imes_.GetValue());
 
     std::vector<std::string> split_values;
-    if (!value.empty())
-      base::SplitString(value, ',', &split_values);
-
+    if (!value.empty()) {
+      split_values = base::SplitString(value, ",", base::TRIM_WHITESPACE,
+                                       base::SPLIT_WANT_ALL);
+    }
     ime_state_->SetEnabledExtensionImes(&split_values);
   }
 
@@ -622,8 +623,10 @@ void Preferences::SetLanguageConfigStringListAsCSV(const char* section,
   VLOG(1) << "Setting " << name << " to '" << value << "'";
 
   std::vector<std::string> split_values;
-  if (!value.empty())
-    base::SplitString(value, ',', &split_values);
+  if (!value.empty()) {
+    split_values = base::SplitString(value, ",", base::TRIM_WHITESPACE,
+                                     base::SPLIT_WANT_ALL);
+  }
 
   // Transfers the xkb id to extension-xkb id.
   if (input_method_manager_->MigrateInputMethods(&split_values))
diff --git a/chrome/browser/chromeos/preferences_unittest.cc b/chrome/browser/chromeos/preferences_unittest.cc
index f790cba..3d391ef 100644
--- a/chrome/browser/chromeos/preferences_unittest.cc
+++ b/chrome/browser/chromeos/preferences_unittest.cc
@@ -340,8 +340,8 @@ class InputMethodPreferencesTest : public PreferencesTest {
 
   // Translates engine IDs in a CSV string to input method IDs.
   std::string ToInputMethodIds(std::string value) {
-    std::vector<std::string> tokens;
-    base::SplitString(value, ',', &tokens);
+    std::vector<std::string> tokens = base::SplitString(
+        value, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     std::transform(tokens.begin(), tokens.end(), tokens.begin(),
                    &extension_ime_util::GetInputMethodIDByEngineID);
     return base::JoinString(tokens, ",");
diff --git a/chrome/browser/component_updater/widevine_cdm_component_installer.cc b/chrome/browser/component_updater/widevine_cdm_component_installer.cc
index 403c487..3552617 100644
--- a/chrome/browser/component_updater/widevine_cdm_component_installer.cc
+++ b/chrome/browser/component_updater/widevine_cdm_component_installer.cc
@@ -156,12 +156,11 @@ bool CheckForCompatibleVersion(const base::DictionaryValue& manifest,
   DLOG_IF(WARNING, versions_string.empty())
       << "Widevine CDM component manifest has empty " << version_name;
 
-  std::vector<std::string> versions;
-  base::SplitString(versions_string, kCdmValueDelimiter, &versions);
-
-  for (size_t i = 0; i < versions.size(); ++i) {
+  for (const base::StringPiece& ver_str : base::SplitStringPiece(
+           versions_string, std::string(1, kCdmValueDelimiter),
+           base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
     int version = 0;
-    if (base::StringToInt(versions[i], &version))
+    if (base::StringToInt(ver_str, &version))
       if (version_check_func(version))
         return true;
   }
diff --git a/chrome/browser/download/download_prefs.cc b/chrome/browser/download/download_prefs.cc
index 589a18f..f6a3209 100644
--- a/chrome/browser/download/download_prefs.cc
+++ b/chrome/browser/download/download_prefs.cc
@@ -159,10 +159,10 @@ DownloadPrefs::DownloadPrefs(Profile* profile) : profile_(profile) {
   // download completion in this pref.
   std::string extensions_to_open =
       prefs->GetString(prefs::kDownloadExtensionsToOpen);
-  std::vector<std::string> extensions;
-  base::SplitString(extensions_to_open, ':', &extensions);
 
-  for (const auto& extension_string : extensions) {
+  for (const auto& extension_string : base::SplitString(
+           extensions_to_open, ":",
+           base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
 #if defined(OS_POSIX)
     base::FilePath::StringType extension = extension_string;
 #elif defined(OS_WIN)
diff --git a/chrome/browser/extensions/api/commands/command_service.cc b/chrome/browser/extensions/api/commands/command_service.cc
index 7636c93..5ff8711 100644
--- a/chrome/browser/extensions/api/commands/command_service.cc
+++ b/chrome/browser/extensions/api/commands/command_service.cc
@@ -389,12 +389,12 @@ Command CommandService::FindCommandByName(const std::string& extension_id,
     bool global = false;
     item->GetBoolean(kGlobal, &global);
 
-    std::vector<std::string> tokens;
-    base::SplitString(shortcut, ':', &tokens);
+    std::vector<base::StringPiece> tokens = base::SplitStringPiece(
+        shortcut, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     CHECK(tokens.size() >= 2);
-    shortcut = tokens[1];
 
-    return Command(command_name, base::string16(), shortcut, global);
+    return Command(command_name, base::string16(), tokens[1].as_string(),
+           global);
   }
 
   return Command();
diff --git a/chrome/browser/extensions/api/file_system/file_system_api_unittest.cc b/chrome/browser/extensions/api/file_system/file_system_api_unittest.cc
index 9a01de9..e6df024 100644
--- a/chrome/browser/extensions/api/file_system/file_system_api_unittest.cc
+++ b/chrome/browser/extensions/api/file_system/file_system_api_unittest.cc
@@ -61,13 +61,15 @@ AcceptOption* BuildAcceptOption(const std::string& description,
     option->description.reset(new std::string(description));
 
   if (!mime_types.empty()) {
-    option->mime_types.reset(new std::vector<std::string>());
-    base::SplitString(mime_types, ',', option->mime_types.get());
+    option->mime_types.reset(new std::vector<std::string>(
+        base::SplitString(mime_types, ",",
+                          base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)));
   }
 
   if (!extensions.empty()) {
-    option->extensions.reset(new std::vector<std::string>());
-    base::SplitString(extensions, ',', option->extensions.get());
+    option->extensions.reset(new std::vector<std::string>(
+        base::SplitString(extensions, ",",
+                          base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)));
   }
 
   return option;
diff --git a/chrome/browser/extensions/api/i18n/i18n_api.cc b/chrome/browser/extensions/api/i18n/i18n_api.cc
index ca40229..b1b9f94 100644
--- a/chrome/browser/extensions/api/i18n/i18n_api.cc
+++ b/chrome/browser/extensions/api/i18n/i18n_api.cc
@@ -45,8 +45,8 @@ bool I18nGetAcceptLanguagesFunction::RunSync() {
     return false;
   }
 
-  std::vector<std::string> languages;
-  base::SplitString(accept_languages, ',', &languages);
+  std::vector<std::string> languages = base::SplitString(
+      accept_languages, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   languages.erase(std::remove(languages.begin(), languages.end(), ""),
                   languages.end());
 
diff --git a/chrome/browser/extensions/api/identity/gaia_web_auth_flow.cc b/chrome/browser/extensions/api/identity/gaia_web_auth_flow.cc
index d97fca42..825c87c 100644
--- a/chrome/browser/extensions/api/identity/gaia_web_auth_flow.cc
+++ b/chrome/browser/extensions/api/identity/gaia_web_auth_flow.cc
@@ -52,8 +52,8 @@ GaiaWebAuthFlow::GaiaWebAuthFlow(Delegate* delegate,
 
   std::vector<std::string> scopes(token_key->scopes.begin(),
                                   token_key->scopes.end());
-  std::vector<std::string> client_id_parts;
-  base::SplitString(oauth2_client_id, '.', &client_id_parts);
+  std::vector<std::string> client_id_parts = base::SplitString(
+      oauth2_client_id, ".", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   std::reverse(client_id_parts.begin(), client_id_parts.end());
   redirect_scheme_ = base::JoinString(client_id_parts, ".");
   std::string signin_scoped_device_id;
diff --git a/chrome/browser/extensions/api/log_private/log_parser.cc b/chrome/browser/extensions/api/log_private/log_parser.cc
index d88c73a..ef6c59e 100644
--- a/chrome/browser/extensions/api/log_private/log_parser.cc
+++ b/chrome/browser/extensions/api/log_private/log_parser.cc
@@ -28,9 +28,9 @@ void LogParser::Parse(
     const string& input,
     std::vector<linked_ptr<api::log_private::LogEntry> >* output,
     FilterHandler* filter_handler) const {
-  std::vector<string> entries;
   // Assume there is no newline in the log entry
-  base::SplitString(input, '\n', &entries);
+  std::vector<string> entries = base::SplitString(
+      input, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   for (size_t i = 0; i < entries.size(); i++) {
     ParseEntry(entries[i], output, filter_handler);
diff --git a/chrome/browser/extensions/extension_apitest.cc b/chrome/browser/extensions/extension_apitest.cc
index 48ddbaf..261ee75 100644
--- a/chrome/browser/extensions/extension_apitest.cc
+++ b/chrome/browser/extensions/extension_apitest.cc
@@ -94,11 +94,9 @@ scoped_ptr<net::test_server::HttpResponse> HandleSetCookieRequest(
   std::string cookie_value =
       request.relative_url.substr(query_string_pos + 1);
 
-  std::vector<std::string> cookies;
-  base::SplitString(cookie_value, '&', &cookies);
-
-  for (size_t i = 0; i < cookies.size(); i++)
-    http_response->AddCustomHeader("Set-Cookie", cookies[i]);
+  for (const std::string& cookie : base::SplitString(
+           cookie_value, "&", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL))
+    http_response->AddCustomHeader("Set-Cookie", cookie);
 
   return http_response.Pass();
 }
diff --git a/chrome/browser/extensions/install_signer.cc b/chrome/browser/extensions/install_signer.cc
index 8ec39e5..6b7aa35 100644
--- a/chrome/browser/extensions/install_signer.cc
+++ b/chrome/browser/extensions/install_signer.cc
@@ -293,8 +293,8 @@ ExtensionIdSet InstallSigner::GetForcedNotFromWebstore() {
   if (value.empty())
     return ExtensionIdSet();
 
-  std::vector<std::string> ids;
-  base::SplitString(value, ',', &ids);
+  std::vector<std::string> ids = base::SplitString(
+      value, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   return ExtensionIdSet(ids.begin(), ids.end());
 }
 
diff --git a/chrome/browser/extensions/updater/extension_updater_unittest.cc b/chrome/browser/extensions/updater/extension_updater_unittest.cc
index e4b7b7b..dc7c70d 100644
--- a/chrome/browser/extensions/updater/extension_updater_unittest.cc
+++ b/chrome/browser/extensions/updater/extension_updater_unittest.cc
@@ -557,11 +557,10 @@ static const int kUpdateFrequencySecs = 15;
 // "foo", and "c" to "".
 static void ExtractParameters(const std::string& params,
                               std::map<std::string, std::string>* result) {
-  std::vector<std::string> pairs;
-  base::SplitString(params, '&', &pairs);
-  for (size_t i = 0; i < pairs.size(); i++) {
-    std::vector<std::string> key_val;
-    base::SplitString(pairs[i], '=', &key_val);
+  for (const std::string& pair : base::SplitString(
+           params, "&", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
+    std::vector<std::string> key_val = base::SplitString(
+        pair, "=", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     if (!key_val.empty()) {
       std::string key = key_val[0];
       EXPECT_TRUE(result->find(key) == result->end());
diff --git a/chrome/browser/io_thread.cc b/chrome/browser/io_thread.cc
index 43eb98b..c0fb936 100644
--- a/chrome/browser/io_thread.cc
+++ b/chrome/browser/io_thread.cc
@@ -314,16 +314,14 @@ void ConfigureSpdyGlobalsFromUseSpdyArgument(const std::string& mode,
   static const char kDisableAltProtocols[] = "no-alt-protocols";
   static const char kInitialMaxConcurrentStreams[] = "init-max-streams";
 
-  std::vector<std::string> spdy_options;
-  base::SplitString(mode, ',', &spdy_options);
-
-  for (const std::string& element : spdy_options) {
-    std::vector<std::string> name_value;
-    base::SplitString(element, '=', &name_value);
-    const std::string& option =
-        name_value.size() > 0 ? name_value[0] : std::string();
-    const std::string value =
-        name_value.size() > 1 ? name_value[1] : std::string();
+  for (const base::StringPiece& element : base::SplitStringPiece(
+           mode, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
+    std::vector<base::StringPiece> name_value = base::SplitStringPiece(
+        element, "=", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+    const base::StringPiece option =
+        name_value.size() > 0 ? name_value[0] : base::StringPiece();
+    const base::StringPiece value =
+        name_value.size() > 1 ? name_value[1] : base::StringPiece();
 
     if (option == kOff) {
       net::HttpStreamFactory::set_spdy_enabled(false);
@@ -335,7 +333,7 @@ void ConfigureSpdyGlobalsFromUseSpdyArgument(const std::string& mode,
     }
     if (option == kExclude) {
       globals->forced_spdy_exclusions.insert(
-          net::HostPortPair::FromURL(GURL(value)));
+          net::HostPortPair::FromURL(GURL(value.as_string())));
       continue;
     }
     if (option == kDisableCompression) {
@@ -353,7 +351,7 @@ void ConfigureSpdyGlobalsFromUseSpdyArgument(const std::string& mode,
         continue;
       }
     }
-    LOG(DFATAL) << "Unrecognized spdy option: " << option;
+    LOG(DFATAL) << "Unrecognized spdy option: " << option.as_string();
   }
 }
 
@@ -688,13 +686,10 @@ void IOThread::Init() {
   if (command_line.HasSwitch(switches::kCertificateTransparencyLog)) {
     std::string switch_value = command_line.GetSwitchValueASCII(
         switches::kCertificateTransparencyLog);
-    std::vector<std::string> logs;
-    base::SplitString(switch_value, ',', &logs);
-    for (std::vector<std::string>::iterator it = logs.begin(); it != logs.end();
-         ++it) {
-      const std::string& curr_log = *it;
-      std::vector<std::string> log_metadata;
-      base::SplitString(curr_log, ':', &log_metadata);
+    for (const base::StringPiece& curr_log : base::SplitStringPiece(
+             switch_value, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
+      std::vector<std::string> log_metadata = base::SplitString(
+          curr_log, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
       CHECK_GE(log_metadata.size(), 3u)
           << "CT log metadata missing: Switch format is "
           << "'description:base64_key:url_without_schema'.";
diff --git a/chrome/browser/media/webrtc_log_uploader_unittest.cc b/chrome/browser/media/webrtc_log_uploader_unittest.cc
index c3bf518..f36e002 100644
--- a/chrome/browser/media/webrtc_log_uploader_unittest.cc
+++ b/chrome/browser/media/webrtc_log_uploader_unittest.cc
@@ -35,8 +35,8 @@ class WebRtcLogUploaderTest : public testing::Test {
     std::string last_line = GetLastLineFromListFile();
     if (last_line.empty())
       return false;
-    std::vector<std::string> line_parts;
-    base::SplitString(last_line, ',', &line_parts);
+    std::vector<std::string> line_parts = base::SplitString(
+        last_line, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     EXPECT_EQ(3u, line_parts.size());
     if (3u != line_parts.size())
       return false;
@@ -52,8 +52,8 @@ class WebRtcLogUploaderTest : public testing::Test {
     std::string last_line = GetLastLineFromListFile();
     if (last_line.empty())
       return false;
-    std::vector<std::string> line_parts;
-    base::SplitString(last_line, ',', &line_parts);
+    std::vector<std::string> line_parts = base::SplitString(
+        last_line, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     EXPECT_EQ(3u, line_parts.size());
     if (3u != line_parts.size())
       return false;
@@ -67,8 +67,8 @@ class WebRtcLogUploaderTest : public testing::Test {
     std::string last_line = GetLastLineFromListFile();
     if (last_line.empty())
       return false;
-    std::vector<std::string> line_parts;
-    base::SplitString(last_line, ',', &line_parts);
+    std::vector<std::string> line_parts = base::SplitString(
+        last_line, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     EXPECT_EQ(3u, line_parts.size());
     if (3u != line_parts.size())
       return false;
@@ -111,8 +111,8 @@ class WebRtcLogUploaderTest : public testing::Test {
     // Since every line should end with '\n', the last line should be empty. So
     // we expect at least two lines including the final empty. Remove the empty
     // line before returning.
-    std::vector<std::string> lines;
-    base::SplitString(contents, '\n', &lines);
+    std::vector<std::string> lines = base::SplitString(
+        contents, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     EXPECT_GT(lines.size(), 1u);
     if (lines.size() < 2)
       return std::vector<std::string>();
diff --git a/chrome/browser/media_galleries/linux/mtp_device_delegate_impl_linux.cc b/chrome/browser/media_galleries/linux/mtp_device_delegate_impl_linux.cc
index ba914a3..01f9a6e 100644
--- a/chrome/browser/media_galleries/linux/mtp_device_delegate_impl_linux.cc
+++ b/chrome/browser/media_galleries/linux/mtp_device_delegate_impl_linux.cc
@@ -1832,8 +1832,8 @@ base::FilePath MTPDeviceDelegateImplLinux::NextUncachedPathComponent(
   std::string device_relpath = GetDeviceRelativePath(device_path_, path);
   if (!device_relpath.empty() && device_relpath != kRootPath) {
     uncached_path = device_path_;
-    std::vector<std::string> device_relpath_components;
-    base::SplitString(device_relpath, '/', &device_relpath_components);
+    std::vector<std::string> device_relpath_components = base::SplitString(
+        device_relpath, "/", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     DCHECK(!device_relpath_components.empty());
     bool all_components_cached = true;
     const MTPFileNode* current_node = root_node_.get();
@@ -1879,8 +1879,10 @@ bool MTPDeviceDelegateImplLinux::CachedPathToId(const base::FilePath& path,
   if (device_relpath.empty())
     return false;
   std::vector<std::string> device_relpath_components;
-  if (device_relpath != kRootPath)
-    base::SplitString(device_relpath, '/', &device_relpath_components);
+  if (device_relpath != kRootPath) {
+    device_relpath_components = base::SplitString(
+        device_relpath, "/", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+  }
   const MTPFileNode* current_node = root_node_.get();
   for (size_t i = 0; i < device_relpath_components.size(); ++i) {
     current_node = current_node->GetChild(device_relpath_components[i]);
diff --git a/chrome/browser/metrics/thread_watcher.cc b/chrome/browser/metrics/thread_watcher.cc
index 12e04bf..370fc9c 100644
--- a/chrome/browser/metrics/thread_watcher.cc
+++ b/chrome/browser/metrics/thread_watcher.cc
@@ -492,11 +492,10 @@ void ThreadWatcherList::ParseCommandLineCrashOnHangThreads(
     uint32 default_crash_seconds,
     CrashOnHangThreadMap* crash_on_hang_threads) {
   base::StringTokenizer tokens(crash_on_hang_thread_names, ",");
-  std::vector<std::string> values;
   while (tokens.GetNext()) {
-    const std::string& token = tokens.token();
-    base::SplitString(token, ':', &values);
-    std::string thread_name = values[0];
+    std::vector<base::StringPiece> values = base::SplitStringPiece(
+        tokens.token_piece(), ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+    std::string thread_name = values[0].as_string();
 
     uint32 live_threads_threshold = default_live_threads_threshold;
     uint32 crash_seconds = default_crash_seconds;
diff --git a/chrome/browser/metrics/thread_watcher_unittest.cc b/chrome/browser/metrics/thread_watcher_unittest.cc
index 464dbfd..15d6d40 100644
--- a/chrome/browser/metrics/thread_watcher_unittest.cc
+++ b/chrome/browser/metrics/thread_watcher_unittest.cc
@@ -352,11 +352,10 @@ TEST_F(ThreadWatcherTest, ThreadNamesOnlyArgs) {
 
   // Verify the data.
   base::StringTokenizer tokens(crash_on_hang_thread_names, ",");
-  std::vector<std::string> values;
   while (tokens.GetNext()) {
-    const std::string& token = tokens.token();
-    base::SplitString(token, ':', &values);
-    std::string thread_name = values[0];
+    std::vector<base::StringPiece> values = base::SplitStringPiece(
+        tokens.token_piece(), ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+    std::string thread_name = values[0].as_string();
 
     ThreadWatcherList::CrashOnHangThreadMap::iterator it =
         crash_on_hang_threads.find(thread_name);
@@ -382,11 +381,10 @@ TEST_F(ThreadWatcherTest, ThreadNamesAndLiveThresholdArgs) {
 
   // Verify the data.
   base::StringTokenizer tokens(thread_names_and_live_threshold, ",");
-  std::vector<std::string> values;
   while (tokens.GetNext()) {
-    const std::string& token = tokens.token();
-    base::SplitString(token, ':', &values);
-    std::string thread_name = values[0];
+    std::vector<base::StringPiece> values = base::SplitStringPiece(
+        tokens.token_piece(), ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+    std::string thread_name = values[0].as_string();
 
     ThreadWatcherList::CrashOnHangThreadMap::iterator it =
         crash_on_hang_threads.find(thread_name);
@@ -412,11 +410,10 @@ TEST_F(ThreadWatcherTest, CrashOnHangThreadsAllArgs) {
 
   // Verify the data.
   base::StringTokenizer tokens(crash_on_hang_thread_data, ",");
-  std::vector<std::string> values;
   while (tokens.GetNext()) {
-    const std::string& token = tokens.token();
-    base::SplitString(token, ':', &values);
-    std::string thread_name = values[0];
+    std::vector<base::StringPiece> values = base::SplitStringPiece(
+        tokens.token_piece(), ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+    std::string thread_name = values[0].as_string();
 
     ThreadWatcherList::CrashOnHangThreadMap::iterator it =
         crash_on_hang_threads.find(thread_name);
diff --git a/chrome/browser/metrics/variations/variations_service_unittest.cc b/chrome/browser/metrics/variations/variations_service_unittest.cc
index d01707e..ff08fed 100644
--- a/chrome/browser/metrics/variations/variations_service_unittest.cc
+++ b/chrome/browser/metrics/variations/variations_service_unittest.cc
@@ -484,9 +484,9 @@ TEST_F(VariationsServiceTest, LoadPermanentConsistencyCountry) {
 
     if (test.pref_value_before) {
       base::ListValue list_value;
-      std::vector<std::string> list_components;
-      base::SplitString(test.pref_value_before, ',', &list_components);
-      for (const std::string& component : list_components)
+      for (const std::string& component : base::SplitString(
+               test.pref_value_before, ",",
+               base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL))
         list_value.AppendString(component);
       prefs.Set(prefs::kVariationsPermanentConsistencyCountry, list_value);
     }
@@ -500,9 +500,9 @@ TEST_F(VariationsServiceTest, LoadPermanentConsistencyCountry) {
                                          base::Version(test.version), seed));
 
     base::ListValue expected_list_value;
-    std::vector<std::string> list_components;
-    base::SplitString(test.expected_pref_value_after, ',', &list_components);
-    for (const std::string& component : list_components)
+    for (const std::string& component : base::SplitString(
+             test.expected_pref_value_after, ",",
+             base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL))
       expected_list_value.AppendString(component);
     EXPECT_TRUE(expected_list_value.Equals(
         prefs.GetList(prefs::kVariationsPermanentConsistencyCountry)));
diff --git a/chrome/browser/nacl_host/nacl_browser_delegate_impl.cc b/chrome/browser/nacl_host/nacl_browser_delegate_impl.cc
index 1ed15da..9ccd880 100644
--- a/chrome/browser/nacl_host/nacl_browser_delegate_impl.cc
+++ b/chrome/browser/nacl_host/nacl_browser_delegate_impl.cc
@@ -152,19 +152,20 @@ void NaClBrowserDelegateImpl::SetDebugPatterns(
     std::string negated_patterns = debug_patterns;
     inverse_debug_patterns_ = true;
     negated_patterns.erase(0, 1);
-    base::SplitString(negated_patterns, ',', &patterns);
+    patterns = base::SplitString(
+        negated_patterns, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   } else {
-    base::SplitString(debug_patterns, ',', &patterns);
+    patterns = base::SplitString(
+        debug_patterns, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   }
-  for (std::vector<std::string>::iterator iter = patterns.begin();
-       iter != patterns.end(); ++iter) {
+  for (const std::string& pattern_str : patterns) {
     // Allow chrome:// schema, which is used to filter out the internal
     // PNaCl translator. Also allow chrome-extension:// schema (which
     // can have NaCl modules). The default is to disallow these schema
     // since they can be dangerous in the context of chrome extension
     // permissions, but they are okay here, for NaCl GDB avoidance.
     URLPattern pattern(URLPattern::SCHEME_ALL);
-    if (pattern.Parse(*iter) == URLPattern::PARSE_SUCCESS) {
+    if (pattern.Parse(pattern_str) == URLPattern::PARSE_SUCCESS) {
       // If URL pattern has scheme equal to *, Parse method resets valid
       // schemes mask to http and https only, so we need to reset it after
       // Parse to re-include chrome-extension and chrome schema.
diff --git a/chrome/browser/net/predictor.cc b/chrome/browser/net/predictor.cc
index 0241aa0..d18979a 100644
--- a/chrome/browser/net/predictor.cc
+++ b/chrome/browser/net/predictor.cc
@@ -501,8 +501,8 @@ struct RightToLeftStringSorter {
   // "http://com.google.www/xyz".
   static std::string ReverseComponents(const GURL& url) {
     // Reverse the components in the hostname.
-    std::vector<std::string> parts;
-    base::SplitString(url.host(), '.', &parts);
+    std::vector<std::string> parts = base::SplitString(
+        url.host(), ".", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     std::reverse(parts.begin(), parts.end());
     std::string reversed_host = base::JoinString(parts, ".");
 
diff --git a/chrome/browser/net/safe_search_util.cc b/chrome/browser/net/safe_search_util.cc
index ac29b6f..2a184aa 100644
--- a/chrome/browser/net/safe_search_util.cc
+++ b/chrome/browser/net/safe_search_util.cc
@@ -50,14 +50,11 @@ std::string AddSafeSearchParameters(const std::string& query) {
   std::string safe_parameter = chrome::kSafeSearchSafeParameter;
   std::string ssui_parameter = chrome::kSafeSearchSsuiParameter;
 
-  std::vector<std::string> parameters;
-  base::SplitString(query, '&', &parameters);
-
-  std::vector<std::string>::iterator it;
-  for (it = parameters.begin(); it < parameters.end(); ++it) {
-    if (!HasSameParameterKey(*it, safe_parameter) &&
-        !HasSameParameterKey(*it, ssui_parameter)) {
-      new_parameters.push_back(*it);
+  for (const std::string& param : base::SplitString(
+           query, "&", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
+    if (!HasSameParameterKey(param, safe_parameter) &&
+        !HasSameParameterKey(param, ssui_parameter)) {
+      new_parameters.push_back(param);
     }
   }
 
diff --git a/chrome/browser/predictors/resource_prefetch_common.cc b/chrome/browser/predictors/resource_prefetch_common.cc
index 1ec32e1..1fd2c09 100644
--- a/chrome/browser/predictors/resource_prefetch_common.cc
+++ b/chrome/browser/predictors/resource_prefetch_common.cc
@@ -34,17 +34,15 @@ const char kSpeculativePrefetchingTrialName[] =
  * The function below extracts the value corresponding to a key provided from
  * the SpeculativeResourcePrefetching field trial.
  */
-string GetFiledTrialSpecValue(string key) {
-  vector<string> elements;
-  base::SplitString(
-      FieldTrialList::FindFullName(kSpeculativePrefetchingTrialName),
-      ':',
-      &elements);
-  for (int i = 0; i < static_cast<int>(elements.size()); i++) {
-    vector<string> key_value;
-    base::SplitString(elements[i], '=', &key_value);
+std::string GetFiledTrialSpecValue(string key) {
+  std::string trial_name =
+      FieldTrialList::FindFullName(kSpeculativePrefetchingTrialName);
+  for (const base::StringPiece& element : base::SplitStringPiece(
+           trial_name, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
+    std::vector<base::StringPiece> key_value = base::SplitStringPiece(
+        element, "=", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     if (key_value.size() == 2 && key_value[0] == key)
-      return key_value[1];
+      return key_value[1].as_string();
   }
   return string();
 }
diff --git a/chrome/browser/prefs/command_line_pref_store.cc b/chrome/browser/prefs/command_line_pref_store.cc
index 80d9375..8e0cab2 100644
--- a/chrome/browser/prefs/command_line_pref_store.cc
+++ b/chrome/browser/prefs/command_line_pref_store.cc
@@ -176,23 +176,19 @@ void CommandLinePrefStore::ApplyProxyMode() {
 
 void CommandLinePrefStore::ApplySSLSwitches() {
   if (command_line_->HasSwitch(switches::kCipherSuiteBlacklist)) {
-    std::string cipher_suites =
-        command_line_->GetSwitchValueASCII(switches::kCipherSuiteBlacklist);
-    std::vector<std::string> cipher_strings;
-    base::SplitString(cipher_suites, ',', &cipher_strings);
     scoped_ptr<base::ListValue> list_value(new base::ListValue());
-    for (std::vector<std::string>::const_iterator it = cipher_strings.begin();
-         it != cipher_strings.end(); ++it) {
-      list_value->AppendString(*it);
-    }
+    list_value->AppendStrings(base::SplitString(
+        command_line_->GetSwitchValueASCII(switches::kCipherSuiteBlacklist),
+        ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL));
     SetValue(prefs::kCipherSuiteBlacklist, list_value.Pass(),
              WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
   }
 }
 
 void CommandLinePrefStore::ApplyBackgroundModeSwitches() {
-  if (command_line_->HasSwitch(switches::kDisableExtensions))
+  if (command_line_->HasSwitch(switches::kDisableExtensions)) {
     SetValue(prefs::kBackgroundModeEnabled,
              make_scoped_ptr(new base::FundamentalValue(false)),
              WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
+  }
 }
diff --git a/chrome/browser/printing/print_preview_pdf_generated_browsertest.cc b/chrome/browser/printing/print_preview_pdf_generated_browsertest.cc
index 0f0d44d9..6a34e20 100644
--- a/chrome/browser/printing/print_preview_pdf_generated_browsertest.cc
+++ b/chrome/browser/printing/print_preview_pdf_generated_browsertest.cc
@@ -618,8 +618,9 @@ IN_PROC_BROWSER_TEST_F(PrintPreviewPdfGeneratedBrowserTest,
     // Splits the command sent by the layout test framework. The first command
     // is always the file path to use for the test. The rest isn't relevant,
     // so it can be ignored. The separator for the commands is an apostrophe.
-    std::vector<base::FilePath::StringType> cmd_arguments;
-    base::SplitString(cmd, '\'', &cmd_arguments);
+    std::vector<base::FilePath::StringType> cmd_arguments = base::SplitString(
+        cmd, base::FilePath::StringType(1, '\''),
+        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
     ASSERT_GE(cmd_arguments.size(), 1U);
     base::FilePath::StringType test_name(cmd_arguments[0]);
diff --git a/chrome/browser/process_singleton_posix.cc b/chrome/browser/process_singleton_posix.cc
index 6ccc265..25e9eca 100644
--- a/chrome/browser/process_singleton_posix.cc
+++ b/chrome/browser/process_singleton_posix.cc
@@ -684,8 +684,9 @@ void ProcessSingleton::LinuxWatcher::SocketReader::OnFileCanReadWithoutBlocking(
   }
 
   std::string str(buf_, bytes_read_);
-  std::vector<std::string> tokens;
-  base::SplitString(str, kTokenDelimiter, &tokens);
+  std::vector<std::string> tokens = base::SplitString(
+      str, std::string(1, kTokenDelimiter),
+      base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   if (tokens.size() < 3 || tokens[0] != kStartToken) {
     LOG(ERROR) << "Wrong message format: " << str;
diff --git a/chrome/browser/profiles/profile_downloader.cc b/chrome/browser/profiles/profile_downloader.cc
index cb6dbb2..5d1c032 100644
--- a/chrome/browser/profiles/profile_downloader.cc
+++ b/chrome/browser/profiles/profile_downloader.cc
@@ -74,8 +74,9 @@ const int kPhotoVersionPathComponentIndex = 3;
 //   https://example.com/--Abc/AAAAAAAAAAI/AAAAAAAAACQ/Efg/s256-c/photo.jpg
 bool GetImageURLWithSize(const GURL& old_url, int size, GURL* new_url) {
   DCHECK(new_url);
-  std::vector<std::string> components;
-  base::SplitString(old_url.path(), kURLPathSeparator, &components);
+  std::vector<std::string> components = base::SplitString(
+      old_url.path(), std::string(1, kURLPathSeparator),
+      base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (components.size() == 0)
     return false;
 
@@ -123,10 +124,9 @@ bool ProfileDownloader::IsDefaultProfileImageURL(const std::string& url) {
   GURL image_url_object(url);
   DCHECK(image_url_object.is_valid());
   VLOG(1) << "URL to check for default image: " << image_url_object.spec();
-  std::vector<std::string> path_components;
-  base::SplitString(image_url_object.path(),
-                    kURLPathSeparator,
-                    &path_components);
+  std::vector<std::string> path_components = base::SplitString(
+      image_url_object.path(), std::string(1, kURLPathSeparator),
+      base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   if (path_components.size() < kProfileImageURLPathComponentsCount)
     return false;
diff --git a/chrome/browser/push_messaging/push_messaging_app_identifier.cc b/chrome/browser/push_messaging/push_messaging_app_identifier.cc
index fa15b94..cfb8c5f 100644
--- a/chrome/browser/push_messaging/push_messaging_app_identifier.cc
+++ b/chrome/browser/push_messaging/push_messaging_app_identifier.cc
@@ -37,8 +37,9 @@ std::string MakePrefValue(const GURL& origin,
 bool GetOriginAndSWRFromPrefValue(
     const std::string& pref_value, GURL* origin,
     int64_t* service_worker_registration_id) {
-  std::vector<std::string> parts;
-  base::SplitString(pref_value, kSeparator, &parts);
+  std::vector<std::string> parts = base::SplitString(
+      pref_value, std::string(1, kSeparator),
+      base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (parts.size() != 2)
     return false;
 
diff --git a/chrome/browser/safe_browsing/chunk_range.cc b/chrome/browser/safe_browsing/chunk_range.cc
index 6e5c3f8..024aa9b 100644
--- a/chrome/browser/safe_browsing/chunk_range.cc
+++ b/chrome/browser/safe_browsing/chunk_range.cc
@@ -69,12 +69,10 @@ bool StringToRanges(const std::string& input,
 
   // Crack the string into chunk parts, then crack each part looking for a
   // range.
-  std::vector<std::string> chunk_parts;
-  base::SplitString(input, ',', &chunk_parts);
-
-  for (size_t i = 0; i < chunk_parts.size(); ++i) {
-    std::vector<std::string> chunk_ranges;
-    base::SplitString(chunk_parts[i], '-', &chunk_ranges);
+  for (const base::StringPiece& chunk : base::SplitStringPiece(
+           input, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
+    std::vector<std::string> chunk_ranges = base::SplitString(
+        chunk, "-", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     int start = atoi(chunk_ranges[0].c_str());
     int stop = start;
     if (chunk_ranges.size() == 2)
diff --git a/chrome/browser/safe_browsing/safe_browsing_test.cc b/chrome/browser/safe_browsing/safe_browsing_test.cc
index 04bebdd..807a2c2 100644
--- a/chrome/browser/safe_browsing/safe_browsing_test.cc
+++ b/chrome/browser/safe_browsing/safe_browsing_test.cc
@@ -83,17 +83,14 @@ bool ParsePhishingUrls(const std::string& data,
   if (data.empty())
     return false;
 
-  std::vector<std::string> urls;
-  base::SplitString(data, '\n', &urls);
-  for (size_t i = 0; i < urls.size(); ++i) {
-    if (urls[i].empty())
-      continue;
+  for (const base::StringPiece& url_str : base::SplitStringPiece(
+           data, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY)) {
     PhishingUrl phishing_url;
-    std::vector<std::string> record_parts;
-    base::SplitString(urls[i], '\t', &record_parts);
+    std::vector<std::string> record_parts = base::SplitString(
+        url_str, "\t", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     if (record_parts.size() != 3) {
       LOG(ERROR) << "Unexpected URL format in phishing URL list: "
-                 << urls[i];
+                 << url_str.as_string();
       return false;
     }
     phishing_url.url = std::string(url::kHttpScheme) + "://" + record_parts[0];
@@ -103,7 +100,7 @@ bool ParsePhishingUrls(const std::string& data,
     } else if (record_parts[2] == "no") {
       phishing_url.is_phishing = false;
     } else {
-      LOG(ERROR) << "Unrecognized expectation in " << urls[i]
+      LOG(ERROR) << "Unrecognized expectation in " << url_str.as_string()
                  << ": " << record_parts[2];
       return false;
     }
diff --git a/chrome/browser/spellchecker/spellcheck_custom_dictionary.cc b/chrome/browser/spellchecker/spellcheck_custom_dictionary.cc
index eec86b5..55390f9 100644
--- a/chrome/browser/spellchecker/spellcheck_custom_dictionary.cc
+++ b/chrome/browser/spellchecker/spellcheck_custom_dictionary.cc
@@ -68,9 +68,10 @@ ChecksumStatus LoadFile(const base::FilePath& file_path,
     if (checksum != base::MD5String(contents))
       return INVALID_CHECKSUM;
   }
-  base::TrimWhitespaceASCII(contents, base::TRIM_ALL, &contents);
-  std::vector<std::string> word_list;
-  base::SplitString(contents, '\n', &word_list);
+
+  std::vector<std::string> word_list = base::SplitString(
+      base::TrimWhitespaceASCII(contents, base::TRIM_ALL), "\n",
+      base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   words->insert(word_list.begin(), word_list.end());
   return VALID_CHECKSUM;
 }
diff --git a/chrome/browser/spellchecker/spellcheck_service.cc b/chrome/browser/spellchecker/spellcheck_service.cc
index 1821a01..3e84263 100644
--- a/chrome/browser/spellchecker/spellcheck_service.cc
+++ b/chrome/browser/spellchecker/spellcheck_service.cc
@@ -121,8 +121,9 @@ size_t SpellcheckService::GetSpellCheckLanguages(
   StringPrefMember accept_languages_pref;
   accept_languages_pref.Init(prefs::kAcceptLanguages, prefs);
 
-  std::vector<std::string> accept_languages;
-  base::SplitString(accept_languages_pref.GetValue(), ',', &accept_languages);
+  std::vector<std::string> accept_languages = base::SplitString(
+      accept_languages_pref.GetValue(), ",",
+      base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   StringListPrefMember dictionaries_pref;
   dictionaries_pref.Init(prefs::kSpellCheckDictionaries, prefs);
diff --git a/chrome/browser/spellchecker/spellcheck_service_unittest.cc b/chrome/browser/spellchecker/spellcheck_service_unittest.cc
index 5a297e5..ad781ef 100644
--- a/chrome/browser/spellchecker/spellcheck_service_unittest.cc
+++ b/chrome/browser/spellchecker/spellcheck_service_unittest.cc
@@ -24,10 +24,12 @@ struct SpellcheckLanguageTestCase {
       : accept_languages(accept_languages),
         num_expected_enabled_spellcheck_languages(
             num_expected_enabled_spellcheck_languages) {
-    base::SplitString(unsplit_spellcheck_dictionaries, ',',
-                      &spellcheck_dictionaries);
-    base::SplitString(unsplit_expected_languages, ',',
-                      &expected_spellcheck_languages);
+    spellcheck_dictionaries = base::SplitString(
+        unsplit_spellcheck_dictionaries, ",",
+        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+    expected_spellcheck_languages = base::SplitString(
+        unsplit_expected_languages, ",",
+        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   }
   ~SpellcheckLanguageTestCase() {}
 
diff --git a/chrome/browser/ssl/ssl_error_classification.cc b/chrome/browser/ssl/ssl_error_classification.cc
index c7ac505b..305b2bb 100644
--- a/chrome/browser/ssl/ssl_error_classification.cc
+++ b/chrome/browser/ssl/ssl_error_classification.cc
@@ -319,9 +319,8 @@ size_t SSLErrorClassification::FindSubDomainDifference(
 
 SSLErrorClassification::Tokens SSLErrorClassification::
 Tokenize(const std::string& name) {
-  Tokens name_tokens;
-  base::SplitStringDontTrim(name, '.', &name_tokens);
-  return name_tokens;
+  return base::SplitString(
+      name, ".", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
 }
 
 // We accept the inverse case for www for historical reasons.
diff --git a/chrome/browser/ssl/ssl_error_classification_unittest.cc b/chrome/browser/ssl/ssl_error_classification_unittest.cc
index c052a4f..318dbc9 100644
--- a/chrome/browser/ssl/ssl_error_classification_unittest.cc
+++ b/chrome/browser/ssl/ssl_error_classification_unittest.cc
@@ -44,9 +44,8 @@ TEST_F(SSLErrorClassificationTest, TestNameMismatch) {
   WebContents* contents = web_contents();
   {
     GURL origin("https://google.com");
-    std::string host_name = origin.host();
-    std::vector<std::string> host_name_tokens;
-    base::SplitStringDontTrim(host_name, '.', &host_name_tokens);
+    std::vector<std::string> host_name_tokens = base::SplitString(
+        origin.host(), ".", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
     SSLErrorClassification ssl_error(contents,
                                      time,
                                      origin,
@@ -64,9 +63,8 @@ TEST_F(SSLErrorClassificationTest, TestNameMismatch) {
 
   {
     GURL origin("https://foo.blah.google.com");
-    std::string host_name = origin.host();
-    std::vector<std::string> host_name_tokens;
-    base::SplitStringDontTrim(host_name, '.', &host_name_tokens);
+    std::vector<std::string> host_name_tokens = base::SplitString(
+        origin.host(), ".", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
     SSLErrorClassification ssl_error(contents,
                                      time,
                                      origin,
@@ -82,9 +80,8 @@ TEST_F(SSLErrorClassificationTest, TestNameMismatch) {
 
   {
     GURL origin("https://foo.www.google.com");
-    std::string host_name = origin.host();
-    std::vector<std::string> host_name_tokens;
-    base::SplitStringDontTrim(host_name, '.', &host_name_tokens);
+    std::vector<std::string> host_name_tokens = base::SplitString(
+        origin.host(), ".", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
     SSLErrorClassification ssl_error(contents,
                                      time,
                                      origin,
@@ -100,9 +97,8 @@ TEST_F(SSLErrorClassificationTest, TestNameMismatch) {
 
   {
      GURL origin("https://www.google.com.foo");
-     std::string host_name = origin.host();
-     std::vector<std::string> host_name_tokens;
-     base::SplitStringDontTrim(host_name, '.', &host_name_tokens);
+     std::vector<std::string> host_name_tokens = base::SplitString(
+         origin.host(), ".", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
      SSLErrorClassification ssl_error(contents,
                                       time,
                                       origin,
@@ -118,9 +114,8 @@ TEST_F(SSLErrorClassificationTest, TestNameMismatch) {
 
   {
     GURL origin("https://www.foogoogle.com.");
-    std::string host_name = origin.host();
-    std::vector<std::string> host_name_tokens;
-    base::SplitStringDontTrim(host_name, '.', &host_name_tokens);
+    std::vector<std::string> host_name_tokens = base::SplitString(
+        origin.host(), ".", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
     SSLErrorClassification ssl_error(contents,
                                      time,
                                      origin,
@@ -145,9 +140,8 @@ TEST_F(SSLErrorClassificationTest, TestNameMismatch) {
   dns_name_tokens_webkit.push_back(dns_names_webkit);
   {
     GURL origin("https://a.b.webkit.org");
-    std::string host_name = origin.host();
-    std::vector<std::string> host_name_tokens;
-    base::SplitStringDontTrim(host_name, '.', &host_name_tokens);
+    std::vector<std::string> host_name_tokens = base::SplitString(
+        origin.host(), ".", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
     SSLErrorClassification ssl_error(contents,
                                      time,
                                      origin,
diff --git a/chrome/browser/supervised_user/supervised_user_whitelist_service.cc b/chrome/browser/supervised_user/supervised_user_whitelist_service.cc
index 9619f3d..c688abe 100644
--- a/chrome/browser/supervised_user/supervised_user_whitelist_service.cc
+++ b/chrome/browser/supervised_user/supervised_user_whitelist_service.cc
@@ -71,17 +71,17 @@ void SupervisedUserWhitelistService::Init() {
       base::CommandLine::ForCurrentProcess();
   std::string command_line_whitelists = command_line->GetSwitchValueASCII(
       switches::kInstallSupervisedUserWhitelists);
-  std::vector<std::string> split_whitelists;
-  base::SplitString(command_line_whitelists, ',', &split_whitelists);
-  for (const std::string& whitelist : split_whitelists) {
+  for (const base::StringPiece& whitelist : base::SplitStringPiece(
+           command_line_whitelists, ",",
+           base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
     std::string id;
     std::string name;
     size_t separator = whitelist.find(':');
-    if (separator != std::string::npos) {
-      id = whitelist.substr(0, separator);
-      name = whitelist.substr(separator + 1);
+    if (separator != base::StringPiece::npos) {
+      whitelist.substr(0, separator).CopyToString(&id);
+      whitelist.substr(separator + 1).CopyToString(&name);
     } else {
-      id = whitelist;
+      whitelist.CopyToString(&id);
     }
 
     // Skip whitelists that were already registered.
diff --git a/chrome/browser/sxs_linux.cc b/chrome/browser/sxs_linux.cc
index 2990693..5ab67ae 100644
--- a/chrome/browser/sxs_linux.cc
+++ b/chrome/browser/sxs_linux.cc
@@ -68,8 +68,10 @@ bool DoAddChannelMarkToUserDataDir(const base::FilePath& user_data_dir) {
   // and legitimate that it doesn't exist, e.g. for new profile or for profile
   // existing before channel marks have been introduced.
   std::string channels_contents;
-  if (base::ReadFileToString(channels_path, &channels_contents))
-    base::SplitString(channels_contents, '\n', &user_data_dir_channels);
+  if (base::ReadFileToString(channels_path, &channels_contents)) {
+    base::SplitString(channels_contents, "\n",
+                      base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+  }
 
   if (std::find(user_data_dir_channels.begin(),
                 user_data_dir_channels.end(),
@@ -126,8 +128,8 @@ int MigrateUserDataDir() {
     return chrome::RESULT_CODE_SXS_MIGRATION_FAILED;
   }
 
-  std::vector<std::string> user_data_dir_channels;
-  base::SplitString(channels_contents, '\n', &user_data_dir_channels);
+  std::vector<std::string> user_data_dir_channels = base::SplitString(
+      channels_contents, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   if (user_data_dir_channels.size() != 1) {
     LOG(WARNING) << "User data dir migration is only possible when the profile "
diff --git a/chrome/browser/themes/theme_properties.cc b/chrome/browser/themes/theme_properties.cc
index 16eaaa0..98b6d5c 100644
--- a/chrome/browser/themes/theme_properties.cc
+++ b/chrome/browser/themes/theme_properties.cc
@@ -177,19 +177,17 @@ SkColor TintForUnderline(SkColor input) {
 
 // static
 int ThemeProperties::StringToAlignment(const std::string& alignment) {
-  std::vector<std::string> split;
-  base::SplitStringAlongWhitespace(alignment, &split);
-
   int alignment_mask = 0;
-  for (std::vector<std::string>::iterator component(split.begin());
-       component != split.end(); ++component) {
-    if (base::LowerCaseEqualsASCII(*component, kAlignmentTop))
+  for (const std::string& component : base::SplitString(
+           alignment, base::kWhitespaceASCII,
+           base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY)) {
+    if (base::LowerCaseEqualsASCII(component, kAlignmentTop))
       alignment_mask |= ALIGN_TOP;
-    else if (base::LowerCaseEqualsASCII(*component, kAlignmentBottom))
+    else if (base::LowerCaseEqualsASCII(component, kAlignmentBottom))
       alignment_mask |= ALIGN_BOTTOM;
-    else if (base::LowerCaseEqualsASCII(*component, kAlignmentLeft))
+    else if (base::LowerCaseEqualsASCII(component, kAlignmentLeft))
       alignment_mask |= ALIGN_LEFT;
-    else if (base::LowerCaseEqualsASCII(*component, kAlignmentRight))
+    else if (base::LowerCaseEqualsASCII(component, kAlignmentRight))
       alignment_mask |= ALIGN_RIGHT;
   }
   return alignment_mask;
diff --git a/chrome/browser/tracing/crash_service_uploader.cc b/chrome/browser/tracing/crash_service_uploader.cc
index 3a41dbb..ec7f37f 100644
--- a/chrome/browser/tracing/crash_service_uploader.cc
+++ b/chrome/browser/tracing/crash_service_uploader.cc
@@ -150,9 +150,9 @@ void TraceCrashServiceUploader::DoUploadOnFileThread(
   // VersionInfo::ProductNameAndVersionForUserAgent() returns a string like
   // "Chrome/aa.bb.cc.dd", split out the part before the "/".
   chrome::VersionInfo version_info;
-  std::vector<std::string> product_components;
-  base::SplitString(version_info.ProductNameAndVersionForUserAgent(), '/',
-                    &product_components);
+  std::vector<std::string> product_components = base::SplitString(
+      version_info.ProductNameAndVersionForUserAgent(), "/",
+      base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   DCHECK_EQ(2U, product_components.size());
   std::string version;
   if (product_components.size() == 2U) {
diff --git a/chrome/browser/translate/chrome_translate_client.cc b/chrome/browser/translate/chrome_translate_client.cc
index f61f5e7..c16a64a 100644
--- a/chrome/browser/translate/chrome_translate_client.cc
+++ b/chrome/browser/translate/chrome_translate_client.cc
@@ -152,8 +152,8 @@ void ChromeTranslateClient::GetTranslateLanguages(
   }
 
   std::string accept_languages_str = prefs->GetString(prefs::kAcceptLanguages);
-  std::vector<std::string> accept_languages_list;
-  base::SplitString(accept_languages_str, ',', &accept_languages_list);
+  std::vector<std::string> accept_languages_list = base::SplitString(
+      accept_languages_str, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   *target =
       translate::TranslateManager::GetTargetLanguage(accept_languages_list);
 }
diff --git a/chrome/browser/translate/translate_service.cc b/chrome/browser/translate/translate_service.cc
index c6d3663..8d360cc 100644
--- a/chrome/browser/translate/translate_service.cc
+++ b/chrome/browser/translate/translate_service.cc
@@ -107,9 +107,9 @@ bool TranslateService::IsTranslateBubbleEnabled() {
 
 // static
 std::string TranslateService::GetTargetLanguage(PrefService* prefs) {
-  std::vector<std::string> accept_languages_list;
-  base::SplitString(prefs->GetString(prefs::kAcceptLanguages), ',',
-                    &accept_languages_list);
+  std::vector<std::string> accept_languages_list = base::SplitString(
+      prefs->GetString(prefs::kAcceptLanguages), ",",
+      base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   return translate::TranslateManager::GetTargetLanguage(accept_languages_list);
 }
 
diff --git a/chrome/browser/ui/android/autofill/autofill_dialog_result.cc b/chrome/browser/ui/android/autofill/autofill_dialog_result.cc
index d17ff4c..9d30526 100644
--- a/chrome/browser/ui/android/autofill/autofill_dialog_result.cc
+++ b/chrome/browser/ui/android/autofill/autofill_dialog_result.cc
@@ -46,10 +46,11 @@ scoped_ptr<wallet::Address> ParseJavaWalletAddress(
   const base::string16 recipient_name =
       FETCH_JSTRING(UTF16, env, address, ResultAddress, Name);
 
-  std::vector<base::string16> address_lines;
   const base::string16 street_address =
       FETCH_JSTRING(UTF16, env, address, ResultAddress, StreetAddress);
-  base::SplitString(street_address, base::char16('\n'), &address_lines);
+  std::vector<base::string16> address_lines = base::SplitString(
+      street_address, base::string16(1, '\n'),
+      base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   const base::string16 locality_name =
       FETCH_JSTRING(UTF16, env, address, ResultAddress, Locality);
diff --git a/chrome/browser/ui/autofill/autofill_dialog_controller_impl.cc b/chrome/browser/ui/autofill/autofill_dialog_controller_impl.cc
index d700e8b..326278f 100644
--- a/chrome/browser/ui/autofill/autofill_dialog_controller_impl.cc
+++ b/chrome/browser/ui/autofill/autofill_dialog_controller_impl.cc
@@ -295,11 +295,9 @@ const wallet::Address* FindDuplicateAddress(
 }
 
 bool IsCardHolderNameValidForWallet(const base::string16& name) {
-  base::string16 whitespace_collapsed_name =
-      base::CollapseWhitespace(name, true);
-  std::vector<base::string16> split_name;
-  base::SplitString(whitespace_collapsed_name, ' ', &split_name);
-  return split_name.size() >= 2;
+  return base::SplitStringPiece(name, base::string16(1, ' '),
+                                base::KEEP_WHITESPACE,
+                                base::SPLIT_WANT_NONEMPTY).size() >= 2;
 }
 
 DialogSection SectionFromLocation(wallet::FormFieldError::Location location) {
diff --git a/chrome/browser/ui/autofill/autofill_dialog_types.cc b/chrome/browser/ui/autofill/autofill_dialog_types.cc
index b990097..90af148 100644
--- a/chrome/browser/ui/autofill/autofill_dialog_types.cc
+++ b/chrome/browser/ui/autofill/autofill_dialog_types.cc
@@ -28,8 +28,9 @@ DialogNotification::DialogNotification(Type type,
       display_text_(display_text),
       checked_(false) {
   // If there's a range separated by bars, mark that as the anchor text.
-  std::vector<base::string16> pieces;
-  base::SplitStringDontTrim(display_text, kRangeSeparator, &pieces);
+  std::vector<base::string16> pieces = base::SplitString(
+      display_text, base::string16(1, kRangeSeparator),
+      base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
   if (pieces.size() > 1) {
     size_t start = pieces[0].size();
     size_t end = start + pieces[1].size();
diff --git a/chrome/browser/ui/autofill/generated_credit_card_bubble_controller.cc b/chrome/browser/ui/autofill/generated_credit_card_bubble_controller.cc
index 405d942..1fabb5c 100644
--- a/chrome/browser/ui/autofill/generated_credit_card_bubble_controller.cc
+++ b/chrome/browser/ui/autofill/generated_credit_card_bubble_controller.cc
@@ -193,16 +193,17 @@ void GeneratedCreditCardBubbleController::SetupAndShow(
 
   // Split the full text on '|' to highlight certain parts. For example, "sly"
   // and "jumped" would be bolded in "The |sly| fox |jumped| over the lazy dog".
-  std::vector<base::string16> pieces;
-  base::SplitStringDontTrim(to_split, kRangeSeparator, &pieces);
+  std::vector<base::string16> pieces = base::SplitString(
+      to_split, base::string16(1, kRangeSeparator),
+      base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
 
   while (!pieces.empty()) {
     base::string16 piece = pieces.front();
 
-    // Every second piece should be bolded. Because |base::SplitString*()|
-    // leaves an empty "" even if '|' is the first character, this is guaranteed
-    // to work for "|highlighting| starts here". Ignore empty pieces because
-    // there's nothing to highlight.
+    // Every second piece should be bolded. Because SPLIT_WANT_ALL makes
+    // SplitString leave an empty "" even if '|' is the first character, this
+    // is guaranteed to work for "|highlighting| starts here". Ignore empty
+    // pieces because there's nothing to highlight.
     if (!piece.empty() && pieces.size() % 2 == 0) {
       const size_t start = contents_text_.size();
       TextRange bold_text;
diff --git a/chrome/browser/ui/elide_url.cc b/chrome/browser/ui/elide_url.cc
index afa6d7a..b5c7ca6 100644
--- a/chrome/browser/ui/elide_url.cc
+++ b/chrome/browser/ui/elide_url.cc
@@ -156,14 +156,14 @@ base::string16 ElideUrl(const GURL& url,
   // domain is now C: - this is a nice hack for eliding to work pleasantly.
   if (url.SchemeIsFile()) {
     // Split the path string using ":"
-    std::vector<base::string16> file_path_split;
-    base::SplitString(url_path, ':', &file_path_split);
+    const base::string16 kColon(1, ':');
+    std::vector<base::string16> file_path_split = base::SplitString(
+        url_path, kColon, base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     if (file_path_split.size() > 1) {  // File is of type "file:///C:/.."
       url_host.clear();
       url_domain.clear();
       url_subdomain.clear();
 
-      const base::string16 kColon = UTF8ToUTF16(":");
       url_host = url_domain = file_path_split.at(0).substr(1) + kColon;
       url_path_query_etc = url_path = file_path_split.at(1);
     }
@@ -201,8 +201,9 @@ base::string16 ElideUrl(const GURL& url,
   }
 
   // Parse url_path using '/'.
-  std::vector<base::string16> url_path_elements;
-  base::SplitString(url_path, kForwardSlash, &url_path_elements);
+  std::vector<base::string16> url_path_elements = base::SplitString(
+      url_path, base::string16(1, kForwardSlash),
+      base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   // Get filename - note that for a path ending with /
   // such as www.google.com/intl/ads/, the file name is ads/.
diff --git a/chrome/browser/ui/libgtk2ui/gtk2_ui.cc b/chrome/browser/ui/libgtk2ui/gtk2_ui.cc
index 698af98..82cff62 100644
--- a/chrome/browser/ui/libgtk2ui/gtk2_ui.cc
+++ b/chrome/browser/ui/libgtk2ui/gtk2_ui.cc
@@ -1390,8 +1390,9 @@ void Gtk2UI::UpdateDefaultFont(const PangoFontDescription* desc) {
   // Use gfx::FontRenderParams to select a family and determine the rendering
   // settings.
   gfx::FontRenderParamsQuery query;
-  base::SplitString(pango_font_description_get_family(desc), ',',
-                    &query.families);
+  query.families = base::SplitString(pango_font_description_get_family(desc),
+                                     ",", base::TRIM_WHITESPACE,
+                                     base::SPLIT_WANT_ALL);
 
   if (pango_font_description_get_size_is_absolute(desc)) {
     // If the size is absolute, it's specified in Pango units. There are
diff --git a/chrome/browser/ui/tabs/tab_strip_model_unittest.cc b/chrome/browser/ui/tabs/tab_strip_model_unittest.cc
index cc5323f..dba7d9f 100644
--- a/chrome/browser/ui/tabs/tab_strip_model_unittest.cc
+++ b/chrome/browser/ui/tabs/tab_strip_model_unittest.cc
@@ -246,11 +246,11 @@ class TabStripModelTest : public ChromeRenderViewHostTestHarness {
       model->SetTabPinned(i, true);
 
     ui::ListSelectionModel selection_model;
-    std::vector<std::string> selection;
-    base::SplitStringAlongWhitespace(selected_tabs, &selection);
-    for (size_t i = 0; i < selection.size(); ++i) {
+    for (const base::StringPiece& sel : base::SplitStringPiece(
+             selected_tabs, base::kWhitespaceASCII,
+             base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY)) {
       int value;
-      ASSERT_TRUE(base::StringToInt(selection[i], &value));
+      ASSERT_TRUE(base::StringToInt(sel, &value));
       selection_model.AddIndexToSelection(value);
     }
     selection_model.set_active(selection_model.selected_indices()[0]);
diff --git a/chrome/browser/ui/views/autofill/expanding_textfield.cc b/chrome/browser/ui/views/autofill/expanding_textfield.cc
index 147742b..c7957d5 100644
--- a/chrome/browser/ui/views/autofill/expanding_textfield.cc
+++ b/chrome/browser/ui/views/autofill/expanding_textfield.cc
@@ -50,8 +50,9 @@ ExpandingTextfield::~ExpandingTextfield() {}
 
 void ExpandingTextfield::SetText(const base::string16& text) {
   textfields_.front()->SetText(text);
-  std::vector<base::string16> strings;
-  base::SplitStringDontTrim(text, '\n', &strings);
+  std::vector<base::string16> strings = base::SplitString(
+      text, base::string16(1, '\n'),
+      base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
 
   size_t i = 0;
   for (std::list<DecoratedTextfield*>::iterator iter = textfields_.begin();
diff --git a/chrome/browser/ui/webui/chromeos/login/terms_of_service_screen_handler.cc b/chrome/browser/ui/webui/chromeos/login/terms_of_service_screen_handler.cc
index 51a1634..83d8663 100644
--- a/chrome/browser/ui/webui/chromeos/login/terms_of_service_screen_handler.cc
+++ b/chrome/browser/ui/webui/chromeos/login/terms_of_service_screen_handler.cc
@@ -149,15 +149,13 @@ void TermsOfServiceScreenHandler::OnLanguageChangedCallback(
 
 void TermsOfServiceScreenHandler::DoShow() {
   // Determine the user's most preferred input method.
-  std::vector<std::string> input_methods;
-  base::SplitString(
+  std::vector<std::string> input_methods = base::SplitString(
       ProfileHelper::Get()
           ->GetProfileByUserUnsafe(
               user_manager::UserManager::Get()->GetActiveUser())
           ->GetPrefs()
           ->GetString(prefs::kLanguagePreloadEngines),
-      ',',
-      &input_methods);
+      ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   if (!input_methods.empty()) {
     // If the user has a preferred input method, enable it and switch to it.
diff --git a/chrome/browser/ui/webui/cookies_tree_model_util.cc b/chrome/browser/ui/webui/cookies_tree_model_util.cc
index 72bb7a9..3a15aca 100644
--- a/chrome/browser/ui/webui/cookies_tree_model_util.cc
+++ b/chrome/browser/ui/webui/cookies_tree_model_util.cc
@@ -317,17 +317,15 @@ void CookiesTreeModelUtil::GetChildNodeList(const CookieTreeNode* parent,
 const CookieTreeNode* CookiesTreeModelUtil::GetTreeNodeFromPath(
     const CookieTreeNode* root,
     const std::string& path) {
-  std::vector<std::string> node_ids;
-  base::SplitString(path, ',', &node_ids);
-
   const CookieTreeNode* child = NULL;
   const CookieTreeNode* parent = root;
   int child_index = -1;
 
   // Validate the tree path and get the node pointer.
-  for (size_t i = 0; i < node_ids.size(); ++i) {
+  for (const base::StringPiece& cur_node : base::SplitStringPiece(
+           path, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
     int32 node_id = 0;
-    if (!base::StringToInt(node_ids[i], &node_id))
+    if (!base::StringToInt(cur_node, &node_id))
       break;
 
     child = id_map_.Lookup(node_id);
diff --git a/chrome/browser/ui/webui/extensions/extension_icon_source.cc b/chrome/browser/ui/webui/extensions/extension_icon_source.cc
index aa4fc2e..2b40ccd 100644
--- a/chrome/browser/ui/webui/extensions/extension_icon_source.cc
+++ b/chrome/browser/ui/webui/extensions/extension_icon_source.cc
@@ -278,9 +278,8 @@ bool ExtensionIconSource::ParseData(
     const content::URLDataSource::GotDataCallback& callback) {
   // Extract the parameters from the path by lower casing and splitting.
   std::string path_lower = base::StringToLowerASCII(path);
-  std::vector<std::string> path_parts;
-
-  base::SplitString(path_lower, '/', &path_parts);
+  std::vector<std::string> path_parts = base::SplitString(
+      path_lower, "/", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (path_lower.empty() || path_parts.size() < 3)
     return false;
 
diff --git a/chrome/browser/ui/webui/net_internals/net_internals_ui.cc b/chrome/browser/ui/webui/net_internals/net_internals_ui.cc
index d5f023e..145294a 100644
--- a/chrome/browser/ui/webui/net_internals/net_internals_ui.cc
+++ b/chrome/browser/ui/webui/net_internals/net_internals_ui.cc
@@ -130,8 +130,8 @@ std::string HashesToBase64String(const net::HashValueVector& hashes) {
 bool Base64StringToHashes(const std::string& hashes_str,
                           net::HashValueVector* hashes) {
   hashes->clear();
-  std::vector<std::string> vector_hash_str;
-  base::SplitString(hashes_str, ',', &vector_hash_str);
+  std::vector<std::string> vector_hash_str = base::SplitString(
+      hashes_str, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   for (size_t i = 0; i != vector_hash_str.size(); ++i) {
     std::string hash_str;
diff --git a/chrome/browser/ui/webui/print_preview/extension_printer_handler.cc b/chrome/browser/ui/webui/print_preview/extension_printer_handler.cc
index 8ff25c6..8866763 100644
--- a/chrome/browser/ui/webui/print_preview/extension_printer_handler.cc
+++ b/chrome/browser/ui/webui/print_preview/extension_printer_handler.cc
@@ -103,8 +103,8 @@ std::string GenerateProvisionalUsbPrinterId(const Extension* extension,
 bool ParseProvisionalUsbPrinterId(const std::string& printer_id,
                                   std::string* extension_id,
                                   std::string* device_guid) {
-  std::vector<std::string> components;
-  base::SplitString(printer_id, ':', &components);
+  std::vector<std::string> components = base::SplitString(
+      printer_id, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   if (components.size() != 3)
     return false;
diff --git a/chrome/browser/ui/webui/print_preview/print_preview_ui.cc b/chrome/browser/ui/webui/print_preview/print_preview_ui.cc
index 6cd974b..ad53e9a 100644
--- a/chrome/browser/ui/webui/print_preview/print_preview_ui.cc
+++ b/chrome/browser/ui/webui/print_preview/print_preview_ui.cc
@@ -129,8 +129,8 @@ bool HandleRequestCallback(
 
   // Print Preview data.
   scoped_refptr<base::RefCountedBytes> data;
-  std::vector<std::string> url_substr;
-  base::SplitString(path, '/', &url_substr);
+  std::vector<std::string> url_substr = base::SplitString(
+      path, "/", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   int preview_ui_id = -1;
   int page_index = 0;
   if (url_substr.size() == 3 &&
diff --git a/chrome/browser/ui/webui/signin/inline_login_ui.cc b/chrome/browser/ui/webui/signin/inline_login_ui.cc
index 843bae5..98f736a 100644
--- a/chrome/browser/ui/webui/signin/inline_login_ui.cc
+++ b/chrome/browser/ui/webui/signin/inline_login_ui.cc
@@ -34,8 +34,8 @@ namespace {
 bool HandleTestFileRequestCallback(
     const std::string& path,
     const content::WebUIDataSource::GotDataCallback& callback) {
-  std::vector<std::string> url_substr;
-  base::SplitString(path, '/', &url_substr);
+  std::vector<std::string> url_substr = base::SplitString(
+      path, "/", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (url_substr.size() != 2 || url_substr[0] != "test")
     return false;
 
diff --git a/chrome/browser/upload_list.cc b/chrome/browser/upload_list.cc
index aca832c..b1200f8 100644
--- a/chrome/browser/upload_list.cc
+++ b/chrome/browser/upload_list.cc
@@ -76,8 +76,8 @@ void UploadList::ParseLogEntries(
     const std::vector<std::string>& log_entries) {
   std::vector<std::string>::const_reverse_iterator i;
   for (i = log_entries.rbegin(); i != log_entries.rend(); ++i) {
-    std::vector<std::string> components;
-    base::SplitString(*i, ',', &components);
+    std::vector<std::string> components = base::SplitString(
+        *i, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     // Skip any blank (or corrupted) lines.
     if (components.size() != 2 && components.size() != 3)
       continue;
diff --git a/chrome/common/chrome_content_client.cc b/chrome/common/chrome_content_client.cc
index ce52fa3..5d13f33 100644
--- a/chrome/common/chrome_content_client.cc
+++ b/chrome/common/chrome_content_client.cc
@@ -239,13 +239,10 @@ content::PepperPluginInfo CreatePepperFlashInfo(const base::FilePath& path,
   plugin.path = path;
   plugin.permissions = chrome::kPepperFlashPermissions;
 
-  std::vector<std::string> flash_version_numbers;
-  base::SplitString(version, '.', &flash_version_numbers);
+  std::vector<std::string> flash_version_numbers = base::SplitString(
+      version, ".", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
   if (flash_version_numbers.size() < 1)
     flash_version_numbers.push_back("11");
-  // |SplitString()| puts in an empty string given an empty string. :(
-  else if (flash_version_numbers[0].empty())
-    flash_version_numbers[0] = "11";
   if (flash_version_numbers.size() < 2)
     flash_version_numbers.push_back("2");
   if (flash_version_numbers.size() < 3)
diff --git a/chrome/common/crash_keys.cc b/chrome/common/crash_keys.cc
index 6d2a216..2934d97 100644
--- a/chrome/common/crash_keys.cc
+++ b/chrome/common/crash_keys.cc
@@ -433,8 +433,8 @@ void SetActiveExtensions(const std::set<std::string>& extensions) {
 }
 
 ScopedPrinterInfo::ScopedPrinterInfo(const base::StringPiece& data) {
-  std::vector<std::string> info;
-  base::SplitString(data.as_string(), ';', &info);
+  std::vector<std::string> info = base::SplitString(
+      data.as_string(), ";", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   for (size_t i = 0; i < kPrinterInfoCount; ++i) {
     std::string key = base::StringPrintf(kPrinterInfo, i + 1);
     std::string value;
diff --git a/chrome/common/extensions/command.cc b/chrome/common/extensions/command.cc
index fc4b47bc..9604c06 100644
--- a/chrome/common/extensions/command.cc
+++ b/chrome/common/extensions/command.cc
@@ -74,8 +74,8 @@ ui::Accelerator ParseImpl(const std::string& accelerator,
     return ui::Accelerator();
   }
 
-  std::vector<std::string> tokens;
-  base::SplitString(accelerator, '+', &tokens);
+  std::vector<std::string> tokens = base::SplitString(
+      accelerator, "+", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (tokens.size() == 0 ||
       (tokens.size() == 1 && DoesRequireModifier(accelerator)) ||
       tokens.size() > kMaxTokenSize) {
@@ -264,8 +264,8 @@ std::string NormalizeShortcutSuggestion(const std::string& suggestion,
   if (!normalize)
     return suggestion;
 
-  std::vector<std::string> tokens;
-  base::SplitString(suggestion, '+', &tokens);
+  std::vector<std::string> tokens = base::SplitString(
+      suggestion, "+", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   for (size_t i = 0; i < tokens.size(); i++) {
     if (tokens[i] == values::kKeyCtrl)
       tokens[i] = values::kKeyCommand;
diff --git a/chrome/common/importer/firefox_importer_utils.cc b/chrome/common/importer/firefox_importer_utils.cc
index 46e120c..3b74d6f 100644
--- a/chrome/common/importer/firefox_importer_utils.cc
+++ b/chrome/common/importer/firefox_importer_utils.cc
@@ -138,11 +138,9 @@ bool GetFirefoxVersionAndPathFromProfile(const base::FilePath& profile_path,
   std::string content;
   base::ReadFileToString(compatibility_file, &content);
   base::ReplaceSubstringsAfterOffset(&content, 0, "\r\n", "\n");
-  std::vector<std::string> lines;
-  base::SplitString(content, '\n', &lines);
 
-  for (size_t i = 0; i < lines.size(); ++i) {
-    const std::string& line = lines[i];
+  for (const std::string& line : base::SplitString(
+           content, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
     if (line.empty() || line[0] == '#' || line[0] == ';')
       continue;
     size_t equal = line.find('=');
@@ -242,11 +240,10 @@ bool IsDefaultHomepage(const GURL& homepage, const base::FilePath& app_path) {
     return homepage.spec() == GURL(default_homepages).spec();
 
   // Crack the string into separate homepage urls.
-  std::vector<std::string> urls;
-  base::SplitString(default_homepages, '|', &urls);
-
-  for (size_t i = 0; i < urls.size(); ++i) {
-    if (homepage.spec() == GURL(urls[i]).spec())
+  for (const std::string& url : base::SplitString(
+           default_homepages, "|",
+           base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
+    if (homepage.spec() == GURL(url).spec())
       return true;
   }
 
@@ -303,19 +300,18 @@ base::string16 GetFirefoxImporterName(const base::FilePath& app_path) {
   if (base::PathExists(app_ini_file)) {
     std::string content;
     base::ReadFileToString(app_ini_file, &content);
-    std::vector<std::string> lines;
-    base::SplitString(content, '\n', &lines);
+
     const std::string name_attr("Name=");
     bool in_app_section = false;
-    for (size_t i = 0; i < lines.size(); ++i) {
-      base::TrimWhitespace(lines[i], base::TRIM_ALL, &lines[i]);
-      if (lines[i] == "[App]") {
+    for (const base::StringPiece& line : base::SplitStringPiece(
+             content, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
+      if (line == "[App]") {
         in_app_section = true;
       } else if (in_app_section) {
-        if (lines[i].find(name_attr) == 0) {
-          branding_name = lines[i].substr(name_attr.size());
+        if (line.find(name_attr) == 0) {
+          line.substr(name_attr.size()).CopyToString(&branding_name);
           break;
-        } else if (lines[i].length() > 0 && lines[i][0] == '[') {
+        } else if (line.length() > 0 && line[0] == '[') {
           // No longer in the [App] section.
           break;
         }
diff --git a/chrome/common/pepper_flash.cc b/chrome/common/pepper_flash.cc
index da1c00d..16b4328 100644
--- a/chrome/common/pepper_flash.cc
+++ b/chrome/common/pepper_flash.cc
@@ -56,10 +56,10 @@ bool SupportsPepperInterface(const char* interface_name) {
 // Returns true if this browser implements one of the interfaces given in
 // |interface_string|, which is a '|'-separated string of interface names.
 bool CheckPepperFlashInterfaceString(const std::string& interface_string) {
-  std::vector<std::string> interface_names;
-  base::SplitString(interface_string, '|', &interface_names);
-  for (size_t i = 0; i < interface_names.size(); i++) {
-    if (SupportsPepperInterface(interface_names[i].c_str()))
+  for (const std::string& name : base::SplitString(
+           interface_string, "|",
+           base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
+    if (SupportsPepperInterface(name.c_str()))
       return true;
   }
   return false;
diff --git a/chrome/common/secure_origin_whitelist.cc b/chrome/common/secure_origin_whitelist.cc
index d8294a4..3715b3b 100644
--- a/chrome/common/secure_origin_whitelist.cc
+++ b/chrome/common/secure_origin_whitelist.cc
@@ -18,10 +18,10 @@ void GetSecureOriginWhitelist(std::set<GURL>* origins) {
       *base::CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kUnsafelyTreatInsecureOriginAsSecure) &&
       command_line.HasSwitch(switches::kUserDataDir)) {
-    std::vector<std::string> given_origins;
-    base::SplitString(command_line.GetSwitchValueASCII(
-        switches::kUnsafelyTreatInsecureOriginAsSecure), ',', &given_origins);
-    for (const auto& origin : given_origins)
+    std::string origins_str = command_line.GetSwitchValueASCII(
+        switches::kUnsafelyTreatInsecureOriginAsSecure);
+    for (const std::string& origin : base::SplitString(
+             origins_str, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL))
       origins->insert(GURL(origin));
   }
 }
diff --git a/chrome/common/service_process_util_unittest.cc b/chrome/common/service_process_util_unittest.cc
index 14af917..11c9b1a 100644
--- a/chrome/common/service_process_util_unittest.cc
+++ b/chrome/common/service_process_util_unittest.cc
@@ -150,8 +150,9 @@ TEST_F(ServiceProcessStateTest, AutoRun) {
   ASSERT_EQ(std::string::npos, exec_value.find('"'));
   ASSERT_EQ(std::string::npos, exec_value.find('\''));
 
-  base::CommandLine::StringVector argv;
-  base::SplitString(exec_value, ' ', &argv);
+  base::CommandLine::StringVector argv = base::SplitString(
+      exec_value, base::CommandLine::StringType(1, ' '),
+      base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   ASSERT_GE(argv.size(), 2U)
       << "Expected at least one command-line option in: " << exec_value;
   autorun_command_line.reset(new base::CommandLine(argv));
diff --git a/chrome/common/variations/experiment_labels_unittest.cc b/chrome/common/variations/experiment_labels_unittest.cc
index 59ddbf7..bf35cca 100644
--- a/chrome/common/variations/experiment_labels_unittest.cc
+++ b/chrome/common/variations/experiment_labels_unittest.cc
@@ -57,8 +57,9 @@ TEST(ExperimentLabelsTest, BuildGoogleUpdateExperimentLabel) {
   for (size_t i = 0; i < arraysize(test_cases); ++i) {
     // Parse the input groups.
     base::FieldTrial::ActiveGroups groups;
-    std::vector<std::string> group_data;
-    base::SplitString(test_cases[i].active_group_pairs, '#', &group_data);
+    std::vector<std::string> group_data = base::SplitString(
+        test_cases[i].active_group_pairs, "#",
+        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     ASSERT_EQ(0U, group_data.size() % 2);
     for (size_t j = 0; j < group_data.size(); j += 2) {
       base::FieldTrial::ActiveGroup group;
@@ -68,26 +69,26 @@ TEST(ExperimentLabelsTest, BuildGoogleUpdateExperimentLabel) {
     }
 
     // Parse the expected output.
-    std::vector<std::string> expected_ids_list;
-    base::SplitString(test_cases[i].expected_ids, '#', &expected_ids_list);
+    std::vector<std::string> expected_ids_list = base::SplitString(
+        test_cases[i].expected_ids, "#",
+        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
     std::string experiment_labels_string = base::UTF16ToUTF8(
         BuildGoogleUpdateExperimentLabel(groups));
 
     // Split the VariationIDs from the labels for verification below.
-    std::vector<std::string> split_labels;
     std::set<std::string> parsed_ids;
-    base::SplitString(experiment_labels_string, ';', &split_labels);
-    for (std::vector<std::string>::const_iterator it = split_labels.begin();
-         it != split_labels.end(); ++it) {
+    for (const std::string& label : base::SplitString(
+             experiment_labels_string, ";",
+             base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
       // The ID is precisely between the '=' and '|' characters in each label.
-      size_t index_of_equals = it->find('=');
-      size_t index_of_pipe = it->find('|');
+      size_t index_of_equals = label.find('=');
+      size_t index_of_pipe = label.find('|');
       ASSERT_NE(std::string::npos, index_of_equals);
       ASSERT_NE(std::string::npos, index_of_pipe);
       ASSERT_GT(index_of_pipe, index_of_equals);
-      parsed_ids.insert(it->substr(index_of_equals + 1,
-                                   index_of_pipe - index_of_equals - 1));
+      parsed_ids.insert(label.substr(index_of_equals + 1,
+                                     index_of_pipe - index_of_equals - 1));
     }
 
     // Verify that the resulting string contains each of the expected labels,
diff --git a/chrome/common/variations/variations_util.cc b/chrome/common/variations/variations_util.cc
index ff7bc5d..3c28336 100644
--- a/chrome/common/variations/variations_util.cc
+++ b/chrome/common/variations/variations_util.cc
@@ -34,21 +34,21 @@ void SetChildProcessLoggingVariationList() {
 
 bool AssociateParamsFromString(const std::string& varations_string) {
   // Format: Trial1.Group1:k1/v1/k2/v2,Trial2.Group2:k1/v1/k2/v2
-  std::vector<std::string> experiment_groups;
-  base::SplitString(varations_string, ',', &experiment_groups);
-  for (const auto& experiment_group : experiment_groups) {
-    std::vector<std::string> experiment;
-    base::SplitString(experiment_group, ':', &experiment);
+  for (const base::StringPiece& experiment_group : base::SplitStringPiece(
+           varations_string, ",",
+           base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
+    std::vector<base::StringPiece> experiment = base::SplitStringPiece(
+        experiment_group, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     if (experiment.size() != 2)
       return false;
 
-    std::vector<std::string> group_parts;
-    base::SplitString(experiment[0], '.', &group_parts);
+    std::vector<std::string> group_parts = base::SplitString(
+        experiment[0], ".", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     if (group_parts.size() != 2)
       return false;
 
-    std::vector<std::string> key_values;
-    base::SplitString(experiment[1], '/', &key_values);
+    std::vector<std::string> key_values = base::SplitString(
+        experiment[1], "/", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     if (key_values.size() % 2 != 0)
       return false;
 
diff --git a/chrome/installer/gcapi/gcapi_omaha_experiment.cc b/chrome/installer/gcapi/gcapi_omaha_experiment.cc
index a790a26..1724b97 100644
--- a/chrome/installer/gcapi/gcapi_omaha_experiment.cc
+++ b/chrome/installer/gcapi/gcapi_omaha_experiment.cc
@@ -42,9 +42,10 @@ bool SetExperimentLabel(const wchar_t* brand_code,
   }
 
   // Split the original labels by the label separator.
-  std::vector<base::string16> entries;
-  base::SplitString(original_labels, google_update::kExperimentLabelSeparator,
-                    &entries);
+  std::vector<base::string16> entries = base::SplitString(
+      original_labels,
+      base::string16(1, google_update::kExperimentLabelSeparator),
+      base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   // Keep all labels, but the one we want to add/replace.
   base::string16 label_and_separator(label);
diff --git a/chrome/installer/util/compat_checks.cc b/chrome/installer/util/compat_checks.cc
index 52a70a6..d2425e8 100644
--- a/chrome/installer/util/compat_checks.cc
+++ b/chrome/installer/util/compat_checks.cc
@@ -26,9 +26,10 @@ std::wstring GetSEPVersion() {
 // The product version should be a string like "11.0.3001.2224". This function
 // returns as params the first 3 values. Return value is false if anything
 // does not fit the format.
-bool ParseSEPVersion(const std::wstring& version, int* v0, int* v1, int* v2) {
-  std::vector<std::wstring> v;
-  base::SplitString(version, L'.', &v);
+bool ParseSEPVersion(const base::string16& version,
+                     int* v0, int* v1, int* v2) {
+  std::vector<base::StringPiece16> v = base::SplitStringPiece(
+      version, L".", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (v.size() != 4)
     return false;
   if (!base::StringToInt(v[0], v0))
diff --git a/chrome/installer/util/user_experiment.cc b/chrome/installer/util/user_experiment.cc
index 4a63eef..af0bb68 100644
--- a/chrome/installer/util/user_experiment.cc
+++ b/chrome/installer/util/user_experiment.cc
@@ -355,13 +355,10 @@ bool CreateExperimentDetails(int flavor, ExperimentDetails* experiment) {
     if (experiment_locale != locale && experiment_locale != L"*")
       continue;
 
-    std::vector<base::string16> brand_codes;
-    base::SplitString(kExperiments[i].brands, L',', &brand_codes);
-    if (brand_codes.empty())
-      return false;
-    for (std::vector<base::string16>::iterator it = brand_codes.begin();
-         it != brand_codes.end(); ++it) {
-      if (*it != brand && *it != L"*")
+    for (const base::string16& cur : base::SplitString(
+             kExperiments[i].brands, L",",
+             base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
+      if (cur != brand && cur != L"*")
         continue;
       // We have found our match.
       const UserExperimentSpecs& match = kExperiments[i];
diff --git a/chrome/renderer/media/chrome_key_systems.cc b/chrome/renderer/media/chrome_key_systems.cc
index c1db59a..8011275 100644
--- a/chrome/renderer/media/chrome_key_systems.cc
+++ b/chrome/renderer/media/chrome_key_systems.cc
@@ -137,9 +137,9 @@ void GetSupportedCodecsForPepperCdm(
         DLOG(WARNING) << "Non-UTF-8 codecs string.";
         // Continue using the best effort conversion.
       }
-      base::SplitString(codecs_string,
-                        kCdmSupportedCodecsValueDelimiter,
-                        codecs);
+      *codecs = base::SplitString(
+          codecs_string, std::string(1, kCdmSupportedCodecsValueDelimiter),
+          base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
       break;
     }
   }
diff --git a/chrome/renderer/page_load_histograms.cc b/chrome/renderer/page_load_histograms.cc
index 78c1d5f..f0322042 100644
--- a/chrome/renderer/page_load_histograms.cc
+++ b/chrome/renderer/page_load_histograms.cc
@@ -165,9 +165,9 @@ bool ViaHeaderContains(WebFrame* frame, const std::string& via_value) {
   // separated by a comma corresponds to a proxy. The value added by a proxy is
   // not expected to contain any commas.
   // Example., Via: 1.0 Compression proxy, 1.1 Google Instant Proxy Preview
-  base::SplitString(
+  values = base::SplitString(
       frame->dataSource()->response().httpHeaderField(kViaHeaderName).utf8(),
-      ',', &values);
+      ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   return std::find(values.begin(), values.end(), via_value) != values.end();
 }
 
diff --git a/chrome/renderer/safe_browsing/phishing_url_feature_extractor.cc b/chrome/renderer/safe_browsing/phishing_url_feature_extractor.cc
index f42837d..65351c6 100644
--- a/chrome/renderer/safe_browsing/phishing_url_feature_extractor.cc
+++ b/chrome/renderer/safe_browsing/phishing_url_feature_extractor.cc
@@ -58,12 +58,8 @@ bool PhishingUrlFeatureExtractor::ExtractFeatures(const GURL& url,
 
     // Pull off the TLD and the preceeding dot.
     host.erase(tld_start - 1);
-    std::vector<std::string> host_tokens;
-    base::SplitStringDontTrim(host, '.', &host_tokens);
-    // Get rid of any empty components.
-    std::vector<std::string>::iterator new_end =
-        std::remove(host_tokens.begin(), host_tokens.end(), "");
-    host_tokens.erase(new_end, host_tokens.end());
+    std::vector<std::string> host_tokens = base::SplitString(
+        host, ".", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
     if (host_tokens.empty()) {
       DVLOG(1) << "Could not find domain for host: " << host;
       return false;
diff --git a/chrome/renderer/spellchecker/spellcheck_worditerator_unittest.cc b/chrome/renderer/spellchecker/spellcheck_worditerator_unittest.cc
index 491a8f2..08809de 100644
--- a/chrome/renderer/spellchecker/spellcheck_worditerator_unittest.cc
+++ b/chrome/renderer/spellchecker/spellcheck_worditerator_unittest.cc
@@ -125,9 +125,9 @@ TEST(SpellcheckWordIteratorTest, SplitWord) {
                                     kTestCases[i].allow_contraction));
     EXPECT_TRUE(iterator.SetText(input.c_str(), input.length()));
 
-    std::vector<base::string16> expected_words;
-    base::SplitString(
-        base::WideToUTF16(kTestCases[i].expected_words), ' ', &expected_words);
+    std::vector<base::string16> expected_words = base::SplitString(
+        base::WideToUTF16(kTestCases[i].expected_words),
+        base::string16(1, ' '), base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
     base::string16 actual_word;
     int actual_start, actual_end;
diff --git a/chrome/renderer/web_apps.cc b/chrome/renderer/web_apps.cc
index aadacca..95514bb 100644
--- a/chrome/renderer/web_apps.cc
+++ b/chrome/renderer/web_apps.cc
@@ -39,7 +39,7 @@ namespace {
 
 // Sizes a single size (the width or height) from a 'sizes' attribute. A size
 // matches must match the following regex: [1-9][0-9]*.
-int ParseSingleIconSize(const base::string16& text) {
+int ParseSingleIconSize(const base::StringPiece16& text) {
   // Size must not start with 0, and be between 0 and 9.
   if (text.empty() || !(text[0] >= L'1' && text[0] <= L'9'))
     return 0;
@@ -59,8 +59,9 @@ int ParseSingleIconSize(const base::string16& text) {
 // [1-9][0-9]*x[1-9][0-9]*.
 // If the input couldn't be parsed, a size with a width/height == 0 is returned.
 gfx::Size ParseIconSize(const base::string16& text) {
-  std::vector<base::string16> sizes;
-  base::SplitStringDontTrim(text, L'x', &sizes);
+  std::vector<base::StringPiece16> sizes = base::SplitStringPiece(
+      text, base::string16(1, 'x'),
+      base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
   if (sizes.size() != 2)
     return gfx::Size();
 
@@ -99,8 +100,9 @@ bool ParseIconSizes(const base::string16& text,
                     std::vector<gfx::Size>* sizes,
                     bool* is_any) {
   *is_any = false;
-  std::vector<base::string16> size_strings;
-  base::SplitStringAlongWhitespace(text, &size_strings);
+  std::vector<base::string16> size_strings = base::SplitString(
+      text, base::kWhitespaceASCIIAs16,
+      base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
   for (size_t i = 0; i < size_strings.size(); ++i) {
     if (base::EqualsASCII(size_strings[i], "any")) {
       *is_any = true;
diff --git a/chrome/service/cloud_print/cloud_print_connector.cc b/chrome/service/cloud_print/cloud_print_connector.cc
index f53c865..0a7d754 100644
--- a/chrome/service/cloud_print/cloud_print_connector.cc
+++ b/chrome/service/cloud_print/cloud_print_connector.cc
@@ -420,8 +420,8 @@ void CloudPrintConnector::InitJobHandlerForPrinter(
       if (tags_list->GetString(index, &tag) &&
           base::StartsWith(tag, kCloudPrintServiceTagsHashTagName,
                            base::CompareCase::INSENSITIVE_ASCII)) {
-        std::vector<std::string> tag_parts;
-        base::SplitStringDontTrim(tag, '=', &tag_parts);
+        std::vector<std::string> tag_parts = base::SplitString(
+            tag, "=", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
         DCHECK_EQ(tag_parts.size(), 2U);
         if (tag_parts.size() == 2)
           printer_info_cloud.tags_hash = tag_parts[1];
diff --git a/chrome/test/base/chrome_process_util_mac.cc b/chrome/test/base/chrome_process_util_mac.cc
index 9073448..cb19bc4 100644
--- a/chrome/test/base/chrome_process_util_mac.cc
+++ b/chrome/test/base/chrome_process_util_mac.cc
@@ -35,16 +35,12 @@ MacChromeProcessInfoList GetRunningMacProcessInfo(
   if (!base::GetAppOutput(base::CommandLine(cmdline), &ps_output))
     return result;  // All the pids might have exited
 
-  // Process the results
-  std::vector<std::string> ps_output_lines;
-  base::SplitString(ps_output, '\n', &ps_output_lines);
-  std::vector<std::string>::const_iterator line_iter;
-  for (line_iter = ps_output_lines.begin();
-       line_iter != ps_output_lines.end();
-       ++line_iter) {
-    std::string line(base::CollapseWhitespaceASCII(*line_iter, false));
-    std::vector<std::string> values;
-    base::SplitString(line, ' ', &values);
+  // Process the results.
+  for (const std::string& raw_line : base::SplitString(
+           ps_output, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
+    std::string line(base::CollapseWhitespaceASCII(raw_line, false));
+    std::vector<base::StringPiece> values = base::SplitStringPiece(
+        line, " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     if (values.size() == 3) {
       MacChromeProcessInfo proc_info;
       int pid;
diff --git a/chrome/test/chromedriver/capabilities.cc b/chrome/test/chromedriver/capabilities.cc
index 33b34d2..bc5bbbb 100644
--- a/chrome/test/chromedriver/capabilities.cc
+++ b/chrome/test/chromedriver/capabilities.cc
@@ -294,8 +294,8 @@ Status ParseUseRemoteBrowser(const base::Value& option,
   if (!option.GetAsString(&server_addr))
     return Status(kUnknownError, "must be 'host:port'");
 
-  std::vector<std::string> values;
-  base::SplitString(server_addr, ':', &values);
+  std::vector<std::string> values = base::SplitString(
+      server_addr, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (values.size() != 2)
     return Status(kUnknownError, "must be 'host:port'");
 
diff --git a/chrome/test/chromedriver/chrome/adb_impl.cc b/chrome/test/chromedriver/chrome/adb_impl.cc
index 46db337..b177d7d 100644
--- a/chrome/test/chromedriver/chrome/adb_impl.cc
+++ b/chrome/test/chromedriver/chrome/adb_impl.cc
@@ -14,6 +14,7 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_tokenizer.h"
+#include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/time/time.h"
@@ -87,8 +88,9 @@ Status AdbImpl::GetDevices(std::vector<std::string>* devices) {
     return status;
   base::StringTokenizer lines(response, "\n");
   while (lines.GetNext()) {
-    std::vector<std::string> fields;
-    base::SplitStringAlongWhitespace(lines.token(), &fields);
+    std::vector<std::string> fields = base::SplitString(
+        lines.token_piece(), base::kWhitespaceASCII,
+        base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
     if (fields.size() == 2 && fields[1] == "device") {
       devices->push_back(fields[0]);
     }
@@ -199,17 +201,14 @@ Status AdbImpl::GetPidByName(const std::string& device_serial,
   if (!status.IsOk())
     return status;
 
-  std::vector<std::string> lines;
-  base::SplitString(response, '\n', &lines);
-  for (size_t i = 0; i < lines.size(); ++i) {
-    std::string line = lines[i];
-    if (line.empty())
-      continue;
-    std::vector<std::string> tokens;
-    base::SplitStringAlongWhitespace(line, &tokens);
+  for (const base::StringPiece& line : base::SplitString(
+           response, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY)) {
+    std::vector<base::StringPiece> tokens = base::SplitStringPiece(
+        line, base::kWhitespaceASCII,
+        base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
     if (tokens.size() != 9)
       continue;
-    if (tokens[8].compare(process_name) == 0) {
+    if (tokens[8] == process_name) {
       if (base::StringToInt(tokens[1], pid)) {
         return Status(kOk);
       } else {
diff --git a/chrome/test/chromedriver/chrome/browser_info.cc b/chrome/test/chromedriver/chrome/browser_info.cc
index 23782f2..4f79ee3 100644
--- a/chrome/test/chromedriver/chrome/browser_info.cc
+++ b/chrome/test/chromedriver/chrome/browser_info.cc
@@ -77,8 +77,8 @@ Status ParseBrowserString(bool has_android_package,
   int build_no = 0;
   if (browser_string.find(kVersionPrefix) == 0u) {
     std::string version = browser_string.substr(kVersionPrefix.length());
-    std::vector<std::string> version_parts;
-    base::SplitString(version, '.', &version_parts);
+    std::vector<base::StringPiece> version_parts = base::SplitStringPiece(
+        version, ".", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
     if (version_parts.size() != 4 ||
         !base::StringToInt(version_parts[2], &build_no)) {
diff --git a/chrome/test/chromedriver/chrome/chrome_android_impl.cc b/chrome/test/chromedriver/chrome/chrome_android_impl.cc
index 5a58e665..5cfcec0 100644
--- a/chrome/test/chromedriver/chrome/chrome_android_impl.cc
+++ b/chrome/test/chromedriver/chrome/chrome_android_impl.cc
@@ -37,8 +37,9 @@ std::string ChromeAndroidImpl::GetOperatingSystemName() {
 bool ChromeAndroidImpl::HasTouchScreen() const {
   const BrowserInfo* browser_info = GetBrowserInfo();
   if (browser_info->browser_name == "webview") {
-    std::vector<std::string> version_parts;
-    base::SplitString(browser_info->browser_version, '.', &version_parts);
+    std::vector<base::StringPiece> version_parts = base::SplitStringPiece(
+        browser_info->browser_version, ".",
+        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     int major_version;
     if (version_parts.size() != 4 ||
         !base::StringToInt(version_parts[0], &major_version)) {
diff --git a/chrome/test/chromedriver/chrome_launcher_unittest.cc b/chrome/test/chromedriver/chrome_launcher_unittest.cc
index 5ccec7c..ec8f7a1 100644
--- a/chrome/test/chromedriver/chrome_launcher_unittest.cc
+++ b/chrome/test/chromedriver/chrome_launcher_unittest.cc
@@ -124,8 +124,9 @@ TEST(ProcessExtensions, MultipleExtensionsNoBgPages) {
   ASSERT_TRUE(switches.HasSwitch("load-extension"));
   base::CommandLine::StringType ext_paths =
       switches.GetSwitchValueNative("load-extension");
-  std::vector<base::CommandLine::StringType> ext_path_list;
-  base::SplitString(ext_paths, FILE_PATH_LITERAL(','), &ext_path_list);
+  std::vector<base::CommandLine::StringType> ext_path_list =
+      base::SplitString(ext_paths, base::CommandLine::StringType(1, ','),
+      base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   ASSERT_EQ(2u, ext_path_list.size());
   ASSERT_TRUE(base::PathExists(base::FilePath(ext_path_list[0])));
   ASSERT_TRUE(base::PathExists(base::FilePath(ext_path_list[1])));
diff --git a/chrome/test/chromedriver/element_commands.cc b/chrome/test/chromedriver/element_commands.cc
index 49df717..ebb7b97 100644
--- a/chrome/test/chromedriver/element_commands.cc
+++ b/chrome/test/chromedriver/element_commands.cc
@@ -334,11 +334,11 @@ Status ExecuteSendKeysToElement(
     }
 
     // Separate the string into separate paths, delimited by '\n'.
-    std::vector<base::FilePath::StringType> path_strings;
-    base::SplitString(paths_string, '\n', &path_strings);
     std::vector<base::FilePath> paths;
-    for (size_t i = 0; i < path_strings.size(); ++i)
-      paths.push_back(base::FilePath(path_strings[i]));
+    for (const auto& path_piece : base::SplitStringPiece(
+             paths_string, base::FilePath::StringType(1, '\n'),
+             base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL))
+      paths.push_back(base::FilePath(path_piece));
 
     bool multiple = false;
     status = IsElementAttributeEqualToIgnoreCase(
diff --git a/chrome/test/chromedriver/server/chromedriver_server.cc b/chrome/test/chromedriver/server/chromedriver_server.cc
index 499338e..f9d1954 100644
--- a/chrome/test/chromedriver/server/chromedriver_server.cc
+++ b/chrome/test/chromedriver/server/chromedriver_server.cc
@@ -287,7 +287,8 @@ int main(int argc, char *argv[]) {
   if (cmd_line->HasSwitch("whitelisted-ips")) {
     allow_remote = true;
     std::string whitelist = cmd_line->GetSwitchValueASCII("whitelisted-ips");
-    base::SplitString(whitelist, ',', &whitelisted_ips);
+    whitelisted_ips = base::SplitString(
+        whitelist, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   }
   if (!cmd_line->HasSwitch("silent")) {
     printf("Starting ChromeDriver %s on port %u\n", kChromeDriverVersion, port);
diff --git a/chrome/test/chromedriver/server/http_handler.cc b/chrome/test/chromedriver/server/http_handler.cc
index 0d54c22..63c0a95 100644
--- a/chrome/test/chromedriver/server/http_handler.cc
+++ b/chrome/test/chromedriver/server/http_handler.cc
@@ -742,10 +742,10 @@ bool MatchesCommand(const std::string& method,
   if (!MatchesMethod(command.method, method))
     return false;
 
-  std::vector<std::string> path_parts;
-  base::SplitString(path, '/', &path_parts);
-  std::vector<std::string> command_path_parts;
-  base::SplitString(command.path_pattern, '/', &command_path_parts);
+  std::vector<std::string> path_parts = base::SplitString(
+      path, "/", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+  std::vector<std::string> command_path_parts = base::SplitString(
+      command.path_pattern, "/", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (path_parts.size() != command_path_parts.size())
     return false;
 
diff --git a/chrome/tools/convert_dict/aff_reader.cc b/chrome/tools/convert_dict/aff_reader.cc
index 8250611..8391c13 100644
--- a/chrome/tools/convert_dict/aff_reader.cc
+++ b/chrome/tools/convert_dict/aff_reader.cc
@@ -229,8 +229,8 @@ void AffReader::AddAffix(std::string* rule) {
           // To make hunspell work more happily, replace this morph rule with
           // a compound flag as listed below.
           //   AFX D   0 d/M e
-          std::vector<std::string> tokens;
-          base::SplitString(part, ' ', &tokens);
+          std::vector<std::string> tokens = base::SplitString(
+              part, " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
           if (tokens.size() >= 5) {
             part = base::StringPrintf("%s %s/%s %s",
                                       tokens[0].c_str(),
@@ -257,8 +257,9 @@ void AffReader::AddAffix(std::string* rule) {
 
           // After the slash are both the flags, then whitespace, then the part
           // that tells us what to strip.
-          std::vector<std::string> after_slash;
-          base::SplitString(part.substr(slash_index + 1), ' ', &after_slash);
+          std::vector<std::string> after_slash = base::SplitString(
+              part.substr(slash_index + 1), " ",
+              base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
           if (after_slash.size() == 0) {
             Panic("Found 0 terms after slash in affix rule '%s', "
                       "but need at least 2.",
diff --git a/chrome/utility/importer/bookmark_html_reader.cc b/chrome/utility/importer/bookmark_html_reader.cc
index 1350512..59048e2 100644
--- a/chrome/utility/importer/bookmark_html_reader.cc
+++ b/chrome/utility/importer/bookmark_html_reader.cc
@@ -96,8 +96,8 @@ void ImportBookmarksFile(
     favicon_base::FaviconUsageDataList* favicons) {
   std::string content;
   base::ReadFileToString(file_path, &content);
-  std::vector<std::string> lines;
-  base::SplitString(content, '\n', &lines);
+  std::vector<std::string> lines = base::SplitString(
+      content, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   base::string16 last_folder;
   bool last_folder_on_toolbar = false;
diff --git a/chrome/utility/importer/ie_importer_win.cc b/chrome/utility/importer/ie_importer_win.cc
index f4d1de4..6bff0e4 100644
--- a/chrome/utility/importer/ie_importer_win.cc
+++ b/chrome/utility/importer/ie_importer_win.cc
@@ -596,7 +596,9 @@ void IEImporter::ImportPasswordsIE6() {
         ac.key.erase(i);
         ac.is_url = (ac.key.find(L"://") != base::string16::npos);
         ac_list.push_back(ac);
-        base::SplitString(data, L'\0', &ac_list[ac_list.size() - 1].data);
+        ac_list[ac_list.size() - 1].data = base::SplitString(
+            data, base::string16(1, '\0'),
+            base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
       }
       CoTaskMemFree(buffer);
     }
diff --git a/chrome/utility/importer/nss_decryptor.cc b/chrome/utility/importer/nss_decryptor.cc
index 01bdb0a..3f5a993 100644
--- a/chrome/utility/importer/nss_decryptor.cc
+++ b/chrome/utility/importer/nss_decryptor.cc
@@ -121,8 +121,8 @@ void NSSDecryptor::ParseSignons(
   forms->clear();
 
   // Splits the file content into lines.
-  std::vector<std::string> lines;
-  base::SplitString(content, '\n', &lines);
+  std::vector<std::string> lines = base::SplitString(
+      content, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   // The first line is the file version. We skip the unknown versions.
   if (lines.empty())
diff --git a/chrome/utility/media_galleries/picasa_albums_indexer.cc b/chrome/utility/media_galleries/picasa_albums_indexer.cc
index e99a141..7eded27 100644
--- a/chrome/utility/media_galleries/picasa_albums_indexer.cc
+++ b/chrome/utility/media_galleries/picasa_albums_indexer.cc
@@ -41,11 +41,9 @@ class PicasaINIParser : public INIParser {
     if (section.find(kAlbumSectionHeader) == 0)
       return;
 
-    std::vector<std::string> containing_albums;
-    base::SplitString(value, ',', &containing_albums);
-    for (std::vector<std::string>::iterator it = containing_albums.begin();
-         it != containing_albums.end(); ++it) {
-      AlbumImagesMap::iterator album_map_it = albums_images_->find(*it);
+    for (const std::string& album : base::SplitString(
+              value, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
+      AlbumImagesMap::iterator album_map_it = albums_images_->find(album);
 
       // Ignore entry if the album uid is not listed among in |album_uids|
       // in the constructor. Happens if the PMP and INI files are inconsistent.