Rename EqualIgnoringCase*() to DeprecatedEqualIgnoringCase*()

third_party/WebKit/Source/platform/wtf/text/StringImpl.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller ( mueller@kde.org )
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2013 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 1268 matching lines @@
     0x00bd, 0x00be, 0x00bf, 0x00e0, 0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5,
     0x00e6, 0x00e7, 0x00e8, 0x00e9, 0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee,
     0x00ef, 0x00f0, 0x00f1, 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00d7,
     0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00df, 0x00e0,
     0x00e1, 0x00e2, 0x00e3, 0x00e4, 0x00e5, 0x00e6, 0x00e7, 0x00e8, 0x00e9,
     0x00ea, 0x00eb, 0x00ec, 0x00ed, 0x00ee, 0x00ef, 0x00f0, 0x00f1, 0x00f2,
     0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f7, 0x00f8, 0x00f9, 0x00fa, 0x00fb,
     0x00fc, 0x00fd, 0x00fe, 0x00ff,
 };
 
-bool EqualIgnoringCase(const LChar* a, const LChar* b, unsigned length) {
+bool DeprecatedEqualIgnoringCase(const LChar* a,
+                                 const LChar* b,
+                                 unsigned length) {
   DCHECK_GE(length, 0u);
   if (a == b)
     return true;
   while (length--) {
     if (StringImpl::kLatin1CaseFoldTable[*a++] !=
         StringImpl::kLatin1CaseFoldTable[*b++])
       return false;
   }
   return true;
 }
 
-bool EqualIgnoringCase(const UChar* a, const UChar* b, unsigned length) {
+bool DeprecatedEqualIgnoringCase(const UChar* a,
+                                 const UChar* b,
+                                 unsigned length) {
   DCHECK_GE(length, 0u);
   if (a == b)
     return true;
   return !Unicode::Umemcasecmp(a, b, length);
 }
 
-bool EqualIgnoringCase(const UChar* a, const LChar* b, unsigned length) {
+bool DeprecatedEqualIgnoringCase(const UChar* a,
+                                 const LChar* b,
+                                 unsigned length) {
   while (length--) {
     if (FoldCase(*a++) != StringImpl::kLatin1CaseFoldTable[*b++])
       return false;
   }
   return true;
 }
 
 size_t StringImpl::Find(CharacterMatchFunctionPtr match_function,
                         unsigned start) {
   if (Is8Bit())
@@ skipping 79 matching lines @@
     const MatchCharacterType* match_characters,
     unsigned index,
     unsigned search_length,
     unsigned match_length) {
   // delta is the number of additional times to test; delta == 0 means test only
   // once.
   unsigned delta = search_length - match_length;
 
   unsigned i = 0;
   // keep looping until we match
-  while (!EqualIgnoringCase(search_characters + i, match_characters,
-                            match_length)) {
+  while (!DeprecatedEqualIgnoringCase(search_characters + i, match_characters,
+                                      match_length)) {
     if (i == delta)
       return kNotFound;
     ++i;
   }
   return index + i;
 }
 
 size_t StringImpl::FindIgnoringCase(const StringView& match_string,
                                     unsigned index) {
   if (UNLIKELY(match_string.IsNull()))
@@ skipping 172 matching lines @@
   }
   if (prefix.Is8Bit())
     return Equal(Characters16(), prefix.Characters8(), prefix.length());
   return Equal(Characters16(), prefix.Characters16(), prefix.length());
 }
 
 bool StringImpl::StartsWithIgnoringCase(const StringView& prefix) const {
   if (prefix.length() > length())
     return false;
   if (Is8Bit()) {
-    if (prefix.Is8Bit())
-      return EqualIgnoringCase(Characters8(), prefix.Characters8(),
-                               prefix.length());
-    return EqualIgnoringCase(Characters8(), prefix.Characters16(),
-                             prefix.length());
+    if (prefix.Is8Bit()) {
+      return DeprecatedEqualIgnoringCase(Characters8(), prefix.Characters8(),
+                                         prefix.length());
+    }
+    return DeprecatedEqualIgnoringCase(Characters8(), prefix.Characters16(),
+                                       prefix.length());
   }
-  if (prefix.Is8Bit())
-    return EqualIgnoringCase(Characters16(), prefix.Characters8(),
-                             prefix.length());
-  return EqualIgnoringCase(Characters16(), prefix.Characters16(),
-                           prefix.length());
+  if (prefix.Is8Bit()) {
+    return DeprecatedEqualIgnoringCase(Characters16(), prefix.Characters8(),
+                                       prefix.length());
+  }
+  return DeprecatedEqualIgnoringCase(Characters16(), prefix.Characters16(),
+                                     prefix.length());
 }
 
 bool StringImpl::StartsWithIgnoringASCIICase(const StringView& prefix) const {
   if (prefix.length() > length())
     return false;
   if (Is8Bit()) {
     if (prefix.Is8Bit())
       return EqualIgnoringASCIICase(Characters8(), prefix.Characters8(),
                                     prefix.length());
     return EqualIgnoringASCIICase(Characters8(), prefix.Characters16(),
@@ skipping 26 matching lines @@
                  suffix.length());
   return Equal(Characters16() + start_offset, suffix.Characters16(),
                suffix.length());
 }
 
 bool StringImpl::EndsWithIgnoringCase(const StringView& suffix) const {
   if (suffix.length() > length())
     return false;
   unsigned start_offset = length() - suffix.length();
   if (Is8Bit()) {
-    if (suffix.Is8Bit())
-      return EqualIgnoringCase(Characters8() + start_offset,
-                               suffix.Characters8(), suffix.length());
-    return EqualIgnoringCase(Characters8() + start_offset,
-                             suffix.Characters16(), suffix.length());
+    if (suffix.Is8Bit()) {
+      return DeprecatedEqualIgnoringCase(Characters8() + start_offset,
+                                         suffix.Characters8(), suffix.length());
+    }
+    return DeprecatedEqualIgnoringCase(Characters8() + start_offset,
+                                       suffix.Characters16(), suffix.length());
   }
-  if (suffix.Is8Bit())
-    return EqualIgnoringCase(Characters16() + start_offset,
-                             suffix.Characters8(), suffix.length());
-  return EqualIgnoringCase(Characters16() + start_offset, suffix.Characters16(),
-                           suffix.length());
+  if (suffix.Is8Bit()) {
+    return DeprecatedEqualIgnoringCase(Characters16() + start_offset,
+                                       suffix.Characters8(), suffix.length());
+  }
+  return DeprecatedEqualIgnoringCase(Characters16() + start_offset,
+                                     suffix.Characters16(), suffix.length());
 }
 
 bool StringImpl::EndsWithIgnoringASCIICase(const StringView& suffix) const {
   if (suffix.length() > length())
     return false;
   unsigned start_offset = length() - suffix.length();
   if (Is8Bit()) {
     if (suffix.Is8Bit())
       return EqualIgnoringASCIICase(Characters8() + start_offset,
                                     suffix.Characters8(), suffix.length());
@@ skipping 566 matching lines @@
     } else if (LocaleIdMatchesLang(locale_identifier, "lt")) {
       // TODO(rob.buis) implement upper-casing rules for lt
       // like in StringImpl::upper(locale).
     }
   }
 
   return ToUpper(c);
 }
 
 }  // namespace WTF