New new versions of Starts/EndsWith and SplitString in net

net/cert/x509_certificate_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/cert/x509_certificate.h"
 
 #include <stdint.h>
 
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 1091 matching lines @@
 
   std::string common_name(test_data.common_name);
   ASSERT_EQ(std::string::npos, common_name.find(','));
   std::replace(common_name.begin(), common_name.end(), '#', '\0');
 
   std::vector<std::string> dns_names, ip_addressses;
   if (test_data.dns_names) {
     // 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());
       if (addr_ascii[0] == 'x') {  // Hex encoded address
         addr_ascii.erase(0, 1);
         std::vector<uint8_t> bytes;
         EXPECT_TRUE(base::HexStringToBytes(addr_ascii, &bytes))
             << "Could not parse hex address " << addr_ascii << " i = " << i;
         ip_addressses.push_back(std::string(reinterpret_cast<char*>(&bytes[0]),
                                             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) {
           int decimal_value;
           EXPECT_TRUE(base::StringToInt(decimals_ascii[j], &decimal_value));
           EXPECT_GE(decimal_value, 0);
           EXPECT_LE(decimal_value, 255);
           addr_bytes.push_back(static_cast<char>(decimal_value));
         }
         ip_addressses.push_back(addr_bytes);
@@ skipping 61 matching lines @@
                                     &actual_type);
 
   EXPECT_EQ(data.expected_bits, actual_bits);
   EXPECT_EQ(data.expected_type, actual_type);
 }
 
 INSTANTIATE_TEST_CASE_P(, X509CertificatePublicKeyInfoTest,
                         testing::ValuesIn(kPublicKeyInfoTestData));
 
 }  // namespace net