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/strings/string_number_conversions.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "base/values.h"
  14
  15 namespace base {
  16
  17 #if defined(OS_WIN)
  18 const char kPrettyPrintLineEnding[] = "\r\n";
  19 #else
  20 const char kPrettyPrintLineEnding[] = "\n";
  21 #endif
  22
  23 // static
  24 bool JSONWriter::Write(const Value* const node, std::string* json) {
  25   return WriteWithOptions(node, 0, json);
  26 }
  27
  28 // static
  29 bool JSONWriter::WriteWithOptions(const Value* const node, int options,
  30                                   std::string* json) {
  31   json->clear();
  32   // Is there a better way to estimate the size of the output?
  33   json->reserve(1024);
  34
  35   JSONWriter writer(options, json);
  36   bool result = writer.BuildJSONString(node, 0U);
  37
  38   if (options & OPTIONS_PRETTY_PRINT)
  39     json->append(kPrettyPrintLineEnding);
  40
  41   return result;
  42 }
  43
  44 JSONWriter::JSONWriter(int options, std::string* json)
  45     : omit_binary_values_((options & OPTIONS_OMIT_BINARY_VALUES) != 0),
  46       omit_double_type_preservation_(
  47           (options & OPTIONS_OMIT_DOUBLE_TYPE_PRESERVATION) != 0),
  48       pretty_print_((options & OPTIONS_PRETTY_PRINT) != 0),
  49       json_string_(json) {
  50   DCHECK(json);
  51 }
  52
  53 bool JSONWriter::BuildJSONString(const Value* const node, size_t depth) {
  54   switch (node->GetType()) {
  55     case Value::TYPE_NULL: {
  56       json_string_->append("null");
  57       return true;
  58     }
  59
  60     case Value::TYPE_BOOLEAN: {
  61       bool value;
  62       bool result = node->GetAsBoolean(&value);
  63       DCHECK(result);
  64       json_string_->append(value ? "true" : "false");
  65       return result;
  66     }
  67
  68     case Value::TYPE_INTEGER: {
  69       int value;
  70       bool result = node->GetAsInteger(&value);
  71       DCHECK(result);
  72       json_string_->append(IntToString(value));
  73       return result;
  74     }
  75
  76     case Value::TYPE_DOUBLE: {
  77       double value;
  78       bool result = node->GetAsDouble(&value);
  79       DCHECK(result);
  80       if (omit_double_type_preservation_ &&
  81           value <= kint64max &&
  82           value >= kint64min &&
  83           std::floor(value) == value) {
  84         json_string_->append(Int64ToString(static_cast<int64>(value)));
  85         return result;
  86       }
  87       std::string real = DoubleToString(value);
  88       // Ensure that the number has a .0 if there's no decimal or 'e'.  This
  89       // makes sure that when we read the JSON back, it's interpreted as a
  90       // real rather than an int.
  91       if (real.find('.') == std::string::npos &&
  92           real.find('e') == std::string::npos &&
  93           real.find('E') == std::string::npos) {
  94         real.append(".0");
  95       }
  96       // The JSON spec requires that non-integer values in the range (-1,1)
  97       // have a zero before the decimal point - ".52" is not valid, "0.52" is.
  98       if (real[0] == '.') {
  99         real.insert(static_cast<size_t>(0), static_cast<size_t>(1), '0');
 100       } else if (real.length() > 1 && real[0] == '-' && real[1] == '.') {
 101         // "-.1" bad "-0.1" good
 102         real.insert(static_cast<size_t>(1), static_cast<size_t>(1), '0');
 103       }
 104       json_string_->append(real);
 105       return result;
 106     }
 107
 108     case Value::TYPE_STRING: {
 109       std::string value;
 110       bool result = node->GetAsString(&value);
 111       DCHECK(result);
 112       EscapeJSONString(value, true, json_string_);
 113       return result;
 114     }
 115
 116     case Value::TYPE_LIST: {
 117       json_string_->push_back('[');
 118       if (pretty_print_)
 119         json_string_->push_back(' ');
 120
 121       const ListValue* list = NULL;
 122       bool first_value_has_been_output = false;
 123       bool result = node->GetAsList(&list);
 124       DCHECK(result);
 125       for (ListValue::const_iterator it = list->begin(); it != list->end();
 126            ++it) {
 127         const Value* value = *it;
 128         if (omit_binary_values_ && value->GetType() == Value::TYPE_BINARY)
 129           continue;
 130
 131         if (first_value_has_been_output) {
 132           json_string_->push_back(',');
 133           if (pretty_print_)
 134             json_string_->push_back(' ');
 135         }
 136
 137         if (!BuildJSONString(value, depth))
 138           result = false;
 139
 140         first_value_has_been_output = true;
 141       }
 142
 143       if (pretty_print_)
 144         json_string_->push_back(' ');
 145       json_string_->push_back(']');
 146       return result;
 147     }
 148
 149     case Value::TYPE_DICTIONARY: {
 150       json_string_->push_back('{');
 151       if (pretty_print_)
 152         json_string_->append(kPrettyPrintLineEnding);
 153
 154       const DictionaryValue* dict = NULL;
 155       bool first_value_has_been_output = false;
 156       bool result = node->GetAsDictionary(&dict);
 157       DCHECK(result);
 158       for (DictionaryValue::Iterator itr(*dict); !itr.IsAtEnd();
 159            itr.Advance()) {
 160         if (omit_binary_values_ &&
 161             itr.value().GetType() == Value::TYPE_BINARY) {
 162           continue;
 163         }
 164
 165         if (first_value_has_been_output) {
 166           json_string_->push_back(',');
 167           if (pretty_print_)
 168             json_string_->append(kPrettyPrintLineEnding);
 169         }
 170
 171         if (pretty_print_)
 172           IndentLine(depth + 1U);
 173
 174         EscapeJSONString(itr.key(), true, json_string_);
 175         json_string_->push_back(':');
 176         if (pretty_print_)
 177           json_string_->push_back(' ');
 178
 179         if (!BuildJSONString(&itr.value(), depth + 1U))
 180           result = false;
 181
 182         first_value_has_been_output = true;
 183       }
 184
 185       if (pretty_print_) {
 186         json_string_->append(kPrettyPrintLineEnding);
 187         IndentLine(depth);
 188       }
 189
 190       json_string_->push_back('}');
 191       return result;
 192     }
 193
 194     case Value::TYPE_BINARY:
 195       // Successful only if we're allowed to omit it.
 196       DLOG_IF(ERROR, !omit_binary_values_) << "Cannot serialize binary value.";
 197       return omit_binary_values_;
 198   }
 199   NOTREACHED();
 200   return false;
 201 }
 202
 203 void JSONWriter::IndentLine(size_t depth) {
 204   json_string_->append(depth * 3U, ' ');
 205 }
 206
 207 }  // namespace base