Experimental CL on top of https://codereview.chromium.org/1812673005/

src/runtime/runtime-i18n.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 
 #ifdef V8_I18N_SUPPORT
 #include "src/runtime/runtime-utils.h"
 
 #include "src/api.h"
 #include "src/api-natives.h"
@@ skipping 735 matching lines @@
   } else if (status >= UBRK_WORD_KANA && status < UBRK_WORD_KANA_LIMIT) {
     return *isolate->factory()->NewStringFromStaticChars("kana");
   } else if (status >= UBRK_WORD_IDEO && status < UBRK_WORD_IDEO_LIMIT) {
     return *isolate->factory()->NewStringFromStaticChars("ideo");
   } else {
     return *isolate->factory()->NewStringFromStaticChars("unknown");
   }
 }
 
 namespace {
+#if 0
 inline void LocaleConvertCaseHelper(icu::UnicodeString* s, bool is_to_upper,
                                     const icu::Locale& locale) {
   if (is_to_upper)
     s->toUpper(locale);
   else
     s->toLower(locale);
 }
 void ConvertCaseWithTransliterator(icu::UnicodeString* input,
                                    const char* transliterator_id) {
   UErrorCode status = U_ZERO_ERROR;
   base::SmartPointer<icu::Transliterator> translit(
       icu::Transliterator::createInstance(
           icu::UnicodeString(transliterator_id, -1, US_INV), UTRANS_FORWARD,
           status));
   if (U_FAILURE(status)) return;
   translit->transliterate(*input);
 }
+#endif
 
 MUST_USE_RESULT Object* LocaleConvertCase(Handle<String> s, Isolate* isolate,
                                           bool is_to_upper, int locale_id) {
   static const char* conversion_locales[] = {
       "az", "el", "lt", "tr",
   };
   RUNTIME_ASSERT(locale_id >= -1 &&
                  locale_id < static_cast<int>(arraysize(conversion_locales)));
   int32_t length = s->length();
-  icu::UnicodeString converted;
+  base::SmartArrayPointer<uc16> sap;
+  const UChar* src;
+  Handle<SeqTwoByteString> result =
+      isolate->factory()->NewRawTwoByteString(length).ToHandleChecked();
   {
     DisallowHeapAllocation no_gc;
     DCHECK(s->IsFlat());
     String::FlatContent flat = s->GetFlatContent();
-
-    const UChar* src;
     if (flat.IsOneByte()) {
-      base::SmartArrayPointer<uc16> sap = s->ToWideCString();
+      sap = s->ToWideCString();
       src = reinterpret_cast<const UChar*>(sap.get());
-      converted = icu::UnicodeString(src, length);
     } else {
       src = reinterpret_cast<const UChar*>(flat.ToUC16Vector().start());
-      converted = icu::UnicodeString(src, length);
+    }
+
+    if (V8_LIKELY(locale_id != 1 || !is_to_upper)) {
+      typedef int32_t (*case_conversion_fn)(
+          UChar * dest, int32_t destCapacity, const UChar* src,
+          int32_t srcLength, const char* locale, UErrorCode* pErrorCode);
+      case_conversion_fn fn = is_to_upper ? u_strToUpper : u_strToLower;
+
+      int32_t target_length = length;
+      const char* locale = locale_id == -1 ? "" : conversion_locales[locale_id];
+      UErrorCode error;
+      do {
+        error = U_ZERO_ERROR;
+        target_length = fn(reinterpret_cast<UChar*>(result->GetChars()),
+                           target_length, src, length, locale, &error);
+        result->synchronized_set_length(target_length);

[jungshik at Google, 2016/04/14 07:46:31]

|set_length| is called over |result| ( which is SeqTwoByteString created before
entering the DisallowHeapAllocation block). Would this be problematic? 
In PS#5,  it's inside the DisallowHeapAllocation block. In PS#4, set_length()
was outside the block. 

+      } while (error == U_BUFFER_OVERFLOW_ERROR);
+      return U_SUCCESS(error) ? *result : *s;
     }
   }
 
-  if (locale_id == -1) {
-    LocaleConvertCaseHelper(&converted, is_to_upper, icu::Locale::getRoot());
-  } else if (V8_UNLIKELY(locale_id == 1 && is_to_upper)) {
-    // TODO(jshin): Once http://bugs.icu-project.org/trac/ticket/10582 is
-    // fixed, remove this special-casing for uppercasing in Greek(el) locale.
-    // This is ~500 times slower than using the case conversion API.
-    ConvertCaseWithTransliterator(&converted, "el-Upper");
-  } else {
-    LocaleConvertCaseHelper(&converted, is_to_upper,
-                            icu::Locale(conversion_locales[locale_id]));
-  }
-
-  Handle<String> result;
+  return *s;
+#if 0
+  // For Greek Uppercasing
+  icu::UnicodeString converted(false, src, length);
+  ConvertCaseWithTransliterator(&converted, "el-Upper");
+  Handle<String> greek_result;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
-      isolate, result,
+      isolate, greek_result,
       isolate->factory()->NewStringFromTwoByte(Vector<const uint16_t>(
           reinterpret_cast<const uint16_t*>(converted.getBuffer()),
           converted.length())));
-  return *result;
+  return *greek_result;
+#endif
 }
 
 inline bool IsASCIIUpper(uint16_t ch) { return ch >= 'A' && ch <= 'Z'; }
 
 inline uint16_t ToASCIILower(uint16_t ch) {
   return ch | ((ch >= 'A' && ch <= 'Z') << 5);
 }
 
 inline uint16_t ToASCIIUpper(uint16_t ch) {
   return ch & ~((ch >= 'a' && ch <= 'z') << 5);
@@ skipping 142 matching lines @@
   CONVERT_BOOLEAN_ARG_CHECKED(is_upper, 1);
   CONVERT_NUMBER_CHECKED(int, lang_id, Int32, args[2]);
 
   return LocaleConvertCase(s, isolate, is_upper, lang_id);
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_I18N_SUPPORT