New new versions of Starts/EndsWith and SplitString in net.

The new calls are longer but more explicit and also more general. I didn't want change the semantics. The old SplitString maps to TRIM_WHITESPACE, SPLIT_WANT_ALL so I generally kept that even if it's not clear if the calling code wants that particular behavior.

In places that obviously didn't need copies, use the StringPiece variant to avoid copies. I didn't expend too much effort in this area, especially in unit test code. It's like that more copies could be deleted with more effort.

Many places just used SplitString to fill a vector that is iterated over. In these places I updated it to use a range-based for loop over the result of the function call.

Add StringPiece versions of TrimWhitesace to match the existing Trim functions.

Update IPLiteralToNumber to take a string piece. This is commonly used in places that have string pieces so this saves a copy.

In net/dns/dns_config_service_win.cc I replaced a UTF16TOASCII call with assign(). This is what UTF16ToASCII actually does and avoids a copy because the current UTF16ToASCII doesn't support StringPiece. Updating this function call or adding an override is a big project due to the way it's use with Blink's WebString.

Removed parts of StringPieceUtils that duplicate base code. Made the remaining functions in that file not locale dependent (tolower is basically always wrong for non-ASCII).

BUG=506920,506255

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

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

51 files changed, 285 insertions, 256 deletions

diff --git a/base/strings/string_util.cc b/base/strings/string_util.cc
index e3dcd85..8d1d238 100644
--- a/base/strings/string_util.cc
+++ b/base/strings/string_util.cc
@@ -307,12 +307,21 @@ TrimPositions TrimWhitespace(const string16& input,
   return TrimStringT(input, StringPiece16(kWhitespaceUTF16), positions, output);
 }
 
+StringPiece16 TrimWhitespaceASCII(StringPiece16 input,
+                                  TrimPositions positions) {
+  return TrimStringPieceT(input, StringPiece16(kWhitespaceUTF16), positions);
+}
+
 TrimPositions TrimWhitespaceASCII(const std::string& input,
                                   TrimPositions positions,
                                   std::string* output) {
   return TrimStringT(input, StringPiece(kWhitespaceASCII), positions, output);
 }
 
+StringPiece TrimWhitespaceASCII(StringPiece input, TrimPositions positions) {
+  return TrimStringPieceT(input, StringPiece(kWhitespaceASCII), positions);
+}
+
 // This function is only for backward-compatibility.
 // To be removed when all callers are updated.
 TrimPositions TrimWhitespace(const std::string& input,
diff --git a/base/strings/string_util.h b/base/strings/string_util.h
index dc3d4d7..1d3469f 100644
--- a/base/strings/string_util.h
+++ b/base/strings/string_util.h
@@ -206,19 +206,23 @@ BASE_EXPORT void TruncateUTF8ToByteSize(const std::string& input,
                                         const size_t byte_size,
                                         std::string* output);
 
-// Trims any whitespace from either end of the input string.  Returns where
-// whitespace was found.
-// The non-wide version has two functions:
-// * TrimWhitespaceASCII()
-//   This function is for ASCII strings and only looks for ASCII whitespace;
-// Please choose the best one according to your usage.
+// Trims any whitespace from either end of the input string.
+//
+// The StringPiece versions return a substring referencing the input buffer.
+// The ASCII versions look only for ASCII whitespace.
+//
+// The std::string versions return where whitespace was found.
 // NOTE: Safe to use the same variable for both input and output.
 BASE_EXPORT TrimPositions TrimWhitespace(const string16& input,
                                          TrimPositions positions,
                                          base::string16* output);
+BASE_EXPORT StringPiece16 TrimWhitespace(StringPiece16 input,
+                                         TrimPositions positions);
 BASE_EXPORT TrimPositions TrimWhitespaceASCII(const std::string& input,
                                               TrimPositions positions,
                                               std::string* output);
+BASE_EXPORT StringPiece TrimWhitespaceASCII(StringPiece input,
+                                            TrimPositions positions);
 
 // Deprecated. This function is only for backward compatibility and calls
 // TrimWhitespaceASCII().
diff --git a/net/base/data_url.cc b/net/base/data_url.cc
index e0502d3..4f26456 100644
--- a/net/base/data_url.cc
+++ b/net/base/data_url.cc
@@ -36,9 +36,9 @@ bool DataURL::Parse(const GURL& url, std::string* mime_type,
   if (comma == end)
     return false;
 
-  std::vector<std::string> meta_data;
-  std::string unparsed_meta_data(after_colon, comma);
-  base::SplitString(unparsed_meta_data, ';', &meta_data);
+  std::vector<std::string> meta_data =
+      base::SplitString(base::StringPiece(after_colon, comma), ";",
+                        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   std::vector<std::string>::iterator iter = meta_data.begin();
   if (iter != meta_data.end()) {
diff --git a/net/base/host_mapping_rules.cc b/net/base/host_mapping_rules.cc
index 179a0dc8..d3da243 100644
--- a/net/base/host_mapping_rules.cc
+++ b/net/base/host_mapping_rules.cc
@@ -66,10 +66,9 @@ bool HostMappingRules::RewriteHost(HostPortPair* host_port) const {
 }
 
 bool HostMappingRules::AddRuleFromString(const std::string& rule_string) {
-  std::string trimmed;
-  base::TrimWhitespaceASCII(rule_string, base::TRIM_ALL, &trimmed);
-  std::vector<std::string> parts;
-  base::SplitString(trimmed, ' ', &parts);
+  std::vector<std::string> parts =
+      base::SplitString(base::TrimWhitespaceASCII(rule_string, base::TRIM_ALL),
+                        " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   // Test for EXCLUSION rule.
   if (parts.size() == 2 && base::LowerCaseEqualsASCII(parts[0], "exclude")) {
diff --git a/net/base/host_port_pair.cc b/net/base/host_port_pair.cc
index 816bbac..cd56089 100644
--- a/net/base/host_port_pair.cc
+++ b/net/base/host_port_pair.cc
@@ -32,8 +32,8 @@ HostPortPair HostPortPair::FromIPEndPoint(const IPEndPoint& ipe) {
 }
 
 HostPortPair HostPortPair::FromString(const std::string& str) {
-  std::vector<std::string> key_port;
-  base::SplitString(str, ':', &key_port);
+  std::vector<base::StringPiece> key_port = base::SplitStringPiece(
+      str, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (key_port.size() != 2)
     return HostPortPair();
   int port;
@@ -42,7 +42,7 @@ HostPortPair HostPortPair::FromString(const std::string& str) {
   if (!IsPortValid(port))
     return HostPortPair();
   HostPortPair host_port_pair;
-  host_port_pair.set_host(key_port[0]);
+  host_port_pair.set_host(key_port[0].as_string());
   host_port_pair.set_port(static_cast<uint16_t>(port));
   return host_port_pair;
 }
diff --git a/net/base/ip_address_number.cc b/net/base/ip_address_number.cc
index 06fc3ac..61af067 100644
--- a/net/base/ip_address_number.cc
+++ b/net/base/ip_address_number.cc
@@ -156,13 +156,15 @@ bool ParseURLHostnameToNumber(const std::string& hostname,
   return family == url::CanonHostInfo::IPV4;
 }
 
-bool ParseIPLiteralToNumber(const std::string& ip_literal,
+bool ParseIPLiteralToNumber(const base::StringPiece& ip_literal,
                             IPAddressNumber* ip_number) {
   // |ip_literal| could be either a IPv4 or an IPv6 literal. If it contains
   // a colon however, it must be an IPv6 address.
-  if (ip_literal.find(':') != std::string::npos) {
+  if (ip_literal.find(':') != base::StringPiece::npos) {
     // GURL expects IPv6 hostnames to be surrounded with brackets.
-    std::string host_brackets = "[" + ip_literal + "]";
+    std::string host_brackets = "[";
+    ip_literal.AppendToString(&host_brackets);
+    host_brackets.push_back(']');
     url::Component host_comp(0, host_brackets.size());
 
     // Try parsing the hostname as an IPv6 literal.
@@ -222,8 +224,8 @@ bool ParseCIDRBlock(const std::string& cidr_literal,
   //   <IPv4-literal> "/" <number of bits>
   //   <IPv6-literal> "/" <number of bits>
 
-  std::vector<std::string> parts;
-  base::SplitString(cidr_literal, '/', &parts);
+  std::vector<base::StringPiece> parts = base::SplitStringPiece(
+      cidr_literal, "/", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (parts.size() != 2)
     return false;
 
diff --git a/net/base/ip_address_number.h b/net/base/ip_address_number.h
index f8adb05..b105875 100644
--- a/net/base/ip_address_number.h
+++ b/net/base/ip_address_number.h
@@ -9,6 +9,7 @@
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/strings/string_piece.h"
 #include "net/base/net_export.h"
 
 namespace net {
@@ -58,7 +59,7 @@ NET_EXPORT bool ParseURLHostnameToNumber(const std::string& hostname,
 
 // Parses an IP address literal (either IPv4 or IPv6) to its numeric value.
 // Returns true on success and fills |ip_number| with the numeric value.
-NET_EXPORT bool ParseIPLiteralToNumber(const std::string& ip_literal,
+NET_EXPORT bool ParseIPLiteralToNumber(const base::StringPiece& ip_literal,
                                        IPAddressNumber* ip_number);
 
 // Converts an IPv4 address to an IPv4-mapped IPv6 address.
diff --git a/net/base/ip_pattern.cc b/net/base/ip_pattern.cc
index 941dbf1..61c8c2e 100644
--- a/net/base/ip_pattern.cc
+++ b/net/base/ip_pattern.cc
@@ -92,44 +92,45 @@ bool IPPattern::ParsePattern(const std::string& ip_pattern) {
   if (ip_pattern.find(':') != std::string::npos) {
     is_ipv4_ = false;
   }
-  Strings components;
-  base::SplitString(ip_pattern, is_ipv4_ ? '.' : ':', &components);
+
+  std::vector<base::StringPiece> components =
+      base::SplitStringPiece(ip_pattern, is_ipv4_ ? "." : ":",
+                             base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (components.size() != (is_ipv4_ ? 4u : 8u)) {
     DVLOG(1) << "Invalid component count: " << ip_pattern;
     return false;
   }
-  for (Strings::iterator component_it = components.begin();
-       component_it != components.end(); ++component_it) {
-    if (component_it->empty()) {
+  for (base::StringPiece component : components) {
+    if (component.empty()) {
       DVLOG(1) << "Empty component: " << ip_pattern;
       return false;
     }
-    if (*component_it == "*") {
+    if (component == "*") {
       // Let standard code handle this below.
-      *component_it = is_ipv4_ ? "[0-255]" : "[0-FFFF]";
-    } else if ((*component_it)[0] != '[') {
+      component = is_ipv4_ ? "[0-255]" : "[0-FFFF]";
+    } else if (component[0] != '[') {
       // This value will just have a specific integer to match.
       uint32_t value;
-      if (!ValueTextToInt(*component_it, &value))
+      if (!ValueTextToInt(component, &value))
         return false;
       ip_mask_.push_back(true);
       component_values_.push_back(value);
       continue;
     }
-    if ((*component_it)[component_it->size() - 1] != ']') {
+    if (component[component.size() - 1] != ']') {
       DVLOG(1) << "Missing close bracket: " << ip_pattern;
       return false;
     }
     // Now we know the size() is at least 2.
-    if (component_it->size() == 2) {
+    if (component.size() == 2) {
       DVLOG(1) << "Empty bracket: " << ip_pattern;
       return false;
     }
     // We'll need a pattern to match this bracketed component.
     scoped_ptr<ComponentPattern> component_pattern(new ComponentPattern);
     // Trim leading and trailing bracket before calling for parsing.
-    if (!ParseComponentPattern(base::StringPiece(component_it->data() + 1,
-        component_it->size() - 2), component_pattern.get())) {
+    if (!ParseComponentPattern(component.substr(1, component.size() - 2),
+                               component_pattern.get())) {
       return false;
     }
     ip_mask_.push_back(false);
@@ -142,18 +143,16 @@ bool IPPattern::ParseComponentPattern(const base::StringPiece& text,
                                       ComponentPattern* pattern) const {
   // We're given a comma separated set of ranges, some of which may be simple
   // constants.
-  Strings ranges;
-  base::SplitString(text.as_string(), ',', &ranges);
-  for (Strings::iterator range_it = ranges.begin();
-        range_it != ranges.end(); ++range_it) {
-    base::StringTokenizer range_pair(*range_it, "-");
+  for (const std::string& range : base::SplitString(
+           text, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
+    base::StringTokenizer range_pair(range, "-");
     uint32_t min = 0;
     range_pair.GetNext();
-    if (!ValueTextToInt(range_pair.token(), &min))
+    if (!ValueTextToInt(range_pair.token_piece(), &min))
       return false;
     uint32_t max = min;  // Sometimes we have no distinct max.
     if (range_pair.GetNext()) {
-      if (!ValueTextToInt(range_pair.token(), &max))
+      if (!ValueTextToInt(range_pair.token_piece(), &max))
         return false;
     }
     if (range_pair.GetNext()) {
diff --git a/net/base/mime_util.cc b/net/base/mime_util.cc
index dee8892..0a17742 100644
--- a/net/base/mime_util.cc
+++ b/net/base/mime_util.cc
@@ -280,13 +280,15 @@ bool MimeUtil::MatchesMimeType(const std::string& mime_type_pattern,
   if (base_type.length() < base_pattern.length() - 1)
     return false;
 
-  const std::string left(base_pattern.substr(0, star));
-  const std::string right(base_pattern.substr(star + 1));
+  base::StringPiece base_pattern_piece(base_pattern);
+  base::StringPiece left(base_pattern_piece.substr(0, star));
+  base::StringPiece right(base_pattern_piece.substr(star + 1));
 
-  if (!base::StartsWithASCII(base_type, left, false))
+  if (!base::StartsWith(base_type, left, base::CompareCase::INSENSITIVE_ASCII))
     return false;
 
-  if (!right.empty() && !base::EndsWith(base_type, right, false))
+  if (!right.empty() &&
+      !base::EndsWith(base_type, right, base::CompareCase::INSENSITIVE_ASCII))
     return false;
 
   return MatchesMimeTypeParameters(mime_type_pattern, mime_type);
@@ -309,8 +311,8 @@ bool MimeUtil::ParseMimeTypeWithoutParameter(
     const std::string& type_string,
     std::string* top_level_type,
     std::string* subtype) const {
-  std::vector<std::string> components;
-  base::SplitString(type_string, '/', &components);
+  std::vector<std::string> components = base::SplitString(
+      type_string, "/", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (components.size() != 2 ||
       !HttpUtil::IsToken(components[0]) ||
       !HttpUtil::IsToken(components[1]))
@@ -331,7 +333,8 @@ bool MimeUtil::IsValidTopLevelMimeType(const std::string& type_string) const {
   }
 
   return type_string.size() > 2 &&
-         base::StartsWithASCII(type_string, "x-", false);
+         base::StartsWith(type_string, "x-",
+                          base::CompareCase::INSENSITIVE_ASCII);
 }
 
 //----------------------------------------------------------------------------
@@ -458,18 +461,16 @@ void GetExtensionsFromHardCodedMappings(
     const std::string& leading_mime_type,
     base::hash_set<base::FilePath::StringType>* extensions) {
   for (size_t i = 0; i < mappings_len; ++i) {
-    if (base::StartsWithASCII(mappings[i].mime_type, leading_mime_type,
-                              false)) {
-      std::vector<string> this_extensions;
-      base::SplitString(mappings[i].extensions, ',', &this_extensions);
-      for (size_t j = 0; j < this_extensions.size(); ++j) {
+    if (base::StartsWith(mappings[i].mime_type, leading_mime_type,
+                         base::CompareCase::INSENSITIVE_ASCII)) {
+      for (const base::StringPiece& this_extension : base::SplitStringPiece(
+               mappings[i].extensions, ",", base::TRIM_WHITESPACE,
+               base::SPLIT_WANT_ALL)) {
 #if defined(OS_WIN)
-        base::FilePath::StringType extension(
-            base::UTF8ToWide(this_extensions[j]));
+        extensions->insert(base::UTF8ToUTF16(this_extension));
 #else
-        base::FilePath::StringType extension(this_extensions[j]);
+        extensions->insert(this_extension.as_string());
 #endif
-        extensions->insert(extension);
       }
     }
   }
diff --git a/net/base/net_util_icu.cc b/net/base/net_util_icu.cc
index 0ece5ea..259baba 100644
--- a/net/base/net_util_icu.cc
+++ b/net/base/net_util_icu.cc
@@ -679,8 +679,8 @@ base::string16 FormatUrlWithAdjustments(
   // Reject "view-source:view-source:..." to avoid deep recursion.
   const char kViewSourceTwice[] = "view-source:view-source:";
   if (url.SchemeIs(kViewSource) &&
-      !base::StartsWithASCII(url.possibly_invalid_spec(), kViewSourceTwice,
-                             false)) {
+      !base::StartsWith(url.possibly_invalid_spec(), kViewSourceTwice,
+                        base::CompareCase::INSENSITIVE_ASCII)) {
     return FormatViewSourceUrl(url, languages, format_types,
                                unescape_rules, new_parsed, prefix_end,
                                adjustments);
@@ -704,9 +704,10 @@ base::string16 FormatUrlWithAdjustments(
   // all input fields), the meaning would be changed.  (In fact, often the
   // formatted URL is directly pre-filled into an input field.)  For this reason
   // we avoid stripping "http://" in this case.
-  bool omit_http = (format_types & kFormatUrlOmitHTTP) &&
-                   base::EqualsASCII(url_string, kHTTP) &&
-                   !base::StartsWithASCII(url.host(), kFTP, true);
+  bool omit_http =
+      (format_types & kFormatUrlOmitHTTP) &&
+      base::EqualsASCII(url_string, kHTTP) &&
+      !base::StartsWith(url.host(), kFTP, base::CompareCase::SENSITIVE);
   new_parsed->scheme = parsed.scheme;
 
   // Username & password.
diff --git a/net/cert/x509_certificate_unittest.cc b/net/cert/x509_certificate_unittest.cc
index c100bae..ec9342a 100644
--- a/net/cert/x509_certificate_unittest.cc
+++ b/net/cert/x509_certificate_unittest.cc
@@ -1109,14 +1109,15 @@ TEST_P(X509CertificateNameVerifyTest, VerifyHostname) {
     // Build up the certificate DNS names list.
     std::string dns_name_line(test_data.dns_names);
     std::replace(dns_name_line.begin(), dns_name_line.end(), '#', '\0');
-    base::SplitString(dns_name_line, ',', &dns_names);
+    dns_names = base::SplitString(dns_name_line, ",", base::TRIM_WHITESPACE,
+                                  base::SPLIT_WANT_ALL);
   }
 
   if (test_data.ip_addrs) {
     // Build up the certificate IP address list.
     std::string ip_addrs_line(test_data.ip_addrs);
-    std::vector<std::string> ip_addressses_ascii;
-    base::SplitString(ip_addrs_line, ',', &ip_addressses_ascii);
+    std::vector<std::string> ip_addressses_ascii = base::SplitString(
+        ip_addrs_line, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     for (size_t i = 0; i < ip_addressses_ascii.size(); ++i) {
       std::string& addr_ascii = ip_addressses_ascii[i];
       ASSERT_NE(0U, addr_ascii.length());
@@ -1129,8 +1130,8 @@ TEST_P(X509CertificateNameVerifyTest, VerifyHostname) {
                                             bytes.size()));
         ASSERT_EQ(16U, ip_addressses.back().size()) << i;
       } else {  // Decimal groups
-        std::vector<std::string> decimals_ascii;
-        base::SplitString(addr_ascii, '.', &decimals_ascii);
+        std::vector<std::string> decimals_ascii = base::SplitString(
+            addr_ascii, ".", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
         EXPECT_EQ(4U, decimals_ascii.size()) << i;
         std::string addr_bytes;
         for (size_t j = 0; j < decimals_ascii.size(); ++j) {
diff --git a/net/cookies/cookie_monster_unittest.cc b/net/cookies/cookie_monster_unittest.cc
index 5452f19..6f3c0b6 100644
--- a/net/cookies/cookie_monster_unittest.cc
+++ b/net/cookies/cookie_monster_unittest.cc
@@ -436,20 +436,18 @@ class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> {
     std::vector<int> id_list[3];  // Indexed by CookiePriority.
 
     // Parse |coded_priority_str| and add cookies.
-    std::vector<std::string> priority_tok_list;
-    base::SplitString(coded_priority_str, ' ', &priority_tok_list);
-    for (std::vector<std::string>::iterator it = priority_tok_list.begin();
-         it != priority_tok_list.end(); ++it) {
-      size_t len = it->length();
-      DCHECK_NE(len, 0U);
+    for (const std::string& token :
+         base::SplitString(coded_priority_str, " ", base::TRIM_WHITESPACE,
+                           base::SPLIT_WANT_ALL)) {
+      DCHECK(!token.empty());
       // Take last character as priority.
-      CookiePriority priority = CharToPriority((*it)[len - 1]);
+      CookiePriority priority = CharToPriority(token[token.length() - 1]);
       std::string priority_str = CookiePriorityToString(priority);
       // The rest of the string (possibly empty) specifies repetition.
       int rep = 1;
-      if (!it->empty()) {
+      if (!token.empty()) {
         bool result = base::StringToInt(
-            base::StringPiece(it->begin(), it->end() - 1), &rep);
+            base::StringPiece(token.begin(), token.end() - 1), &rep);
         DCHECK(result);
       }
       for (; rep > 0; --rep, ++next_cookie_id) {
@@ -466,14 +464,12 @@ class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> {
 
     // Parse the list of cookies
     std::string cookie_str = this->GetCookies(cm, url_google_);
-    std::vector<std::string> cookie_tok_list;
-    base::SplitString(cookie_str, ';', &cookie_tok_list);
-    for (std::vector<std::string>::iterator it = cookie_tok_list.begin();
-         it != cookie_tok_list.end(); ++it) {
+    for (const std::string& token : base::SplitString(
+             cookie_str, ";", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
       // Assuming *it is "a#=b", so extract and parse "#" portion.
       int id = -1;
       bool result = base::StringToInt(
-          base::StringPiece(it->begin() + 1, it->end() - 2), &id);
+          base::StringPiece(token.begin() + 1, token.end() - 2), &id);
       DCHECK(result);
       DCHECK_GE(id, 0);
       DCHECK_LT(id, num_cookies);
diff --git a/net/dns/dns_config_service_unittest.cc b/net/dns/dns_config_service_unittest.cc
index 0ff0b91..ed6d86d 100644
--- a/net/dns/dns_config_service_unittest.cc
+++ b/net/dns/dns_config_service_unittest.cc
@@ -37,18 +37,15 @@ class NameServerClassifierTest : public testing::Test {
  protected:
   NameServerClassifier::NameServersType Classify(
       const std::string& servers_string) {
-    std::vector<std::string> server_strings;
-    base::SplitString(servers_string, ' ', &server_strings);
-
     std::vector<IPEndPoint> servers;
-    for (std::vector<std::string>::const_iterator it = server_strings.begin();
-         it != server_strings.end();
-         ++it) {
-      if (it->empty())
+    for (const base::StringPiece& server_str :
+         base::SplitStringPiece(servers_string, " ", base::TRIM_WHITESPACE,
+                                base::SPLIT_WANT_ALL)) {
+      if (server_str.empty())
         continue;
 
       IPAddressNumber address;
-      bool parsed = ParseIPLiteralToNumber(*it, &address);
+      bool parsed = ParseIPLiteralToNumber(server_str, &address);
       EXPECT_TRUE(parsed);
       servers.push_back(IPEndPoint(address, dns_protocol::kDefaultPort));
     }
diff --git a/net/dns/dns_config_service_win.cc b/net/dns/dns_config_service_win.cc
index bef4b47..23206d4 100644
--- a/net/dns/dns_config_service_win.cc
+++ b/net/dns/dns_config_service_win.cc
@@ -134,14 +134,14 @@ scoped_ptr<IP_ADAPTER_ADDRESSES, base::FreeDeleter> ReadIpHelper(ULONG flags) {
 // Converts a base::string16 domain name to ASCII, possibly using punycode.
 // Returns true if the conversion succeeds and output is not empty. In case of
 // failure, |domain| might become dirty.
-bool ParseDomainASCII(const base::string16& widestr, std::string* domain) {
+bool ParseDomainASCII(base::StringPiece16 widestr, std::string* domain) {
   DCHECK(domain);
   if (widestr.empty())
     return false;
 
   // Check if already ASCII.
   if (base::IsStringASCII(widestr)) {
-    *domain = base::UTF16ToASCII(widestr);
+    domain->assign(widestr.begin(), widestr.end());
     return true;
   }
 
@@ -476,12 +476,10 @@ bool ParseSearchList(const base::string16& value,
   // Although nslookup and network connection property tab ignore such
   // fragments ("a,b,,c" becomes ["a", "b", "c"]), our reference is getaddrinfo
   // (which sees ["a", "b"]). WMI queries also return a matching search list.
-  std::vector<base::string16> woutput;
-  base::SplitString(value, ',', &woutput);
-  for (size_t i = 0; i < woutput.size(); ++i) {
+  for (const base::StringPiece16& t : base::SplitStringPiece(
+           value, L",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
     // Convert non-ASCII to punycode, although getaddrinfo does not properly
     // handle such suffixes.
-    const base::string16& t = woutput[i];
     std::string parsed;
     if (!ParseDomainASCII(t, &parsed))
       break;
diff --git a/net/dns/host_resolver.cc b/net/dns/host_resolver.cc
index 06128b5..deacb2d 100644
--- a/net/dns/host_resolver.cc
+++ b/net/dns/host_resolver.cc
@@ -47,9 +47,8 @@ PrioritizedDispatcher::Limits HostResolver::Options::GetDispatcherLimits()
   // The format of the group name is a list of non-negative integers separated
   // by ':'. Each of the elements in the list corresponds to an element in
   // |reserved_slots|, except the last one which is the |total_jobs|.
-
-  std::vector<std::string> group_parts;
-  base::SplitString(group, ':', &group_parts);
+  std::vector<base::StringPiece> group_parts = base::SplitStringPiece(
+      group, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (group_parts.size() != NUM_PRIORITIES + 1) {
     NOTREACHED();
     return limits;
diff --git a/net/dns/host_resolver_impl.cc b/net/dns/host_resolver_impl.cc
index 0e2de32..d3f8365 100644
--- a/net/dns/host_resolver_impl.cc
+++ b/net/dns/host_resolver_impl.cc
@@ -278,8 +278,10 @@ bool ConfigureAsyncDnsNoFallbackFieldTrial() {
   // groups SystemDnsA and SystemDnsB: return false,
   // otherwise (trial absent): return default.
   std::string group_name = base::FieldTrialList::FindFullName("AsyncDns");
-  if (!group_name.empty())
-    return base::StartsWithASCII(group_name, "AsyncDnsNoFallback", false);
+  if (!group_name.empty()) {
+    return base::StartsWith(group_name, "AsyncDnsNoFallback",
+                            base::CompareCase::INSENSITIVE_ASCII);
+  }
   return kDefault;
 }
 
diff --git a/net/dns/mock_host_resolver.cc b/net/dns/mock_host_resolver.cc
index 288276b..a053b9d 100644
--- a/net/dns/mock_host_resolver.cc
+++ b/net/dns/mock_host_resolver.cc
@@ -41,13 +41,12 @@ int ParseAddressList(const std::string& host_list,
                      const std::string& canonical_name,
                      AddressList* addrlist) {
   *addrlist = AddressList();
-  std::vector<std::string> addresses;
-  base::SplitString(host_list, ',', &addresses);
   addrlist->set_canonical_name(canonical_name);
-  for (size_t index = 0; index < addresses.size(); ++index) {
+  for (const base::StringPiece& address : base::SplitStringPiece(
+           host_list, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
     IPAddressNumber ip_number;
-    if (!ParseIPLiteralToNumber(addresses[index], &ip_number)) {
-      LOG(WARNING) << "Not a supported IP literal: " << addresses[index];
+    if (!ParseIPLiteralToNumber(address, &ip_number)) {
+      LOG(WARNING) << "Not a supported IP literal: " << address.as_string();
       return ERR_UNEXPECTED;
     }
     addrlist->push_back(IPEndPoint(ip_number, 0));
diff --git a/net/filter/filter.cc b/net/filter/filter.cc
index 0e6544b..708ad81 100644
--- a/net/filter/filter.cc
+++ b/net/filter/filter.cc
@@ -267,7 +267,8 @@ void Filter::FixupEncodingTypes(
   // supported server side on paths that only send HTML content, this mode has
   // never surfaced in the wild (and is unlikely to).
   // We will gather a lot of stats as we perform the fixups
-  if (base::StartsWithASCII(mime_type, kTextHtml, false)) {
+  if (base::StartsWith(mime_type, kTextHtml,
+                       base::CompareCase::INSENSITIVE_ASCII)) {
     // Suspicious case: Advertised dictionary, but server didn't use sdch, and
     // we're HTML tagged.
     if (encoding_types->empty()) {
diff --git a/net/ftp/ftp_directory_listing_parser_ls.cc b/net/ftp/ftp_directory_listing_parser_ls.cc
index 7fb92073..caca122 100644
--- a/net/ftp/ftp_directory_listing_parser_ls.cc
+++ b/net/ftp/ftp_directory_listing_parser_ls.cc
@@ -24,8 +24,9 @@ bool TwoColumnDateListingToTime(const base::string16& date,
   base::Time::Exploded time_exploded = { 0 };
 
   // Date should be in format YYYY-MM-DD.
-  std::vector<base::string16> date_parts;
-  base::SplitString(date, '-', &date_parts);
+  std::vector<base::string16> date_parts =
+      base::SplitString(date, base::ASCIIToUTF16("-"), base::TRIM_WHITESPACE,
+                        base::SPLIT_WANT_ALL);
   if (date_parts.size() != 3)
     return false;
   if (!base::StringToInt(date_parts[0], &time_exploded.year))
@@ -39,8 +40,9 @@ bool TwoColumnDateListingToTime(const base::string16& date,
   if (time.length() != 5)
     return false;
 
-  std::vector<base::string16> time_parts;
-  base::SplitString(time, ':', &time_parts);
+  std::vector<base::string16> time_parts =
+      base::SplitString(time, base::ASCIIToUTF16(":"), base::TRIM_WHITESPACE,
+                        base::SPLIT_WANT_ALL);
   if (time_parts.size() != 2)
     return false;
   if (!base::StringToInt(time_parts[0], &time_exploded.hour))
@@ -128,8 +130,9 @@ bool ParseFtpDirectoryListingLs(
     if (lines[i].empty())
       continue;
 
-    std::vector<base::string16> columns;
-    base::SplitString(base::CollapseWhitespace(lines[i], false), ' ', &columns);
+    std::vector<base::string16> columns = base::SplitString(
+        base::CollapseWhitespace(lines[i], false), base::ASCIIToUTF16(" "),
+        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
     // Some FTP servers put a "total n" line at the beginning of the listing
     // (n is an integer). Allow such a line, but only once, and only if it's
diff --git a/net/ftp/ftp_directory_listing_parser_netware.cc b/net/ftp/ftp_directory_listing_parser_netware.cc
index bc738ae..fa04bf2 100644
--- a/net/ftp/ftp_directory_listing_parser_netware.cc
+++ b/net/ftp/ftp_directory_listing_parser_netware.cc
@@ -49,8 +49,9 @@ bool ParseFtpDirectoryListingNetware(
     if (lines[i].empty())
       continue;
 
-    std::vector<base::string16> columns;
-    base::SplitString(base::CollapseWhitespace(lines[i], false), ' ', &columns);
+    std::vector<base::string16> columns = base::SplitString(
+        base::CollapseWhitespace(lines[i], false), base::ASCIIToUTF16(" "),
+        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
     if (columns.size() < 8)
       return false;
diff --git a/net/ftp/ftp_directory_listing_parser_os2.cc b/net/ftp/ftp_directory_listing_parser_os2.cc
index a393d32..7d0ee62 100644
--- a/net/ftp/ftp_directory_listing_parser_os2.cc
+++ b/net/ftp/ftp_directory_listing_parser_os2.cc
@@ -9,6 +9,7 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "net/ftp/ftp_directory_listing_parser.h"
 #include "net/ftp/ftp_util.h"
@@ -22,8 +23,9 @@ bool ParseFtpDirectoryListingOS2(
     if (lines[i].empty())
       continue;
 
-    std::vector<base::string16> columns;
-    base::SplitString(base::CollapseWhitespace(lines[i], false), ' ', &columns);
+    std::vector<base::string16> columns = base::SplitString(
+        base::CollapseWhitespace(lines[i], false), base::ASCIIToUTF16(" "),
+        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
     // Every line of the listing consists of the following:
     //
diff --git a/net/ftp/ftp_directory_listing_parser_vms.cc b/net/ftp/ftp_directory_listing_parser_vms.cc
index d05446c..ac7a464 100644
--- a/net/ftp/ftp_directory_listing_parser_vms.cc
+++ b/net/ftp/ftp_directory_listing_parser_vms.cc
@@ -25,8 +25,9 @@ bool ParseVmsFilename(const base::string16& raw_filename,
                       FtpDirectoryListingEntry::Type* type) {
   // On VMS, the files and directories are versioned. The version number is
   // separated from the file name by a semicolon. Example: ANNOUNCE.TXT;2.
-  std::vector<base::string16> listing_parts;
-  base::SplitString(raw_filename, ';', &listing_parts);
+  std::vector<base::string16> listing_parts =
+      base::SplitString(raw_filename, base::ASCIIToUTF16(";"),
+                        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (listing_parts.size() != 2)
     return false;
   int version_number;
@@ -39,8 +40,9 @@ bool ParseVmsFilename(const base::string16& raw_filename,
   // for directories; it's awkward for non-VMS users. Also, VMS is
   // case-insensitive, but generally uses uppercase characters. This may look
   // awkward, so we convert them to lower case.
-  std::vector<base::string16> filename_parts;
-  base::SplitString(listing_parts[0], '.', &filename_parts);
+  std::vector<base::string16> filename_parts =
+      base::SplitString(listing_parts[0], base::ASCIIToUTF16("."),
+                        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (filename_parts.size() != 2)
     return false;
   if (base::EqualsASCII(filename_parts[1], "DIR")) {
@@ -72,8 +74,9 @@ bool ParseVmsFilesize(const base::string16& input, int64* size) {
     return true;
   }
 
-  std::vector<base::string16> parts;
-  base::SplitString(input, '/', &parts);
+  std::vector<base::StringPiece16> parts =
+      base::SplitStringPiece(input, base::ASCIIToUTF16("/"),
+                             base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (parts.size() != 2)
     return false;
 
@@ -115,8 +118,9 @@ bool LooksLikeVmsFileProtectionListing(const base::string16& input) {
 
   // We expect four parts of the file protection listing: for System, Owner,
   // Group, and World.
-  std::vector<base::string16> parts;
-  base::SplitString(input.substr(1, input.length() - 2), ',', &parts);
+  std::vector<base::string16> parts = base::SplitString(
+      base::StringPiece16(input).substr(1, input.length() - 2),
+      base::ASCIIToUTF16(","), base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (parts.size() != 4)
     return false;
 
@@ -156,13 +160,14 @@ bool VmsDateListingToTime(const std::vector<base::string16>& columns,
   base::Time::Exploded time_exploded = { 0 };
 
   // Date should be in format DD-MMM-YYYY.
-  std::vector<base::string16> date_parts;
-  base::SplitString(columns[2], '-', &date_parts);
+  std::vector<base::StringPiece16> date_parts =
+      base::SplitStringPiece(columns[2], base::ASCIIToUTF16("-"),
+                             base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (date_parts.size() != 3)
     return false;
   if (!base::StringToInt(date_parts[0], &time_exploded.day_of_month))
     return false;
-  if (!FtpUtil::AbbreviatedMonthToNumber(date_parts[1],
+  if (!FtpUtil::AbbreviatedMonthToNumber(date_parts[1].as_string(),
                                          &time_exploded.month))
     return false;
   if (!base::StringToInt(date_parts[2], &time_exploded.year))
@@ -177,8 +182,9 @@ bool VmsDateListingToTime(const std::vector<base::string16>& columns,
     time_column = time_column.substr(0, 5);
   if (time_column.length() != 5)
     return false;
-  std::vector<base::string16> time_parts;
-  base::SplitString(time_column, ':', &time_parts);
+  std::vector<base::StringPiece16> time_parts =
+      base::SplitStringPiece(time_column, base::ASCIIToUTF16(":"),
+                             base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (time_parts.size() != 2)
     return false;
   if (!base::StringToInt(time_parts[0], &time_exploded.hour))
diff --git a/net/ftp/ftp_directory_listing_parser_windows.cc b/net/ftp/ftp_directory_listing_parser_windows.cc
index f394b17..25ceaf7 100644
--- a/net/ftp/ftp_directory_listing_parser_windows.cc
+++ b/net/ftp/ftp_directory_listing_parser_windows.cc
@@ -9,6 +9,7 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "net/ftp/ftp_directory_listing_parser.h"
 #include "net/ftp/ftp_util.h"
@@ -22,8 +23,9 @@ bool ParseFtpDirectoryListingWindows(
     if (lines[i].empty())
       continue;
 
-    std::vector<base::string16> columns;
-    base::SplitString(base::CollapseWhitespace(lines[i], false), ' ', &columns);
+    std::vector<base::string16> columns = base::SplitString(
+        base::CollapseWhitespace(lines[i], false), base::ASCIIToUTF16(" "),
+        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
     // Every line of the listing consists of the following:
     //
diff --git a/net/ftp/ftp_network_transaction.cc b/net/ftp/ftp_network_transaction.cc
index f34f7a8..0964486 100644
--- a/net/ftp/ftp_network_transaction.cc
+++ b/net/ftp/ftp_network_transaction.cc
@@ -182,8 +182,8 @@ bool ExtractPortFromPASVResponse(const FtpCtrlResponse& response, int* port) {
 
   // Split the line into comma-separated pieces and extract
   // the last two.
-  std::vector<std::string> pieces;
-  base::SplitString(line, ',', &pieces);
+  std::vector<base::StringPiece> pieces = base::SplitStringPiece(
+      line, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (pieces.size() != 6)
     return false;
 
diff --git a/net/ftp/ftp_util.cc b/net/ftp/ftp_util.cc
index a653dee..91854c4 100644
--- a/net/ftp/ftp_util.cc
+++ b/net/ftp/ftp_util.cc
@@ -296,8 +296,9 @@ bool FtpUtil::WindowsDateListingToTime(const base::string16& date,
   base::Time::Exploded time_exploded = { 0 };
 
   // Date should be in format MM-DD-YY[YY].
-  std::vector<base::string16> date_parts;
-  base::SplitString(date, '-', &date_parts);
+  std::vector<base::StringPiece16> date_parts =
+      base::SplitStringPiece(date, base::ASCIIToUTF16("-"),
+                             base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (date_parts.size() != 3)
     return false;
   if (!base::StringToInt(date_parts[0], &time_exploded.month))
@@ -319,8 +320,9 @@ bool FtpUtil::WindowsDateListingToTime(const base::string16& date,
   if (time.length() < 5)
     return false;
 
-  std::vector<base::string16> time_parts;
-  base::SplitString(time.substr(0, 5), ':', &time_parts);
+  std::vector<base::StringPiece16> time_parts = base::SplitStringPiece(
+      base::StringPiece16(time).substr(0, 5), base::ASCIIToUTF16(":"),
+      base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (time_parts.size() != 2)
     return false;
   if (!base::StringToInt(time_parts[0], &time_exploded.hour))
diff --git a/net/http/http_auth_cache.cc b/net/http/http_auth_cache.cc
index 56ce99e..d76d3ed 100644
--- a/net/http/http_auth_cache.cc
+++ b/net/http/http_auth_cache.cc
@@ -37,7 +37,8 @@ void CheckPathIsValid(const std::string& path) {
 bool IsEnclosingPath(const std::string& container, const std::string& path) {
   DCHECK(container.empty() || *(container.end() - 1) == '/');
   return ((container.empty() && path.empty()) ||
-          (!container.empty() && base::StartsWithASCII(path, container, true)));
+          (!container.empty() &&
+           base::StartsWith(path, container, base::CompareCase::SENSITIVE)));
 }
 
 // Debug helper to check that |origin| arguments are properly formed.
diff --git a/net/http/http_response_headers.cc b/net/http/http_response_headers.cc
index cd554e9..7c0c5ad 100644
--- a/net/http/http_response_headers.cc
+++ b/net/http/http_response_headers.cc
@@ -102,8 +102,9 @@ bool ShouldUpdateHeader(const std::string::const_iterator& name_begin,
       return false;
   }
   for (size_t i = 0; i < arraysize(kNonUpdatedHeaderPrefixes); ++i) {
-    if (base::StartsWithASCII(std::string(name_begin, name_end),
-                              kNonUpdatedHeaderPrefixes[i], false))
+    if (base::StartsWith(base::StringPiece(name_begin, name_end),
+                         kNonUpdatedHeaderPrefixes[i],
+                         base::CompareCase::INSENSITIVE_ASCII))
       return false;
   }
   return true;
diff --git a/net/http/http_stream_factory.cc b/net/http/http_stream_factory.cc
index e3d35b7..b2b0274 100644
--- a/net/http/http_stream_factory.cc
+++ b/net/http/http_stream_factory.cc
@@ -38,9 +38,10 @@ void HttpStreamFactory::ProcessAlternateProtocol(
   double probability = 1;
   bool is_valid = true;
   for (size_t i = 0; i < alternate_protocol_values.size(); ++i) {
-    const std::string& alternate_protocol_str = alternate_protocol_values[i];
-    if (base::StartsWithASCII(alternate_protocol_str, "p=", true)) {
-      if (!base::StringToDouble(alternate_protocol_str.substr(2),
+    base::StringPiece alternate_protocol_str = alternate_protocol_values[i];
+    if (base::StartsWith(alternate_protocol_str, "p=",
+                         base::CompareCase::SENSITIVE)) {
+      if (!base::StringToDouble(alternate_protocol_str.substr(2).as_string(),
                                 &probability) ||
           probability < 0 || probability > 1) {
         DVLOG(1) << kAlternateProtocolHeader
@@ -52,8 +53,9 @@ void HttpStreamFactory::ProcessAlternateProtocol(
       continue;
     }
 
-    std::vector<std::string> port_protocol_vector;
-    base::SplitString(alternate_protocol_str, ':', &port_protocol_vector);
+    std::vector<base::StringPiece> port_protocol_vector =
+        base::SplitStringPiece(alternate_protocol_str, ":",
+                               base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     if (port_protocol_vector.size() != 2) {
       DVLOG(1) << kAlternateProtocolHeader
                << " header has too many tokens: "
@@ -71,7 +73,7 @@ void HttpStreamFactory::ProcessAlternateProtocol(
       break;
     }
 
-    protocol = AlternateProtocolFromString(port_protocol_vector[1]);
+    protocol = AlternateProtocolFromString(port_protocol_vector[1].as_string());
 
     if (IsAlternateProtocolValid(protocol) &&
         !session.IsProtocolEnabled(protocol)) {
diff --git a/net/http/http_util.cc b/net/http/http_util.cc
index b3819c21..53693f4 100644
--- a/net/http/http_util.cc
+++ b/net/http/http_util.cc
@@ -353,8 +353,8 @@ const char* const kForbiddenHeaderFields[] = {
 // static
 bool HttpUtil::IsSafeHeader(const std::string& name) {
   std::string lower_name(base::StringToLowerASCII(name));
-  if (base::StartsWithASCII(lower_name, "proxy-", true) ||
-      base::StartsWithASCII(lower_name, "sec-", true))
+  if (base::StartsWith(lower_name, "proxy-", base::CompareCase::SENSITIVE) ||
+      base::StartsWith(lower_name, "sec-", base::CompareCase::SENSITIVE))
     return false;
   for (size_t i = 0; i < arraysize(kForbiddenHeaderFields); ++i) {
     if (lower_name == kForbiddenHeaderFields[i])
diff --git a/net/proxy/proxy_bypass_rules.cc b/net/proxy/proxy_bypass_rules.cc
index 9dc40315..cec4fb5 100644
--- a/net/proxy/proxy_bypass_rules.cc
+++ b/net/proxy/proxy_bypass_rules.cc
@@ -328,12 +328,13 @@ bool ProxyBypassRules::AddRuleFromStringInternal(
 
   // Special-case hostnames that begin with a period.
   // For example, we remap ".google.com" --> "*.google.com".
-  if (base::StartsWithASCII(raw, ".", false))
+  if (base::StartsWith(raw, ".", base::CompareCase::SENSITIVE))
     raw = "*" + raw;
 
   // If suffix matching was asked for, make sure the pattern starts with a
   // wildcard.
-  if (use_hostname_suffix_matching && !base::StartsWithASCII(raw, "*", false))
+  if (use_hostname_suffix_matching &&
+      !base::StartsWith(raw, "*", base::CompareCase::SENSITIVE))
     raw = "*" + raw;
 
   return AddRuleForHostname(scheme, raw, port);
diff --git a/net/proxy/proxy_config_service_linux.cc b/net/proxy/proxy_config_service_linux.cc
index 58ae1df..de4d472 100644
--- a/net/proxy/proxy_config_service_linux.cc
+++ b/net/proxy/proxy_config_service_linux.cc
@@ -55,7 +55,8 @@ namespace {
 std::string FixupProxyHostScheme(ProxyServer::Scheme scheme,
                                  std::string host) {
   if (scheme == ProxyServer::SCHEME_SOCKS5 &&
-      base::StartsWithASCII(host, "socks4://", false)) {
+      base::StartsWith(host, "socks4://",
+                       base::CompareCase::INSENSITIVE_ASCII)) {
     // We default to socks 5, but if the user specifically set it to
     // socks4://, then use that.
     scheme = ProxyServer::SCHEME_SOCKS4;
diff --git a/net/quic/quic_utils.cc b/net/quic/quic_utils.cc
index 3d59b07..7895fee 100644
--- a/net/quic/quic_utils.cc
+++ b/net/quic/quic_utils.cc
@@ -292,11 +292,11 @@ string QuicUtils::TagToString(QuicTag tag) {
 QuicTagVector QuicUtils::ParseQuicConnectionOptions(
     const std::string& connection_options) {
   QuicTagVector options;
-  std::vector<std::string> tokens;
-  base::SplitString(connection_options, ',', &tokens);
   // Tokens are expected to be no more than 4 characters long, but we
   // handle overflow gracefully.
-  for (const std::string& token : tokens) {
+  for (const base::StringPiece& token :
+       base::SplitStringPiece(connection_options, ",", base::TRIM_WHITESPACE,
+                              base::SPLIT_WANT_ALL)) {
     uint32 option = 0;
     for (char token_char : base::Reversed(token)) {
       option <<= 8;
diff --git a/net/server/http_server_unittest.cc b/net/server/http_server_unittest.cc
index c76ae63..8830e3f 100644
--- a/net/server/http_server_unittest.cc
+++ b/net/server/http_server_unittest.cc
@@ -270,8 +270,8 @@ TEST_F(HttpServerTest, Request) {
   ASSERT_EQ("/test", GetRequest(0).path);
   ASSERT_EQ("", GetRequest(0).data);
   ASSERT_EQ(0u, GetRequest(0).headers.size());
-  ASSERT_TRUE(
-      base::StartsWithASCII(GetRequest(0).peer.ToString(), "127.0.0.1", true));
+  ASSERT_TRUE(base::StartsWith(GetRequest(0).peer.ToString(), "127.0.0.1",
+                               base::CompareCase::SENSITIVE));
 }
 
 TEST_F(HttpServerTest, RequestWithHeaders) {
@@ -442,8 +442,10 @@ TEST_F(HttpServerTest, Send200) {
 
   std::string response;
   ASSERT_TRUE(client.ReadResponse(&response));
-  ASSERT_TRUE(base::StartsWithASCII(response, "HTTP/1.1 200 OK", true));
-  ASSERT_TRUE(base::EndsWith(response, "Response!", true));
+  ASSERT_TRUE(base::StartsWith(response, "HTTP/1.1 200 OK",
+                               base::CompareCase::SENSITIVE));
+  ASSERT_TRUE(
+      base::EndsWith(response, "Response!", base::CompareCase::SENSITIVE));
 }
 
 TEST_F(HttpServerTest, SendRaw) {
@@ -591,8 +593,10 @@ TEST_F(HttpServerTest, MultipleRequestsOnSameConnection) {
   server_->Send200(client_connection_id, "Content for /test", "text/plain");
   std::string response1;
   ASSERT_TRUE(client.ReadResponse(&response1));
-  ASSERT_TRUE(base::StartsWithASCII(response1, "HTTP/1.1 200 OK", true));
-  ASSERT_TRUE(base::EndsWith(response1, "Content for /test", true));
+  ASSERT_TRUE(base::StartsWith(response1, "HTTP/1.1 200 OK",
+                               base::CompareCase::SENSITIVE));
+  ASSERT_TRUE(base::EndsWith(response1, "Content for /test",
+                             base::CompareCase::SENSITIVE));
 
   client.Send("GET /test2 HTTP/1.1\r\n\r\n");
   ASSERT_TRUE(RunUntilRequestsReceived(2));
@@ -602,7 +606,8 @@ TEST_F(HttpServerTest, MultipleRequestsOnSameConnection) {
   server_->Send404(client_connection_id);
   std::string response2;
   ASSERT_TRUE(client.ReadResponse(&response2));
-  ASSERT_TRUE(base::StartsWithASCII(response2, "HTTP/1.1 404 Not Found", true));
+  ASSERT_TRUE(base::StartsWith(response2, "HTTP/1.1 404 Not Found",
+                               base::CompareCase::SENSITIVE));
 
   client.Send("GET /test3 HTTP/1.1\r\n\r\n");
   ASSERT_TRUE(RunUntilRequestsReceived(3));
@@ -612,8 +617,10 @@ TEST_F(HttpServerTest, MultipleRequestsOnSameConnection) {
   server_->Send200(client_connection_id, "Content for /test3", "text/plain");
   std::string response3;
   ASSERT_TRUE(client.ReadResponse(&response3));
-  ASSERT_TRUE(base::StartsWithASCII(response3, "HTTP/1.1 200 OK", true));
-  ASSERT_TRUE(base::EndsWith(response3, "Content for /test3", true));
+  ASSERT_TRUE(base::StartsWith(response3, "HTTP/1.1 200 OK",
+                               base::CompareCase::SENSITIVE));
+  ASSERT_TRUE(base::EndsWith(response3, "Content for /test3",
+                             base::CompareCase::SENSITIVE));
 }
 
 class CloseOnConnectHttpServerTest : public HttpServerTest {
diff --git a/net/spdy/spdy_test_util_common.cc b/net/spdy/spdy_test_util_common.cc
index 846f965..2a00140 100644
--- a/net/spdy/spdy_test_util_common.cc
+++ b/net/spdy/spdy_test_util_common.cc
@@ -869,11 +869,10 @@ std::string SpdyTestUtil::ConstructSpdyReplyString(
     // above).
     if (spdy_version() >= SPDY3 && key[0] == ':')
       key = key.substr(1);
-    std::vector<std::string> values;
-    base::SplitString(it->second, '\0', &values);
-    for (std::vector<std::string>::const_iterator it2 = values.begin();
-         it2 != values.end(); ++it2) {
-      reply_string += key + ": " + *it2 + "\n";
+    for (const std::string& value :
+         base::SplitString(it->second, base::StringPiece("\0", 1),
+                           base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
+      reply_string += key + ": " + value + "\n";
     }
   }
   return reply_string;
diff --git a/net/ssl/ssl_cipher_suite_names.cc b/net/ssl/ssl_cipher_suite_names.cc
index 6a2dff1..271ccdf 100644
--- a/net/ssl/ssl_cipher_suite_names.cc
+++ b/net/ssl/ssl_cipher_suite_names.cc
@@ -349,8 +349,8 @@ bool ParseSSLCipherString(const std::string& cipher_string,
                           uint16* cipher_suite) {
   int value = 0;
   if (cipher_string.size() == 6 &&
-      base::StartsWithASCII(cipher_string, "0x",
-                            false /* case insensitive */) &&
+      base::StartsWith(cipher_string, "0x",
+                       base::CompareCase::INSENSITIVE_ASCII) &&
       base::HexStringToInt(cipher_string, &value)) {
     *cipher_suite = static_cast<uint16>(value);
     return true;
diff --git a/net/test/embedded_test_server/embedded_test_server.cc b/net/test/embedded_test_server/embedded_test_server.cc
index e90ff2c..49bd6ba 100644
--- a/net/test/embedded_test_server/embedded_test_server.cc
+++ b/net/test/embedded_test_server/embedded_test_server.cc
@@ -263,7 +263,7 @@ void EmbeddedTestServer::HandleRequest(HttpConnection* connection,
 
 GURL EmbeddedTestServer::GetURL(const std::string& relative_url) const {
   DCHECK(Started()) << "You must start the server first.";
-  DCHECK(base::StartsWithASCII(relative_url, "/", true /* case_sensitive */))
+  DCHECK(base::StartsWith(relative_url, "/", base::CompareCase::SENSITIVE))
       << relative_url;
   return base_url_.Resolve(relative_url);
 }
diff --git a/net/test/embedded_test_server/http_request.cc b/net/test/embedded_test_server/http_request.cc
index 51d6f06..26cb49e 100644
--- a/net/test/embedded_test_server/http_request.cc
+++ b/net/test/embedded_test_server/http_request.cc
@@ -88,8 +88,8 @@ HttpRequestParser::ParseResult HttpRequestParser::ParseHeaders() {
   {
     const std::string header_line = ShiftLine();
     http_request_->all_headers += header_line + "\r\n";
-    std::vector<std::string> header_line_tokens;
-    base::SplitString(header_line, ' ', &header_line_tokens);
+    std::vector<std::string> header_line_tokens = base::SplitString(
+        header_line, " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     DCHECK_EQ(3u, header_line_tokens.size());
     // Method.
     http_request_->method_string = header_line_tokens[0];
diff --git a/net/test/spawned_test_server/remote_test_server.cc b/net/test/spawned_test_server/remote_test_server.cc
index bf2c025..0e1303e 100644
--- a/net/test/spawned_test_server/remote_test_server.cc
+++ b/net/test/spawned_test_server/remote_test_server.cc
@@ -176,8 +176,8 @@ bool RemoteTestServer::Init(const base::FilePath& document_root) {
     return false;
   }
 
-  std::vector<std::string> ports;
-  base::SplitString(port_info, ':', &ports);
+  std::vector<std::string> ports = base::SplitString(
+      port_info, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (ports.size() != 2u)
     return false;
 
diff --git a/net/tools/balsa/balsa_frame.cc b/net/tools/balsa/balsa_frame.cc
index 1105c80..cbd11ba 100644
--- a/net/tools/balsa/balsa_frame.cc
+++ b/net/tools/balsa/balsa_frame.cc
@@ -22,6 +22,7 @@
 
 #include "base/logging.h"
 #include "base/strings/string_piece.h"
+#include "base/strings/string_util.h"
 #include "net/tools/balsa/balsa_enums.h"
 #include "net/tools/balsa/balsa_headers.h"
 #include "net/tools/balsa/balsa_visitor_interface.h"
@@ -724,8 +725,8 @@ bool SplitStringPiece(base::StringPiece original, char delim,
         *after = base::StringPiece(p + 1, end - (p + 1));
       else
         *after = base::StringPiece("");
-      StringPieceUtils::RemoveWhitespaceContext(before);
-      StringPieceUtils::RemoveWhitespaceContext(after);
+      *before = base::TrimWhitespaceASCII(*before, base::TRIM_ALL);
+      *after = base::TrimWhitespaceASCII(*after, base::TRIM_ALL);
       return true;
     }
   }
@@ -742,7 +743,7 @@ void ProcessChunkExtensionsManual(base::StringPiece all_extensions,
                                   BalsaHeaders* extensions) {
   base::StringPiece extension;
   base::StringPiece remaining;
-  StringPieceUtils::RemoveWhitespaceContext(&all_extensions);
+  all_extensions = base::TrimWhitespaceASCII(all_extensions, base::TRIM_ALL);
   SplitStringPiece(all_extensions, ';', &extension, &remaining);
   while (!extension.empty()) {
     base::StringPiece key;
@@ -758,7 +759,7 @@ void ProcessChunkExtensionsManual(base::StringPiece all_extensions,
 
     extensions->AppendHeader(key, value);
 
-    StringPieceUtils::RemoveWhitespaceContext(&remaining);
+    remaining = base::TrimWhitespaceASCII(remaining, base::TRIM_ALL);
     SplitStringPiece(remaining, ';', &extension, &remaining);
   }
 }
diff --git a/net/tools/balsa/balsa_headers_token_utils.cc b/net/tools/balsa/balsa_headers_token_utils.cc
index c807e05..c5dfeea 100644
--- a/net/tools/balsa/balsa_headers_token_utils.cc
+++ b/net/tools/balsa/balsa_headers_token_utils.cc
@@ -3,7 +3,6 @@
 // found in the LICENSE file.
 
 #include "net/tools/balsa/balsa_headers_token_utils.h"
-#include "net/tools/balsa/string_piece_utils.h"
 
 namespace net {
 
@@ -86,7 +85,8 @@ bool BalsaHeadersTokenUtils::CheckHeaderForLastToken(
                  &tokens);
 
   return !tokens.empty() &&
-      StringPieceUtils::StartsWithIgnoreCase(tokens.back(), token);
+         base::StartsWith(tokens.back(), token,
+                          base::CompareCase::INSENSITIVE_ASCII);
 }
 
 void BalsaHeadersTokenUtils::TokenizeHeaderValue(
diff --git a/net/tools/balsa/string_piece_utils.h b/net/tools/balsa/string_piece_utils.h
index cab48fb..7d8a1aa 100644
--- a/net/tools/balsa/string_piece_utils.h
+++ b/net/tools/balsa/string_piece_utils.h
@@ -5,9 +5,8 @@
 #ifndef NET_TOOLS_BALSA_STRING_PIECE_UTILS_H_
 #define NET_TOOLS_BALSA_STRING_PIECE_UTILS_H_
 
-#include <ctype.h>
-
 #include "base/strings/string_piece.h"
+#include "base/strings/string_util.h"
 
 namespace net {
 
@@ -20,7 +19,7 @@ struct StringPieceCaseCompare {
     size_t hash_val = 0;
     for (base::StringPiece::const_iterator it = sp.begin();
          it != sp.end(); ++it) {
-      hash_val = 5 * hash_val + tolower(*it);
+      hash_val = 5 * hash_val + base::ToLowerASCII(*it);
     }
     return hash_val;
   }
@@ -31,7 +30,21 @@ struct StringPieceCaseCompare {
     size_t len2 = sp2.length();
     bool sp1_shorter = len1 < len2;
     size_t len = sp1_shorter ? len1 : len2;
-    int rv = _memicmp(sp1.data(), sp2.data(), len);
+
+    int rv = 0;
+    for (size_t i = 0; i < len; i++) {
+      char sp1_lower = base::ToLowerASCII(sp1[i]);
+      char sp2_lower = base::ToLowerASCII(sp2[i]);
+      if (sp1_lower < sp2_lower) {
+        rv = -1;
+        break;
+      }
+      if (sp1_lower > sp2_lower) {
+        rv = 1;
+        break;
+      }
+    }
+
     if (rv == 0) {
       return sp1_shorter;
     }
@@ -45,7 +58,7 @@ struct StringPieceCaseHash {
     size_t hash_val = 0;
     for (base::StringPiece::const_iterator it = sp.begin();
          it != sp.end(); ++it) {
-      hash_val = 5 * hash_val + tolower(*it);
+      hash_val = 5 * hash_val + base::ToLowerASCII(*it);
     }
     return hash_val;
   }
@@ -53,6 +66,7 @@ struct StringPieceCaseHash {
 #endif  // COMPILER_MSVC
 
 struct StringPieceUtils {
+  // ASCII case-insensitive equality.
   static bool EqualIgnoreCase(const base::StringPiece& piece1,
                               const base::StringPiece& piece2) {
     base::StringPiece::const_iterator p1i = piece1.begin();
@@ -63,39 +77,15 @@ struct StringPieceUtils {
       return false;
     }
     while (p1i != piece1.end() && p2i != piece2.end()) {
-      if (tolower(*p1i) != tolower(*p2i))
+      if (base::ToLowerASCII(*p1i) != base::ToLowerASCII(*p2i))
         return false;
       ++p1i;
       ++p2i;
     }
     return true;
   }
-
-  static void RemoveWhitespaceContext(base::StringPiece* piece1) {
-    base::StringPiece::const_iterator c = piece1->begin();
-    base::StringPiece::const_iterator e = piece1->end();
-    while (c != e && isspace(*c)) {
-      ++c;
-    }
-    if (c == e) {
-      *piece1 = base::StringPiece(c, e-c);
-      return;
-    }
-    --e;
-    while (c != e &&isspace(*e)) {
-      --e;
-    }
-    ++e;
-    *piece1 = base::StringPiece(c, e-c);
-  }
-
-  static bool StartsWithIgnoreCase(const base::StringPiece& text,
-                                   const base::StringPiece& starts_with) {
-    if (text.size() < starts_with.size())
-      return false;
-    return EqualIgnoreCase(text.substr(0, starts_with.size()), starts_with);
-  }
 };
+
 struct StringPieceCaseEqual {
   bool operator()(const base::StringPiece& piece1,
                   const base::StringPiece& piece2) const {
@@ -103,8 +93,6 @@ struct StringPieceCaseEqual {
   }
 };
 
-
-
 }  // namespace net
 
 #endif  // NET_TOOLS_BALSA_STRING_PIECE_UTILS_H_
diff --git a/net/tools/disk_cache_memory_test/disk_cache_memory_test.cc b/net/tools/disk_cache_memory_test/disk_cache_memory_test.cc
index 745a032..0c1fedb 100644
--- a/net/tools/disk_cache_memory_test/disk_cache_memory_test.cc
+++ b/net/tools/disk_cache_memory_test/disk_cache_memory_test.cc
@@ -45,8 +45,8 @@ const char kKb[] = "kB";
 struct CacheSpec {
  public:
   static scoped_ptr<CacheSpec> Parse(const std::string& spec_string) {
-    std::vector<std::string> tokens;
-    base::SplitString(spec_string, ':', &tokens);
+    std::vector<std::string> tokens = base::SplitString(
+        spec_string, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     if (tokens.size() != 3)
       return scoped_ptr<CacheSpec>();
     if (tokens[0] != kBlockFileBackendType && tokens[0] != kSimpleBackendType)
diff --git a/net/tools/flip_server/flip_in_mem_edsm_server.cc b/net/tools/flip_server/flip_in_mem_edsm_server.cc
index d646b2e..1e6a8cef 100644
--- a/net/tools/flip_server/flip_in_mem_edsm_server.cc
+++ b/net/tools/flip_server/flip_in_mem_edsm_server.cc
@@ -286,8 +286,8 @@ int main(int argc, char** argv) {
       break;
     }
     std::string value = cl.GetSwitchValueASCII(name.str());
-    std::vector<std::string> valueArgs;
-    base::SplitString(value, ',', &valueArgs);
+    std::vector<std::string> valueArgs = base::SplitString(
+        value, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     CHECK_EQ((unsigned int)9, valueArgs.size());
     int spdy_only = atoi(valueArgs[8].c_str());
     // If wait_for_iface is enabled, then this call will block
@@ -315,8 +315,8 @@ int main(int argc, char** argv) {
   if (cl.HasSwitch("spdy-server")) {
     spdy_memory_cache.AddFiles();
     std::string value = cl.GetSwitchValueASCII("spdy-server");
-    std::vector<std::string> valueArgs;
-    base::SplitString(value, ',', &valueArgs);
+    std::vector<std::string> valueArgs = base::SplitString(
+        value, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     while (valueArgs.size() < 4)
       valueArgs.push_back(std::string());
     g_proxy_config.AddAcceptor(net::FLIP_HANDLER_SPDY_SERVER,
@@ -342,8 +342,8 @@ int main(int argc, char** argv) {
   if (cl.HasSwitch("http-server")) {
     http_memory_cache.AddFiles();
     std::string value = cl.GetSwitchValueASCII("http-server");
-    std::vector<std::string> valueArgs;
-    base::SplitString(value, ',', &valueArgs);
+    std::vector<std::string> valueArgs = base::SplitString(
+        value, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     while (valueArgs.size() < 4)
       valueArgs.push_back(std::string());
     g_proxy_config.AddAcceptor(net::FLIP_HANDLER_HTTP_SERVER,
diff --git a/net/tools/flip_server/loadtime_measurement.h b/net/tools/flip_server/loadtime_measurement.h
index d18ac2f..d1a8e07 100644
--- a/net/tools/flip_server/loadtime_measurement.h
+++ b/net/tools/flip_server/loadtime_measurement.h
@@ -30,7 +30,8 @@ class LoadtimeMeasurement {
       : num_urls_(0), pageload_html_file_(pageload_html_file) {
     std::string urls_string;
     base::ReadFileToString(urls_file, &urls_string);
-    base::SplitString(urls_string, '\n', &urls_);
+    urls_ = base::SplitString(urls_string, "\n", base::TRIM_WHITESPACE,
+                              base::SPLIT_WANT_ALL);
     num_urls_ = urls_.size();
   }
 
@@ -72,14 +73,14 @@ class LoadtimeMeasurement {
       return;
     }
     if (action.find("record_page_load") == 0) {
-      std::vector<std::string> query;
-      base::SplitString(action, '?', &query);
-      std::vector<std::string> params;
-      base::SplitString(query[1], '&', &params);
-      std::vector<std::string> url;
-      std::vector<std::string> loadtime;
-      base::SplitString(params[1], '=', &url);
-      base::SplitString(params[2], '=', &loadtime);
+      std::vector<std::string> query = base::SplitString(
+          action, "?", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+      std::vector<std::string> params = base::SplitString(
+          query[1], "&", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+      std::vector<std::string> url = base::SplitString(
+          params[1], "=", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+      std::vector<std::string> loadtime = base::SplitString(
+          params[2], "=", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
       loadtimes_[url[1]] = atoi(loadtime[1].c_str());
       output.append("OK");
       return;
diff --git a/net/tools/gdig/gdig.cc b/net/tools/gdig/gdig.cc
index 634c397..cc490cd 100644
--- a/net/tools/gdig/gdig.cc
+++ b/net/tools/gdig/gdig.cc
@@ -133,15 +133,15 @@ bool LoadReplayLog(const base::FilePath& file_path, ReplayLog* replay_log) {
   std::string replay_log_contents;
   base::RemoveChars(original_replay_log_contents, "\r", &replay_log_contents);
 
-  std::vector<std::string> lines;
-  base::SplitString(replay_log_contents, '\n', &lines);
+  std::vector<std::string> lines = base::SplitString(
+      replay_log_contents, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   base::TimeDelta previous_delta;
   bool bad_parse = false;
   for (unsigned i = 0; i < lines.size(); ++i) {
     if (lines[i].empty())
       continue;
-    std::vector<std::string> time_and_name;
-    base::SplitString(lines[i], ' ', &time_and_name);
+    std::vector<std::string> time_and_name = base::SplitString(
+        lines[i], " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     if (time_and_name.size() != 2) {
       fprintf(
           stderr,
diff --git a/net/tools/net_watcher/net_watcher.cc b/net/tools/net_watcher/net_watcher.cc
index 03d8d93..ca25040 100644
--- a/net/tools/net_watcher/net_watcher.cc
+++ b/net/tools/net_watcher/net_watcher.cc
@@ -170,9 +170,9 @@ int main(int argc, char* argv[]) {
       command_line->GetSwitchValueASCII(kIgnoreNetifFlag);
   base::hash_set<std::string> ignored_interfaces;
   if (!ignored_netifs_str.empty()) {
-    std::vector<std::string> ignored_netifs;
-    base::SplitString(ignored_netifs_str, ',', &ignored_netifs);
-    for (const std::string& ignored_netif : ignored_netifs) {
+    for (const std::string& ignored_netif :
+         base::SplitString(ignored_netifs_str, ",", base::TRIM_WHITESPACE,
+                           base::SPLIT_WANT_ALL)) {
       LOG(INFO) << "Ignoring: " << ignored_netif;
       ignored_interfaces.insert(ignored_netif);
     }
diff --git a/net/tools/quic/quic_client_bin.cc b/net/tools/quic/quic_client_bin.cc
index 4a6b97b..3fc8be1 100644
--- a/net/tools/quic/quic_client_bin.cc
+++ b/net/tools/quic/quic_client_bin.cc
@@ -242,8 +242,8 @@ int main(int argc, char *argv[]) {
     if (sp.empty()) {
       continue;
     }
-    vector<string> kv;
-    base::SplitString(sp, ':', &kv);
+    vector<string> kv =
+        base::SplitString(sp, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     CHECK_EQ(2u, kv.size());
     string key;
     base::TrimWhitespaceASCII(kv[0], base::TRIM_ALL, &key);
diff --git a/net/tools/quic/quic_in_memory_cache.cc b/net/tools/quic/quic_in_memory_cache.cc
index 8bf1713..d611c31 100644
--- a/net/tools/quic/quic_in_memory_cache.cc
+++ b/net/tools/quic/quic_in_memory_cache.cc
@@ -128,9 +128,11 @@ void QuicInMemoryCache::InitializeFromDirectory(const string& cache_directory) {
     if (response_headers->GetNormalizedHeader("X-Original-Url", &base)) {
       response_headers->RemoveHeader("X-Original-Url");
       // Remove the protocol so we can add it below.
-      if (base::StartsWithASCII(base, "https://", false)) {
+      if (base::StartsWith(base, "https://",
+                           base::CompareCase::INSENSITIVE_ASCII)) {
         base = base.substr(8);
-      } else if (base::StartsWithASCII(base, "http://", false)) {
+      } else if (base::StartsWith(base, "http://",
+                                  base::CompareCase::INSENSITIVE_ASCII)) {
         base = base.substr(7);
       }
     } else {
diff --git a/net/tools/quic/quic_simple_client_bin.cc b/net/tools/quic/quic_simple_client_bin.cc
index acc1fa3..824521d 100644
--- a/net/tools/quic/quic_simple_client_bin.cc
+++ b/net/tools/quic/quic_simple_client_bin.cc
@@ -242,8 +242,8 @@ int main(int argc, char *argv[]) {
     if (sp.empty()) {
       continue;
     }
-    vector<string> kv;
-    base::SplitString(sp, ':', &kv);
+    vector<string> kv =
+        base::SplitString(sp, ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     CHECK_EQ(2u, kv.size());
     string key;
     base::TrimWhitespaceASCII(kv[0], base::TRIM_ALL, &key);
diff --git a/net/url_request/url_request_unittest.cc b/net/url_request/url_request_unittest.cc
index 0640dd4..6b09473 100644
--- a/net/url_request/url_request_unittest.cc
+++ b/net/url_request/url_request_unittest.cc
@@ -7776,15 +7776,15 @@ TEST_F(HTTPSRequestTest, ResumeTest) {
     // four lines.
 
     EXPECT_EQ(1, d.response_started_count());
-    std::vector<std::string> lines;
-    base::SplitString(d.data_received(), '\n', &lines);
+    std::vector<std::string> lines = base::SplitString(
+        d.data_received(), "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     ASSERT_EQ(4u, lines.size()) << d.data_received();
 
     std::string session_id;
 
     for (size_t i = 0; i < 2; i++) {
-      std::vector<std::string> parts;
-      base::SplitString(lines[i], '\t', &parts);
+      std::vector<std::string> parts = base::SplitString(
+          lines[i], "\t", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
       ASSERT_EQ(2u, parts.size());
       if (i == 0) {
         EXPECT_EQ("insert", parts[0]);
@@ -7801,14 +7801,14 @@ TEST_F(HTTPSRequestTest, ResumeTest) {
 // the result of fetching "ssl-session-cache" from the test server, indicates
 // that exactly two different sessions were inserted, with no lookups etc.
 static void AssertTwoDistinctSessionsInserted(const string& session_info) {
-  std::vector<std::string> lines;
-  base::SplitString(session_info, '\n', &lines);
+  std::vector<std::string> lines = base::SplitString(
+      session_info, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   ASSERT_EQ(3u, lines.size()) << session_info;
 
   std::string session_id;
   for (size_t i = 0; i < 2; i++) {
-    std::vector<std::string> parts;
-    base::SplitString(lines[i], '\t', &parts);
+    std::vector<std::string> parts = base::SplitString(
+        lines[i], "\t", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     ASSERT_EQ(2u, parts.size());
     EXPECT_EQ("insert", parts[0]);
     if (i == 0) {
@@ -7924,8 +7924,8 @@ TEST_F(HTTPSRequestTest, DisableECDSAOnXP) {
   base::RunLoop().Run();
 
   EXPECT_EQ(1, d.response_started_count());
-  std::vector<std::string> lines;
-  base::SplitString(d.data_received(), '\n', &lines);
+  std::vector<std::string> lines = base::SplitString(
+      d.data_received(), "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
 
   for (size_t i = 0; i < lines.size(); i++) {
     int cipher_suite;
diff --git a/pdf/pdfium/pdfium_engine.cc b/pdf/pdfium/pdfium_engine.cc
index 410b29b..026eeb4 100644
--- a/pdf/pdfium/pdfium_engine.cc
+++ b/pdf/pdfium/pdfium_engine.cc
@@ -3917,7 +3917,7 @@ bool PDFiumEngineExports::RenderPDFPageToDC(const void* pdf_buffer,
         doc, "Creator", WriteInto(&creator, buffer_bytes + 1), buffer_bytes);
   }
   bool use_bitmap = false;
-  if (base::StartsWith(creator, L"cairo", false))
+  if (base::StartsWith(creator, L"cairo", base::CompareCase::INSENSITIVE_ASCII))
     use_bitmap = true;
 
   // Another temporary hack. Some PDFs seems to render very slowly if