base/json/json_writer.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/json/json_writer.h"
   6
   7 #include <cmath>
   8
   9 #include "base/json/string_escape.h"
  10 #include "base/logging.h"
  11 #include "base/stringprintf.h"
  12 #include "base/string_number_conversions.h"
  13 #include "base/values.h"
  14 #include "base/utf_string_conversions.h"
  15
  16 namespace base {
  17
  18 #if defined(OS_WIN)
  19 static const char kPrettyPrintLineEnding[] = "\r\n";
  20 #else
  21 static const char kPrettyPrintLineEnding[] = "\n";
  22 #endif
  23
  24 /* static */
  25 const char* JSONWriter::kEmptyArray = "[]";
  26
  27 /* static */
  28 void JSONWriter::Write(const Value* const node, std::string* json) {
  29   WriteWithOptions(node, 0, json);
  30 }
  31
  32 /* static */
  33 void JSONWriter::WriteWithOptions(const Value* const node, int options,
  34                                   std::string* json) {
  35   json->clear();
  36   // Is there a better way to estimate the size of the output?
  37   json->reserve(1024);
  38
  39   bool escape = !(options & OPTIONS_DO_NOT_ESCAPE);
  40   bool omit_binary_values = !!(options & OPTIONS_OMIT_BINARY_VALUES);
  41   bool omit_double_type_preservation =
  42       !!(options & OPTIONS_OMIT_DOUBLE_TYPE_PRESERVATION);
  43   bool pretty_print = !!(options & OPTIONS_PRETTY_PRINT);
  44
  45   JSONWriter writer(escape, omit_binary_values, omit_double_type_preservation,
  46                     pretty_print, json);
  47   writer.BuildJSONString(node, 0);
  48
  49   if (pretty_print)
  50     json->append(kPrettyPrintLineEnding);
  51 }
  52
  53 JSONWriter::JSONWriter(bool escape, bool omit_binary_values,
  54                        bool omit_double_type_preservation, bool pretty_print,
  55                        std::string* json)
  56     : escape_(escape),
  57       omit_binary_values_(omit_binary_values),
  58       omit_double_type_preservation_(omit_double_type_preservation),
  59       pretty_print_(pretty_print),
  60       json_string_(json) {
  61   DCHECK(json);
  62 }
  63
  64 void JSONWriter::BuildJSONString(const Value* const node, int depth) {
  65   switch (node->GetType()) {
  66     case Value::TYPE_NULL:
  67       json_string_->append("null");
  68       break;
  69
  70     case Value::TYPE_BOOLEAN:
  71       {
  72         bool value;
  73         bool result = node->GetAsBoolean(&value);
  74         DCHECK(result);
  75         json_string_->append(value ? "true" : "false");
  76         break;
  77       }
  78
  79     case Value::TYPE_INTEGER:
  80       {
  81         int value;
  82         bool result = node->GetAsInteger(&value);
  83         DCHECK(result);
  84         base::StringAppendF(json_string_, "%d", value);
  85         break;
  86       }
  87
  88     case Value::TYPE_DOUBLE:
  89       {
  90         double value;
  91         bool result = node->GetAsDouble(&value);
  92         DCHECK(result);
  93         if (omit_double_type_preservation_ &&
  94             value <= kint64max &&
  95             value >= kint64min &&
  96             std::floor(value) == value) {
  97           json_string_->append(Int64ToString(static_cast<int64>(value)));
  98           break;
  99         }
 100         std::string real = DoubleToString(value);
 101         // Ensure that the number has a .0 if there's no decimal or 'e'.  This
 102         // makes sure that when we read the JSON back, it's interpreted as a
 103         // real rather than an int.
 104         if (real.find('.') == std::string::npos &&
 105             real.find('e') == std::string::npos &&
 106             real.find('E') == std::string::npos) {
 107           real.append(".0");
 108         }
 109         // The JSON spec requires that non-integer values in the range (-1,1)
 110         // have a zero before the decimal point - ".52" is not valid, "0.52" is.
 111         if (real[0] == '.') {
 112           real.insert(0, "0");
 113         } else if (real.length() > 1 && real[0] == '-' && real[1] == '.') {
 114           // "-.1" bad "-0.1" good
 115           real.insert(1, "0");
 116         }
 117         json_string_->append(real);
 118         break;
 119       }
 120
 121     case Value::TYPE_STRING:
 122       {
 123         std::string value;
 124         bool result = node->GetAsString(&value);
 125         DCHECK(result);
 126         if (escape_) {
 127           JsonDoubleQuote(UTF8ToUTF16(value), true, json_string_);
 128         } else {
 129           JsonDoubleQuote(value, true, json_string_);
 130         }
 131         break;
 132       }
 133
 134     case Value::TYPE_LIST:
 135       {
 136         json_string_->append("[");
 137         if (pretty_print_)
 138           json_string_->append(" ");
 139
 140         const ListValue* list = static_cast<const ListValue*>(node);
 141         for (size_t i = 0; i < list->GetSize(); ++i) {
 142           const Value* value = NULL;
 143           bool result = list->Get(i, &value);
 144           DCHECK(result);
 145
 146           if (omit_binary_values_ && value->GetType() == Value::TYPE_BINARY) {
 147             continue;
 148           }
 149
 150           if (i != 0) {
 151             json_string_->append(",");
 152             if (pretty_print_)
 153               json_string_->append(" ");
 154           }
 155
 156           BuildJSONString(value, depth);
 157         }
 158
 159         if (pretty_print_)
 160           json_string_->append(" ");
 161         json_string_->append("]");
 162         break;
 163       }
 164
 165     case Value::TYPE_DICTIONARY:
 166       {
 167         json_string_->append("{");
 168         if (pretty_print_)
 169           json_string_->append(kPrettyPrintLineEnding);
 170
 171         const DictionaryValue* dict =
 172           static_cast<const DictionaryValue*>(node);
 173         for (DictionaryValue::key_iterator key_itr = dict->begin_keys();
 174              key_itr != dict->end_keys();
 175              ++key_itr) {
 176           const Value* value = NULL;
 177           bool result = dict->GetWithoutPathExpansion(*key_itr, &value);
 178           DCHECK(result);
 179
 180           if (omit_binary_values_ && value->GetType() == Value::TYPE_BINARY) {
 181             continue;
 182           }
 183
 184           if (key_itr != dict->begin_keys()) {
 185             json_string_->append(",");
 186             if (pretty_print_)
 187               json_string_->append(kPrettyPrintLineEnding);
 188           }
 189
 190           if (pretty_print_)
 191             IndentLine(depth + 1);
 192           AppendQuotedString(*key_itr);
 193           if (pretty_print_) {
 194             json_string_->append(": ");
 195           } else {
 196             json_string_->append(":");
 197           }
 198           BuildJSONString(value, depth + 1);
 199         }
 200
 201         if (pretty_print_) {
 202           json_string_->append(kPrettyPrintLineEnding);
 203           IndentLine(depth);
 204           json_string_->append("}");
 205         } else {
 206           json_string_->append("}");
 207         }
 208         break;
 209       }
 210
 211     case Value::TYPE_BINARY:
 212       {
 213         if (!omit_binary_values_) {
 214           NOTREACHED() << "Cannot serialize binary value.";
 215         }
 216         break;
 217       }
 218
 219     default:
 220       NOTREACHED() << "unknown json type";
 221   }
 222 }
 223
 224 void JSONWriter::AppendQuotedString(const std::string& str) {
 225   // TODO(viettrungluu): |str| is UTF-8, not ASCII, so to properly escape it we
 226   // have to convert it to UTF-16. This round-trip is suboptimal.
 227   JsonDoubleQuote(UTF8ToUTF16(str), true, json_string_);
 228 }
 229
 230 void JSONWriter::IndentLine(int depth) {
 231   // It may be faster to keep an indent string so we don't have to keep
 232   // reallocating.
 233   json_string_->append(std::string(depth * 3, ' '));
 234 }
 235
 236 }  // namespace base