Thread-local trace-event buffers

base/debug/trace_event_unittest.cc

 // Copyright (c) 2012 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_unittest.h"
 
 #include <cstdlib>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 32 matching lines @@
 
 const int kThreadId = 42;
 const int kAsyncId = 5;
 const char kAsyncIdStr[] = "0x5";
 const int kAsyncId2 = 6;
 const char kAsyncId2Str[] = "0x6";
 
 class TraceEventTestFixture : public testing::Test {
  public:
   void OnTraceDataCollected(
-      const scoped_refptr<base::RefCountedString>& events_str);
+      WaitableEvent* flush_complete_event,
+      const scoped_refptr<base::RefCountedString>& events_str,
+      bool has_more_events);
   void OnTraceNotification(int notification) {
     if (notification & TraceLog::EVENT_WATCH_NOTIFICATION)
       ++event_watch_notification_;
     notifications_received_ |= notification;
   }
   DictionaryValue* FindMatchingTraceEntry(const JsonKeyValue* key_values);
   DictionaryValue* FindNamePhase(const char* name, const char* phase);
   DictionaryValue* FindNamePhaseKeyValue(const char* name,
                                          const char* phase,
                                          const char* key,
@@ skipping 12 matching lines @@
   }
 
   void BeginSpecificTrace(const std::string& filter) {
     event_watch_notification_ = 0;
     notifications_received_ = 0;
     TraceLog::GetInstance()->SetEnabled(CategoryFilter(filter),
                                         TraceLog::RECORD_UNTIL_FULL);
   }
 
   void EndTraceAndFlush() {
+    WaitableEvent flush_complete_event(false, false);
+    EndTraceAndFlushAsync(&flush_complete_event);
+    flush_complete_event.Wait();
+  }
+
+  void EndTraceAndFlushAsync(WaitableEvent* flush_complete_event) {
     while (TraceLog::GetInstance()->IsEnabled())
       TraceLog::GetInstance()->SetDisabled();
     TraceLog::GetInstance()->Flush(
         base::Bind(&TraceEventTestFixture::OnTraceDataCollected,
-                   base::Unretained(this)));
+                   base::Unretained(static_cast<TraceEventTestFixture*>(this)),
+                   base::Unretained(flush_complete_event)));
   }
 
   virtual void SetUp() OVERRIDE {
     const char* name = PlatformThread::GetName();
     old_thread_name_ = name ? strdup(name) : NULL;
     notifications_received_ = 0;
 
     TraceLog::DeleteForTesting();
     TraceLog* tracelog = TraceLog::GetInstance();
     ASSERT_TRUE(tracelog);
@@ skipping 20 matching lines @@
   int event_watch_notification_;
   int notifications_received_;
 
  private:
   // We want our singleton torn down after each test.
   ShadowingAtExitManager at_exit_manager_;
   Lock lock_;
 };
 
 void TraceEventTestFixture::OnTraceDataCollected(
-    const scoped_refptr<base::RefCountedString>& events_str) {
+    WaitableEvent* flush_complete_event,
+    const scoped_refptr<base::RefCountedString>& events_str,
+    bool has_more_events) {
   AutoLock lock(lock_);
   json_output_.json_output.clear();
   trace_buffer_.Start();
   trace_buffer_.AddFragment(events_str->data());
   trace_buffer_.Finish();
 
   scoped_ptr<Value> root;
   root.reset(base::JSONReader::Read(json_output_.json_output,
                                     JSON_PARSE_RFC | JSON_DETACHABLE_CHILDREN));
 
   if (!root.get()) {
     LOG(ERROR) << json_output_.json_output;
   }
 
   ListValue* root_list = NULL;
   ASSERT_TRUE(root.get());
   ASSERT_TRUE(root->GetAsList(&root_list));
 
   // Move items into our aggregate collection
   while (root_list->GetSize()) {
     scoped_ptr<Value> item;
     root_list->Remove(0, &item);
     trace_parsed_.Append(item.release());
   }
+
+  if (!has_more_events)
+    flush_complete_event->Signal();
 }
 
 static bool CompareJsonValues(const std::string& lhs,
                               const std::string& rhs,
                               CompareOp op) {
   switch (op) {
     case IS_EQUAL:
       return lhs == rhs;
     case IS_NOT_EQUAL:
       return lhs != rhs;
@@ skipping 1168 matching lines @@
     threads[i]->Start();
     threads[i]->message_loop()->PostTask(
         FROM_HERE, base::Bind(&TraceManyInstantEvents,
                               i, num_events, task_complete_events[i]));
   }
 
   for (int i = 0; i < num_threads; i++) {
     task_complete_events[i]->Wait();
   }
 
-  for (int i = 0; i < num_threads; i++) {
+  // Let half of the threads end before flush.
+  for (int i = 0; i < num_threads / 2; i++) {
     threads[i]->Stop();
     delete threads[i];
     delete task_complete_events[i];
   }
 
-  EndTraceAndFlush();
-
+  WaitableEvent flush_complete_event(false, false);
+  Thread flush_thread("flush");
+  flush_thread.Start();
+  flush_thread.message_loop()->PostTask(FROM_HERE,
+    base::Bind(&TraceEventTestFixture::EndTraceAndFlushAsync,
+               base::Unretained(this),
+               &flush_complete_event));
+  flush_complete_event.Wait();
   ValidateInstantEventPresentOnEveryThread(trace_parsed_,
                                            num_threads, num_events);
+
+  // Let the other half of the threads end after flush.
+  for (int i = num_threads / 2; i < num_threads; i++) {
+    threads[i]->Stop();
+    delete threads[i];
+    delete task_complete_events[i];
+  }
 }
 
 // Test that thread and process names show up in the trace
 TEST_F(TraceEventTestFixture, ThreadNames) {
   // 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];
@@ skipping 651 matching lines @@
   EXPECT_TRUE(CategoryFilter::IsEmptyOrContainsLeadingOrTrailingWhitespace(
       "   bad_category   "));
   EXPECT_TRUE(CategoryFilter::IsEmptyOrContainsLeadingOrTrailingWhitespace(
       ""));
   EXPECT_FALSE(CategoryFilter::IsEmptyOrContainsLeadingOrTrailingWhitespace(
       "good_category"));
 }
 
 }  // namespace debug
 }  // namespace base