DevTools: Introduce lightweight version of JSON serialization.

base/json_writer.cc

 // Copyright (c) 2006-2008 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 "base/json_writer.h"
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "base/string_escape.h"
 
 const char kPrettyPrintLineEnding[] = "\r\n";
 
 /* static */
-void JSONWriter::Write(const Value* const node, bool pretty_print,
+void JSONWriter::Write(const Value* const node,
+                       bool pretty_print,
                        std::string* json) {
+  WriteWithOptionalEscape(node, pretty_print, true, json);
+}
+
+/* static */
+void JSONWriter::WriteWithOptionalEscape(const Value* const node,
+                                         bool pretty_print,
+                                         bool escape,
+                                         std::string* json) {
   json->clear();
   // Is there a better way to estimate the size of the output?
   json->reserve(1024);
   JSONWriter writer(pretty_print, json);
-  writer.BuildJSONString(node, 0);
+  writer.BuildJSONString(node, 0, escape);
   if (pretty_print)
     json->append(kPrettyPrintLineEnding);
 }
 
 JSONWriter::JSONWriter(bool pretty_print, std::string* json)
     : json_string_(json),
       pretty_print_(pretty_print) {
   DCHECK(json);
 }
 
-void JSONWriter::BuildJSONString(const Value* const node, int depth) {
+void JSONWriter::BuildJSONString(const Value* const node,
+                                 int depth,
+                                 bool escape) {
   switch(node->GetType()) {
     case Value::TYPE_NULL:
       json_string_->append("null");
       break;
 
     case Value::TYPE_BOOLEAN:
       {
         bool value;
         bool result = node->GetAsBoolean(&value);
         DCHECK(result);
@@ skipping 31 matching lines @@
         } else if (real.length() > 1 && real[0] == '-' && real[1] == '.') {
           // "-.1" bad "-0.1" good
           real.insert(1, "0");
         }
         json_string_->append(real);
         break;
       }
 
     case Value::TYPE_STRING:
       {
-        std::wstring value;
-        bool result = node->GetAsString(&value);
-        DCHECK(result);
-        AppendQuotedString(value);
+        if (escape) {
+          std::wstring value;
+          bool result = node->GetAsString(&value);
+          DCHECK(result);
+          AppendQuotedString(value);
+        } else {
+          std::string value;
+          bool result = node->GetAsString(&value);
+          DCHECK(result);
+          string_escape::JavascriptDoubleQuote(value, true, json_string_);
+        }
         break;
       }
 
     case Value::TYPE_LIST:
       {
         json_string_->append("[");
         if (pretty_print_)
           json_string_->append(" ");
 
         const ListValue* list = static_cast<const ListValue*>(node);
         for (size_t i = 0; i < list->GetSize(); ++i) {
           if (i != 0) {
             json_string_->append(",");
             if (pretty_print_)
               json_string_->append(" ");
           }
 
           Value* value = NULL;
           bool result = list->Get(i, &value);
           DCHECK(result);
-          BuildJSONString(value, depth);
+          BuildJSONString(value, depth, escape);
         }
 
         if (pretty_print_)
           json_string_->append(" ");
         json_string_->append("]");
         break;
       }
 
     case Value::TYPE_DICTIONARY:
       {
@@ skipping 18 matching lines @@
           DCHECK(result);
 
           if (pretty_print_)
             IndentLine(depth + 1);
           AppendQuotedString(*key_itr);
           if (pretty_print_) {
             json_string_->append(": ");
           } else {
             json_string_->append(":");
           }
-          BuildJSONString(value, depth + 1);
+          BuildJSONString(value, depth + 1, escape);
         }
 
         if (pretty_print_) {
           json_string_->append(kPrettyPrintLineEnding);
           IndentLine(depth);
           json_string_->append("}");
         } else {
           json_string_->append("}");
         }
         break;
       }
 
     default:
       // TODO(jhughes): handle TYPE_BINARY
       NOTREACHED() << "unknown json type";
   }
 }
 
 void JSONWriter::AppendQuotedString(const std::wstring& str) {
-  string_escape::JavascriptDoubleQuote(WideToUTF16Hack(str), true,
+  string_escape::JavascriptDoubleQuote(WideToUTF16Hack(str),
+                                       true,
                                        json_string_);
 }
 
 void JSONWriter::IndentLine(int depth) {
   // It may be faster to keep an indent string so we don't have to keep
   // reallocating.
   json_string_->append(std::string(depth * 3, ' '));
 }