[tracing] Make TracedValue accept const char* strings

src/tracing/traced-value.cc

 // Copyright 2016 the V8 project 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 "src/tracing/traced-value.h"
 
 #include "src/base/platform/platform.h"
 
 namespace v8 {
 namespace tracing {
 
 namespace {
 
 #define DCHECK_CURRENT_CONTAINER_IS(x) DCHECK_EQ(x, nesting_stack_.back())
 #define DCHECK_CONTAINER_STACK_DEPTH_EQ(x) DCHECK_EQ(x, nesting_stack_.size())
 #ifdef DEBUG
 const bool kStackTypeDict = false;
 const bool kStackTypeArray = true;
 #define DEBUG_PUSH_CONTAINER(x) nesting_stack_.push_back(x)
 #define DEBUG_POP_CONTAINER() nesting_stack_.pop_back()
 #else
 #define DEBUG_PUSH_CONTAINER(x) ((void)0)
 #define DEBUG_POP_CONTAINER() ((void)0)
 #endif
 
-std::string EscapeString(const std::string& value) {
-  std::string result;
-  result.reserve(value.length() + 2);
-  result += '"';
-  size_t length = value.length();
+void EscapeAndAppendString(const char* value, std::string* result) {
+  *result += '"';
   char number_buffer[10];
-  for (size_t src = 0; src < length; ++src) {
-    char c = value[src];
+  while (*value) {
+    char c = *value++;
     switch (c) {
       case '\t':
-        result += "\\t";
+        *result += "\\t";
         break;
       case '\n':
-        result += "\\n";
+        *result += "\\n";
         break;
       case '\"':
-        result += "\\\"";
+        *result += "\\\"";
         break;
       case '\\':
-        result += "\\\\";
+        *result += "\\\\";
         break;
       default:
         if (c < '\040') {
           base::OS::SNPrintF(
               number_buffer, arraysize(number_buffer), "\\u%04X",
               static_cast<unsigned>(static_cast<unsigned char>(c)));
-          result += number_buffer;
+          *result += number_buffer;
         } else {
-          result += c;
+          *result += c;
         }
     }
   }
-  result += '"';
-  return result;
+  *result += '"';
 }
 
 }  // namespace
 
 std::unique_ptr<TracedValue> TracedValue::Create() {
   return std::unique_ptr<TracedValue>(new TracedValue());
 }
 
 TracedValue::TracedValue() : first_item_(true) {
   DEBUG_PUSH_CONTAINER(kStackTypeDict);
@@ skipping 16 matching lines @@
   WriteName(name);
   data_ += std::to_string(value);
 }
 
 void TracedValue::SetBoolean(const char* name, bool value) {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
   WriteName(name);
   data_ += value ? "true" : "false";
 }
 
-void TracedValue::SetString(const char* name, const std::string& value) {
+void TracedValue::SetString(const char* name, const char* value) {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
   WriteName(name);
-  data_ += EscapeString(value);
+  EscapeAndAppendString(value, &data_);
 }
 
 void TracedValue::BeginDictionary(const char* name) {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeDict);
   DEBUG_PUSH_CONTAINER(kStackTypeDict);
   WriteName(name);
   data_ += '{';
   first_item_ = true;
 }
 
@@ skipping 16 matching lines @@
   WriteComma();
   data_ += std::to_string(value);
 }
 
 void TracedValue::AppendBoolean(bool value) {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray);
   WriteComma();
   data_ += value ? "true" : "false";
 }
 
-void TracedValue::AppendString(const std::string& value) {
+void TracedValue::AppendString(const char* value) {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray);
   WriteComma();
-  data_ += EscapeString(value);
+  EscapeAndAppendString(value, &data_);
 }
 
 void TracedValue::BeginDictionary() {
   DCHECK_CURRENT_CONTAINER_IS(kStackTypeArray);
   DEBUG_PUSH_CONTAINER(kStackTypeDict);
   WriteComma();
   data_ += '{';
   first_item_ = true;
 }
 
@@ skipping 35 matching lines @@
 }
 
 void TracedValue::AppendAsTraceFormat(std::string* out) const {
   *out += '{';
   *out += data_;
   *out += '}';
 }
 
 }  // namespace tracing
 }  // namespace v8