Tracing V2 prototype [NOT FOR REVIEW]

base/trace_event/trace_log.cc

Index: base/trace_event/trace_log.cc
diff --git a/base/trace_event/trace_log.cc b/base/trace_event/trace_log.cc
index 5692e835bab88905786ba53616796c3ff086914c..6c922e9c76806a38e6f1ef06f4128afa2233f509 100644
--- a/base/trace_event/trace_log.cc
+++ b/base/trace_event/trace_log.cc
@@ -41,6 +41,7 @@
 #include "base/trace_event/trace_sampling_thread.h"
 #include "build/build_config.h"
 
+
 #if defined(OS_WIN)
 #include "base/trace_event/trace_event_etw_export_win.h"
 #endif
@@ -205,10 +206,14 @@ class TraceLog::OptionalAutoLock {
   DISALLOW_COPY_AND_ASSIGN(OptionalAutoLock);
 };
 
+bool TraceLog::use_v2 = false;
+
 class TraceLog::ThreadLocalEventBuffer
     : public MessageLoop::DestructionObserver,
       public MemoryDumpProvider {
  public:
+   v2::ZeroCopyTraceBufferWriter* v2;
+
   explicit ThreadLocalEventBuffer(TraceLog* trace_log);
   ~ThreadLocalEventBuffer() override;
 
@@ -225,6 +230,8 @@ class TraceLog::ThreadLocalEventBuffer
 
   int generation() const { return generation_; }
 
+  v2::ZeroCopyTraceBufferWriter v2_wri;
+
  private:
   // MessageLoop::DestructionObserver
   void WillDestroyCurrentMessageLoop() override;
@@ -250,7 +257,8 @@ class TraceLog::ThreadLocalEventBuffer
 };
 
 TraceLog::ThreadLocalEventBuffer::ThreadLocalEventBuffer(TraceLog* trace_log)
-    : trace_log_(trace_log),
+    : v2_wri(&trace_log->v2_rb, 42),
+      trace_log_(trace_log),
       chunk_index_(0),
       generation_(trace_log->generation()) {
   // ThreadLocalEventBuffer is created only if the thread has a message loop, so
@@ -357,7 +365,8 @@ TraceLog::TraceLog()
       event_callback_trace_config_(TraceConfig()),
       thread_shared_chunk_index_(0),
       generation_(0),
-      use_worker_thread_(false) {
+      use_worker_thread_(false),
+      v2_rb(&v2_buf[0], sizeof(v2_buf)) {
   // Trace is enabled or disabled on one thread while other threads are
   // accessing the enabled flag. We don't care whether edge-case events are
   // traced or not, so we allow races on the enabled flag to keep the trace
@@ -569,6 +578,7 @@ void TraceLog::GetKnownCategoryGroups(
 }
 
 void TraceLog::SetEnabled(const TraceConfig& trace_config, Mode mode) {
+  memset(v2_buf, 0, sizeof(v2_buf));
   std::vector<EnabledStateObserver*> observer_list;
   {
     AutoLock lock(lock_);
@@ -1251,6 +1261,49 @@ TraceEventHandle TraceLog::AddTraceEventWithThreadIdAndTimestamp(
     OptionalAutoLock lock(&lock_);
 
     TraceEvent* trace_event = NULL;
+    if (TraceLog::use_v2) {
+      v2::TraceEventHandle evt = thread_local_event_buffer->v2_wri.AddEvent();
+      evt->set_thread_id(thread_id);
+      evt->set_timestamp(offset_event_timestamp.ToInternalValue());
+      evt->set_thread_timestamp(thread_now.ToInternalValue());
+      evt->set_type((::tracing::Event_Type) phase);
+      evt->set_category_id(static_cast<uint32_t>((uintptr_t)category_group_enabled));
+      evt->set_name_id(static_cast<uint32_t>((uintptr_t)name));
+      evt->set_id(id);
+      if (num_args > 0) {
+        tracing::EventArgsSimple* v2_args = evt->add_args_simple();
+
+        v2_args->set_arg_1_name_idx((uintptr_t) arg_names[0]);
+        switch(arg_types[0]) {
+          case TRACE_VALUE_TYPE_POINTER: {
+              // Super hack to test future convertable items. Assume that if a
+              // pointer was passed it was a pointer to a TraceEventHandle.
+              v2::TraceEventHandle* h = reinterpret_cast<v2::TraceEventHandle*>((uintptr_t)arg_values[0]);
+              *h = std::move(evt);
+            }
+            break;
+          case TRACE_VALUE_TYPE_BOOL:
+            v2_args->set_arg_1_bool_value(arg_values[0]); break;
+          // I am too lazy for all the cases :P
+          default:
+            v2_args->set_arg_1_int_value(arg_values[0]); break;
+            break;
+        }
+
+        if (num_args > 1) {
+          v2_args->set_arg_2_name_idx((uintptr_t) arg_names[1]);
+          switch(arg_types[1]) {
+            case TRACE_VALUE_TYPE_BOOL:
+              v2_args->set_arg_2_bool_value(arg_values[1]); break;
+            // I am too lazy for all the cases :P
+            default:
+              v2_args->set_arg_2_int_value(arg_values[1]); break;
+              break;
+          }
+        }
+      } // if num_args > 0
+    } else {
+
     if (thread_local_event_buffer) {
       trace_event = thread_local_event_buffer->AddTraceEvent(&handle);
     } else {
@@ -1274,7 +1327,7 @@ TraceEventHandle TraceLog::AddTraceEventWithThreadIdAndTimestamp(
                               arg_values,
                               convertable_values,
                               flags);
-
+    }  // else v2
 #if defined(OS_ANDROID)
       trace_event->SendToATrace();
 #endif