Fix JSON stringify.

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 118 matching lines @@
   Result SerializeJSArraySlow(Handle<JSArray> object, int length);
 
   void SerializeString(Handle<String> object);
 
   template <typename SrcChar, typename DestChar>
   INLINE(void SerializeStringUnchecked_(const SrcChar* src,
                                         DestChar* dest,
                                         int length));
 
   template <bool is_ascii, typename Char>
-  INLINE(void SerializeString_(Vector<const Char> vector,
-                               Handle<String> string));
+  INLINE(void SerializeString_(Handle<String> string));
 
   template <typename Char>
   INLINE(bool DoNotEscape(Char c));
 
   template <typename Char>
   INLINE(Vector<const Char> GetCharVector(Handle<String> string));
 
   Result StackPush(Handle<Object> object);
   void StackPop();
 
@@ skipping 517 matching lines @@
       const char* chars = &JsonEscapeTable[c * kJsonEscapeTableEntrySize];
       while (*chars != '\0') *(dest++) = *(chars++);
     }
   }
 
   current_index_ += static_cast<int>(dest - dest_start);
 }
 
 
 template <bool is_ascii, typename Char>
-void BasicJsonStringifier::SerializeString_(Vector<const Char> vector,
-                                            Handle<String> string) {
-  int length = vector.length();
+void BasicJsonStringifier::SerializeString_(Handle<String> string) {
+  int length = string->length();
   Append_<is_ascii, char>('"');
   // We make a rough estimate to find out if the current string can be
   // serialized without allocating a new string part. The worst case length of
   // an escaped character is 6.  Shifting the remainin string length right by 3
   // is a more pessimistic estimate, but faster to calculate.
 
   if (((part_length_ - current_index_) >> 3) > length) {
+    AssertNoAllocation no_allocation;
+    Vector<const Char> vector = GetCharVector<Char>(string);
     if (is_ascii) {
       SerializeStringUnchecked_(
           vector.start(),
           SeqOneByteString::cast(*current_part_)->GetChars(),
           length);
     } else {
       SerializeStringUnchecked_(
           vector.start(),
           SeqTwoByteString::cast(*current_part_)->GetChars(),
           length);
     }
   } else {
     String* string_location = *string;
+    Vector<const Char> vector = GetCharVector<Char>(string);
     for (int i = 0; i < length; i++) {
       Char c = vector[i];
       if (DoNotEscape(c)) {
         Append_<is_ascii, Char>(c);
       } else {
         Append_<is_ascii, char>(
             &JsonEscapeTable[c * kJsonEscapeTableEntrySize]);
       }
       // If GC moved the string, we need to refresh the vector.
       if (*string != string_location) {
@@ skipping 33 matching lines @@
   ASSERT(flat.IsTwoByte());
   return flat.ToUC16Vector();
 }
 
 
 void BasicJsonStringifier::SerializeString(Handle<String> object) {
   FlattenString(object);
   String::FlatContent flat = object->GetFlatContent();
   if (is_ascii_) {
     if (flat.IsAscii()) {
-      SerializeString_<true, char>(flat.ToAsciiVector(), object);
+      SerializeString_<true, char>(object);
     } else {
       ChangeEncoding();
       SerializeString(object);
     }
   } else {
     if (flat.IsAscii()) {
-      SerializeString_<false, char>(flat.ToAsciiVector(), object);
+      SerializeString_<false, char>(object);
     } else {
-      SerializeString_<false, uc16>(flat.ToUC16Vector(), object);
+      SerializeString_<false, uc16>(object);
     }
   }
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_JSON_STRINGIFIER_H_