[Tracing] Expose trace serialization as part of tracing interface

src/libplatform/tracing/trace-serializer.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/libplatform/tracing/trace-writer.h"
+#include <cmath>
 
-#include <cmath>
+#include "include/libplatform/v8-tracing.h"
 
 #include "base/trace_event/common/trace_event_common.h"
 #include "src/base/platform/platform.h"
 
 namespace v8 {
 namespace platform {
 namespace tracing {
 
-// Currently we do not support JSON-escaping strings in trace arguments.
-// Thus we perform an IsJSONString() check before writing any string argument.
-// In particular, this means strings cannot have control characters or \.
-V8_INLINE static bool IsJSONString(const char* str) {
+// Writes the given string to a stream, taking care to escape characters
+// when necessary.
+V8_INLINE static void WriteJSONStringToStream(const char* str,
+                                              std::ostream& stream) {
   size_t len = strlen(str);
+  stream << "\"";
   for (size_t i = 0; i < len; ++i) {
-    if (iscntrl(str[i]) || str[i] == '\\') {
-      return false;
+    // All of the permitted escape sequences in JSON strings, as per
+    // https://mathiasbynens.be/notes/javascript-escapes
+    switch (str[i]) {
+      case '\b':
+        stream << "\\b";
+        break;
+      case '\f':
+        stream << "\\f";
+        break;
+      case '\n':
+        stream << "\\n";
+        break;
+      case '\r':
+        stream << "\\r";
+        break;
+      case '\t':
+        stream << "\\t";
+        break;
+      case '\"':
+        stream << "\\\"";
+        break;
+      case '\\':
+        stream << "\\\\";
+        break;
+      // Note that because we use double quotes for JSON strings,
+      // we don't need to escape single quotes.
+      default:
+        stream << str[i];
+        break;
     }
   }
-  return true;
+  stream << "\"";
 }
 
-void JSONTraceWriter::AppendArgValue(uint8_t type,
+void TraceSerializer::AppendArgValue(uint8_t type,
                                      TraceObject::ArgValue value) {
   switch (type) {
     case TRACE_VALUE_TYPE_BOOL:
       stream_ << (value.as_bool ? "true" : "false");
       break;
     case TRACE_VALUE_TYPE_UINT:
       stream_ << value.as_uint;
       break;
     case TRACE_VALUE_TYPE_INT:
       stream_ << value.as_int;
@@ skipping 25 matching lines @@
       stream_ << real;
       break;
     }
     case TRACE_VALUE_TYPE_POINTER:
       // JSON only supports double and int numbers.
       // So as not to lose bits from a 64-bit pointer, output as a hex string.
       stream_ << "\"" << value.as_pointer << "\"";
       break;
     case TRACE_VALUE_TYPE_STRING:
     case TRACE_VALUE_TYPE_COPY_STRING:
-      // Strings are currently not JSON-escaped, so we need to perform a check
-      // to see if they are valid JSON strings.
-      CHECK(value.as_string != nullptr && IsJSONString(value.as_string));
-      stream_ << (value.as_string ? value.as_string : "NULL");
+      if (value.as_string == nullptr) {
+        stream_ << "\"NULL\"";
+      } else {
+        WriteJSONStringToStream(value.as_string, stream_);
+      }
       break;
     default:
       UNREACHABLE();
       break;
   }
 }
 
-JSONTraceWriter::JSONTraceWriter(std::ostream& stream) : stream_(stream) {
+TraceSerializer::TraceSerializer(std::ostream& stream) : stream_(stream) {}
+
+void TraceSerializer::WritePrefix() {
   stream_ << "{\"traceEvents\":[";
+  append_comma_ = false;
 }
 
-JSONTraceWriter::~JSONTraceWriter() { stream_ << "]}"; }
+void TraceSerializer::WriteSuffix() { stream_ << "]}"; }
 
-void JSONTraceWriter::AppendTraceEvent(TraceObject* trace_event) {
+void TraceSerializer::AppendTraceEvent(TraceObject* trace_event) {
   if (append_comma_) stream_ << ",";
   append_comma_ = true;
   stream_ << "{\"pid\":" << trace_event->pid()
           << ",\"tid\":" << trace_event->tid()
           << ",\"ts\":" << trace_event->ts()
           << ",\"tts\":" << trace_event->tts() << ",\"ph\":\""
           << trace_event->phase() << "\",\"cat\":\""
           << TracingController::GetCategoryGroupName(
                  trace_event->category_enabled_flag())
           << "\",\"name\":\"" << trace_event->name()
@@ skipping 13 matching lines @@
   TraceObject::ArgValue* arg_values = trace_event->arg_values();
   for (int i = 0; i < trace_event->num_args(); ++i) {
     if (i > 0) stream_ << ",";
     stream_ << "\"" << arg_names[i] << "\":";
     AppendArgValue(arg_types[i], arg_values[i]);
   }
   stream_ << "}}";
   // TODO(fmeawad): Add support for Flow Events.
 }
 
-void JSONTraceWriter::Flush() {}
-
-TraceWriter* TraceWriter::CreateJSONTraceWriter(std::ostream& stream) {
-  return new JSONTraceWriter(stream);
-}
-
 }  // namespace tracing
 }  // namespace platform
 }  // namespace v8