Make V8ValueConverter.FromV8Value behave similarly to JSON.stringify

content/renderer/v8_value_converter_impl.cc

 // Copyright (c) 2012 The Chromium 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 "content/renderer/v8_value_converter_impl.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebArrayBuffer.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebArrayBufferView.h"
 #include "v8/include/v8.h"
 
 using base::BinaryValue;
 using base::DictionaryValue;
 using base::ListValue;
 using base::StringValue;
 using base::Value;
 
 namespace content {
 
 V8ValueConverter* V8ValueConverter::create() {
   return new V8ValueConverterImpl();
 }
 }  // namespace content
 
 V8ValueConverterImpl::V8ValueConverterImpl()
-    : undefined_allowed_(false),
-      date_allowed_(false),
-      regexp_allowed_(false),
+    : date_allowed_(false),
+      reg_exp_allowed_(false),
+      function_allowed_(false),
       strip_null_from_objects_(false) {
 }
 
-bool V8ValueConverterImpl::GetUndefinedAllowed() const {
-  return undefined_allowed_;
-}
-
-void V8ValueConverterImpl::SetUndefinedAllowed(bool val) {
-  undefined_allowed_ = val;
-}
-
-bool V8ValueConverterImpl::GetDateAllowed() const {
-  return date_allowed_;
-}
-
 void V8ValueConverterImpl::SetDateAllowed(bool val) {
   date_allowed_ = val;
 }
 
-bool V8ValueConverterImpl::GetRegexpAllowed() const {
-  return regexp_allowed_;
+void V8ValueConverterImpl::SetRegExpAllowed(bool val) {
+  reg_exp_allowed_ = val;
 }
 
-void V8ValueConverterImpl::SetRegexpAllowed(bool val) {
-  regexp_allowed_ = val;
-}
-
-bool V8ValueConverterImpl::GetStripNullFromObjects() const {
-  return strip_null_from_objects_;
+void V8ValueConverterImpl::SetFunctionAllowed(bool val) {
+  function_allowed_ = val;
 }
 
 void V8ValueConverterImpl::SetStripNullFromObjects(bool val) {
   strip_null_from_objects_ = val;
 }
 
 v8::Handle<v8::Value> V8ValueConverterImpl::ToV8Value(
     const Value* value, v8::Handle<v8::Context> context) const {
   v8::Context::Scope context_scope(context);
   v8::HandleScope handle_scope;
@@ skipping 121 matching lines @@
     return Value::CreateIntegerValue(val->ToInt32()->Value());
 
   if (val->IsNumber())
     return Value::CreateDoubleValue(val->ToNumber()->Value());
 
   if (val->IsString()) {
     v8::String::Utf8Value utf8(val->ToString());
     return Value::CreateStringValue(std::string(*utf8, utf8.length()));
   }
 
-  if (undefined_allowed_ && val->IsUndefined())
-    return Value::CreateNullValue();
+  if (val->IsUndefined())
+    // JSON.stringify ignores undefined.
+    return NULL;
 
-  if (date_allowed_ && val->IsDate()) {
+  if (val->IsDate()) {
+    if (!date_allowed_)
+      // JSON.stringify would convert this to a string, but an object is more
+      // consistent within this class.
+      return FromV8Object(val->ToObject(), unique_set);
     v8::Date* date = v8::Date::Cast(*val);
     return Value::CreateDoubleValue(date->NumberValue() / 1000.0);
   }
 
-  if (regexp_allowed_ && val->IsRegExp()) {
-    return Value::CreateStringValue(
-        *v8::String::Utf8Value(val->ToString()));
+  if (val->IsRegExp()) {
+    if (!reg_exp_allowed_)
+      // JSON.stringify converts to an object.
+      return FromV8Object(val->ToObject(), unique_set);
+    return Value::CreateStringValue(*v8::String::Utf8Value(val->ToString()));
   }
 
   // v8::Value doesn't have a ToArray() method for some reason.
   if (val->IsArray())
     return FromV8Array(val.As<v8::Array>(), unique_set);
 
+  if (val->IsFunction()) {
+    if (!function_allowed_)
+      // JSON.stringify refuses to convert function(){}.
+      return NULL;
+    return FromV8Object(val->ToObject(), unique_set);
+  }
+
   if (val->IsObject()) {
     BinaryValue* binary_value = FromV8Buffer(val);
     if (binary_value) {
       return binary_value;
     } else {
       return FromV8Object(val->ToObject(), unique_set);
     }
   }
+
   LOG(ERROR) << "Unexpected v8 value type encountered.";
-  return Value::CreateNullValue();
+  return NULL;
 }
 
 Value* V8ValueConverterImpl::FromV8Array(v8::Handle<v8::Array> val,
     std::set<int>* unique_set) const {
   if (unique_set && unique_set->count(val->GetIdentityHash()))
     return Value::CreateNullValue();
 
   scoped_ptr<v8::Context::Scope> scope;
   // If val was created in a different context than our current one, change to
   // that context, but change back after val is converted.
@@ skipping 11 matching lines @@
     v8::Handle<v8::Value> child_v8 = val->Get(i);
     if (try_catch.HasCaught()) {
       LOG(ERROR) << "Getter for index " << i << " threw an exception.";
       child_v8 = v8::Null();
     }
 
     if (!val->HasRealIndexedProperty(i))
       continue;
 
     Value* child = FromV8ValueImpl(child_v8, unique_set);
-    CHECK(child);
-
-    result->Append(child);
+    if (child)
+      result->Append(child);
+    else
+      // JSON.stringify puts null in places where values don't serialize, for
+      // example undefined and functions. Emulate that behavior.
+      result->Append(Value::CreateNullValue());
   }
   return result;
 }
 
 base::BinaryValue* V8ValueConverterImpl::FromV8Buffer(
     v8::Handle<v8::Value> val) const {
   char* data = NULL;
   size_t length = 0;
 
   scoped_ptr<WebKit::WebArrayBuffer> array_buffer(
@@ skipping 54 matching lines @@
     v8::TryCatch try_catch;
     v8::Handle<v8::Value> child_v8 = val->Get(key);
 
     if (try_catch.HasCaught()) {
       LOG(ERROR) << "Getter for property " << *name_utf8
                  << " threw an exception.";
       child_v8 = v8::Null();
     }
 
     scoped_ptr<Value> child(FromV8ValueImpl(child_v8, unique_set));
-    CHECK(child.get());
+    if (!child.get())
+      // JSON.stringify skips properties whose values don't serialize, for
+      // example undefined and functions. Emulate that behavior.
+      continue;
 
     // Strip null if asked (and since undefined is turned into null, undefined
     // too). The use case for supporting this is JSON-schema support,
     // specifically for extensions, where "optional" JSON properties may be
     // represented as null, yet due to buggy legacy code elsewhere isn't
     // treated as such (potentially causing crashes). For example, the
     // "tabs.create" function takes an object as its first argument with an
     // optional "windowId" property.
     //
     // Given just
@@ skipping 10 matching lines @@
     // We can avoid all bugs related to this by stripping null.
     if (strip_null_from_objects_ && child->IsType(Value::TYPE_NULL))
       continue;
 
     result->SetWithoutPathExpansion(std::string(*name_utf8, name_utf8.length()),
                                     child.release());
   }
 
   return result.release();
 }