[json] support replacer function in BasicJsonStringifier.

src/json-stringifier.cc

 // Copyright 2016 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.
 
 #include "src/json-stringifier.h"
 
 #include "src/conversions.h"
 #include "src/lookup.h"
 #include "src/messages.h"
 #include "src/objects-inl.h"
 #include "src/utils.h"
 
 namespace v8 {
 namespace internal {
 
 // Translation table to escape Latin1 characters.
 // Table entries start at a multiple of 8 and are null-terminated.
-const char* const BasicJsonStringifier::JsonEscapeTable =
+const char* const JsonStringifier::JsonEscapeTable =
     "\\u0000\0 \\u0001\0 \\u0002\0 \\u0003\0 "
     "\\u0004\0 \\u0005\0 \\u0006\0 \\u0007\0 "
     "\\b\0     \\t\0     \\n\0     \\u000b\0 "
     "\\f\0     \\r\0     \\u000e\0 \\u000f\0 "
     "\\u0010\0 \\u0011\0 \\u0012\0 \\u0013\0 "
     "\\u0014\0 \\u0015\0 \\u0016\0 \\u0017\0 "
     "\\u0018\0 \\u0019\0 \\u001a\0 \\u001b\0 "
     "\\u001c\0 \\u001d\0 \\u001e\0 \\u001f\0 "
     " \0      !\0      \\\"\0     #\0      "
     "$\0      %\0      &\0      '\0      "
@@ skipping 45 matching lines @@
     "\334\0      \335\0      \336\0      \337\0      "
     "\340\0      \341\0      \342\0      \343\0      "
     "\344\0      \345\0      \346\0      \347\0      "
     "\350\0      \351\0      \352\0      \353\0      "
     "\354\0      \355\0      \356\0      \357\0      "
     "\360\0      \361\0      \362\0      \363\0      "
     "\364\0      \365\0      \366\0      \367\0      "
     "\370\0      \371\0      \372\0      \373\0      "
     "\374\0      \375\0      \376\0      \377\0      ";
 
-BasicJsonStringifier::BasicJsonStringifier(Isolate* isolate)
+JsonStringifier::JsonStringifier(Isolate* isolate)
     : isolate_(isolate), builder_(isolate), gap_(nullptr), indent_(0) {
   tojson_string_ = factory()->toJSON_string();
   stack_ = factory()->NewJSArray(8);
 }
 
-MaybeHandle<Object> BasicJsonStringifier::Stringify(Handle<Object> object,
-                                                    Handle<Object> replacer,
-                                                    Handle<Object> gap) {
+MaybeHandle<Object> JsonStringifier::Stringify(Handle<Object> object,
+                                               Handle<Object> replacer,
+                                               Handle<Object> gap) {
   if (!InitializeReplacer(replacer)) return MaybeHandle<Object>();
   if (!gap->IsUndefined() && !InitializeGap(gap)) return MaybeHandle<Object>();
   Result result = SerializeObject(object);
   if (result == UNCHANGED) return factory()->undefined_value();
   if (result == SUCCESS) return builder_.Finish();
   DCHECK(result == EXCEPTION);
   return MaybeHandle<Object>();
 }
 
 bool IsInList(Handle<String> key, List<Handle<String> >* list) {
   // TODO(yangguo): This is O(n^2) for n properties in the list. Deal with this
   // if this becomes an issue.
   for (const Handle<String>& existing : *list) {
     if (String::Equals(existing, key)) return true;
   }
   return false;
 }
 
-bool BasicJsonStringifier::InitializeReplacer(Handle<Object> replacer) {
+bool JsonStringifier::InitializeReplacer(Handle<Object> replacer) {
   DCHECK(property_list_.is_null());
+  DCHECK(replacer_function_.is_null());
   Maybe<bool> is_array = Object::IsArray(replacer);
   if (is_array.IsNothing()) return false;
   if (is_array.FromJust()) {
     HandleScope handle_scope(isolate_);
     List<Handle<String> > list;
     Handle<Object> length_obj;
     ASSIGN_RETURN_ON_EXCEPTION_VALUE(
         isolate_, length_obj,
         Object::GetLengthFromArrayLike(isolate_, replacer), false);
     uint32_t length;
@@ skipping 14 matching lines @@
         }
       }
       if (key.is_null()) continue;
       if (!IsInList(key, &list)) list.Add(key);
     }
     property_list_ = factory()->NewUninitializedFixedArray(list.length());
     for (int i = 0; i < list.length(); i++) {
       property_list_->set(i, *list[i]);
     }
     property_list_ = handle_scope.CloseAndEscape(property_list_);
+  } else if (replacer->IsCallable()) {
+    replacer_function_ = Handle<JSReceiver>::cast(replacer);
   }
   return true;
 }
 
-bool BasicJsonStringifier::InitializeGap(Handle<Object> gap) {
+bool JsonStringifier::InitializeGap(Handle<Object> gap) {
   DCHECK_NULL(gap_);
   HandleScope scope(isolate_);
   if (gap->IsJSValue()) {
     Handle<Object> value(Handle<JSValue>::cast(gap)->value(), isolate_);
     if (value->IsString()) {
       ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate_, gap,
                                        Object::ToString(isolate_, gap), false);
     } else if (value->IsNumber()) {
       ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate_, gap, Object::ToNumber(gap),
                                        false);
@@ skipping 19 matching lines @@
     if (num_value > 0) {
       int gap_length = std::min(num_value, 10);
       gap_ = NewArray<uc16>(gap_length + 1);
       for (int i = 0; i < gap_length; i++) gap_[i] = ' ';
       gap_[gap_length] = '\0';
     }
   }
   return true;
 }
 
-MaybeHandle<Object> BasicJsonStringifier::StringifyString(
-    Isolate* isolate, Handle<String> object) {
-  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);
-    Handle<Object> undefined = isolate->factory()->undefined_value();
-    return stringifier.Stringify(object, undefined, undefined);
-  }
-
-  object = String::Flatten(object);
-  DCHECK(object->IsFlat());
-  Handle<SeqString> result;
-  if (object->IsOneByteRepresentationUnderneath()) {
-    result = isolate->factory()
-                 ->NewRawOneByteString(worst_case_length)
-                 .ToHandleChecked();
-    IncrementalStringBuilder::NoExtendString<uint8_t> no_extend(
-        result, worst_case_length);
-    no_extend.Append('\"');
-    SerializeStringUnchecked_(object->GetFlatContent().ToOneByteVector(),
-                              &no_extend);
-    no_extend.Append('\"');
-    return no_extend.Finalize();
-  } else {
-    result = isolate->factory()
-                 ->NewRawTwoByteString(worst_case_length)
-                 .ToHandleChecked();
-    IncrementalStringBuilder::NoExtendString<uc16> no_extend(result,
-                                                             worst_case_length);
-    no_extend.Append('\"');
-    SerializeStringUnchecked_(object->GetFlatContent().ToUC16Vector(),
-                              &no_extend);
-    no_extend.Append('\"');
-    return no_extend.Finalize();
-  }
-}
-
-MaybeHandle<Object> BasicJsonStringifier::ApplyToJsonFunction(
-    Handle<Object> object, Handle<Object> key) {
+MaybeHandle<Object> JsonStringifier::ApplyToJsonFunction(Handle<Object> object,
+                                                         Handle<Object> key) {
+  HandleScope scope(isolate_);
   LookupIterator it(object, tojson_string_,
                     LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR);
   Handle<Object> fun;
   ASSIGN_RETURN_ON_EXCEPTION(isolate_, fun, Object::GetProperty(&it), Object);
   if (!fun->IsCallable()) return object;
 
   // Call toJSON function.
   if (key->IsSmi()) key = factory()->NumberToString(key);
   Handle<Object> argv[] = {key};
-  HandleScope scope(isolate_);
   ASSIGN_RETURN_ON_EXCEPTION(isolate_, object,
                              Execution::Call(isolate_, fun, object, 1, argv),
                              Object);
   return scope.CloseAndEscape(object);
 }
 
-BasicJsonStringifier::Result BasicJsonStringifier::StackPush(
-    Handle<Object> object) {
+MaybeHandle<Object> JsonStringifier::ApplyReplacerFunction(
+    Handle<Object> object, Handle<Object> key) {
+  HandleScope scope(isolate_);
+  if (key->IsSmi()) key = factory()->NumberToString(key);
+  Handle<Object> argv[] = {key, object};
+  Handle<JSReceiver> holder = CurrentHolder(object);
+  ASSIGN_RETURN_ON_EXCEPTION(
+      isolate_, object,
+      Execution::Call(isolate_, replacer_function_, holder, 2, argv), Object);
+  return scope.CloseAndEscape(object);
+}
+
+Handle<JSReceiver> JsonStringifier::CurrentHolder(Handle<Object> value) {
+  int length = Smi::cast(stack_->length())->value();
+  if (length == 0) {
+    Handle<JSObject> holder =
+        factory()->NewJSObject(isolate_->object_function());
+    JSObject::AddProperty(holder, factory()->empty_string(), value, NONE);
+    return holder;
+  } else {
+    FixedArray* elements = FixedArray::cast(stack_->elements());
+    return Handle<JSReceiver>(JSReceiver::cast(elements->get(length - 1)),
+                              isolate_);
+  }
+}
+
+JsonStringifier::Result JsonStringifier::StackPush(Handle<Object> object) {
   StackLimitCheck check(isolate_);
   if (check.HasOverflowed()) {
     isolate_->StackOverflow();
     return EXCEPTION;
   }
 
   int length = Smi::cast(stack_->length())->value();
   {
     DisallowHeapAllocation no_allocation;
     FixedArray* elements = FixedArray::cast(stack_->elements());
     for (int i = 0; i < length; i++) {
       if (elements->get(i) == *object) {
         AllowHeapAllocation allow_to_return_error;
         Handle<Object> error =
             factory()->NewTypeError(MessageTemplate::kCircularStructure);
         isolate_->Throw(*error);
         return EXCEPTION;
       }
     }
   }
   JSArray::SetLength(stack_, length + 1);
   FixedArray::cast(stack_->elements())->set(length, *object);
   return SUCCESS;
 }
 
-void BasicJsonStringifier::StackPop() {
+void JsonStringifier::StackPop() {
   int length = Smi::cast(stack_->length())->value();
   stack_->set_length(Smi::FromInt(length - 1));
 }
 
 template <bool deferred_string_key>
-BasicJsonStringifier::Result BasicJsonStringifier::Serialize_(
-    Handle<Object> object, bool comma, Handle<Object> key) {
+JsonStringifier::Result JsonStringifier::Serialize_(Handle<Object> object,
+                                                    bool comma,
+                                                    Handle<Object> key) {
   if (object->IsJSReceiver()) {
     ASSIGN_RETURN_ON_EXCEPTION_VALUE(
         isolate_, object, ApplyToJsonFunction(object, key), EXCEPTION);
   }
+  if (!replacer_function_.is_null()) {
+    ASSIGN_RETURN_ON_EXCEPTION_VALUE(
+        isolate_, object, ApplyReplacerFunction(object, key), EXCEPTION);
+  }
 
   if (object->IsSmi()) {
     if (deferred_string_key) SerializeDeferredKey(comma, key);
     return SerializeSmi(Smi::cast(*object));
   }
 
   switch (HeapObject::cast(*object)->map()->instance_type()) {
     case HEAP_NUMBER_TYPE:
     case MUTABLE_HEAP_NUMBER_TYPE:
       if (deferred_string_key) SerializeDeferredKey(comma, key);
@@ skipping 38 matching lines @@
           return SerializeJSProxy(Handle<JSProxy>::cast(object));
         }
         return SerializeJSObject(Handle<JSObject>::cast(object));
       }
   }
 
   UNREACHABLE();
   return UNCHANGED;
 }
 
-BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSValue(
+JsonStringifier::Result JsonStringifier::SerializeJSValue(
     Handle<JSValue> object) {
   String* class_name = object->class_name();
   if (class_name == isolate_->heap()->String_string()) {
     Handle<Object> value;
     ASSIGN_RETURN_ON_EXCEPTION_VALUE(
         isolate_, value, Object::ToString(isolate_, object), EXCEPTION);
     SerializeString(Handle<String>::cast(value));
   } else if (class_name == isolate_->heap()->Number_string()) {
     Handle<Object> value;
     ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate_, value, Object::ToNumber(object),
                                      EXCEPTION);
     if (value->IsSmi()) return SerializeSmi(Smi::cast(*value));
     SerializeHeapNumber(Handle<HeapNumber>::cast(value));
   } else if (class_name == isolate_->heap()->Boolean_string()) {
     Object* value = JSValue::cast(*object)->value();
     DCHECK(value->IsBoolean());
     builder_.AppendCString(value->IsTrue() ? "true" : "false");
   } else {
     // ES6 24.3.2.1 step 10.c, serialize as an ordinary JSObject.
     return SerializeJSObject(object);
   }
   return SUCCESS;
 }
 
-BasicJsonStringifier::Result BasicJsonStringifier::SerializeSmi(Smi* object) {
+JsonStringifier::Result JsonStringifier::SerializeSmi(Smi* object) {
   static const int kBufferSize = 100;
   char chars[kBufferSize];
   Vector<char> buffer(chars, kBufferSize);
   builder_.AppendCString(IntToCString(object->value(), buffer));
   return SUCCESS;
 }
 
-BasicJsonStringifier::Result BasicJsonStringifier::SerializeDouble(
-    double number) {
+JsonStringifier::Result JsonStringifier::SerializeDouble(double number) {
   if (std::isinf(number) || std::isnan(number)) {
     builder_.AppendCString("null");
     return SUCCESS;
   }
   static const int kBufferSize = 100;
   char chars[kBufferSize];
   Vector<char> buffer(chars, kBufferSize);
   builder_.AppendCString(DoubleToCString(number, buffer));
   return SUCCESS;
 }
 
-BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSArray(
+JsonStringifier::Result JsonStringifier::SerializeJSArray(
     Handle<JSArray> object) {
   HandleScope handle_scope(isolate_);
   Result stack_push = StackPush(object);
   if (stack_push != SUCCESS) return stack_push;
   uint32_t length = 0;
   CHECK(object->length()->ToArrayLength(&length));
   DCHECK(!object->IsAccessCheckNeeded());
   builder_.AppendCharacter('[');
   Indent();
-  switch (object->GetElementsKind()) {
-    case FAST_SMI_ELEMENTS: {
-      Handle<FixedArray> elements(FixedArray::cast(object->elements()),
-                                  isolate_);
-      for (uint32_t i = 0; i < length; i++) {
-        Separator(i == 0);
-        SerializeSmi(Smi::cast(elements->get(i)));
+  uint32_t i = 0;
+  if (replacer_function_.is_null()) {
+    switch (object->GetElementsKind()) {
+      case FAST_SMI_ELEMENTS: {
+        Handle<FixedArray> elements(FixedArray::cast(object->elements()),
+                                    isolate_);
+        while (i < length) {
+          Separator(i == 0);
+          SerializeSmi(Smi::cast(elements->get(i)));
+          i++;
+        }
+        break;
       }
-      break;
+      case FAST_DOUBLE_ELEMENTS: {
+        // Empty array is FixedArray but not FixedDoubleArray.
+        if (length == 0) break;
+        Handle<FixedDoubleArray> elements(
+            FixedDoubleArray::cast(object->elements()), isolate_);
+        while (i < length) {
+          Separator(i == 0);
+          SerializeDouble(elements->get_scalar(i));
+          i++;
+        }
+        break;
+      }
+      case FAST_ELEMENTS: {
+        Handle<Object> old_length(object->length(), isolate_);
+        while (i < length) {
+          if (object->length() != *old_length ||
+              object->GetElementsKind() != FAST_ELEMENTS) {
+            // Fall back to slow path.
+            break;
+          }
+          Separator(i == 0);
+          Result result = SerializeElement(
+              isolate_,
+              Handle<Object>(FixedArray::cast(object->elements())->get(i),
+                             isolate_),
+              i);
+          if (result == UNCHANGED) {
+            builder_.AppendCString("null");
+          } else if (result != SUCCESS) {
+            return result;
+          }
+          i++;
+        }
+        break;
+      }
+      // The FAST_HOLEY_* cases could be handled in a faster way. They resemble
+      // the non-holey cases except that a lookup is necessary for holes.
+      default:
+        break;
     }
-    case FAST_DOUBLE_ELEMENTS: {
-      // Empty array is FixedArray but not FixedDoubleArray.
-      if (length == 0) break;
-      Handle<FixedDoubleArray> elements(
-          FixedDoubleArray::cast(object->elements()), isolate_);
-      for (uint32_t i = 0; i < length; i++) {
-        Separator(i == 0);
-        SerializeDouble(elements->get_scalar(i));
-      }
-      break;
-    }
-    case FAST_ELEMENTS: {
-      Handle<Object> old_length(object->length(), isolate_);
-      for (uint32_t i = 0; i < length; i++) {
-        if (object->length() != *old_length ||
-            object->GetElementsKind() != FAST_ELEMENTS) {
-          Result result = SerializeArrayLikeSlow(object, i, length);
-          if (result != SUCCESS) return result;
-          break;
-        }
-        Separator(i == 0);
-        Result result = SerializeElement(
-            isolate_,
-            Handle<Object>(FixedArray::cast(object->elements())->get(i),
-                           isolate_),
-            i);
-        if (result == SUCCESS) continue;
-        if (result == UNCHANGED) {
-          builder_.AppendCString("null");
-        } else {
-          return result;
-        }
-      }
-      break;
-    }
-    // The FAST_HOLEY_* cases could be handled in a faster way. They resemble
-    // the non-holey cases except that a lookup is necessary for holes.
-    default: {
-      Result result = SerializeArrayLikeSlow(object, 0, length);
-      if (result != SUCCESS) return result;
-      break;
-    }
+  }
+  if (i < length) {
+    // Slow path for non-fast elements and fall-back in edge case.
+    Result result = SerializeArrayLikeSlow(object, i, length);
+    if (result != SUCCESS) return result;
   }
   Unindent();
   if (length > 0) NewLine();
   builder_.AppendCharacter(']');
   StackPop();
   return SUCCESS;
 }
 
-BasicJsonStringifier::Result BasicJsonStringifier::SerializeArrayLikeSlow(
+JsonStringifier::Result JsonStringifier::SerializeArrayLikeSlow(
     Handle<JSReceiver> object, uint32_t start, uint32_t length) {
   for (uint32_t i = start; i < length; i++) {
     Separator(i == 0);
     Handle<Object> element;
     ASSIGN_RETURN_ON_EXCEPTION_VALUE(
         isolate_, element, JSReceiver::GetElement(isolate_, object, i),
         EXCEPTION);
-    if (element->IsUndefined()) {
+    Result result = SerializeElement(isolate_, element, i);
+    if (result == SUCCESS) continue;
+    if (result == UNCHANGED) {
       builder_.AppendCString("null");
     } else {
-      Result result = SerializeElement(isolate_, element, i);
-      if (result == SUCCESS) continue;
-      if (result == UNCHANGED) {
-        builder_.AppendCString("null");
-      } else {
-        return result;
-      }
+      return result;
     }
   }
   return SUCCESS;
 }
 
-BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSObject(
+JsonStringifier::Result JsonStringifier::SerializeJSObject(
     Handle<JSObject> object) {
   HandleScope handle_scope(isolate_);
   Result stack_push = StackPush(object);
   if (stack_push != SUCCESS) return stack_push;
 
   if (property_list_.is_null() &&
       object->map()->instance_type() > LAST_CUSTOM_ELEMENTS_RECEIVER &&
       object->HasFastProperties() &&
       Handle<JSObject>::cast(object)->elements()->length() == 0) {
     DCHECK(object->IsJSObject());
     DCHECK(!object->IsJSGlobalProxy());
     Handle<JSObject> js_obj = Handle<JSObject>::cast(object);
     DCHECK(!js_obj->HasIndexedInterceptor());
     DCHECK(!js_obj->HasNamedInterceptor());
     Handle<Map> map(js_obj->map());
     builder_.AppendCharacter('{');
     Indent();
     bool comma = false;
     for (int i = 0; i < map->NumberOfOwnDescriptors(); i++) {
       Handle<Name> name(map->instance_descriptors()->GetKey(i), isolate_);
       // TODO(rossberg): Should this throw?
       if (!name->IsString()) continue;
       Handle<String> key = Handle<String>::cast(name);
       PropertyDetails details = map->instance_descriptors()->GetDetails(i);
       if (details.IsDontEnum()) continue;
       Handle<Object> property;
       if (details.type() == DATA && *map == js_obj->map()) {
         FieldIndex field_index = FieldIndex::ForDescriptor(*map, i);
-        if (js_obj->IsUnboxedDoubleField(field_index)) {
-          double value = js_obj->RawFastDoublePropertyAt(field_index);
-          property = isolate_->factory()->NewHeapNumber(value);
-        } else {
-          property = handle(js_obj->RawFastPropertyAt(field_index), isolate_);
-        }
+        property = JSObject::FastPropertyAt(js_obj, details.representation(),
+                                            field_index);
       } else {
         ASSIGN_RETURN_ON_EXCEPTION_VALUE(
             isolate_, property, Object::GetPropertyOrElement(js_obj, key),
             EXCEPTION);
       }
       Result result = SerializeProperty(property, comma, key);
       if (!comma && result == SUCCESS) comma = true;
       if (result == EXCEPTION) return result;
     }
     Unindent();
     if (comma) NewLine();
     builder_.AppendCharacter('}');
   } else {
     Result result = SerializeJSReceiverSlow(object);
     if (result != SUCCESS) return result;
   }
   StackPop();
   return SUCCESS;
 }
 
-BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSReceiverSlow(
+JsonStringifier::Result JsonStringifier::SerializeJSReceiverSlow(
     Handle<JSReceiver> object) {
   Handle<FixedArray> contents = property_list_;
   if (contents.is_null()) {
     ASSIGN_RETURN_ON_EXCEPTION_VALUE(
         isolate_, contents,
         KeyAccumulator::GetKeys(object, OWN_ONLY, ENUMERABLE_STRINGS),
         EXCEPTION);
   }
   builder_.AppendCharacter('{');
   Indent();
@@ skipping 21 matching lines @@
     Result result = SerializeProperty(property, comma, key_handle);
     if (!comma && result == SUCCESS) comma = true;
     if (result == EXCEPTION) return result;
   }
   Unindent();
   if (comma) NewLine();
   builder_.AppendCharacter('}');
   return SUCCESS;
 }
 
-BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSProxy(
+JsonStringifier::Result JsonStringifier::SerializeJSProxy(
     Handle<JSProxy> object) {
   Result stack_push = StackPush(object);
   if (stack_push != SUCCESS) return stack_push;
   Maybe<bool> is_array = Object::IsArray(object);
   if (is_array.IsNothing()) return EXCEPTION;
   if (is_array.FromJust()) {
     Handle<Object> length_object;
     ASSIGN_RETURN_ON_EXCEPTION_VALUE(
         isolate_, length_object,
         Object::GetLengthFromArrayLike(isolate_, object), EXCEPTION);
@@ skipping 14 matching lines @@
     builder_.AppendCharacter(']');
   } else {
     Result result = SerializeJSReceiverSlow(object);
     if (result != SUCCESS) return result;
   }
   StackPop();
   return SUCCESS;
 }
 
 template <typename SrcChar, typename DestChar>
-void BasicJsonStringifier::SerializeStringUnchecked_(
+void JsonStringifier::SerializeStringUnchecked_(
     Vector<const SrcChar> src,
     IncrementalStringBuilder::NoExtend<DestChar>* dest) {
   // Assert that uc16 character is not truncated down to 8 bit.
   // The <uc16, char> version of this method must not be called.
   DCHECK(sizeof(DestChar) >= sizeof(SrcChar));
 
   for (int i = 0; i < src.length(); i++) {
     SrcChar c = src[i];
     if (DoNotEscape(c)) {
       dest->Append(c);
     } else {
       dest->AppendCString(&JsonEscapeTable[c * kJsonEscapeTableEntrySize]);
     }
   }
 }
 
 template <typename SrcChar, typename DestChar>
-void BasicJsonStringifier::SerializeString_(Handle<String> string) {
+void JsonStringifier::SerializeString_(Handle<String> string) {
   int length = string->length();
   builder_.Append<uint8_t, DestChar>('"');
   // 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.
   int worst_case_length = length << 3;
   if (builder_.CurrentPartCanFit(worst_case_length)) {
     DisallowHeapAllocation no_gc;
     Vector<const SrcChar> vector = string->GetCharVector<SrcChar>();
     IncrementalStringBuilder::NoExtendBuilder<DestChar> no_extend(
         &builder_, worst_case_length);
     SerializeStringUnchecked_(vector, &no_extend);
   } else {
     FlatStringReader reader(isolate_, string);
     for (int i = 0; i < reader.length(); i++) {
       SrcChar c = reader.Get<SrcChar>(i);
       if (DoNotEscape(c)) {
         builder_.Append<SrcChar, DestChar>(c);
       } else {
         builder_.AppendCString(&JsonEscapeTable[c * kJsonEscapeTableEntrySize]);
       }
     }
   }
 
   builder_.Append<uint8_t, DestChar>('"');
 }
 
 template <>
-bool BasicJsonStringifier::DoNotEscape(uint8_t c) {
+bool JsonStringifier::DoNotEscape(uint8_t c) {
   return c >= '#' && c <= '~' && c != '\\';
 }
 
 template <>
-bool BasicJsonStringifier::DoNotEscape(uint16_t c) {
+bool JsonStringifier::DoNotEscape(uint16_t c) {
   return c >= '#' && c != '\\' && c != 0x7f;
 }
 
-void BasicJsonStringifier::NewLine() {
+void JsonStringifier::NewLine() {
   if (gap_ == nullptr) return;
   builder_.AppendCharacter('\n');
   for (int i = 0; i < indent_; i++) builder_.AppendCString(gap_);
 }
 
-void BasicJsonStringifier::Separator(bool first) {
+void JsonStringifier::Separator(bool first) {
   if (!first) builder_.AppendCharacter(',');
   NewLine();
 }
 
-void BasicJsonStringifier::SerializeDeferredKey(bool deferred_comma,
-                                                Handle<Object> deferred_key) {
+void JsonStringifier::SerializeDeferredKey(bool deferred_comma,
+                                           Handle<Object> deferred_key) {
   Separator(!deferred_comma);
   SerializeString(Handle<String>::cast(deferred_key));
   builder_.AppendCharacter(':');
   if (gap_ != nullptr) builder_.AppendCharacter(' ');
 }
 
-void BasicJsonStringifier::SerializeString(Handle<String> object) {
+void JsonStringifier::SerializeString(Handle<String> object) {
   object = String::Flatten(object);
   if (builder_.CurrentEncoding() == String::ONE_BYTE_ENCODING) {
     if (object->IsOneByteRepresentationUnderneath()) {
       SerializeString_<uint8_t, uint8_t>(object);
     } else {
       builder_.ChangeEncoding();
       SerializeString(object);
     }
   } else {
     if (object->IsOneByteRepresentationUnderneath()) {
       SerializeString_<uint8_t, uc16>(object);
     } else {
       SerializeString_<uc16, uc16>(object);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8