trace_event support for thread names

base/debug/trace_event_unittest.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"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/process_util.h"
 #include "base/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/values.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace debug {
 
@@ skipping 125 matching lines @@
   // Recurse to test arguments
   DictionaryValue* args_dict = NULL;
   dict->GetDictionary("args", &args_dict);
   if (args_dict)
     return IsStringInDict(string_to_match, args_dict);
 
   return false;
 }
 
 DictionaryValue* FindTraceEntry(const ListValue& trace_parsed,
-                                const char *string_to_match,
+                                const char* string_to_match,
                                 DictionaryValue* match_after_this_item = NULL) {
   // Scan all items
   size_t trace_parsed_count = trace_parsed.GetSize();
   for (size_t i = 0; i < trace_parsed_count; i++) {
     Value* value = NULL;
     trace_parsed.Get(i, &value);
     if (match_after_this_item) {
       if (value == match_after_this_item)
          match_after_this_item = NULL;
       continue;
     }
     if (!value || value->GetType() != Value::TYPE_DICTIONARY)
       continue;
     DictionaryValue* dict = static_cast<DictionaryValue*>(value);
 
     if (IsStringInDict(string_to_match, dict))
       return dict;
   }
   return NULL;
 }
 
+std::vector<DictionaryValue*> FindTraceEntries(
+    const ListValue& trace_parsed,
+    const char* string_to_match) {
+  std::vector<DictionaryValue*> hits;
+  size_t trace_parsed_count = trace_parsed.GetSize();
+  for (size_t i = 0; i < trace_parsed_count; i++) {
+    Value* value = NULL;
+    trace_parsed.Get(i, &value);
+    if (!value || value->GetType() != Value::TYPE_DICTIONARY)
+      continue;
+    DictionaryValue* dict = static_cast<DictionaryValue*>(value);
+
+    if (IsStringInDict(string_to_match, dict))
+      hits.push_back(dict);
+  }
+  return hits;
+}
+
 void DataCapturedCallTraces(WaitableEvent* task_complete_event) {
   {
     TRACE_EVENT_BEGIN_ETW("TRACE_EVENT_BEGIN_ETW call", 1122, "extrastring1");
     TRACE_EVENT_END_ETW("TRACE_EVENT_END_ETW call", 3344, "extrastring2");
     TRACE_EVENT_INSTANT_ETW("TRACE_EVENT_INSTANT_ETW call",
                             5566, "extrastring3");
 
     TRACE_EVENT0("all", "TRACE_EVENT0 call");
     TRACE_EVENT1("all", "TRACE_EVENT1 call", "name1", "value1");
     TRACE_EVENT2("all", "TRACE_EVENT2 call",
@@ skipping 297 matching lines @@
   for (int i = 0; i < num_threads; i++) {
     threads[i]->Stop();
     delete threads[i];
     delete task_complete_events[i];
   }
 
   DataCapturedValidateManyTraces(trace_parsed_, trace_string_,
                                   num_threads, num_events);
 }
 
+// Test that thread and process names show up in the trace
+TEST_F(TraceEventTestFixture, ThreadNames) {
+  ManualTestSetUp();
+
+  // Create threads before we enable tracing to make sure
+  // that tracelog still captures them.
+  const int num_threads = 4;
+  const int num_events = 10;
+  Thread* threads[num_threads];
+  PlatformThreadId thread_ids[num_threads];
+  for (int i = 0; i < num_threads; i++)
+    threads[i] = new Thread(StringPrintf("Thread %d", i).c_str());
+
+  // Enable tracing.
+  TraceLog::GetInstance()->SetEnabled(true);
+
+  // Now run some trace code on these threads.
+  WaitableEvent* task_complete_events[num_threads];
+  for (int i = 0; i < num_threads; i++) {
+    task_complete_events[i] = new WaitableEvent(false, false);
+    threads[i]->Start();
+    thread_ids[i] = threads[i]->thread_id();
+    threads[i]->message_loop()->PostTask(
+      FROM_HERE, NewRunnableFunction(&DataCapturedCallManyTraces,
+                                     i, num_events, task_complete_events[i]));
+  }
+  for (int i = 0; i < num_threads; i++) {
+    task_complete_events[i]->Wait();
+  }
+
+  // Shut things down.
+  TraceLog::GetInstance()->SetEnabled(false);
+  for (int i = 0; i < num_threads; i++) {
+    threads[i]->Stop();
+    delete threads[i];
+    delete task_complete_events[i];
+  }
+
+  std::string tmp;
+  int tmp_int;
+  DictionaryValue* item;
+
+  // Make sure we get thread name metadata.
+  // Note, the test suite may have created a ton of threads.
+  // So, we'll have thread names for threads we didn't create.
+  std::vector<DictionaryValue*> items =
+      FindTraceEntries(trace_parsed_, "thread_name");
+  for (int i = 0; i < static_cast<int>(items.size()); i++) {
+    item = items[i];
+    EXPECT_TRUE(item);
+    EXPECT_TRUE(item->GetInteger("tid", &tmp_int));
+
+    // See if this thread name is one of the threads we just created
+    for (int j = 0; j < num_threads; j++) {
+      if(static_cast<int>(thread_ids[j]) != tmp_int)
+        continue;
+
+      std::string expected_name = StringPrintf("Thread %d", j).c_str();
+      EXPECT_TRUE(item->GetString("ph", &tmp) && tmp == "M");
+      EXPECT_TRUE(item->GetInteger("pid", &tmp_int) &&
+                  tmp_int == static_cast<int>(base::GetCurrentProcId()));
+      EXPECT_TRUE(item->GetString("args.name", &tmp) &&
+                  tmp == expected_name);
+    }
+  }
+}
+
+namespace {
+
 void TraceCallsWithCachedCategoryPointersPointers(const char* name_str) {
   TRACE_EVENT0("category name1", name_str);
   TRACE_EVENT_INSTANT0("category name2", name_str);
   TRACE_EVENT_BEGIN0("category name3", name_str);
   TRACE_EVENT_END0("category name4", name_str);
 }
 
+
+}  // namespace
+
+
 // Test trace calls made after tracing singleton shut down.
 //
 // The singleton is destroyed by our base::AtExitManager, but there can be
 // code still executing as the C++ static objects are destroyed. This test
 // forces the singleton to destroy early, and intentinally makes trace calls
 // afterwards.
 TEST_F(TraceEventTestFixture, AtExit) {
   // Repeat this test a few times. Besides just showing robustness, it also
   // allows us to test that events at shutdown do not appear with valid events
   // recorded after the system is started again.
@@ skipping 114 matching lines @@
 
   std::string s;
   EXPECT_TRUE(entry3->GetString("args.arg1", &s));
   EXPECT_EQ("val1", s);
   EXPECT_TRUE(entry3->GetString("args.arg2", &s));
   EXPECT_EQ("val2", s);
 }
 
 }  // namespace debug
 }  // namespace base