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;
-      base::SplitString(proc, ':', &proc_parts);
+      std::vector<std::string> proc_parts = base::SplitString(
+          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;
-  SplitStringAlongWhitespace(totmaps_data, &totmaps_fields);
+  std::vector<std::string> totmaps_fields = SplitString(
+      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;
-    SplitStringAlongWhitespace(data[i].input, &results);
+    std::vector<std::string> results = base::SplitString(
+        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;
-  // This call also trims whitespaces, including carriage-returns (\r).
-  SplitString(zone_path_contents, '\n', &lines);
-
+  std::vector<std::string> lines = SplitString(
+      zone_path_contents, "\n", TRIM_WHITESPACE, SPLIT_WANT_ALL);
   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;
-  base::SplitString(auth_schemes_, ',', &supported_schemes);
+  std::vector<std::string> supported_schemes = base::SplitString(
+      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;
-  base::SplitString(metrics_name, kMetricsNameAppInfoDelimiter, &tokens);
+  std::vector<std::string> tokens = base::SplitString(
+      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;
-  base::SplitString(netifs_to_ignore_str, ',', &netifs_to_ignore_vector);
-  for (const auto& netif : netifs_to_ignore_vector)
+  for (const std::string& netif : base::SplitString(
+           netifs_to_ignore_str, ",", base::TRIM_WHITESPACE,
+           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;
-  base::SplitString(unstub_list, ',', &unstub_components);
-  for (std::vector<std::string>::const_iterator iter =
-          unstub_components.begin();
-       iter != unstub_components.end(); ++iter) {
-    DBusClientBundle::DBusClientType client = GetDBusClientType(*iter);
+  for (const std::string& cur : base::SplitString(
+           unstub_list, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
+    DBusClientBundle::DBusClientType client = GetDBusClientType(cur);
     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;
-    base::SplitString(notifier_state.dns_servers, ',', &dns_servers);
+    std::vector<std::string> 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;
-    base::SplitString(notifier_state.dns_servers, ',', &dns_servers);
+    std::vector<std::string> 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;
-    base::SplitString(default_network_state.dns_servers, ',', &dns_servers);
+    std::vector<std::string> dns_servers =
+        base::SplitString(default_network_state.dns_servers, ",",
+                          base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     default_network_.dns_servers_ = dns_servers;
   }