Make V8ValueConverter.FromV8Value behave similarly to JSON.stringify

chrome/renderer/extensions/send_request_natives.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 "chrome/renderer/extensions/send_request_natives.h"
 
+#include <string>
+#include <vector>
+
+#include "base/lazy_instance.h"
 #include "base/json/json_reader.h"
+#include "base/string_util.h"
 #include "content/public/renderer/v8_value_converter.h"
 #include "chrome/renderer/extensions/request_sender.h"
 
 using content::V8ValueConverter;
 
 namespace extensions {
 
+namespace {
+
+// Safely converts v8 objects into values depending on the API that's being
+// called.
+//
+// Some APIs can handle nulls in objects, others can't. For some that can

[koz (OOO until 15th September), 2012/09/12 02:08:28]

"For some that can" -> "For those that can"

+// (e.g. the storage API) it's important that they can handle nulls since this
+// actually changes what values would be stored.
+class NullSafeV8ValueConverter {
+ public:
+  NullSafeV8ValueConverter() {
+    null_safe_apis_.push_back("storage.");
+  }
+
+  scoped_ptr<Value> FromV8Value(const std::string& name,
+                                v8::Handle<v8::Value> value) {
+    scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
+
+    // Make "undefined" the same as "null" for optional arguments, but for
+    // objects strip nulls (like {foo: null}, and therefore {foo: undefined} as
+    // well) to make it easier for extension APIs to check for optional
+    // arguments (and unless it's a "null safe" API (as explained above).
+    converter->SetUndefinedAllowed(true);
+    if (!IsNullSafe(name)) {
+      converter->SetStripNullFromObjects(true);
+    }
+
+    return make_scoped_ptr(
+        converter->FromV8Value(value, v8::Context::GetCurrent()));
+  }
+
+ private:
+  bool IsNullSafe(const std::string& name) {
+    for (std::vector<std::string>::iterator it = null_safe_apis_.begin();
+         it != null_safe_apis_.end(); ++it) {
+      if (StartsWithASCII(name, *it, true /* case sensitive */))
+        return true;
+    }
+    return false;
+  }
+
+  std::vector<std::string> null_safe_apis_;
+};
+
+base::LazyInstance<NullSafeV8ValueConverter> g_null_safe_v8_value_converter =
+    LAZY_INSTANCE_INITIALIZER;
+
+}  // namespace
+
+
 SendRequestNatives::SendRequestNatives(Dispatcher* dispatcher,
                                        RequestSender* request_sender)
     : ChromeV8Extension(dispatcher), request_sender_(request_sender) {
   RouteFunction("GetNextRequestId",
                 base::Bind(&SendRequestNatives::GetNextRequestId,
                            base::Unretained(this)));
   RouteFunction("StartRequest",
                 base::Bind(&SendRequestNatives::StartRequest,
                            base::Unretained(this)));
 }
 
 v8::Handle<v8::Value> SendRequestNatives::GetNextRequestId(
     const v8::Arguments& args) {
   static int next_request_id = 0;
   return v8::Integer::New(next_request_id++);
 }
 
 // Starts an API request to the browser, with an optional callback.  The
 // callback will be dispatched to EventBindings::HandleResponse.
 v8::Handle<v8::Value> SendRequestNatives::StartRequest(
     const v8::Arguments& args) {
   std::string name = *v8::String::AsciiValue(args[0]);
   int request_id = args[2]->Int32Value();
   bool has_callback = args[3]->BooleanValue();
   bool for_io_thread = args[4]->BooleanValue();
 
-  scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
-
-  // Make "undefined" the same as "null" for optional arguments, but for objects
-  // strip nulls (like {foo: null}, and therefore {foo: undefined} as well) to
-  // make it easier for extension APIs to check for optional arguments.
-  converter->SetUndefinedAllowed(true);
-  converter->SetStripNullFromObjects(true);
-
-  scoped_ptr<Value> value_args(
-      converter->FromV8Value(args[1], v8::Context::GetCurrent()));
+  scoped_ptr<Value> value_args =
+      g_null_safe_v8_value_converter.Get().FromV8Value(name, args[1]);
   if (!value_args.get() || !value_args->IsType(Value::TYPE_LIST)) {
     NOTREACHED() << "Unable to convert args passed to StartRequest";
     return v8::Undefined();
   }
 
   request_sender_->StartRequest(name, request_id, has_callback, for_io_thread,
                                 static_cast<ListValue*>(value_args.get()));
   return v8::Undefined();
 }
 
 }  // namespace extensions