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

base/strings/string_util.h

 // Copyright 2013 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.
 //
 // This file defines utility functions for working with strings.
 
 #ifndef BASE_STRINGS_STRING_UTIL_H_
 #define BASE_STRINGS_STRING_UTIL_H_
 
 #include <ctype.h>
@@ skipping 311 matching lines @@
                                       const char* b_begin,
                                       const char* b_end);
 BASE_EXPORT bool LowerCaseEqualsASCII(const char16* a_begin,
                                       const char16* a_end,
                                       const char* b);
 
 // Performs a case-sensitive string compare. The behavior is undefined if both
 // strings are not ASCII.
 BASE_EXPORT bool EqualsASCII(const string16& a, const StringPiece& b);
 
-// Returns true if str starts with search, or false otherwise.
-// TODO(brettw) the case sensitive flag makes callsites difficult to read.
-// Consider splitting this out in two variants (few callers want
-// case-insensitive compares) or use an enum that makes this more explicit.
-BASE_EXPORT bool StartsWithASCII(const std::string& str,
-                                 const std::string& search,
-                                 bool case_sensitive);
-BASE_EXPORT bool StartsWith(const base::string16& str,
-                            const base::string16& search,
+// Indicates case insensitivity of comparisons. Only ASCII case insensitivity

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

Nit: insensitivity -> sensitivity

+// is supported. Full Unicode case-insensitive conversions would need to go in

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

So, does the "would" here mean there aren't appropriate i18n functions for this
yet (and if so, are you going to implement some)?  Or do the relevant functions
already exist (e.g. StringSearchIgnoringCaseAndAccents())?

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

Correct, there are not equivalent replacements. My current plan is to have such
places call base::i18n::ToLower for the arguments and then do a case-sensitive
comparison. I'll write a comment to this effect.

I started on a patch to replace the current uses of the legacy Starts/EndsWith
wide versions which "kind of" did case insensitive unicode comparisons (I think
only in UCS-2). There were more than I expected so I may revisit the above
advice when I finish, depending on how many there end up being.

+// base/i18n so it can use ICU.

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

Nit: "so it can use" -> "and be implemented using"?

+enum class CompareCase {
+  SENSITIVE,
+  INSENSITIVE_ASCII,
+};
+
+BASE_EXPORT bool StartsWith(StringPiece str,
+                            StringPiece search_for,
+                            CompareCase case_sensitivity);
+BASE_EXPORT bool StartsWith(StringPiece16 str,
+                            StringPiece16 search_for,
+                            CompareCase case_sensitivity);
+BASE_EXPORT bool EndsWith(StringPiece str,
+                          StringPiece search_for,
+                          CompareCase case_sensitivity);
+BASE_EXPORT bool EndsWith(StringPiece16 str,
+                          StringPiece16 search_for,
+                          CompareCase case_sensitivity);
+
+// Returns true if str starts/ends with search, or false otherwise.
+// DEPRECATED. TODO(brettw) remove in favor of the "enum" versions above.

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

Tiny nit: I'd say "DEPRECATED: Returns true..." and then the "TODO(brettw):",
just so people are less likely to miss the DEPRECATED.

+inline bool StartsWithASCII(const std::string& str,
+                            const std::string& search,
+                            bool case_sensitive) {
+  return StartsWith(StringPiece(str), StringPiece(search),
+                    case_sensitive ? CompareCase::SENSITIVE
+                                   : CompareCase::INSENSITIVE_ASCII);
+}
+BASE_EXPORT bool StartsWith(const string16& str,
+                            const string16& search,
                             bool case_sensitive);
-
-// Returns true if str ends with search, or false otherwise.
-// TODO(brettw) case sensitive flag confusion, see StartsWith above.
-BASE_EXPORT bool EndsWith(const std::string& str,
-                          const std::string& search,
-                          bool case_sensitive);
-BASE_EXPORT bool EndsWith(const base::string16& str,
-                          const base::string16& search,
+inline bool EndsWith(const std::string& str,
+                     const std::string& search,
+                     bool case_sensitive) {
+  return EndsWith(StringPiece(str), StringPiece(search),
+                  case_sensitive ? CompareCase::SENSITIVE
+                                 : CompareCase::INSENSITIVE_ASCII);
+}
+BASE_EXPORT bool EndsWith(const string16& str,
+                          const string16& search,
                           bool case_sensitive);
 
 }  // namespace base
 
 #if defined(OS_WIN)
 #include "base/strings/string_util_win.h"
 #elif defined(OS_POSIX)
 #include "base/strings/string_util_posix.h"
 #else
 #error Define string operations appropriately for your platform
@@ skipping 158 matching lines @@
 // string can contain wildcards like * and ?
 // The backslash character (\) is an escape character for * and ?
 // We limit the patterns to having a max of 16 * or ? characters.
 // ? matches 0 or 1 character, while * matches 0 or more characters.
 BASE_EXPORT bool MatchPattern(const base::StringPiece& string,
                               const base::StringPiece& pattern);
 BASE_EXPORT bool MatchPattern(const base::string16& string,
                               const base::string16& pattern);
 
 #endif  // BASE_STRINGS_STRING_UTIL_H_