Report trace event overhead stat with metadata

base/debug/trace_event_impl.cc

 // Copyright (c) 2012 The Chromium 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 "base/debug/trace_event_impl.h"
 
 #include <algorithm>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
@@ skipping 798 matching lines @@
   TimeDelta overhead_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadLocalEventBuffer);
 };
 
 TraceLog::ThreadLocalEventBuffer::ThreadLocalEventBuffer(TraceLog* trace_log)
     : trace_log_(trace_log),
       event_count_(0) {
   logged_events_.reserve(kTraceEventThreadLocalBufferSize);
 
-  if (g_category_group_enabled[g_category_trace_event_overhead]) {
-    int thread_id = static_cast<int>(PlatformThread::CurrentId());
-    logged_events_.push_back(TraceEvent(
-        thread_id,
-        TimeTicks::NowFromSystemTraceTime() - trace_log->time_offset_,
-        ThreadNow(),
-        TRACE_EVENT_PHASE_ASYNC_BEGIN,
-        &g_category_group_enabled[g_category_trace_event_overhead],
-        "thread_trace_event",
-        thread_id,
-        0, NULL, NULL, NULL, NULL,
-        TRACE_EVENT_FLAG_HAS_ID));
-  }
-
   // ThreadLocalEventBuffer is created only if the thread has a message loop, so
   // the following message_loop won't be NULL.
   MessageLoop* message_loop = MessageLoop::current();
   message_loop->AddDestructionObserver(this);
 
   AutoLock lock(trace_log->lock_);
   trace_log->thread_message_loops_.insert(message_loop);
 }
 
 TraceLog::ThreadLocalEventBuffer::~ThreadLocalEventBuffer() {
   CheckThisIsCurrentBuffer();
   MessageLoop::current()->RemoveDestructionObserver(this);
 
   // Zero event_count_ happens in either of the following cases:
   // - no event generated for the thread;
   // - the thread has no message loop;
   // - trace_event_overhead is disabled.
-  // The trace-viewer will ignore the TRACE_EVENT_PHASE_ASYNC_BEGIN event
-  // because of no matching TRACE_EVENT_PHASE_ASYNC_END event.
   if (event_count_) {
     const char* arg_names[2] = { "event_count", "average_overhead" };
     unsigned char arg_types[2];
     unsigned long long arg_values[2];
     trace_event_internal::SetTraceValue(
         event_count_, &arg_types[0], &arg_values[0]);
     trace_event_internal::SetTraceValue(
         overhead_.InMillisecondsF() / event_count_,
         &arg_types[1], &arg_values[1]);
-    int thread_id = static_cast<int>(PlatformThread::CurrentId());
     logged_events_.push_back(TraceEvent(
-        thread_id,
-        TimeTicks::NowFromSystemTraceTime() - trace_log_->time_offset_,
-        ThreadNow(),
-        TRACE_EVENT_PHASE_ASYNC_END,
-        &g_category_group_enabled[g_category_trace_event_overhead],
-        "thread_trace_event",
-        thread_id,
+        static_cast<int>(PlatformThread::CurrentId()),
+        TimeTicks(), TimeTicks(), TRACE_EVENT_PHASE_METADATA,
+        &g_category_group_enabled[g_category_metadata],
+        "trace_event_overhead", trace_event_internal::kNoEventId,
         2, arg_names, arg_types, arg_values, NULL,
-        TRACE_EVENT_FLAG_HAS_ID));
+        TRACE_EVENT_FLAG_NONE));
   }
 
   NotificationHelper notifier(trace_log_);
   {
     AutoLock lock(trace_log_->lock_);
     FlushWhileLocked(&notifier);
     trace_log_->thread_message_loops_.erase(MessageLoop::current());
   }
   trace_log_->thread_local_event_buffer_.Set(NULL);
   notifier.SendNotificationIfAny();
@@ skipping 1149 matching lines @@
         0,                       // num_args
         NULL,                    // arg_names
         NULL,                    // arg_types
         NULL,                    // arg_values
         NULL,                    // convertable values
         TRACE_EVENT_FLAG_NONE);  // flags
   }
 }
 
 }  // namespace trace_event_internal