Write new Starts/EndsWith and convert FilePath functions to StringPiece.

base/version.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 "base/version.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 
 namespace base {
 
 namespace {
 
 // Parses the |numbers| vector representing the different numbers
 // inside the version string and constructs a vector of valid integers. It stops
 // when it reaches an invalid item (including the wildcard character). |parsed|
 // is the resulting integer vector. Function returns true if all numbers were
 // parsed successfully, false otherwise.
 bool ParseVersionNumbers(const std::string& version_str,
                          std::vector<uint32_t>* parsed) {
-  std::vector<std::string> numbers;
-  SplitString(version_str, '.', &numbers);
+  std::vector<StringPiece> numbers =
+      SplitStringPiece(version_str, ".", KEEP_WHITESPACE, SPLIT_WANT_ALL);
   if (numbers.empty())
     return false;
 
-  for (std::vector<std::string>::const_iterator it = numbers.begin();
-       it != numbers.end(); ++it) {
-    if (StartsWithASCII(*it, "+", false))
+  for (auto it = numbers.begin(); it != numbers.end(); ++it) {
+    if (StartsWith(*it, "+", CompareCase::SENSITIVE))
       return false;
+
+    // TODO(brettw) when we have a StringPiece version of StringToUint, delete
+    // this string conversion.
     unsigned int num;
     if (!StringToUint(*it, &num))
       return false;
 
     // This throws out leading zeros for the first item only.
     if (it == numbers.begin() && UintToString(num) != *it)
       return false;
 
     // StringToUint returns unsigned int but Version fields are uint32_t.
     static_assert(sizeof (uint32_t) == sizeof (unsigned int),
@@ skipping 44 matching lines @@
 
   components_.swap(parsed);
 }
 
 bool Version::IsValid() const {
   return (!components_.empty());
 }
 
 // static
 bool Version::IsValidWildcardString(const std::string& wildcard_string) {
-  std::string version_string = wildcard_string;
-  if (EndsWith(wildcard_string.c_str(), ".*", false))
+  std::string version_string;
+  if (EndsWith(wildcard_string, ".*", CompareCase::SENSITIVE))
     version_string = wildcard_string.substr(0, wildcard_string.size() - 2);

[Peter Kasting, 2015/06/15 20:41:40]

Nit: Hmm... I think it might be more efficient to do:

  std::string vesion_string(wildcard_string);
  if (EndsWith(wildcard_string, ".*", CompareCase::SENSITIVE))
    version_string.erase(version_string.length() - 2);

[brettw, 2015/06/15 23:00:48]

You're right. I'm going to do resize(version_string.length() - 2) instead since
I think that's more clear (I had to look up the erase arguments).

[Peter Kasting, 2015/06/16 00:08:18]

OK... I actually find it a bit less clear semantically ("erase" obviously erases
stuff, "resize" could be making the string longer) but it's a minor point and I
won't press it.

+  else
+    version_string = wildcard_string;
 
   Version version(version_string);
   return version.IsValid();
 }
 
 bool Version::IsOlderThan(const std::string& version_str) const {
   Version proposed_ver(version_str);
   if (!proposed_ver.IsValid())
     return false;
   return (CompareTo(proposed_ver) < 0);
 }
 
 int Version::CompareToWildcardString(const std::string& wildcard_string) const {
   DCHECK(IsValid());
   DCHECK(Version::IsValidWildcardString(wildcard_string));
 
   // Default behavior if the string doesn't end with a wildcard.
-  if (!EndsWith(wildcard_string.c_str(), ".*", false)) {
+  if (!EndsWith(wildcard_string, ".*", CompareCase::SENSITIVE)) {
     Version version(wildcard_string);
     DCHECK(version.IsValid());
     return CompareTo(version);
   }
 
   std::vector<uint32_t> parsed;
   const bool success = ParseVersionNumbers(
       wildcard_string.substr(0, wildcard_string.length() - 2), &parsed);
   DCHECK(success);
   const int comparison = CompareVersionComponents(components_, parsed);
@@ skipping 36 matching lines @@
   size_t count = components_.size();
   for (size_t i = 0; i < count - 1; ++i) {
     version_str.append(IntToString(components_[i]));
     version_str.append(".");
   }
   version_str.append(IntToString(components_[count - 1]));
   return version_str;
 }
 
 }  // namespace base