New new versions of Starts/EndsWith and SplitString in net

net/base/ip_address_number.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/base/ip_address_number.h"
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
@@ skipping 138 matching lines @@
   }
 
   // Otherwise, try IPv4.
   ip_number->resize(4);  // 32 bits.
   int num_components;
   url::CanonHostInfo::Family family = url::IPv4AddressToNumber(
       hostname.data(), host_comp, &(*ip_number)[0], &num_components);
   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.
     ip_number->resize(16);  // 128 bits.
     return url::IPv6AddressToNumber(host_brackets.data(), host_comp,
                                     &(*ip_number)[0]);
   }
 
   // Otherwise the string is an IPv4 address.
   ip_number->resize(4);  // 32 bits.
@@ skipping 39 matching lines @@
                          address.end());
 }
 
 bool ParseCIDRBlock(const std::string& cidr_literal,
                     IPAddressNumber* ip_number,
                     size_t* prefix_length_in_bits) {
   // We expect CIDR notation to match one of these two templates:
   //   <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;
 
   // Parse the IP address.
   if (!ParseIPLiteralToNumber(parts[0], ip_number))
     return false;
 
   // Parse the prefix length.
   int number_of_bits = -1;
   if (!base::StringToInt(parts[1], &number_of_bits))
@@ skipping 49 matching lines @@
   }
   return a1.size() * CHAR_BIT;
 }
 
 unsigned MaskPrefixLength(const IPAddressNumber& mask) {
   IPAddressNumber all_ones(mask.size(), 0xFF);
   return CommonPrefixLength(mask, all_ones);
 }
 
 }  // namespace net