diff --git a/src/base/files/file_path.cc b/src/base/files/file_path.cc
index 3b53abc..be045b0 100644
--- a/src/base/files/file_path.cc
+++ b/src/base/files/file_path.cc
@@ -67,7 +67,7 @@
 
   StringViewType a_letter(a.substr(0, a_letter_pos + 1));
   StringViewType b_letter(b.substr(0, b_letter_pos + 1));
-  if (!StartsWith(a_letter, b_letter, CompareCase::INSENSITIVE_ASCII))
+  if (!StartsWithCaseInsensitiveASCII(a_letter, b_letter))
     return false;
 
   StringViewType a_rest(a.substr(a_letter_pos + 1));
@@ -271,7 +271,7 @@
   // never case sensitive.
   if ((FindDriveLetter(*parent_comp) != StringType::npos) &&
       (FindDriveLetter(*child_comp) != StringType::npos)) {
-    if (!StartsWith(*parent_comp, *child_comp, CompareCase::INSENSITIVE_ASCII))
+    if (!StartsWithCaseInsensitiveASCII(*parent_comp, *child_comp))
       return false;
     ++parent_comp;
     ++child_comp;
diff --git a/src/base/strings/string_util.cc b/src/base/strings/string_util.cc
index e1b494d..b00d77f 100644
--- a/src/base/strings/string_util.cc
+++ b/src/base/strings/string_util.cc
@@ -505,75 +505,50 @@
 }
 
 template <typename char_type>
-bool StartsWithT(std::basic_string_view<char_type> str,
-                 std::basic_string_view<char_type> search_for,
-                 CompareCase case_sensitivity) {
+bool StartsWithCaseInsensitiveASCIIT(
+    std::basic_string_view<char_type> str,
+    std::basic_string_view<char_type> search_for) {
   if (search_for.size() > str.size())
     return false;
 
   std::basic_string_view<char_type> source = str.substr(0, search_for.size());
 
-  switch (case_sensitivity) {
-    case CompareCase::SENSITIVE:
-      return source == search_for;
-
-    case CompareCase::INSENSITIVE_ASCII:
-      return std::equal(search_for.begin(), search_for.end(), source.begin(),
-                        CaseInsensitiveCompareASCII<char_type>());
-
-    default:
-      NOTREACHED();
-      return false;
-  }
+  return std::equal(search_for.begin(), search_for.end(), source.begin(),
+                    CaseInsensitiveCompareASCII<char_type>());
 }
 
-bool StartsWith(std::string_view str,
-                std::string_view search_for,
-                CompareCase case_sensitivity) {
-  return StartsWithT(str, search_for, case_sensitivity);
+bool StartsWithCaseInsensitiveASCII(std::string_view str,
+                                    std::string_view search_for) {
+  return StartsWithCaseInsensitiveASCIIT(str, search_for);
 }
 
-bool StartsWith(std::u16string_view str,
-                std::u16string_view search_for,
-                CompareCase case_sensitivity) {
-  return StartsWithT(str, search_for, case_sensitivity);
+bool StartsWithCaseInsensitiveASCII(std::u16string_view str,
+                                    std::u16string_view search_for) {
+  return StartsWithCaseInsensitiveASCIIT(str, search_for);
 }
 
-template <typename Str>
-bool EndsWithT(std::basic_string_view<typename Str::value_type> str,
-               std::basic_string_view<typename Str::value_type> search_for,
-               CompareCase case_sensitivity) {
+template <typename char_type>
+bool EndsWithCaseInsensitiveASCIIT(
+    std::basic_string_view<char_type> str,
+    std::basic_string_view<char_type> search_for) {
   if (search_for.size() > str.size())
     return false;
 
-  std::basic_string_view<typename Str::value_type> source =
+  std::basic_string_view<char_type> source =
       str.substr(str.size() - search_for.size(), search_for.size());
 
-  switch (case_sensitivity) {
-    case CompareCase::SENSITIVE:
-      return source == search_for;
-
-    case CompareCase::INSENSITIVE_ASCII:
-      return std::equal(
-          source.begin(), source.end(), search_for.begin(),
-          CaseInsensitiveCompareASCII<typename Str::value_type>());
-
-    default:
-      NOTREACHED();
-      return false;
-  }
+  return std::equal(source.begin(), source.end(), search_for.begin(),
+                    CaseInsensitiveCompareASCII<char_type>());
 }
 
-bool EndsWith(std::string_view str,
-              std::string_view search_for,
-              CompareCase case_sensitivity) {
-  return EndsWithT<std::string>(str, search_for, case_sensitivity);
+bool EndsWithCaseInsensitiveASCII(std::string_view str,
+                                  std::string_view search_for) {
+  return EndsWithCaseInsensitiveASCIIT(str, search_for);
 }
 
-bool EndsWith(std::u16string_view str,
-              std::u16string_view search_for,
-              CompareCase case_sensitivity) {
-  return EndsWithT<std::u16string>(str, search_for, case_sensitivity);
+bool EndsWithCaseInsensitiveASCII(std::u16string_view str,
+                                  std::u16string_view search_for) {
+  return EndsWithCaseInsensitiveASCIIT(str, search_for);
 }
 
 char HexDigitToInt(char16_t c) {
diff --git a/src/base/strings/string_util.h b/src/base/strings/string_util.h
index 9ed66b2..bd28dbd 100644
--- a/src/base/strings/string_util.h
+++ b/src/base/strings/string_util.h
@@ -246,31 +246,19 @@
 // undefined if the |ascii| string is not ASCII.
 bool EqualsASCII(std::u16string_view str, std::string_view ascii);
 
-// 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.
-//
+// starts_with/ends_with for ASCII case-insensitive comparisons.
 // If you need to do Unicode-aware case-insensitive StartsWith/EndsWith, it's
 // best to call base::i18n::ToLower() or base::i18n::FoldCase() (see
 // base/i18n/case_conversion.h for usage advice) on the arguments, and then use
 // the results to a case-sensitive comparison.
-enum class CompareCase {
-  SENSITIVE,
-  INSENSITIVE_ASCII,
-};
-
-bool StartsWith(std::string_view str,
-                std::string_view search_for,
-                CompareCase case_sensitivity);
-bool StartsWith(std::u16string_view str,
-                std::u16string_view search_for,
-                CompareCase case_sensitivity);
-bool EndsWith(std::string_view str,
-              std::string_view search_for,
-              CompareCase case_sensitivity);
-bool EndsWith(std::u16string_view str,
-              std::u16string_view search_for,
-              CompareCase case_sensitivity);
+bool StartsWithCaseInsensitiveASCII(std::string_view str,
+                                    std::string_view search_for);
+bool StartsWithCaseInsensitiveASCII(std::u16string_view str,
+                                    std::u16string_view search_for);
+bool EndsWithCaseInsensitiveASCII(std::string_view str,
+                                  std::string_view search_for);
+bool EndsWithCaseInsensitiveASCII(std::u16string_view str,
+                                  std::u16string_view search_for);
 
 // Determines the type of ASCII character, independent of locale (the C
 // library versions will change based on locale).
diff --git a/src/gn/ninja_target_writer.cc b/src/gn/ninja_target_writer.cc
index 2f7ec38..6ecbaa7 100644
--- a/src/gn/ninja_target_writer.cc
+++ b/src/gn/ninja_target_writer.cc
@@ -524,8 +524,7 @@
 
   // First validate that the target's dependency is a stamp file. Otherwise,
   // we shouldn't have gotten here!
-  CHECK(base::EndsWith(stamp_file.value(), ".stamp",
-                       base::CompareCase::INSENSITIVE_ASCII))
+  CHECK(base::EndsWithCaseInsensitiveASCII(stamp_file.value(), ".stamp"))
       << "Output should end in \".stamp\" for stamp file output. Instead got: "
       << "\"" << stamp_file.value() << "\"";