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 sensitivity of comparisons. Only ASCII case insensitivity
+// is supported. Full Unicode case-insensitive conversions would need to go in
+// base/i18n so it can use ICU.
+//
+// If you need to do Unicode-aware case-insensitive StartsWith/EndsWith, it's
+// best to just call base::i18n::ToLower() on the arguements, and then use the
+// results to a case-sensitive comparison.

[Nico, 2015/07/06 17:29:37]

This suggestion won't do the right thing for strings containing an upper-case
turkish dotted i? ( http://www.i18nguy.com/unicode/turkish-i18n.html ).

(Also "arguements")

[brettw, 2015/07/06 17:48:14]

Good find! I'll follow up with Jungskik on writing better advice here.

+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);
+
+// DEPRECATED. Returns true if str starts/ends with search, or false otherwise.
+// TODO(brettw) remove in favor of the "enum" versions above.
+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_