Fix JSON.stringifier's slow path wrt external strings.

src/json-stringifier.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 69 matching lines @@
   }
 
   Handle<Object> ApplyToJsonFunction(Handle<Object> object,
                                      Handle<Object> key);
 
   Result SerializeGeneric(Handle<Object> object,
                           Handle<Object> key,
                           bool deferred_comma,
                           bool deferred_key);
 
-  template <typename StringType>
+  template <typename ResultType, typename Char>
   INLINE(static MaybeObject* StringifyString_(Isolate* isolate,
-                                              Handle<String> string,
+                                              Vector<Char> vector,
                                               Handle<String> result));
 
   // Entry point to serialize the object.
   INLINE(Result SerializeObject(Handle<Object> obj)) {
     return Serialize_<false>(obj, false, factory_->empty_string());
   }
 
   // Serialize an array element.
   // The index may serve as argument for the toJSON function.
   INLINE(Result SerializeElement(Isolate* isolate,
@@ skipping 185 matching lines @@
   static const int kJsonQuoteWorstCaseBlowup = 6;
   static const int kSpaceForQuotes = 2;
   int worst_case_length =
       object->length() * kJsonQuoteWorstCaseBlowup + kSpaceForQuotes;
 
   if (worst_case_length > 32 * KB) {  // Slow path if too large.
     BasicJsonStringifier stringifier(isolate);
     return stringifier.Stringify(object);
   }
 
-  object = FlattenGetString(object);
-  if (object->IsSeqOneByteString()) {
+  FlattenString(object);
+  String::FlatContent flat = object->GetFlatContent();
+  if (flat.IsAscii()) {
     return StringifyString_<SeqOneByteString>(
         isolate,
-        object,
+        flat.ToOneByteVector(),
         isolate->factory()->NewRawOneByteString(worst_case_length));
   } else {
     return StringifyString_<SeqTwoByteString>(
         isolate,
-        object,
+        flat.ToUC16Vector(),
         isolate->factory()->NewRawTwoByteString(worst_case_length));
   }
 }
 
 
-template <typename StringType>
+template <typename ResultType, typename Char>
 MaybeObject* BasicJsonStringifier::StringifyString_(Isolate* isolate,
-                                                    Handle<String> string,
+                                                    Vector<Char> vector,
                                                     Handle<String> result) {
   AssertNoAllocation no_allocation;
   int final_size = 0;
-  StringType* dest = StringType::cast(*result);
+  ResultType* dest = ResultType::cast(*result);
   dest->Set(final_size++, '\"');
-  final_size += SerializeStringUnchecked_(StringType::cast(*string)->GetChars(),
+  final_size += SerializeStringUnchecked_(vector.start(),
                                           dest->GetChars() + 1,
-                                          string->length());
+                                          vector.length());
   dest->Set(final_size++, '\"');
   if (isolate->heap()->InNewSpace(*result)) {
     // In new space, simply lower the allocation top to fit the actual size.
-    isolate->heap()->new_space()->ShrinkStringAtAllocationBoundary<StringType>(
+    isolate->heap()->new_space()->ShrinkStringAtAllocationBoundary<ResultType>(
         *result, final_size);
     return *result;
   } else {
     // Not in new space, need to fill the wasted space with filler objects.
     return SeqString::cast(*result)->Truncate(final_size);
   }
 }
 
 
 template <bool is_ascii, typename Char>
@@ skipping 502 matching lines @@
       SerializeString_<false, uint8_t>(object);
     } else {
       SerializeString_<false, uc16>(object);
     }
   }
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_JSON_STRINGIFIER_H_