Make TracedValue lower overhead.

base/json/json_writer.cc

 // 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"
@@ skipping 32 matching lines @@
   bool pretty_print = !!(options & OPTIONS_PRETTY_PRINT);
 
   JSONWriter writer(escape, omit_binary_values, omit_double_type_preservation,
                     pretty_print, json);
   writer.BuildJSONString(node, 0);
 
   if (pretty_print)
     json->append(kPrettyPrintLineEnding);
 }
 
+std::string JSONWriter::DoubleToFormattedString(double value,
+    bool omit_double_type_preservation) {
+  if (omit_double_type_preservation &&
+      value <= kint64max &&
+      value >= kint64min &&
+      std::floor(value) == value) {
+    return Int64ToString(static_cast<int64>(value));
+  }
+  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)
+  // have a zero before the decimal point - ".52" is not valid, "0.52" is.
+  if (real[0] == '.') {
+    real.insert(0, "0");
+  } else if (real.length() > 1 && real[0] == '-' && real[1] == '.') {
+    // "-.1" bad "-0.1" good
+    real.insert(1, "0");
+  }
+  return real;
+}
+
 JSONWriter::JSONWriter(bool escape, bool omit_binary_values,
                        bool omit_double_type_preservation, bool pretty_print,
                        std::string* json)
     : escape_(escape),
       omit_binary_values_(omit_binary_values),
       omit_double_type_preservation_(omit_double_type_preservation),
       pretty_print_(pretty_print),
       json_string_(json) {
   DCHECK(json);
 }
@@ skipping 20 matching lines @@
         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)
-        // have a zero before the decimal point - ".52" is not valid, "0.52" is.
-        if (real[0] == '.') {
-          real.insert(0, "0");
-        } else if (real.length() > 1 && real[0] == '-' && real[1] == '.') {
-          // "-.1" bad "-0.1" good
-          real.insert(1, "0");
-        }
-        json_string_->append(real);
+        json_string_->append(DoubleToFormattedString(value,
+            omit_double_type_preservation_));
         break;
       }
 
     case Value::TYPE_STRING:
       {
         std::string value;
         bool result = node->GetAsString(&value);
         DCHECK(result);
         if (escape_) {
           JsonDoubleQuote(UTF8ToUTF16(value), true, json_string_);
@@ skipping 96 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