Remove remaining legacy SplitString calls.

TBR=zelidrag@chromium.org (chromeos)

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

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

base/process/process_linux.cc

@@ -102,8 +102,8 @@ bool Process::IsProcessBackgrounded() const {
     if (base::ReadFileToString(
             base::FilePath(StringPrintf(kProcPath, process_)),
             &proc)) {
-      std::vector<std::string> proc_parts;
+      std::vector<std::string> proc_parts = base::SplitString(
-      base::SplitString(proc, ':', &proc_parts);
+          proc, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
       DCHECK_EQ(proc_parts.size(), 3u);
       bool ret = proc_parts[2] == std::string(kBackground);
       return ret;

base/process/process_metrics_linux.cc

@@ -316,8 +316,9 @@ bool ProcessMetrics::GetWorkingSetKBytesTotmaps(WorkingSetKBytes *ws_usage)
       return false;
   }
 
-  std::vector<std::string> totmaps_fields;
+  std::vector<std::string> totmaps_fields = SplitString(
-  SplitStringAlongWhitespace(totmaps_data, &totmaps_fields);
+      totmaps_data, base::kWhitespaceASCII, base::KEEP_WHITESPACE,
+      base::SPLIT_WANT_NONEMPTY);
 
   DCHECK_EQ("Pss:", totmaps_fields[kPssIndex-1]);
   DCHECK_EQ("Private_Clean:", totmaps_fields[kPrivate_CleanIndex - 1]);

base/strings/string_split.cc

@@ -271,37 +271,4 @@ void SplitStringUsingSubstr(const std::string& str,
   SplitStringUsingSubstrT(str, s, r);
 }
 
-void SplitStringDontTrim(StringPiece16 str,
-                         char16 c,
-                         std::vector<string16>* result) {
-  DCHECK(CBU16_IS_SINGLE(c));
-  *result = SplitStringT<string16, string16, char16>(
-      str, c, KEEP_WHITESPACE, SPLIT_WANT_ALL);
-}
-
-void SplitStringDontTrim(StringPiece str,
-                         char c,
-                         std::vector<std::string>* result) {
-#if CHAR_MIN < 0
-  DCHECK_GE(c, 0);
-#endif
-  DCHECK_LT(c, 0x7F);
-  *result = SplitStringT<std::string, std::string, char>(
-      str, c, KEEP_WHITESPACE, SPLIT_WANT_ALL);
-}
-
-void SplitStringAlongWhitespace(const string16& str,
-                                std::vector<string16>* result) {
-  *result = SplitStringT<string16, string16, StringPiece16>(
-      str, StringPiece16(kWhitespaceASCIIAs16),
-      TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
-}
-
-void SplitStringAlongWhitespace(const std::string& str,
-                                std::vector<std::string>* result) {
-  *result = SplitStringT<std::string, std::string, StringPiece>(
-      str, StringPiece(kWhitespaceASCII),
-      TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
-}
-
 }  // namespace base

base/strings/string_split.h

@@ -101,58 +101,6 @@ BASE_EXPORT void SplitStringUsingSubstr(const std::string& str,
                                         const std::string& s,
                                         std::vector<std::string>* r);
 
-// -----------------------------------------------------------------------------
-// Backwards-compat wrappers
-//
-// New code should use one of the more general variants above.
-// TODO(brettw) remove these and convert to the versions above.
-
-// Splits |str| into a vector of strings delimited by |c|, placing the results
-// in |r|. If several instances of |c| are contiguous, or if |str| begins with
-// or ends with |c|, then an empty string is inserted.
-//
-// Every substring is trimmed of any leading or trailing white space.
-// NOTE: |c| must be in BMP (Basic Multilingual Plane)
-BASE_EXPORT void SplitString(const string16& str,
-                             char16 c,
-                             std::vector<string16>* r);
-
-// |str| should not be in a multi-byte encoding like Shift-JIS or GBK in which
-// the trailing byte of a multi-byte character can be in the ASCII range.
-// UTF-8, and other single/multi-byte ASCII-compatible encodings are OK.
-// Note: |c| must be in the ASCII range.
-BASE_EXPORT void SplitString(const std::string& str,
-                             char c,
-                             std::vector<std::string>* r);
-
-// The same as SplitString, but don't trim white space.
-// NOTE: |c| must be in BMP (Basic Multilingual Plane)
-BASE_EXPORT void SplitStringDontTrim(StringPiece16 str,
-                                     char16 c,
-                                     std::vector<string16>* r);
-// |str| should not be in a multi-byte encoding like Shift-JIS or GBK in which
-// the trailing byte of a multi-byte character can be in the ASCII range.
-// UTF-8, and other single/multi-byte ASCII-compatible encodings are OK.
-// Note: |c| must be in the ASCII range.
-BASE_EXPORT void SplitStringDontTrim(StringPiece str,
-                                     char c,
-                                     std::vector<std::string>* result);
-
-// WARNING: this uses whitespace as defined by the HTML5 spec (ASCII whitespace
-// only).
-//
-// The difference between this and calling SplitString with the whitespace
-// characters as separators is the treatment of the first element when the
-// string starts with whitespace.
-//
-// Input        SplitString      SplitStringAlongWhitespace
-// --------------------------------------------------------
-// " a "        "", "a"          "a"
-BASE_EXPORT void SplitStringAlongWhitespace(const string16& str,
-                                            std::vector<string16>* result);
-BASE_EXPORT void SplitStringAlongWhitespace(const std::string& str,
-                                            std::vector<std::string>* result);
-
 }  // namespace base
 
 #endif  // BASE_STRINGS_STRING_SPLIT_H_

base/strings/string_split_unittest.cc

@@ -4,6 +4,7 @@
 
 #include "base/strings/string_split.h"
 
+#include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -12,23 +13,6 @@ using ::testing::ElementsAre;
 
 namespace base {
 
-namespace {
-
-#if !defined(WCHAR_T_IS_UTF16)
-// Overload SplitString with a wide-char version to make it easier to
-// test the string16 version with wide character literals.
-void SplitString(const std::wstring& str,
-                 wchar_t c,
-                 std::vector<std::wstring>* result) {
-  std::vector<string16> result16;
-  SplitString(WideToUTF16(str), c, &result16);
-  for (size_t i = 0; i < result16.size(); ++i)
-    result->push_back(UTF16ToWide(result16[i]));
-}
-#endif
-
-}  // anonymous namespace
-
 class SplitStringIntoKeyValuePairsTest : public testing::Test {
  protected:
   base::StringPairs kv_pairs;
@@ -243,77 +227,6 @@ TEST(StringUtilTest, SplitString_WhitespaceAndResultType) {
   ASSERT_TRUE(r.empty());
 }
 
-TEST(StringUtilTest, SplitString_Legacy) {
-  std::vector<std::wstring> r;
-
-  SplitString(std::wstring(), L',', &r);
-  EXPECT_EQ(0U, r.size());
-  r.clear();
-
-  SplitString(L"a,b,c", L',', &r);
-  ASSERT_EQ(3U, r.size());
-  EXPECT_EQ(r[0], L"a");
-  EXPECT_EQ(r[1], L"b");
-  EXPECT_EQ(r[2], L"c");
-  r.clear();
-
-  SplitString(L"a, b, c", L',', &r);
-  ASSERT_EQ(3U, r.size());
-  EXPECT_EQ(r[0], L"a");
-  EXPECT_EQ(r[1], L"b");
-  EXPECT_EQ(r[2], L"c");
-  r.clear();
-
-  SplitString(L"a,,c", L',', &r);
-  ASSERT_EQ(3U, r.size());
-  EXPECT_EQ(r[0], L"a");
-  EXPECT_EQ(r[1], L"");
-  EXPECT_EQ(r[2], L"c");
-  r.clear();
-
-  SplitString(L"a, ,c", L',', &r);
-  ASSERT_EQ(3U, r.size());
-  EXPECT_EQ(r[0], L"a");
-  EXPECT_EQ(r[1], L"");
-  EXPECT_EQ(r[2], L"c");
-  r.clear();
-
-  SplitString(L"   ", L'*', &r);
-  EXPECT_EQ(0U, r.size());
-  r.clear();
-
-  SplitString(L"foo", L'*', &r);
-  ASSERT_EQ(1U, r.size());
-  EXPECT_EQ(r[0], L"foo");
-  r.clear();
-
-  SplitString(L"foo ,", L',', &r);
-  ASSERT_EQ(2U, r.size());
-  EXPECT_EQ(r[0], L"foo");
-  EXPECT_EQ(r[1], L"");
-  r.clear();
-
-  SplitString(L",", L',', &r);
-  ASSERT_EQ(2U, r.size());
-  EXPECT_EQ(r[0], L"");
-  EXPECT_EQ(r[1], L"");
-  r.clear();
-
-  SplitString(L"\t\ta\t", L'\t', &r);
-  ASSERT_EQ(4U, r.size());
-  EXPECT_EQ(r[0], L"");
-  EXPECT_EQ(r[1], L"");
-  EXPECT_EQ(r[2], L"a");
-  EXPECT_EQ(r[3], L"");
-  r.clear();
-
-  SplitString(L"\ta\t\nb\tcc", L'\n', &r);
-  ASSERT_EQ(2U, r.size());
-  EXPECT_EQ(r[0], L"a");
-  EXPECT_EQ(r[1], L"b\tcc");
-  r.clear();
-}
-
 TEST(SplitStringUsingSubstrTest, StringWithNoDelimiter) {
   std::vector<std::string> results;
   SplitStringUsingSubstr("alongwordwithnodelimiter", "DELIMITER", &results);
@@ -352,21 +265,23 @@ TEST(SplitStringUsingSubstrTest, TrailingDelimitersSkipped) {
       results, ElementsAre("un", "deux", "trois", "quatre", "", "", ""));
 }
 
-TEST(StringSplitTest, StringSplitDontTrim) {
+TEST(StringSplitTest, StringSplitKeepWhitespace) {
   std::vector<std::string> r;
 
-  SplitStringDontTrim("   ", '*', &r);
+  r = SplitString("   ", "*", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
   ASSERT_EQ(1U, r.size());
   EXPECT_EQ(r[0], "   ");
 
-  SplitStringDontTrim("\t  \ta\t ", '\t', &r);
+  r = SplitString("\t  \ta\t ", "\t", base::KEEP_WHITESPACE,
+                  base::SPLIT_WANT_ALL);
   ASSERT_EQ(4U, r.size());
   EXPECT_EQ(r[0], "");
   EXPECT_EQ(r[1], "  ");
   EXPECT_EQ(r[2], "a");
   EXPECT_EQ(r[3], " ");
 
-  SplitStringDontTrim("\ta\t\nb\tcc", '\n', &r);
+  r = SplitString("\ta\t\nb\tcc", "\n", base::KEEP_WHITESPACE,
+                  base::SPLIT_WANT_ALL);
   ASSERT_EQ(2U, r.size());
   EXPECT_EQ(r[0], "\ta\t");
   EXPECT_EQ(r[1], "b\tcc");
@@ -394,8 +309,9 @@ TEST(StringSplitTest, SplitStringAlongWhitespace) {
     { "b\t at",  2, "b",  "at" },
   };
   for (size_t i = 0; i < arraysize(data); ++i) {
-    std::vector<std::string> results;
+    std::vector<std::string> results = base::SplitString(
-    SplitStringAlongWhitespace(data[i].input, &results);
+        data[i].input, kWhitespaceASCII, base::KEEP_WHITESPACE,
+        base::SPLIT_WANT_NONEMPTY);
     ASSERT_EQ(data[i].expected_result_count, results.size());
     if (data[i].expected_result_count > 0)
       ASSERT_EQ(data[i].output1, results[0]);

base/test/test_file_util_win.cc

@@ -242,10 +242,8 @@ bool HasInternetZoneIdentifier(const FilePath& full_path) {
   if (!ReadFileToString(zone_path, &zone_path_contents))
     return false;
 
-  std::vector<std::string> lines;
+  std::vector<std::string> lines = SplitString(
-  // This call also trims whitespaces, including carriage-returns (\r).
+      zone_path_contents, "\n", TRIM_WHITESPACE, SPLIT_WANT_ALL);
-  SplitString(zone_path_contents, '\n', &lines);
-
   switch (lines.size()) {
     case 3:
       // optional empty line at end of file:

chrome/browser/io_thread.cc

@@ -1072,8 +1072,8 @@ net::HttpAuthHandlerFactory* IOThread::CreateDefaultAuthHandlerFactory(
   globals_->url_security_manager.reset(
       net::URLSecurityManager::Create(auth_filter_default_credentials,
                                       auth_filter_delegate));
-  std::vector<std::string> supported_schemes;
+  std::vector<std::string> supported_schemes = base::SplitString(
-  base::SplitString(auth_schemes_, ',', &supported_schemes);
+      auth_schemes_, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   scoped_ptr<net::HttpAuthHandlerRegistryFactory> registry_factory(
       net::HttpAuthHandlerRegistryFactory::Create(

chrome/browser/ui/webui/about_ui.cc

@@ -536,11 +536,11 @@ std::vector<std::string> GetHtmlTabDescriptorsForDiscardPage() {
 
 std::string AboutDiscards(const std::string& path) {
   std::string output;
-  std::vector<std::string> path_split;
   int64 web_content_id;
   memory::OomPriorityManager* oom = g_browser_process->GetOomPriorityManager();
 
-  base::SplitString(path, '/', &path_split);
+  std::vector<std::string> path_split = base::SplitString(
+      path, "/", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (path_split.size() == 2 && path_split[0] == kAboutDiscardsRunCommand &&
       base::StringToInt64(path_split[1], &web_content_id)) {
     oom->DiscardTabById(web_content_id);

chromecast/base/metrics/cast_metrics_helper.cc

@@ -54,8 +54,9 @@ bool CastMetricsHelper::DecodeAppInfoFromMetricsName(
   if (metrics_name.find(kMetricsNameAppInfoDelimiter) == std::string::npos)
     return false;
 
-  std::vector<std::string> tokens;
+  std::vector<std::string> tokens = base::SplitString(
-  base::SplitString(metrics_name, kMetricsNameAppInfoDelimiter, &tokens);
+      metrics_name, std::string(1, kMetricsNameAppInfoDelimiter),
+      base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   DCHECK_EQ(tokens.size(), 4u);
   // The order of tokens should match EncodeAppInfoIntoMetricsName().
   *action_name = tokens[0];

chromecast/net/net_util_cast.cc

@@ -22,9 +22,9 @@ base::hash_set<std::string> GetIgnoredInterfaces() {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   base::CommandLine::StringType netifs_to_ignore_str =
       command_line->GetSwitchValueNative(switches::kNetifsToIgnore);
-  base::CommandLine::StringVector netifs_to_ignore_vector;
+  for (const std::string& netif : base::SplitString(
-  base::SplitString(netifs_to_ignore_str, ',', &netifs_to_ignore_vector);
+           netifs_to_ignore_str, ",", base::TRIM_WHITESPACE,
-  for (const auto& netif : netifs_to_ignore_vector)
+           base::SPLIT_WANT_ALL))
     ignored_interfaces.insert(netif);
 
   return ignored_interfaces;

chromeos/dbus/dbus_client_bundle.cc

@@ -354,17 +354,14 @@ void DBusClientBundle::SetupDefaultEnvironment() {
 DBusClientBundle::DBusClientTypeMask DBusClientBundle::ParseUnstubList(
     const std::string& unstub_list) {
   DBusClientTypeMask unstub_mask = 0;
-  std::vector<std::string> unstub_components;
+  for (const std::string& cur : base::SplitString(
-  base::SplitString(unstub_list, ',', &unstub_components);
+           unstub_list, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
-  for (std::vector<std::string>::const_iterator iter =
+    DBusClientBundle::DBusClientType client = GetDBusClientType(cur);
-          unstub_components.begin();
-       iter != unstub_components.end(); ++iter) {
-    DBusClientBundle::DBusClientType client = GetDBusClientType(*iter);
     if (client != NO_CLIENT) {
-      LOG(WARNING) << "Unstubbing dbus client for " << *iter;
+      LOG(WARNING) << "Unstubbing dbus client for " << cur;
       unstub_mask |= client;
     } else {
-      LOG(ERROR) << "Unknown dbus client: " << *iter;
+      LOG(ERROR) << "Unknown dbus client: " << cur;
     }
   }
 

chromeos/network/network_change_notifier_chromeos_unittest.cc

@@ -127,8 +127,9 @@ class NetworkChangeNotifierChromeosUpdateTest : public testing::Test {
     notifier_.service_path_ = notifier_state.service_path;
     notifier_.ip_address_ = notifier_state.ip_address;
     notifier_.max_bandwidth_mbps_ = notifier_state.max_bandwidth;
-    std::vector<std::string> dns_servers;
+    std::vector<std::string> dns_servers =
-    base::SplitString(notifier_state.dns_servers, ',', &dns_servers);
+        base::SplitString(notifier_state.dns_servers, ",",
+                          base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     notifier_.dns_servers_ = dns_servers;
   }
 
@@ -137,8 +138,9 @@ class NetworkChangeNotifierChromeosUpdateTest : public testing::Test {
     EXPECT_EQ(notifier_state.service_path, notifier_.service_path_);
     EXPECT_EQ(notifier_state.ip_address, notifier_.ip_address_);
     EXPECT_EQ(notifier_state.max_bandwidth, notifier_.max_bandwidth_mbps_);
-    std::vector<std::string> dns_servers;
+    std::vector<std::string> dns_servers =
-    base::SplitString(notifier_state.dns_servers, ',', &dns_servers);
+        base::SplitString(notifier_state.dns_servers, ",",
+                          base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     EXPECT_EQ(dns_servers, notifier_.dns_servers_);
   }
 
@@ -155,8 +157,9 @@ class NetworkChangeNotifierChromeosUpdateTest : public testing::Test {
         default_network_state.network_technology;
     default_network_.path_ = default_network_state.service_path;
     default_network_.ip_address_ = default_network_state.ip_address;
-    std::vector<std::string> dns_servers;
+    std::vector<std::string> dns_servers =
-    base::SplitString(default_network_state.dns_servers, ',', &dns_servers);
+        base::SplitString(default_network_state.dns_servers, ",",
+                          base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     default_network_.dns_servers_ = dns_servers;
   }
 

chromeos/system/version_loader.cc

@@ -75,12 +75,12 @@ std::string ParseFirmware(const std::string& contents) {
   //   fixed. So we just match kFirmwarePrefix at the start of the line and find
   //   the first character that is not "|" or space
 
-  std::vector<std::string> lines;
+  base::StringPiece firmware_prefix(kFirmwarePrefix);
-  base::SplitString(contents, '\n', &lines);
+  for (const std::string& line : base::SplitString(
-  for (size_t i = 0; i < lines.size(); ++i) {
+           contents, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
-    if (base::StartsWith(lines[i], kFirmwarePrefix,
+    if (base::StartsWith(line, firmware_prefix,
                          base::CompareCase::INSENSITIVE_ASCII)) {
-      std::string str = lines[i].substr(std::string(kFirmwarePrefix).size());
+      std::string str = line.substr(firmware_prefix.size());
       size_t found = str.find_first_not_of("| ");
       if (found != std::string::npos)
         return str.substr(found);

components/signin/core/browser/child_account_info_fetcher_impl.cc

@@ -122,8 +122,9 @@ void ChildAccountInfoFetcherImpl::OnGetUserInfoSuccess(
     const UserInfoMap& data) {
   UserInfoMap::const_iterator services_iter = data.find("allServices");
   if (services_iter != data.end()) {
-    std::vector<std::string> service_flags;
+    std::vector<std::string> service_flags = base::SplitString(
-    base::SplitString(services_iter->second, ',', &service_flags);
+        services_iter->second, ",", base::TRIM_WHITESPACE,
+        base::SPLIT_WANT_ALL);
     bool is_child_account =
         std::find(service_flags.begin(), service_flags.end(),
                   AccountTrackerService::kChildAccountServiceFlag) !=

components/upload_list/upload_list.cc

@@ -12,6 +12,7 @@
 #include "base/location.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
+#include "base/strings/string_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/sequenced_worker_pool.h"
 
@@ -60,8 +61,9 @@ void UploadList::LoadUploadList() {
   if (base::PathExists(upload_log_path_)) {
     std::string contents;
     base::ReadFileToString(upload_log_path_, &contents);
-    std::vector<std::string> log_entries;
+    std::vector<std::string> log_entries = base::SplitString(
-    base::SplitStringAlongWhitespace(contents, &log_entries);
+        contents, base::kWhitespaceASCII, base::KEEP_WHITESPACE,
+        base::SPLIT_WANT_NONEMPTY);
     ClearUploads();
     ParseLogEntries(log_entries);
   }

content/renderer/render_thread_impl.cc

@@ -424,8 +424,8 @@ void CreateEmbeddedWorkerSetup(
 
 void StringToUintVector(const std::string& str, std::vector<unsigned>* vector) {
   DCHECK(vector->empty());
-  std::vector<std::string> pieces;
+  std::vector<std::string> pieces = base::SplitString(
-  base::SplitString(str, ',', &pieces);
+      str, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   DCHECK_EQ(pieces.size(), static_cast<size_t>(gfx::BufferFormat::LAST) + 1);
   for (size_t i = 0; i < pieces.size(); ++i) {
     unsigned number = 0;

device/hid/hid_service_linux.cc

@@ -112,8 +112,8 @@ class HidServiceLinux::FileThreadHelper
       return;
     }
 
-    std::vector<std::string> parts;
+    std::vector<std::string> parts = base::SplitString(
-    base::SplitString(hid_id, ':', &parts);
+        hid_id, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     if (parts.size() != 3) {
       return;
     }

gin/modules/file_module_provider.cc

@@ -20,8 +20,8 @@ void AttempToLoadModule(const base::WeakPtr<Runner>& runner,
   if (!runner)
     return;
 
-  std::vector<std::string> components;
+  std::vector<std::string> components = base::SplitString(
-  base::SplitString(id, '/', &components);
+      id, "/", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   base::FilePath path;
   for (size_t i = 0; i < components.size(); ++i) {

jingle/notifier/communicator/single_login_attempt.cc

@@ -57,8 +57,8 @@ namespace {
 // unparseable, it assumes the default XMPP port.  The hostname may be
 // empty.
 net::HostPortPair ParseRedirectText(const std::string& redirect_text) {
-  std::vector<std::string> parts;
+  std::vector<std::string> parts = base::SplitString(
-  base::SplitString(redirect_text, ':', &parts);
+      redirect_text, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   net::HostPortPair redirect_server;
   redirect_server.set_port(kDefaultXmppPort);
   if (parts.empty()) {

mojo/runner/context.cc

@@ -133,8 +133,8 @@ void InitContentHandlers(shell::ApplicationManager* manager,
   base::ReplaceSubstringsAfterOffset(&handlers_spec, 0, "\\,", ",");
 #endif
 
-  std::vector<std::string> parts;
+  std::vector<std::string> parts = base::SplitString(
-  base::SplitString(handlers_spec, ',', &parts);
+      handlers_spec, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (parts.size() % 2 != 0) {
     LOG(ERROR) << "Invalid value for switch " << switches::kContentHandlers
                << ": must be a comma-separated list of mimetype/url pairs."
@@ -157,9 +157,9 @@ void InitContentHandlers(shell::ApplicationManager* manager,
 
 void InitNativeOptions(shell::ApplicationManager* manager,
                        const base::CommandLine& command_line) {
-  std::vector<std::string> force_in_process_url_list;
+  std::vector<std::string> force_in_process_url_list = base::SplitString(
-  base::SplitString(command_line.GetSwitchValueASCII(switches::kForceInProcess),
+      command_line.GetSwitchValueASCII(switches::kForceInProcess), ",",
-                    ',', &force_in_process_url_list);
+      base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   for (const auto& force_in_process_url : force_in_process_url_list) {
     GURL gurl(force_in_process_url);
     if (!gurl.is_valid()) {

mojo/runner/init.cc

@@ -38,10 +38,9 @@ void WaitForDebuggerIfNecessary() {
   const base::CommandLine* command_line =
       base::CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kWaitForDebugger)) {
-    std::vector<std::string> apps_to_debug;
+    std::vector<std::string> apps_to_debug = base::SplitString(
-    base::SplitString(
+        command_line->GetSwitchValueASCII(switches::kWaitForDebugger), ",",
-        command_line->GetSwitchValueASCII(switches::kWaitForDebugger), ',',
+        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
-        &apps_to_debug);
     std::string app = "launcher";
     if (command_line->HasSwitch(switches::kChildProcess)) {
       app = command_line->GetSwitchValuePath(switches::kChildProcess)

native_client_sdk/src/libraries/sdk_util/string_util.h

@@ -15,7 +15,7 @@ namespace sdk_util {
 // or ends with |c|, then an empty string is inserted. If |str| is empty, then
 // no strings are inserted.
 //
-// NOTE: Unlike Chrome's base::SplitString, this DOES NOT trim white space.
+// NOTE: Does not trim white space.
 inline void SplitString(const std::string& str,
                         char c,
                         std::vector<std::string>* r) {

net/tools/disk_cache_memory_test/disk_cache_memory_test.cc

@@ -20,6 +20,7 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
+#include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/base/cache_type.h"
@@ -137,8 +138,8 @@ scoped_ptr<Backend> CreateAndInitBackend(const CacheSpec& spec) {
 bool ParseRangeLine(const std::string& line,
                     std::vector<std::string>* tokens,
                     bool* is_anonymous_read_write) {
-  tokens->clear();
+  *tokens = base::SplitString(line, base::kWhitespaceASCII,
-  base::SplitStringAlongWhitespace(line, tokens);
+                              base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
   if (tokens->size() == 5) {
     const std::string& mode = (*tokens)[1];
     *is_anonymous_read_write = !mode.compare(0, 3, kReadWrite);
@@ -163,8 +164,8 @@ bool ParseRangeProperty(const std::string& line,
                         std::vector<std::string>* tokens,
                         uint64* size,
                         bool* is_private_dirty) {
-  tokens->clear();
+  *tokens = base::SplitString(line, base::kWhitespaceASCII,
-  base::SplitStringAlongWhitespace(line, tokens);
+                              base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
 
   // If the line is long, attempt to parse new range outside of this scope.
   if (tokens->size() > 3)

pdf/out_of_process_instance.cc

@@ -206,8 +206,9 @@ const PPP_Pdf ppp_private = {
 
 int ExtractPrintPreviewPageIndex(const std::string& src_url) {
   // Sample |src_url| format: chrome://print/id/page_index/print.pdf
-  std::vector<std::string> url_substr;
+  std::vector<std::string> url_substr = base::SplitString(
-  base::SplitString(src_url.substr(strlen(kChromePrint)), '/', &url_substr);
+      src_url.substr(strlen(kChromePrint)), "/",
+      base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (url_substr.size() != 3)
     return -1;
 

ppapi/proxy/file_chooser_resource.cc

@@ -78,8 +78,8 @@ void FileChooserResource::PopulateAcceptTypes(
   if (input.empty())
     return;
 
-  std::vector<std::string> type_list;
+  std::vector<std::string> type_list = base::SplitString(
-  base::SplitString(input, ',', &type_list);
+      input, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   output->reserve(type_list.size());
 
   for (size_t i = 0; i < type_list.size(); ++i) {

remoting/client/plugin/chromoting_instance.cc

@@ -552,8 +552,10 @@ void ChromotingInstance::HandleConnect(const base::DictionaryValue& data) {
   // Read and parse list of experiments.
   std::string experiments;
   std::vector<std::string> experiments_list;
-  if (data.GetString("experiments", &experiments))
+  if (data.GetString("experiments", &experiments)) {
-    base::SplitString(experiments, ' ', &experiments_list);
+    experiments_list = base::SplitString(
+        experiments, " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+  }
 
   VLOG(0) << "Connecting to " << host_jid
           << ". Local jid: " << local_jid << ".";

rlz/win/lib/machine_deal.cc

@@ -107,8 +107,8 @@ bool GetResponseValue(const std::string& response_line,
                         base::CompareCase::SENSITIVE))
     return false;
 
-  std::vector<std::string> tokens;
+  std::vector<std::string> tokens = base::SplitString(
-  base::SplitString(response_line, ':', &tokens);
+      response_line, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (tokens.size() != 2)
     return false;
 

sandbox/win/src/named_pipe_dispatcher.cc

@@ -56,16 +56,15 @@ bool NamedPipeDispatcher::CreateNamedPipe(IPCInfo* ipc,
   ipc->return_info.win32_result = ERROR_ACCESS_DENIED;
   ipc->return_info.handle = INVALID_HANDLE_VALUE;
 
-  std::vector<base::string16> paths;
+  base::StringPiece16 dotdot(L"..");
-  std::vector<base::string16> innerpaths;
-  base::SplitString(*name, '/', &paths);
 
-  for (std::vector<base::string16>::const_iterator iter = paths.begin();
+  for (const base::StringPiece16& path : base::SplitStringPiece(
-       iter != paths.end(); ++iter) {
+           *name, base::string16(1, '/'),
-    base::SplitString(*iter, '\\', &innerpaths);
+           base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
-    for (std::vector<base::string16>::const_iterator iter2 = innerpaths.begin();
+    for (const base::StringPiece16& inner : base::SplitStringPiece(
-         iter2 != innerpaths.end(); ++iter2) {
+             path, base::string16(1, '\\'),
-      if (*iter2 == L"..")
+             base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
+      if (inner == dotdot)
         return true;
     }
   }

skia/ext/image_operations_bench.cc

@@ -119,8 +119,8 @@ class Dimensions {
   // On failure, will set its state in such a way that IsValid will return
   // false.
   void FromString(const std::string& arg) {
-    std::vector<std::string> strings;
+    std::vector<base::StringPiece> strings = base::SplitStringPiece(
-    base::SplitString(std::string(arg), 'x', &strings);
+        arg, "x", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     if (strings.size() != 2 ||
         base::StringToInt(strings[0], &width_) == false ||
         base::StringToInt(strings[1], &height_) == false) {

sql/connection.cc

@@ -1327,7 +1327,8 @@ bool Connection::IntegrityCheckHelper(
     // it could return separate lines, so loop _and_ split.
     while (stmt.Step()) {
       std::string result(stmt.ColumnString(0));
-      base::SplitString(result, '\n', messages);
+      *messages = base::SplitString(result, "\n", base::TRIM_WHITESPACE,
+                                    base::SPLIT_WANT_ALL);
     }
     ret = stmt.Succeeded();
   }

third_party/mojo/src/mojo/edk/test/test_support_impl.cc

@@ -28,12 +28,10 @@ base::FilePath ResolveSourceRootRelativePath(const char* relative_path) {
   if (!PathService::Get(base::DIR_SOURCE_ROOT, &path))
     return base::FilePath();
 
-  std::vector<std::string> components;
+  for (const base::StringPiece& component : base::SplitStringPiece(
-  base::SplitString(relative_path, '/', &components);
+           relative_path, "/", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
-
+    if (!component.empty())
-  for (size_t i = 0; i < components.size(); ++i) {
+      path = path.AppendASCII(component);
-    if (!components[i].empty())
-      path = path.AppendASCII(components[i]);
   }
 
   return path;

tools/android/memdump/memdump.cc

@@ -130,13 +130,13 @@ typedef base::hash_map<uint64, int> PFNMap;
 bool ParseMemoryMapLine(const std::string& line,
                         std::vector<std::string>* tokens,
                         MemoryMap* memory_map) {
-  tokens->clear();
+  *tokens = base::SplitString(
-  base::SplitString(line, ' ', tokens);
+      line, " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (tokens->size() < 2)
     return false;
   const std::string& addr_range = tokens->at(0);
-  std::vector<std::string> range_tokens;
+  std::vector<std::string> range_tokens = base::SplitString(
-  base::SplitString(addr_range, '-', &range_tokens);
+      addr_range, "-", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   const std::string& start_address_token = range_tokens.at(0);
   if (!base::HexStringToUInt64(start_address_token,
                                &memory_map->start_address)) {

tools/gn/command_clean.cc

@@ -25,8 +25,8 @@ std::string ExtractGNBuildCommands(const base::FilePath& build_ninja_file) {
     return std::string();
   }
 
-  std::vector<std::string> lines;
+  std::vector<std::string> lines = base::SplitString(
-  base::SplitStringDontTrim(file_contents, '\n', &lines);
+      file_contents, "\n", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
 
   std::string result;
   int num_blank_lines = 0;

tools/gn/command_format.cc

@@ -80,9 +80,8 @@ enum Precedence {
 };
 
 int CountLines(const std::string& str) {
-  std::vector<std::string> lines;
+  return static_cast<int>(base::SplitStringPiece(
-  base::SplitStringDontTrim(str, '\n', &lines);
+      str, "\n", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL).size());
-  return static_cast<int>(lines.size());
 }
 
 class Printer {
@@ -394,8 +393,8 @@ void Printer::Block(const ParseNode* root) {
 
 int Printer::AssessPenalty(const std::string& output) {
   int penalty = 0;
-  std::vector<std::string> lines;
+  std::vector<std::string> lines = base::SplitString(
-  base::SplitStringDontTrim(output, '\n', &lines);
+      output, "\n", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
   penalty += static_cast<int>(lines.size() - 1) * GetPenaltyForLineBreak();
   for (const auto& line : lines) {
     if (line.size() > kMaximumWidth)
@@ -405,9 +404,8 @@ int Printer::AssessPenalty(const std::string& output) {
 }
 
 bool Printer::ExceedsMaximumWidth(const std::string& output) {
-  std::vector<std::string> lines;
+  for (const auto& line : base::SplitString(
-  base::SplitStringDontTrim(output, '\n', &lines);
+           output, "\n", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL)) {
-  for (const auto& line : lines) {
     if (line.size() > kMaximumWidth)
       return true;
   }

tools/gn/command_refs.cc

@@ -408,7 +408,6 @@ int RunRefs(const std::vector<std::string>& args) {
     if (args[i][0] == '@') {
       // The argument is as a path to a response file.
       std::string contents;
-      std::vector<std::string> lines;
       bool ret = base::ReadFileToString(UTF8ToFilePath(args[i].substr(1)),
                                         &contents);
       if (!ret) {
@@ -416,8 +415,8 @@ int RunRefs(const std::vector<std::string>& args) {
             .PrintToStdout();
         return 1;
       }
-      base::SplitString(contents, '\n', &lines);
+      for (const std::string& line : base::SplitString(
-      for (const auto& line : lines) {
+               contents, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
         if (!line.empty())
           inputs.push_back(line);
       }

tools/gn/input_conversion.cc

@@ -87,8 +87,8 @@ Value ParseValueOrScope(const Settings* settings,
 
 Value ParseList(const std::string& input, const ParseNode* origin, Err* err) {
   Value ret(origin, Value::LIST);
-  std::vector<std::string> as_lines;
+  std::vector<std::string> as_lines = base::SplitString(
-  base::SplitString(input, '\n', &as_lines);
+      input, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   // Trim one empty line from the end since the last line might end in a
   // newline. If the user wants more trimming, they'll specify "trim" in the

tools/gn/runtime_deps.cc

@@ -241,12 +241,10 @@ bool WriteRuntimeDepsFilesIfNecessary(const Builder& builder, Err* err) {
   }
   load_trace.Done();
 
-  std::vector<std::string> lines;
-  base::SplitString(list_contents, '\n', &lines);
-
   SourceDir root_dir("//");
   Label default_toolchain_label = builder.loader()->GetDefaultToolchain();
-  for (const auto& line : lines) {
+  for (const auto& line : base::SplitString(
+           list_contents, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
     if (line.empty())
       continue;
     Label label = Label::Resolve(root_dir, default_toolchain_label,

tools/gn/standard_out.cc

@@ -204,12 +204,10 @@ void PrintShortHelp(const std::string& line) {
 void PrintLongHelp(const std::string& text) {
   EnsureInitialized();
 
-  std::vector<std::string> lines;
-  base::SplitStringDontTrim(text, '\n', &lines);
-
   bool first_header = true;
   bool in_body = false;
-  for (const auto& line : lines) {
+  for (const std::string& line : base::SplitString(
+           text, "\n", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL)) {
     // Check for a heading line.
     if (!line.empty() && line[0] != ' ') {
       if (is_markdown) {

tools/ipc_fuzzer/fuzzer/fuzzer_main.cc

@@ -159,8 +159,8 @@ int Mutate(base::CommandLine* cmd, Fuzzer* fuzzer) {
   bool permute = cmd->HasSwitch(kPermuteSwitch);
 
   std::string type_string_list = cmd->GetSwitchValueASCII(kTypeListSwitch);
-  std::vector<std::string> type_string_vector;
+  std::vector<std::string> type_string_vector = base::SplitString(
-  base::SplitString(type_string_list, ',', &type_string_vector);
+      type_string_list, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   std::set<uint32> type_set;
   for (size_t i = 0; i < type_string_vector.size(); ++i) {
     type_set.insert(atoi(type_string_vector[i].c_str()));

tools/ipc_fuzzer/message_tools/message_util.cc

@@ -108,9 +108,7 @@ int main(int argc, char** argv) {
   bool invert = cmd->HasSwitch(kInvertSwitch);
   bool perform_dump = cmd->HasSwitch(kDumpSwitch);
 
-  std::vector<base::FilePath::StringType> input_file_names;
   base::FilePath::StringType output_file_name;
-  base::SplitString(args[0], ',', &input_file_names);
 
   if (!perform_dump) {
     if (args.size() < 2) {
@@ -121,10 +119,11 @@ int main(int argc, char** argv) {
   }
 
   ipc_fuzzer::MessageVector input_message_vector;
-  for (std::vector<base::FilePath::StringType>::iterator
+  for (const base::FilePath::StringType& name : base::SplitString(
-      it = input_file_names.begin(); it != input_file_names.end(); ++it) {
+           args[0], base::FilePath::StringType(1, ','),
+           base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
     ipc_fuzzer::MessageVector message_vector;
-    if (!ipc_fuzzer::MessageFile::Read(base::FilePath(*it), &message_vector))
+    if (!ipc_fuzzer::MessageFile::Read(base::FilePath(name), &message_vector))
       return EXIT_FAILURE;
     input_message_vector.insert(input_message_vector.end(),
                                 message_vector.begin(), message_vector.end());
@@ -136,11 +135,10 @@ int main(int argc, char** argv) {
 
   if (has_indices) {
     indices.resize(input_message_vector.size(), false);
-    std::vector<std::string> index_strings;
+    for (const std::string& cur : base::SplitString(
-    base::SplitString(cmd->GetSwitchValueASCII(kInSwitch), ',', &index_strings);
+             cmd->GetSwitchValueASCII(kInSwitch), ",", base::TRIM_WHITESPACE,
-    for (std::vector<std::string>::iterator it = index_strings.begin();
+             base::SPLIT_WANT_ALL)) {
-         it != index_strings.end(); ++it) {
+      int index = atoi(cur.c_str());
-      int index = atoi(it->c_str());
       if (index >= 0 && static_cast<size_t>(index) < indices.size())
         indices[index] = true;
     }

win8/delegate_execute/delegate_execute_operation.cc

@@ -52,8 +52,8 @@ bool DelegateExecuteOperation::Init(const base::CommandLine* cmd_line) {
 }
 
 base::Process DelegateExecuteOperation::GetParent() const {
-  std::vector<base::string16> parts;
+  std::vector<base::StringPiece16> parts = base::SplitStringPiece(
-  base::SplitString(mutex_, L'.', &parts);
+      mutex_, L".", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (parts.size() != 3)
     return base::Process();
   DWORD pid;