[JSON] implement indentation in the BasicJsonStringifier and expose via API.

src/json-stringifier.h

 // Copyright 2012 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.
 
 #ifndef V8_JSON_STRINGIFIER_H_
 #define V8_JSON_STRINGIFIER_H_
 
 #include "src/conversions.h"
 #include "src/lookup.h"
 #include "src/messages.h"
 #include "src/string-builder.h"
 #include "src/utils.h"
 
 namespace v8 {
 namespace internal {
 
 class BasicJsonStringifier BASE_EMBEDDED {
  public:
-  explicit BasicJsonStringifier(Isolate* isolate);
+  BasicJsonStringifier(Isolate* isolate, Handle<String> gap);
+
+  ~BasicJsonStringifier() { DeleteArray(gap_); }
 
   MUST_USE_RESULT MaybeHandle<Object> Stringify(Handle<Object> object);
 
   MUST_USE_RESULT INLINE(static MaybeHandle<Object> StringifyString(
       Isolate* isolate,
       Handle<String> object));
 
  private:
   enum Result { UNCHANGED, SUCCESS, EXCEPTION };
 
@@ skipping 28 matching lines @@
                                   bool deferred_comma,
                                   Handle<String> deferred_key)) {
     DCHECK(!deferred_key.is_null());
     return Serialize_<true>(object, deferred_comma, deferred_key);
   }
 
   template <bool deferred_string_key>
   Result Serialize_(Handle<Object> object, bool comma, Handle<Object> key);
 
   void SerializeDeferredKey(bool deferred_comma, Handle<Object> deferred_key) {
-    if (deferred_comma) builder_.AppendCharacter(',');
+    Separator(!deferred_comma);
     SerializeString(Handle<String>::cast(deferred_key));
     builder_.AppendCharacter(':');
+    if (gap_ != nullptr) builder_.AppendCharacter(' ');
   }
 
   Result SerializeSmi(Smi* object);
 
   Result SerializeDouble(double number);
   INLINE(Result SerializeHeapNumber(Handle<HeapNumber> object)) {
     return SerializeDouble(object->value());
   }
 
   Result SerializeJSValue(Handle<JSValue> object);
@@ skipping 10 matching lines @@
   INLINE(static void SerializeStringUnchecked_(
       Vector<const SrcChar> src,
       IncrementalStringBuilder::NoExtend<DestChar>* dest));
 
   template <typename SrcChar, typename DestChar>
   INLINE(void SerializeString_(Handle<String> string));
 
   template <typename Char>
   INLINE(static bool DoNotEscape(Char c));
 
+  INLINE(void NewLine());
+  INLINE(void Indent() { indent_++; });
+  INLINE(void Unindent() { indent_--; });
+  INLINE(void Separator(bool first) {
+    if (!first) builder_.AppendCharacter(',');
+    NewLine();
+  })
+
   Result StackPush(Handle<Object> object);
   void StackPop();
 
   Factory* factory() { return isolate_->factory(); }
 
   Isolate* isolate_;
   IncrementalStringBuilder builder_;
   Handle<String> tojson_string_;
   Handle<JSArray> stack_;
+  Handle<String> gap_string_;
+  uc16* gap_;
+  int indent_;
 
   static const int kJsonEscapeTableEntrySize = 8;
   static const char* const JsonEscapeTable;
 };
 
 
 // Translation table to escape Latin1 characters.
 // Table entries start at a multiple of 8 and are null-terminated.
 const char* const BasicJsonStringifier::JsonEscapeTable =
     "\\u0000\0 \\u0001\0 \\u0002\0 \\u0003\0 "
@@ skipping 54 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)
-    : isolate_(isolate), builder_(isolate) {
+BasicJsonStringifier::BasicJsonStringifier(Isolate* isolate, Handle<String> gap)
+    : isolate_(isolate), builder_(isolate), gap_string_(gap), indent_(0) {
   tojson_string_ = factory()->toJSON_string();
   stack_ = factory()->NewJSArray(8);
+  int gap_length = gap->length();
+  if (gap_length != 0) {
+    String::Flatten(gap);
+    DisallowHeapAllocation no_gc;
+    String::FlatContent flat = gap->GetFlatContent();
+    gap_ = NewArray<uc16>(gap_length + 1);
+    if (flat.IsOneByte()) {
+      CopyChars(gap_, flat.ToOneByteVector().start(), gap_length);
+    } else {
+      CopyChars(gap_, flat.ToUC16Vector().start(), gap_length);
+      builder_.ChangeEncoding();
+    }
+    gap_[gap_length] = '\0';
+  } else {
+    gap_ = nullptr;
+  }
 }
 
 
 MaybeHandle<Object> BasicJsonStringifier::Stringify(Handle<Object> object) {
   Result result = SerializeObject(object);
   if (result == UNCHANGED) return factory()->undefined_value();
   if (result == SUCCESS) return builder_.Finish();
   DCHECK(result == EXCEPTION);
   return MaybeHandle<Object>();
 }
 
 
 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);
+    BasicJsonStringifier stringifier(isolate,
+                                     isolate->factory()->empty_string());
     return stringifier.Stringify(object);
   }
 
   object = String::Flatten(object);
   DCHECK(object->IsFlat());
   Handle<SeqString> result;
   if (object->IsOneByteRepresentationUnderneath()) {
     result = isolate->factory()
                  ->NewRawOneByteString(worst_case_length)
                  .ToHandleChecked();
@@ skipping 134 matching lines @@
   return SerializeGeneric(object, key, comma, deferred_string_key);
 }
 
 
 BasicJsonStringifier::Result BasicJsonStringifier::SerializeGeneric(
     Handle<Object> object,
     Handle<Object> key,
     bool deferred_comma,
     bool deferred_key) {
   Handle<JSFunction> fun = isolate_->json_serialize_adapter();
-  Handle<Object> argv[] = { key, object };
+  Handle<Object> indent(Smi::FromInt(indent_), isolate_);
+  Handle<Object> argv[] = {key, object, indent, gap_string_};
   Handle<Object> result;
   ASSIGN_RETURN_ON_EXCEPTION_VALUE(
-      isolate_, result, Execution::Call(isolate_, fun, object, 2, argv),
-      EXCEPTION);
+      isolate_, result,
+      Execution::Call(isolate_, fun, object, arraysize(argv), argv), EXCEPTION);
   if (result->IsUndefined()) return UNCHANGED;
   if (deferred_key) {
     if (key->IsSmi()) key = factory()->NumberToString(key);
     SerializeDeferredKey(deferred_comma, key);
   }
 
   builder_.AppendString(Handle<String>::cast(result));
   return SUCCESS;
 }
 
@@ skipping 50 matching lines @@
 
 
 BasicJsonStringifier::Result BasicJsonStringifier::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));
   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++) {
-        if (i > 0) builder_.AppendCharacter(',');
+        Separator(i == 0);
         SerializeSmi(Smi::cast(elements->get(i)));
       }
       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++) {
-        if (i > 0) builder_.AppendCharacter(',');
+        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 = SerializeJSArraySlow(object, i, length);
           if (result != SUCCESS) return result;
           break;
         }
-        if (i > 0) builder_.AppendCharacter(',');
+        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 = SerializeJSArraySlow(object, 0, length);
       if (result != SUCCESS) return result;
       break;
     }
   }
+  Unindent();
+  if (length > 0) NewLine();
   builder_.AppendCharacter(']');
   StackPop();
   return SUCCESS;
 }
 
 
 BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSArraySlow(
     Handle<JSArray> object, uint32_t start, uint32_t length) {
   for (uint32_t i = start; i < length; i++) {
-    if (i > 0) builder_.AppendCharacter(',');
+    Separator(i == 0);
     Handle<Object> element;
     ASSIGN_RETURN_ON_EXCEPTION_VALUE(
         isolate_, element, JSReceiver::GetElement(isolate_, object, i),
         EXCEPTION);
     if (element->IsUndefined()) {
       builder_.AppendCString("null");
     } else {
       Result result = SerializeElement(isolate_, element, i);
       if (result == SUCCESS) continue;
       if (result == UNCHANGED) {
         builder_.AppendCString("null");
       } else {
         return result;
       }
     }
   }
   return SUCCESS;
 }
 
 
 BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSObject(
     Handle<JSObject> object) {
   HandleScope handle_scope(isolate_);
   Result stack_push = StackPush(object);
   if (stack_push != SUCCESS) return stack_push;
   DCHECK(!object->IsJSGlobalProxy() && !object->IsJSGlobalObject());
 
   builder_.AppendCharacter('{');
+  Indent();
   bool comma = false;
 
   if (object->HasFastProperties() &&
       !object->HasIndexedInterceptor() &&
       !object->HasNamedInterceptor() &&
       object->elements()->length() == 0) {
     Handle<Map> map(object->map());
     for (int i = 0; i < map->NumberOfOwnDescriptors(); i++) {
       Handle<Name> name(map->instance_descriptors()->GetKey(i), isolate_);
       // TODO(rossberg): Should this throw?
@@ skipping 46 matching lines @@
         }
       }
       Handle<Object> property;
       ASSIGN_RETURN_ON_EXCEPTION_VALUE(
           isolate_, property, maybe_property, EXCEPTION);
       Result result = SerializeProperty(property, comma, key_handle);
       if (!comma && result == SUCCESS) comma = true;
       if (result == EXCEPTION) return result;
     }
   }
-
+  Unindent();
+  if (comma) NewLine();
   builder_.AppendCharacter('}');
   StackPop();
   return SUCCESS;
 }
 
 
 template <typename SrcChar, typename DestChar>
 void BasicJsonStringifier::SerializeStringUnchecked_(
     Vector<const SrcChar> src,
     IncrementalStringBuilder::NoExtend<DestChar>* dest) {
@@ skipping 47 matching lines @@
 bool BasicJsonStringifier::DoNotEscape(uint8_t c) {
   return c >= '#' && c <= '~' && c != '\\';
 }
 
 
 template <>
 bool BasicJsonStringifier::DoNotEscape(uint16_t c) {
   return c >= '#' && c != '\\' && c != 0x7f;
 }
 
+void BasicJsonStringifier::NewLine() {
+  if (gap_ == nullptr) return;
+  builder_.AppendCharacter('\n');
+  for (int i = 0; i < indent_; i++) builder_.AppendCString(gap_);
+}
 
 void BasicJsonStringifier::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
 
 #endif  // V8_JSON_STRINGIFIER_H_