[Tracing] V8 Tracing Controller - Add args and copy support

include/libplatform/v8-tracing.h

 // 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.
 
 #ifndef V8_LIBPLATFORM_V8_TRACING_H_
 #define V8_LIBPLATFORM_V8_TRACING_H_
 
 #include <fstream>
 #include <memory>
 #include <vector>
 
+#include "include/v8.h"

[lpy, 2016/07/28 21:18:20]

Please do not include v8.h here.

[rskang, 2016/07/28 22:44:27]

Done.

+
 namespace v8 {
 namespace platform {
 namespace tracing {
 
+const int kTraceMaxNumArgs = 2;
+
 class TraceObject {
  public:
+  union TraceValue {
+    bool as_bool;
+    uint64_t as_uint;
+    int64_t as_int;
+    double as_double;
+    const void* as_pointer;
+    const char* as_string;
+  };
+
   TraceObject() {}
+  ~TraceObject();
   void Initialize(char phase, const uint8_t* category_enabled_flag,
                   const char* name, const char* scope, uint64_t id,
                   uint64_t bind_id, int num_args, const char** arg_names,
                   const uint8_t* arg_types, const uint64_t* arg_values,
                   unsigned int flags);
   void UpdateDuration();
   void InitializeForTesting(char phase, const uint8_t* category_enabled_flag,
                             const char* name, const char* scope, uint64_t id,
                             uint64_t bind_id, int num_args,
                             const char** arg_names, const uint8_t* arg_types,
                             const uint64_t* arg_values, unsigned int flags,
                             int pid, int tid, int64_t ts, int64_t tts,
                             uint64_t duration, uint64_t cpu_duration);
 
   int pid() const { return pid_; }
   int tid() const { return tid_; }
   char phase() const { return phase_; }
   const uint8_t* category_enabled_flag() const {
     return category_enabled_flag_;
   }
   const char* name() const { return name_; }
   const char* scope() const { return scope_; }
   uint64_t id() const { return id_; }
   uint64_t bind_id() const { return bind_id_; }
+  TraceValue* arg_values() { return arg_values_; }
+  const char** arg_names() { return arg_names_; }
+  uint8_t* arg_types() { return arg_types_; }
   unsigned int flags() const { return flags_; }
   int64_t ts() { return ts_; }
   int64_t tts() { return tts_; }
   uint64_t duration() { return duration_; }
   uint64_t cpu_duration() { return cpu_duration_; }
 
  private:
   int pid_;
   int tid_;
   char phase_;
   const char* name_;
   const char* scope_;
   const uint8_t* category_enabled_flag_;
   uint64_t id_;
   uint64_t bind_id_;
-  int num_args_;
+  TraceValue arg_values_[kTraceMaxNumArgs];
+  const char* arg_names_[kTraceMaxNumArgs];
+  uint8_t arg_types_[kTraceMaxNumArgs];
+  char* parameter_copy_storage_ = nullptr;
   unsigned int flags_;
   int64_t ts_;
   int64_t tts_;
   uint64_t duration_;
   uint64_t cpu_duration_;
-  // TODO(fmeawad): Add args support.
 
   // Disallow copy and assign
   TraceObject(const TraceObject&) = delete;
   void operator=(const TraceObject&) = delete;
 };
 
 class TraceWriter {
  public:
   TraceWriter() {}
   virtual ~TraceWriter() {}
   virtual void AppendTraceEvent(TraceObject* trace_event) = 0;
   virtual void Flush() = 0;
 
-  static TraceWriter* CreateJSONTraceWriter(std::ostream& stream);
+  static TraceWriter* CreateJSONTraceWriter(Isolate* isolate,
+                                            std::ostream& stream);
 
  private:
   // Disallow copy and assign
   TraceWriter(const TraceWriter&) = delete;
   void operator=(const TraceWriter&) = delete;
 };
 
 class TraceBufferChunk {
  public:
   explicit TraceBufferChunk(uint32_t seq);
@@ skipping 134 matching lines @@
   // Disallow copy and assign
   TracingController(const TracingController&) = delete;
   void operator=(const TracingController&) = delete;
 };
 
 }  // namespace tracing
 }  // namespace platform
 }  // namespace v8
 
 #endif  // V8_LIBPLATFORM_V8_TRACING_H_