Replace Utf8Value() with a more efficient method

src/runtime/runtime-i18n.cc

Index: src/runtime/runtime-i18n.cc
diff --git a/src/runtime/runtime-i18n.cc b/src/runtime/runtime-i18n.cc
index 14974e8ac44195fcd90b7d133d3d50e439bfb7b7..72381877d726c427bf230beb7e479a9fd21b8ce5 100644
--- a/src/runtime/runtime-i18n.cc
+++ b/src/runtime/runtime-i18n.cc
@@ -59,6 +59,20 @@ const UChar* GetUCharBufferFromFlat(const String::FlatContent& flat,
   }
 }
 
+base::SmartArrayPointer<char> GetAsciiCString(Handle<String> src) {
+  String::FlatContent flat = src->GetFlatContent();
+  DCHECK(flat.IsFlat());
+  int length = src->length();
+  char* dest = NewArray<char>(length + 1);
+  if (flat.IsOneByte()) {
+    CopyChars(dest, flat.ToOneByteVector().start(), length);
+  } else {
+    CopyChars(dest, flat.ToUC16Vector().start(), length);

[Yang, 2016/05/30 11:01:49]

Do we not care about clamping uc16 characters to char? This could give false
positives. For example "\uAB64\uAB65-DE" would result in the same as "de-DE".

+  }
+  dest[length] = 0;
+  return base::SmartArrayPointer<char>(dest);
+}
+
 }  // namespace
 
 RUNTIME_FUNCTION(Runtime_CanonicalizeLanguageTag) {
@@ -66,19 +80,21 @@ RUNTIME_FUNCTION(Runtime_CanonicalizeLanguageTag) {
   Factory* factory = isolate->factory();
 
   DCHECK(args.length() == 1);
-  CONVERT_ARG_HANDLE_CHECKED(String, locale_id_str, 0);
-
-  v8::String::Utf8Value locale_id(v8::Utils::ToLocal(locale_id_str));
-
-  // Return value which denotes invalid language tag.
-  const char* const kInvalidTag = "invalid-tag";
+  CONVERT_ARG_HANDLE_CHECKED(String, tag, 0);
+  // CONVERT_ARG_HANDLE_CHECKED(SeqOneByteString, locale_id_str, 0);

[Yang, 2016/05/30 11:01:49]

Please remove this line.

 
+  tag = String::Flatten(tag);
   UErrorCode error = U_ZERO_ERROR;
   char icu_result[ULOC_FULLNAME_CAPACITY];
   int icu_length = 0;
-
-  uloc_forLanguageTag(*locale_id, icu_result, ULOC_FULLNAME_CAPACITY,
-                      &icu_length, &error);
+  {
+    DisallowHeapAllocation no_gc;
+    base::SmartArrayPointer<char> locale_id = GetAsciiCString(tag);
+    uloc_forLanguageTag(locale_id.get(), icu_result, ULOC_FULLNAME_CAPACITY,
+                        &icu_length, &error);
+  }
+  // Return value which denotes invalid language tag.
+  const char* const kInvalidTag = "invalid-tag";
   if (U_FAILURE(error) || icu_length == 0) {
     return *factory->NewStringFromAsciiChecked(kInvalidTag);
   }
@@ -178,26 +194,29 @@ RUNTIME_FUNCTION(Runtime_GetLanguageTagVariants) {
   Handle<Name> maximized = factory->NewStringFromStaticChars("maximized");
   Handle<Name> base = factory->NewStringFromStaticChars("base");
   for (unsigned int i = 0; i < length; ++i) {
-    Handle<Object> locale_id;
+    Handle<Object> entry;
     ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
-        isolate, locale_id, JSReceiver::GetElement(isolate, input, i));
-    if (!locale_id->IsString()) {
+        isolate, entry, JSReceiver::GetElement(isolate, input, i));
+    if (!entry->IsString()) {
       return isolate->Throw(*factory->illegal_argument_string());
     }
 
-    v8::String::Utf8Value utf8_locale_id(
-        v8::Utils::ToLocal(Handle<String>::cast(locale_id)));
-
-    UErrorCode error = U_ZERO_ERROR;
+    Handle<String> locale_id = String::Flatten(Handle<String>::cast(entry));
 
     // Convert from BCP47 to ICU format.
     // de-DE-u-co-phonebk -> de_DE@collation=phonebook
     char icu_locale[ULOC_FULLNAME_CAPACITY];
     int icu_locale_length = 0;
-    uloc_forLanguageTag(*utf8_locale_id, icu_locale, ULOC_FULLNAME_CAPACITY,
-                        &icu_locale_length, &error);
-    if (U_FAILURE(error) || icu_locale_length == 0) {
-      return isolate->Throw(*factory->illegal_argument_string());
+    UErrorCode error = U_ZERO_ERROR;
+    {
+      DisallowHeapAllocation no_gc;
+      base::SmartArrayPointer<char> input_locale = GetAsciiCString(locale_id);
+
+      uloc_forLanguageTag(input_locale.get(), icu_locale,
+                          ULOC_FULLNAME_CAPACITY, &icu_locale_length, &error);
+      if (U_FAILURE(error) || icu_locale_length == 0) {
+        return isolate->Throw(*factory->illegal_argument_string());
+      }
     }
 
     // Maximize the locale.
@@ -400,15 +419,22 @@ RUNTIME_FUNCTION(Runtime_InternalDateParse) {
   CONVERT_ARG_HANDLE_CHECKED(JSObject, date_format_holder, 0);
   CONVERT_ARG_HANDLE_CHECKED(String, date_string, 1);
 
-  v8::String::Utf8Value utf8_date(v8::Utils::ToLocal(date_string));
-  icu::UnicodeString u_date(icu::UnicodeString::fromUTF8(*utf8_date));
   icu::SimpleDateFormat* date_format =
       DateFormat::UnpackDateFormat(isolate, date_format_holder);
   if (!date_format) return isolate->ThrowIllegalOperation();
-
-  UErrorCode status = U_ZERO_ERROR;
-  UDate date = date_format->parse(u_date, status);
-  if (U_FAILURE(status)) return isolate->heap()->undefined_value();
+  date_string = String::Flatten(date_string);
+  UDate date;
+  {
+    DisallowHeapAllocation no_gc;
+    String::FlatContent flat = date_string->GetFlatContent();
+    base::SmartArrayPointer<uc16> sap;
+    int length = date_string->length();
+    icu::UnicodeString u_date(false, GetUCharBufferFromFlat(flat, &sap, length),
+                              length);
+    UErrorCode status = U_ZERO_ERROR;
+    date = date_format->parse(u_date, status);
+    if (U_FAILURE(status)) return isolate->heap()->undefined_value();
+  }
 
   Handle<JSDate> result;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(