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 26 matching lines @@
       scoped_refptr<TraceLog::RefCountedString> json_events_str);
   bool FindMatchingTraceEntry(const JsonKeyValue* key_values);
   bool FindNamePhase(const char* name, const char* phase);
 
   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)));
 }
 
 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 451 matching lines @@
   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));
   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]));
   }
 
   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.
@@ skipping 15 matching lines @@
     thread_ids[i] = threads[i]->thread_id();
     threads[i]->message_loop()->PostTask(
       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