Replace Utf8Value() with a more efficient method

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 41 matching lines @@
     if (dest->is_empty()) {
       dest->Reset(NewArray<uc16>(length));
       CopyChars(dest->get(), flat.ToOneByteVector().start(), length);
     }
     return reinterpret_cast<const UChar*>(dest->get());
   } else {
     return reinterpret_cast<const UChar*>(flat.ToUC16Vector().start());
   }
 }
 
+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) {
   HandleScope scope(isolate);
   Factory* factory = isolate->factory();
 
   DCHECK(args.length() == 1);
-  CONVERT_ARG_HANDLE_CHECKED(String, locale_id_str, 0);
+  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.

 
-  v8::String::Utf8Value locale_id(v8::Utils::ToLocal(locale_id_str));
-
-  // Return value which denotes invalid language tag.
-  const char* const kInvalidTag = "invalid-tag";
-
+  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);
   }
 
   char result[ULOC_FULLNAME_CAPACITY];
 
   // Force strict BCP47 rules.
   uloc_toLanguageTag(icu_result, result, ULOC_FULLNAME_CAPACITY, TRUE, &error);
 
   if (U_FAILURE(error)) {
@@ skipping 79 matching lines @@
   CONVERT_ARG_HANDLE_CHECKED(JSArray, input, 0);
 
   uint32_t length = static_cast<uint32_t>(input->length()->Number());
   // Set some limit to prevent fuzz tests from going OOM.
   // Can be bumped when callers' requirements change.
   RUNTIME_ASSERT(length < 100);
   Handle<FixedArray> output = factory->NewFixedArray(length);
   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.
     // de_DE@collation=phonebook -> de_Latn_DE@collation=phonebook
     char icu_max_locale[ULOC_FULLNAME_CAPACITY];
     uloc_addLikelySubtags(icu_locale, icu_max_locale, ULOC_FULLNAME_CAPACITY,
                           &error);
 
     // Remove extensions from maximized locale.
     // de_Latn_DE@collation=phonebook -> de_Latn_DE
@@ skipping 182 matching lines @@
 
 
 RUNTIME_FUNCTION(Runtime_InternalDateParse) {
   HandleScope scope(isolate);
 
   DCHECK(args.length() == 2);
 
   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(
       isolate, result,
       JSDate::New(isolate->date_function(), isolate->date_function(),
                   static_cast<double>(date)));
   return *result;
 }
 
 
@@ skipping 720 matching lines @@
   // mapping of ASCII range characters are different in those locales.
   // Greek (el) does not require any adjustment, though.
   return LocaleConvertCase(s, isolate, is_upper,
                            reinterpret_cast<const char*>(lang_str));
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_I18N_SUPPORT