Add a JSON sanitizer.

components/safe_json/json_sanitizer.cc

Index: components/safe_json/json_sanitizer.cc
diff --git a/components/safe_json/json_sanitizer.cc b/components/safe_json/json_sanitizer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e2000cac4023b90e10bcb0eb227c46bb4c849f1a
--- /dev/null
+++ b/components/safe_json/json_sanitizer.cc
@@ -0,0 +1,90 @@
+// Copyright 2015 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 "components/safe_json/json_sanitizer.h"
+
+#if defined(OS_ANDROID)
+#error Build json_sanitizer_android.cc instead of this file on Android.
+#endif
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/json/json_writer.h"
+#include "base/memory/weak_ptr.h"
+#include "base/strings/string_util.h"
+#include "base/values.h"
+#include "components/safe_json/safe_json_parser.h"
+
+namespace safe_json {
+
+namespace {
+
+class OopJsonSanitizer : public JsonSanitizer {
+ public:
+  OopJsonSanitizer(const StringCallback& success_callback,
+                   const StringCallback& error_callback);
+  ~OopJsonSanitizer() override {}
+
+  // JsonSanitizer implementation:
+  void Start(const std::string& unsafe_json) override;
+
+ private:
+  void OnParseSuccess(scoped_ptr<base::Value> value);
+  void OnParseError(const std::string& error);
+
+  StringCallback success_callback_;
+  StringCallback error_callback_;
+
+  base::WeakPtrFactory<OopJsonSanitizer> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(OopJsonSanitizer);
+};
+
+OopJsonSanitizer::OopJsonSanitizer(const StringCallback& success_callback,
+                                   const StringCallback& error_callback)
+    : success_callback_(success_callback),
+      error_callback_(error_callback),
+      weak_ptr_factory_(this) {}
+
+void OopJsonSanitizer::Start(const std::string& unsafe_json) {
+  SafeJsonParser::Parse(unsafe_json,
+                        base::Bind(&OopJsonSanitizer::OnParseSuccess,
+                                   weak_ptr_factory_.GetWeakPtr()),
+                        base::Bind(&OopJsonSanitizer::OnParseError,
+                                   weak_ptr_factory_.GetWeakPtr()));
+}
+
+void OopJsonSanitizer::OnParseSuccess(scoped_ptr<base::Value> value) {
+  // A valid JSON document may only have a dictionary or list as its top-level
+  // type, but the JSON parser also accepts other types, so we filter them out.
+  base::Value::Type type = value->GetType();
+  if (type != base::Value::TYPE_DICTIONARY && type != base::Value::TYPE_LIST) {
+    error_callback_.Run("Invalid top-level type");
+    return;
+  }
+
+  std::string json;
+  if (!base::JSONWriter::Write(*value, &json)) {
+    error_callback_.Run("Encoding error");
+    return;
+  }
+
+  success_callback_.Run(json);
+}
+
+void OopJsonSanitizer::OnParseError(const std::string& error) {
+  error_callback_.Run("Parse error: " + error);
+}
+
+}  // namespace
+
+// static
+scoped_ptr<JsonSanitizer> JsonSanitizer::Create(
+    const StringCallback& success_callback,
+    const StringCallback& error_callback) {
+  return make_scoped_ptr(
+      new OopJsonSanitizer(success_callback, error_callback));
+}
+
+}  // namespace safe_json