Add "Unicode" suffixes to some functions of WTF::String and WTF::StringImpl.

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 615 matching lines @@
   UChar* data16;
   RefPtr<StringImpl> new_impl = CreateUninitialized(length_, data16);
 
   for (unsigned i = 0; i < length; ++i) {
     UChar c = Characters16()[i];
     data16[i] = IsASCIIUpper(c) ? ToASCIILower(c) : c;
   }
   return new_impl.Release();
 }
 
-PassRefPtr<StringImpl> StringImpl::Lower() {
+PassRefPtr<StringImpl> StringImpl::LowerUnicode() {
   // Note: This is a hot function in the Dromaeo benchmark, specifically the
   // no-op code path up through the first 'return' statement.
 
   // First scan the string for uppercase and non-ASCII characters:
   if (Is8Bit()) {
     unsigned first_index_to_be_lowered = length_;
     for (unsigned i = 0; i < length_; ++i) {
       LChar ch = Characters8()[i];
       if (UNLIKELY(IsASCIIUpper(ch) || ch & ~0x7F)) {
         first_index_to_be_lowered = i;
@@ skipping 56 matching lines @@
   if (!error && real_length == length)
     return new_impl.Release();
 
   new_impl = CreateUninitialized(real_length, data16);
   Unicode::ToLower(data16, real_length, Characters16(), length_, &error);
   if (error)
     return this;
   return new_impl.Release();
 }
 
-PassRefPtr<StringImpl> StringImpl::Upper() {
-  // This function could be optimized for no-op cases the way lower() is,
-  // but in empirical testing, few actual calls to upper() are no-ops, so
+PassRefPtr<StringImpl> StringImpl::UpperUnicode() {
+  // This function could be optimized for no-op cases the way LowerUnicode() is,
+  // but in empirical testing, few actual calls to UpperUnicode() are no-ops, so
   // it wouldn't be worth the extra time for pre-scanning.
 
   RELEASE_ASSERT(length_ <=
                  static_cast<unsigned>(numeric_limits<int32_t>::max()));
   int32_t length = length_;
 
   if (Is8Bit()) {
     LChar* data8;
     RefPtr<StringImpl> new_impl = CreateUninitialized(length_, data8);
 
@@ skipping 138 matching lines @@
         return output->Substring(0, target_length);
       return output.Release();
     }
     if (status != U_BUFFER_OVERFLOW_ERROR)
       return original_string;
     // Expand the buffer.
     output = StringImpl::CreateUninitialized(target_length, data16);
   } while (true);
 }
 
-PassRefPtr<StringImpl> StringImpl::Lower(
+PassRefPtr<StringImpl> StringImpl::LowerUnicode(
     const AtomicString& locale_identifier) {
   // Use the more optimized code path most of the time.
   // Only Turkic (tr and az) languages and Lithuanian requires
   // locale-specific lowercasing rules. Even though CLDR has el-Lower,
   // it's identical to the locale-agnostic lowercasing. Context-dependent
   // handling of Greek capital sigma is built into the common lowercasing
   // function in ICU.
   const char* locale_for_conversion = 0;
   if (LocaleIdMatchesLang(locale_identifier, "tr") ||
       LocaleIdMatchesLang(locale_identifier, "az"))
     locale_for_conversion = "tr";
   else if (LocaleIdMatchesLang(locale_identifier, "lt"))
     locale_for_conversion = "lt";
   else
-    return Lower();
+    return LowerUnicode();
 
   if (length_ > static_cast<unsigned>(numeric_limits<int32_t>::max()))
     CRASH();
   int length = length_;
 
   RefPtr<StringImpl> upconverted = UpconvertedString();
   const UChar* source16 = upconverted->Characters16();
   return CaseConvert(source16, length, u_strToLower, locale_for_conversion,
                      this);
 }
 
-PassRefPtr<StringImpl> StringImpl::Upper(
+PassRefPtr<StringImpl> StringImpl::UpperUnicode(
     const AtomicString& locale_identifier) {
   // Use the more-optimized code path most of the time.
   // Only Turkic (tr and az) languages, Greek and Lithuanian require
   // locale-specific uppercasing rules.
   const char* locale_for_conversion = 0;
   if (LocaleIdMatchesLang(locale_identifier, "tr") ||
       LocaleIdMatchesLang(locale_identifier, "az"))
     locale_for_conversion = "tr";
   else if (LocaleIdMatchesLang(locale_identifier, "el"))
     locale_for_conversion = "el";
   else if (LocaleIdMatchesLang(locale_identifier, "lt"))
     locale_for_conversion = "lt";
   else
-    return Upper();
+    return UpperUnicode();
 
   if (length_ > static_cast<unsigned>(numeric_limits<int32_t>::max()))
     CRASH();
   int length = length_;
 
   RefPtr<StringImpl> upconverted = UpconvertedString();
   const UChar* source16 = upconverted->Characters16();
 
   return CaseConvert(source16, length, u_strToUpper, locale_for_conversion,
                      this);
@@ skipping 1320 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