Add option for not adding '.0' to the end of doubles that have no fractional

base/json/json_writer.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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/json_writer.h"
 
+#include <cmath>
+
 #include "base/json/string_escape.h"
 #include "base/logging.h"
 #include "base/stringprintf.h"
 #include "base/string_number_conversions.h"
 #include "base/values.h"
 #include "base/utf_string_conversions.h"
 
 namespace base {
 
 #if defined(OS_WIN)
@@ skipping 16 matching lines @@
 void JSONWriter::WriteWithOptions(const Value* const node,
                                   bool pretty_print,
                                   int options,
                                   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);
   bool escape = !(options & OPTIONS_DO_NOT_ESCAPE);
   bool omit_binary_values = !!(options & OPTIONS_OMIT_BINARY_VALUES);
-  writer.BuildJSONString(node, 0, escape, omit_binary_values);
+  bool omit_double_type_preservation =
+      !!(options & OPTIONS_OMIT_DOUBLE_TYPE_PRESERVATION);
+  writer.BuildJSONString(node, 0, escape, omit_binary_values,
+                         omit_double_type_preservation);
   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,
                                  bool escape,
-                                 bool omit_binary_values) {
+                                 bool omit_binary_values,
+                                 bool omit_double_type_preservation) {
   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);
         json_string_->append(value ? "true" : "false");
         break;
       }
 
     case Value::TYPE_INTEGER:
       {
         int value;
         bool result = node->GetAsInteger(&value);
         DCHECK(result);
         base::StringAppendF(json_string_, "%d", value);
         break;
       }
 
     case Value::TYPE_DOUBLE:
       {
         double value;
         bool result = node->GetAsDouble(&value);
         DCHECK(result);
+        if (omit_double_type_preservation &&
+            value <= kint64max &&
+            value >= kint64min &&
+            std::floor(value) == value) {
+          json_string_->append(Int64ToString(static_cast<int64>(value)));
+          break;
+        }
         std::string real = DoubleToString(value);
         // Ensure that the number has a .0 if there's no decimal or 'e'.  This
         // makes sure that when we read the JSON back, it's interpreted as a
         // real rather than an int.
         if (real.find('.') == std::string::npos &&
             real.find('e') == std::string::npos &&
             real.find('E') == std::string::npos) {
           real.append(".0");
         }
         // The JSON spec requires that non-integer values in the range (-1,1)
@@ skipping 36 matching lines @@
           if (omit_binary_values && value->GetType() == Value::TYPE_BINARY) {
             continue;
           }
 
           if (i != 0) {
             json_string_->append(",");
             if (pretty_print_)
               json_string_->append(" ");
           }
 
-          BuildJSONString(value, depth, escape, omit_binary_values);
+          BuildJSONString(value, depth, escape, omit_binary_values,
+                          omit_double_type_preservation);
         }
 
         if (pretty_print_)
           json_string_->append(" ");
         json_string_->append("]");
         break;
       }
 
     case Value::TYPE_DICTIONARY:
       {
@@ skipping 21 matching lines @@
           }
 
           if (pretty_print_)
             IndentLine(depth + 1);
           AppendQuotedString(*key_itr);
           if (pretty_print_) {
             json_string_->append(": ");
           } else {
             json_string_->append(":");
           }
-          BuildJSONString(value, depth + 1, escape, omit_binary_values);
+          BuildJSONString(value, depth + 1, escape, omit_binary_values,
+                          omit_double_type_preservation);
         }
 
         if (pretty_print_) {
           json_string_->append(kPrettyPrintLineEnding);
           IndentLine(depth);
           json_string_->append("}");
         } else {
           json_string_->append("}");
         }
         break;
@@ skipping 18 matching lines @@
   JsonDoubleQuote(UTF8ToUTF16(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, ' '));
 }
 
 }  // namespace base