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