[tracing] Support ConvertableToTraceFormat argument type.

test/cctest/libplatform/test-tracing.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 <limits>
 
 #include "include/libplatform/v8-tracing.h"
 #include "src/tracing/trace-event.h"
 #include "test/cctest/cctest.h"
 
 namespace v8 {
@@ skipping 17 matching lines @@
   CHECK_EQ(trace_config->IsCategoryGroupEnabled(
                TRACE_DISABLED_BY_DEFAULT("v8.runtime")),
            true);
   delete trace_config;
 }
 
 TEST(TestTraceObject) {
   TraceObject trace_object;
   uint8_t category_enabled_flag = 41;
   trace_object.Initialize('X', &category_enabled_flag, "Test.Trace",
-                          "Test.Scope", 42, 123, 0, NULL, NULL, NULL, 0);
+                          "Test.Scope", 42, 123, 0, nullptr, nullptr, nullptr,
+                          nullptr, 0);
   CHECK_EQ('X', trace_object.phase());
   CHECK_EQ(category_enabled_flag, *trace_object.category_enabled_flag());
   CHECK_EQ(std::string("Test.Trace"), std::string(trace_object.name()));
   CHECK_EQ(std::string("Test.Scope"), std::string(trace_object.scope()));
   CHECK_EQ(0, trace_object.duration());
   CHECK_EQ(0, trace_object.cpu_duration());
 }
 
+class ConvertableToTraceFormatMock : public v8::ConvertableToTraceFormat {
+ public:
+  explicit ConvertableToTraceFormatMock(int value) : value_(value) {}
+  void AppendAsTraceFormat(std::string* out) const override {
+    *out += "[" + std::to_string(value_) + "," + std::to_string(value_) + "]";
+  }
+
+ private:
+  int value_;
+
+  DISALLOW_COPY_AND_ASSIGN(ConvertableToTraceFormatMock);
+};
+
 class MockTraceWriter : public TraceWriter {
  public:
   void AppendTraceEvent(TraceObject* trace_event) override {
     events_.push_back(trace_event->name());
   }
 
   void Flush() override {}
 
   std::vector<std::string> events() { return events_; }
 
@@ skipping 11 matching lines @@
   for (int i = 0; i < HANDLES_COUNT; ++i) {
     names[i] = "Test.EventNo" + std::to_string(i);
   }
 
   std::vector<uint64_t> handles(HANDLES_COUNT);
   uint8_t category_enabled_flag = 41;
   for (size_t i = 0; i < handles.size(); ++i) {
     TraceObject* trace_object = ring_buffer->AddTraceEvent(&handles[i]);
     CHECK_NOT_NULL(trace_object);
     trace_object->Initialize('X', &category_enabled_flag, names[i].c_str(),
-                             "Test.Scope", 42, 123, 0, NULL, NULL, NULL, 0);
+                             "Test.Scope", 42, 123, 0, nullptr, nullptr,
+                             nullptr, nullptr, 0);
     trace_object = ring_buffer->GetEventByHandle(handles[i]);
     CHECK_NOT_NULL(trace_object);
     CHECK_EQ('X', trace_object->phase());
     CHECK_EQ(names[i], std::string(trace_object->name()));
     CHECK_EQ(category_enabled_flag, *trace_object->category_enabled_flag());
   }
 
   // We should only be able to retrieve the last kChunkSize + 1.
   for (size_t i = 0; i < TraceBufferChunk::kChunkSize; ++i) {
     CHECK_NULL(ring_buffer->GetEventByHandle(handles[i]));
@@ skipping 32 matching lines @@
     TraceBuffer* ring_buffer =
         TraceBuffer::CreateTraceBufferRingBuffer(1, writer);
     tracing_controller.Initialize(ring_buffer);
     TraceConfig* trace_config = new TraceConfig();
     trace_config->AddIncludedCategory("v8-cat");
     tracing_controller.StartTracing(trace_config);
 
     TraceObject trace_object;
     trace_object.InitializeForTesting(
         'X', tracing_controller.GetCategoryGroupEnabled("v8-cat"), "Test0",
-        v8::internal::tracing::kGlobalScope, 42, 123, 0, NULL, NULL, NULL,
-        TRACE_EVENT_FLAG_HAS_ID, 11, 22, 100, 50, 33, 44);
+        v8::internal::tracing::kGlobalScope, 42, 123, 0, nullptr, nullptr,
+        nullptr, nullptr, TRACE_EVENT_FLAG_HAS_ID, 11, 22, 100, 50, 33, 44);
     writer->AppendTraceEvent(&trace_object);
     trace_object.InitializeForTesting(
         'Y', tracing_controller.GetCategoryGroupEnabled("v8-cat"), "Test1",
-        v8::internal::tracing::kGlobalScope, 43, 456, 0, NULL, NULL, NULL, 0,
-        55, 66, 110, 55, 77, 88);
+        v8::internal::tracing::kGlobalScope, 43, 456, 0, nullptr, nullptr,
+        nullptr, nullptr, 0, 55, 66, 110, 55, 77, 88);
     writer->AppendTraceEvent(&trace_object);
     tracing_controller.StopTracing();
   }
 
   std::string trace_str = stream.str();
   std::string expected_trace_str =
       "{\"traceEvents\":[{\"pid\":11,\"tid\":22,\"ts\":100,\"tts\":50,"
       "\"ph\":\"X\",\"cat\":\"v8-cat\",\"name\":\"Test0\",\"dur\":33,"
       "\"tdur\":44,\"id\":\"0x2a\",\"args\":{}},{\"pid\":55,\"tid\":66,"
       "\"ts\":110,\"tts\":55,\"ph\":\"Y\",\"cat\":\"v8-cat\",\"name\":"
@@ skipping 109 matching lines @@
     TRACE_EVENT2("v8", "v8.Test2.2", "mm1", TRACE_STR_COPY(mm.c_str()), "mm2",
                  TRACE_STR_COPY(mmm.c_str()));
 
     // Check copies are correct.
     TRACE_EVENT_COPY_INSTANT0("v8", mm.c_str(), TRACE_EVENT_SCOPE_THREAD);
     TRACE_EVENT_COPY_INSTANT2("v8", mm.c_str(), TRACE_EVENT_SCOPE_THREAD, "mm1",
                               mm.c_str(), "mm2", mmm.c_str());
     mm = "CHANGED";
     mmm = "CHANGED";
 
+    TRACE_EVENT_INSTANT1("v8", "v8.Test", TRACE_EVENT_SCOPE_THREAD, "a1",
+                         new ConvertableToTraceFormatMock(42));
+    std::unique_ptr<ConvertableToTraceFormatMock> trace_event_arg(
+        new ConvertableToTraceFormatMock(42));
+    TRACE_EVENT_INSTANT2("v8", "v8.Test", TRACE_EVENT_SCOPE_THREAD, "a1",
+                         std::move(trace_event_arg), "a2",
+                         new ConvertableToTraceFormatMock(123));
+
     tracing_controller.StopTracing();
   }
 
   std::string trace_str = stream.str();
 
   std::vector<std::string> all_args, all_names, all_cats;
   GetJSONStrings(all_args, trace_str, "\"args\"", "{", "}");
   GetJSONStrings(all_names, trace_str, "\"name\"", "\"", "\"");
   GetJSONStrings(all_cats, trace_str, "\"cat\"", "\"", "\"");
 
-  CHECK_EQ(all_args.size(), 22);
+  CHECK_EQ(all_args.size(), 24);
   CHECK_EQ(all_args[0], "\"aa\":11");
   CHECK_EQ(all_args[1], "\"bb\":22");
   CHECK_EQ(all_args[2], "\"cc\":33");
   CHECK_EQ(all_args[3], "\"dd\":44");
   CHECK_EQ(all_args[4], "\"ee\":-55");
   CHECK_EQ(all_args[5], "\"ff\":-66");
   CHECK_EQ(all_args[6], "\"gg\":-77");
   CHECK_EQ(all_args[7], "\"hh\":-88");
   CHECK_EQ(all_args[8], "\"ii1\":true");
   CHECK_EQ(all_args[9], "\"ii2\":false");
   CHECK_EQ(all_args[10], "\"jj1\":99.0");
   CHECK_EQ(all_args[11], "\"jj2\":1e+100");
   CHECK_EQ(all_args[12], "\"jj3\":\"NaN\"");
   CHECK_EQ(all_args[13], "\"jj4\":\"Infinity\"");
   CHECK_EQ(all_args[14], "\"jj5\":\"-Infinity\"");
   std::ostringstream pointer_stream;
   pointer_stream << "\"kk\":\"" << &aa << "\"";
   CHECK_EQ(all_args[15], pointer_stream.str());
   CHECK_EQ(all_args[16], "\"ll\":\"100\"");
   CHECK_EQ(all_args[17], "\"mm\":\"\\\"INIT\\\"\"");
 
   CHECK_EQ(all_names[18], "v8.Test2.1");
   CHECK_EQ(all_args[18], "\"aa\":11,\"ll\":\"100\"");
   CHECK_EQ(all_args[19], "\"mm1\":\"INIT\",\"mm2\":\"\\\"INIT\\\"\"");
 
   CHECK_EQ(all_names[20], "INIT");
   CHECK_EQ(all_names[21], "INIT");
   CHECK_EQ(all_args[21], "\"mm1\":\"INIT\",\"mm2\":\"\\\"INIT\\\"\"");
+  CHECK_EQ(all_args[22], "\"a1\":[42,42]");
+  CHECK_EQ(all_args[23], "\"a1\":[42,42],\"a2\":[123,123]");
 
   i::V8::SetPlatformForTesting(old_platform);
 }
 
 }  // namespace tracing
 }  // namespace platform
 }  // namespace v8