Add trace code to track all posted tasks in message_loop.

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"
@@ skipping 40 matching lines @@
     trace_string_.clear();
     trace_parsed_.Clear();
   }
 
   std::string trace_string_;
   ListValue trace_parsed_;
 
  private:
   // We want our singleton torn down after each test.
   ShadowingAtExitManager at_exit_manager_;
+  Lock lock_;
 };
 
 void TraceEventTestFixture::ManualTestSetUp() {
+  TraceLog::DeleteForTesting();
   TraceLog::Resurrect();
   TraceLog* tracelog = TraceLog::GetInstance();
   ASSERT_TRUE(tracelog);
   ASSERT_FALSE(tracelog->IsEnabled());
   tracelog->SetOutputCallback(
-    base::Bind(&TraceEventTestFixture::OnTraceDataCollected,
-               base::Unretained(this)));
+      base::Bind(&TraceEventTestFixture::OnTraceDataCollected,
+                 base::Unretained(this)));
 }
 
 void TraceEventTestFixture::OnTraceDataCollected(
     scoped_refptr<TraceLog::RefCountedString> json_events_str) {
+  AutoLock lock(lock_);
   trace_string_ += json_events_str->data;
 
   scoped_ptr<Value> root;
   root.reset(base::JSONReader::Read(json_events_str->data, false));
 
   ListValue* root_list = NULL;
   ASSERT_TRUE(root.get());
   ASSERT_TRUE(root->GetAsList(&root_list));
 
   // Move items into our aggregate collection
@@ skipping 191 matching lines @@
 
   if (task_complete_event)
     task_complete_event->Signal();
 }
 
 void ValidateAllTraceMacrosCreatedData(const ListValue& trace_parsed,
                                  const std::string& trace_string) {
   DictionaryValue* item = NULL;
 
 #define EXPECT_FIND_(string) \
-  EXPECT_TRUE((item = FindTraceEntry(trace_parsed, string)));
+    EXPECT_TRUE((item = FindTraceEntry(trace_parsed, string)));
 #define EXPECT_NOT_FIND_(string) \
-  EXPECT_FALSE((item = FindTraceEntry(trace_parsed, string)));
+    EXPECT_FALSE((item = FindTraceEntry(trace_parsed, string)));
 #define EXPECT_SUB_FIND_(string) \
-  if (item) EXPECT_TRUE((IsStringInDict(string, item)));
+    if (item) EXPECT_TRUE((IsStringInDict(string, item)));
 
   EXPECT_FIND_("ETW Trace Event");
   EXPECT_FIND_("all");
   EXPECT_FIND_("TRACE_EVENT_BEGIN_ETW call");
   {
     int int_val = 0;
     EXPECT_TRUE(item && item->GetInteger("args.id", &int_val));
     EXPECT_EQ(1122, int_val);
   }
   EXPECT_SUB_FIND_("extrastring1");
@@ skipping 371 matching lines @@
 // Test that data sent from other threads is gathered
 TEST_F(TraceEventTestFixture, DataCapturedOnThread) {
   ManualTestSetUp();
   TraceLog::GetInstance()->SetEnabled(true);
 
   Thread thread("1");
   WaitableEvent task_complete_event(false, false);
   thread.Start();
 
   thread.message_loop()->PostTask(
-    FROM_HERE, NewRunnableFunction(&TraceWithAllMacroVariants,
-                                   &task_complete_event));
+      FROM_HERE, NewRunnableFunction(&TraceWithAllMacroVariants,
+                                     &task_complete_event));
   task_complete_event.Wait();
+  thread.Stop();
 
   TraceLog::GetInstance()->SetEnabled(false);
-  thread.Stop();
   ValidateAllTraceMacrosCreatedData(trace_parsed_, trace_string_);
 }
 
 // Test that data sent from multiple threads is gathered
 TEST_F(TraceEventTestFixture, DataCapturedManyThreads) {
   ManualTestSetUp();
   TraceLog::GetInstance()->SetEnabled(true);
 
   const int num_threads = 4;
   const int num_events = 4000;
   Thread* threads[num_threads];
   WaitableEvent* task_complete_events[num_threads];
   for (int i = 0; i < num_threads; i++) {
     threads[i] = new Thread(StringPrintf("Thread %d", i).c_str());
     task_complete_events[i] = new WaitableEvent(false, false);
     threads[i]->Start();
     threads[i]->message_loop()->PostTask(
-      FROM_HERE, NewRunnableFunction(&TraceManyInstantEvents,
-                                     i, num_events, task_complete_events[i]));
+        FROM_HERE, NewRunnableFunction(&TraceManyInstantEvents,
+                                       i, num_events, task_complete_events[i]));
   }
 
   for (int i = 0; i < num_threads; i++) {
     task_complete_events[i]->Wait();
   }
 
-  TraceLog::GetInstance()->SetEnabled(false);
-
   for (int i = 0; i < num_threads; i++) {
     threads[i]->Stop();
     delete threads[i];
     delete task_complete_events[i];
   }
 
+  TraceLog::GetInstance()->SetEnabled(false);
+
   ValidateInstantEventPresentOnEveryThread(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(&TraceManyInstantEvents,
-                                     i, num_events, task_complete_events[i]));
+        FROM_HERE, NewRunnableFunction(&TraceManyInstantEvents,
+                                       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];
   }
 
+  TraceLog::GetInstance()->SetEnabled(false);
+
   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++) {
@@ skipping 144 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