[json] support property list argument 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"
@@ skipping 70 matching lines @@
     "\370\0      \371\0      \372\0      \373\0      "
     "\374\0      \375\0      \376\0      \377\0      ";
 
 BasicJsonStringifier::BasicJsonStringifier(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) {
+  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) {
+  DCHECK(property_list_.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;
+    if (!length_obj->ToUint32(&length)) length = kMaxUInt32;
+    for (uint32_t i = 0; i < length; i++) {
+      Handle<Object> element;
+      Handle<String> key;
+      ASSIGN_RETURN_ON_EXCEPTION_VALUE(
+          isolate_, element, Object::GetElement(isolate_, replacer, i), false);
+      if (element->IsNumber() || element->IsString()) {
+        ASSIGN_RETURN_ON_EXCEPTION_VALUE(
+            isolate_, key, Object::ToString(isolate_, element), false);
+      } else if (element->IsJSValue()) {
+        Handle<Object> value(Handle<JSValue>::cast(element)->value(), isolate_);
+        if (value->IsNumber() || value->IsString()) {
+          ASSIGN_RETURN_ON_EXCEPTION_VALUE(
+              isolate_, key, Object::ToString(isolate_, element), false);
+        }
+      }
+      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_);
+  }
+  return true;
+}
+
 bool BasicJsonStringifier::InitializeGap(Handle<Object> gap) {
   DCHECK_NULL(gap_);
   HandleScope scope(isolate_);
-  if (gap->IsJSReceiver()) {
-    Handle<String> class_name(Handle<JSReceiver>::cast(gap)->class_name());
-    if (class_name.is_identical_to(factory()->String_string())) {
+  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 (class_name.is_identical_to(factory()->number_string())) {
+    } else if (value->IsNumber()) {
       ASSIGN_RETURN_ON_EXCEPTION_VALUE(isolate_, gap, Object::ToNumber(gap),
                                        false);
     }
   }
 
   if (gap->IsString()) {
     Handle<String> gap_string = Handle<String>::cast(gap);
     if (gap_string->length() > 0) {
       int gap_length = std::min(gap_string->length(), 10);
       gap_ = NewArray<uc16>(gap_length + 1);
@@ skipping 20 matching lines @@
 
 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);
-    return stringifier.Stringify(object, isolate->factory()->undefined_value());
+    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(
@@ skipping 270 matching lines @@
   }
   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;
 
-  if (object->map()->instance_type() > LAST_CUSTOM_ELEMENTS_RECEIVER &&
+  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();
@@ skipping 29 matching lines @@
   } else {
     Result result = SerializeJSReceiverSlow(object);
     if (result != SUCCESS) return result;
   }
   StackPop();
   return SUCCESS;
 }
 
 BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSReceiverSlow(
     Handle<JSReceiver> object) {
-  Handle<FixedArray> contents;
-  ASSIGN_RETURN_ON_EXCEPTION_VALUE(
-      isolate_, contents,
-      JSReceiver::GetKeys(object, OWN_ONLY, ENUMERABLE_STRINGS), EXCEPTION);
+  Handle<FixedArray> contents = property_list_;
+  if (contents.is_null()) {
+    ASSIGN_RETURN_ON_EXCEPTION_VALUE(
+        isolate_, contents,
+        JSReceiver::GetKeys(object, OWN_ONLY, ENUMERABLE_STRINGS), EXCEPTION);
+  }
 
   builder_.AppendCharacter('{');
   Indent();
   bool comma = false;
   for (int i = 0; i < contents->length(); i++) {
     Object* key = contents->get(i);
     Handle<String> key_handle;
     MaybeHandle<Object> maybe_property;
     if (key->IsString()) {
       key_handle = Handle<String>(String::cast(key), isolate_);
@@ skipping 145 matching lines @@
     if (object->IsOneByteRepresentationUnderneath()) {
       SerializeString_<uint8_t, uc16>(object);
     } else {
       SerializeString_<uc16, uc16>(object);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8