trace_event support for thread names

base/debug/trace_event.cc

 // Copyright (c) 2011 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.h"
 
 #if defined(OS_WIN)
 #include "base/debug/trace_event_win.h"
 #endif
 #include "base/format_macros.h"
@@ skipping 86 matching lines @@
 namespace {
 
 const char* GetPhaseStr(TraceEventPhase phase) {
   switch(phase) {
     case TRACE_EVENT_PHASE_BEGIN:
       return "B";
     case TRACE_EVENT_PHASE_INSTANT:
       return "I";
     case TRACE_EVENT_PHASE_END:
       return "E";
+    case TRACE_EVENT_PHASE_METADATA:
+      return "M";
     default:
       NOTREACHED() << "Invalid phase argument";
       return "?";
   }
 }
 
 size_t GetAllocLength(const char* str) { return str ? strlen(str) + 1 : 0; }
 
 // Copies |*member| into |*buffer|, sets |*member| to point to this new
 // location, and then advances |*buffer| by the amount written.
@@ skipping 171 matching lines @@
     if (enabled == enabled_)
       return;
     logged_events_.reserve(1024);
     enabled_ = enabled;
     for (int i = 0; i < g_category_index; i++) {
       //TODO(scheib): If changed to enable specific categories instead of all
       // check GetCategoryInternal creation code that users TraceLog::enabled_
       g_categories[i].enabled = enabled;
     }
   } // release lock
-  if (!enabled)
+  if (!enabled) {
+    AddCurrentMetadataEvents();
     Flush();
+  }
 }
 
 float TraceLog::GetBufferPercentFull() const {
   return (float)((double)logged_events_.size()/(double)kTraceEventBufferSize);
 }
 
 void TraceLog::SetOutputCallback(const TraceLog::OutputCallback& cb) {
   AutoLock lock(lock_);
   output_callback_ = cb;
   logged_events_.clear();
@@ skipping 102 matching lines @@
     TraceLog* tracelog = TraceLog::GetInstance();
     if (!tracelog)
       return;
     tracelog->AddTraceEvent(phase, category, name,
                             "id", id,
                             "extra", extra ? extra : "",
                             -1, 0, false);
   }
 }
 
+void TraceLog::SetCurrentThreadName(const char* name) {
+  AutoLock lock(lock_);
+  thread_names_[PlatformThread::CurrentId()] = name;
+}
+
+void TraceLog::AddCurrentMetadataEvents() {
+  const TraceCategory* metadata_category = GetCategoryInternal("__metadata");

[joth, 2011/07/26 09:53:17]

static const?

+#ifdef USE_UNRELIABLE_NOW
+  TimeTicks now = TimeTicks::HighResNow();

[jbates, 2011/07/26 20:57:00]

can we replace the timestamp with 0 for metadata events or would that trip up
the javascript range calculation?

+#else
+  TimeTicks now = TimeTicks::Now();
+#endif
+  for(base::hash_map<PlatformThreadId, std::string>::iterator it =
+          thread_names_.begin();
+      it != thread_names_.end();
+      it++) {
+    logged_events_.push_back(
+        TraceEvent(static_cast<unsigned long>(base::GetCurrentProcId()),
+                   it->first,
+                   now, base::debug::TRACE_EVENT_PHASE_METADATA,
+                   metadata_category, "thread_name",
+                   "name", it->second.c_str(),
+                   NULL, 0,
+                   true));

[joth, 2011/07/26 09:53:17]

you can pass false here. (The only thing that needs copying is the arg value,
and that's always copied)

+  }
+}
+
 void TraceLog::Resurrect() {
   StaticMemorySingletonTraits<TraceLog>::Resurrect();
 }
 
 namespace internal {
 
 void TraceEndOnScopeClose::Initialize(const TraceCategory* category,
                                       const char* name) {
   data_.category = category;
   data_.name = name;
@@ skipping 32 matching lines @@
         p_data_->name,
         NULL, 0, NULL, 0,
         p_data_->threshold_begin_id, p_data_->threshold, false);
   }
 }
 
 } // namespace internal
 
 }  // namespace debug
 }  // namespace base