TraceEvent fixes for thread name changes

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/ref_counted_memory.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/singleton.h"
 #include "base/process_util.h"
 #include "base/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
+#include "base/threading/platform_thread.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 {
 
 namespace {
 
@@ skipping 19 matching lines @@
   bool FindNamePhase(const char* name, const char* phase);
   bool FindMatchingValue(const char* key,
                          const char* value);
   bool FindNonMatchingValue(const char* key,
                             const char* value);
   void Clear() {
     trace_parsed_.Clear();
     json_output_.json_output.clear();
   }
 
+  virtual void SetUp() {
+    old_thread_name_ = PlatformThread::GetName();
+  }
+  virtual void TearDown() {
+    PlatformThread::SetName(old_thread_name_);
+  }
+
+  const char* old_thread_name_;
   ListValue trace_parsed_;
   base::debug::TraceResultBuffer trace_buffer_;
   base::debug::TraceResultBuffer::SimpleOutput json_output_;
 
  private:
   // We want our singleton torn down after each test.
   ShadowingAtExitManager at_exit_manager_;
   Lock lock_;
 };
 
@@ skipping 706 matching lines @@
   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);
+    ASSERT_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);
     }
   }
 }
 
+TEST_F(TraceEventTestFixture, ThreadNameChanges) {
+  ManualTestSetUp();
+
+  TraceLog::GetInstance()->SetEnabled(true);
+
+  PlatformThread::SetName(NULL);
+  TRACE_EVENT_INSTANT0("drink", "water");
+
+  PlatformThread::SetName("cafe");
+  TRACE_EVENT_INSTANT0("drink", "coffee");
+
+  PlatformThread::SetName("shop");
+  // No event here, so won't appear in combined name.
+
+  PlatformThread::SetName("pub");
+  TRACE_EVENT_INSTANT0("drink", "beer");
+  TRACE_EVENT_INSTANT0("drink", "wine");
+
+  PlatformThread::SetName(" bar");
+  TRACE_EVENT_INSTANT0("drink", "whisky");
+
+  TraceLog::GetInstance()->SetEnabled(false);
+
+  std::vector<DictionaryValue*> items =
+      FindTraceEntries(trace_parsed_, "thread_name");
+  EXPECT_EQ(1u, items.size());
+  ASSERT_GT(items.size(), 0u);
+  DictionaryValue* item = items[0];
+  ASSERT_TRUE(item);
+  int tid;
+  EXPECT_TRUE(item->GetInteger("tid", &tid));
+  EXPECT_EQ(PlatformThread::CurrentId(), static_cast<PlatformThreadId>(tid));
+
+  std::string expected_name = "cafe,pub, bar";
+  std::string tmp;
+  EXPECT_TRUE(item->GetString("args.name", &tmp));
+  EXPECT_EQ(expected_name, tmp);
+}
 
 // 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
@@ skipping 137 matching lines @@
   Clear();
 
   trace_buffer_.Start();
   trace_buffer_.AddFragment("bla1,bla2,bla3,bla4");
   trace_buffer_.Finish();
   EXPECT_STREQ(json_output_.json_output.c_str(), "[bla1,bla2,bla3,bla4]");
 }
 
 }  // namespace debug
 }  // namespace base