Invoke trace callback even when trace buffer is full

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 37 matching lines @@
 class TraceEventTestFixture : public testing::Test {
  public:
   // This fixture does not use SetUp() because the fixture must be manually set
   // up multiple times when testing AtExit. Use ManualTestSetUp for this.
   void ManualTestSetUp();
   void OnTraceDataCollected(
       const scoped_refptr<base::RefCountedString>& events_str);
   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,
                                          const char* value);
   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();
   }
 
   void BeginTrace() {
     event_watch_notification_ = 0;
+    notifications_received_ = 0;
     TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
                                         TraceLog::RECORD_UNTIL_FULL);
   }
 
   void EndTraceAndFlush() {
     while (TraceLog::GetInstance()->IsEnabled())
       TraceLog::GetInstance()->SetDisabled();
     TraceLog::GetInstance()->Flush(
         base::Bind(&TraceEventTestFixture::OnTraceDataCollected,
                    base::Unretained(this)));
   }
 
   virtual void SetUp() OVERRIDE {
     const char* name = PlatformThread::GetName();
     old_thread_name_ = name ? strdup(name) : NULL;
   }
   virtual void TearDown() OVERRIDE {
     if (TraceLog::GetInstance())
       EXPECT_FALSE(TraceLog::GetInstance()->IsEnabled());
     PlatformThread::SetName(old_thread_name_ ? old_thread_name_ : "");
     free(old_thread_name_);
     old_thread_name_ = NULL;
   }
 
   char* old_thread_name_;
   ListValue trace_parsed_;
   base::debug::TraceResultBuffer trace_buffer_;
   base::debug::TraceResultBuffer::SimpleOutput json_output_;
   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::ManualTestSetUp() {
   TraceLog::DeleteForTesting();
   TraceLog::Resurrect();
@@ skipping 1544 matching lines @@
   TRACE_EVENT_INSTANT0("all", "before enable", TRACE_EVENT_SCOPE_THREAD);
   TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
       TraceLog::RECORD_UNTIL_FULL);
   TRACE_EVENT_INSTANT0("all", "before callback set", TRACE_EVENT_SCOPE_THREAD);
   TraceLog::GetInstance()->SetEventCallback(Callback);
   TRACE_EVENT_INSTANT0("all", "event1", TRACE_EVENT_SCOPE_GLOBAL);
   TRACE_EVENT_INSTANT0("all", "event2", TRACE_EVENT_SCOPE_GLOBAL);
   TraceLog::GetInstance()->SetEventCallback(NULL);
   TRACE_EVENT_INSTANT0("all", "after callback removed",
                        TRACE_EVENT_SCOPE_GLOBAL);
-  EXPECT_EQ(2u, collected_events_.size());
+  ASSERT_EQ(2u, collected_events_.size());

[jar (doing other things), 2013/04/26 16:43:31]

nice catch/correction.

   EXPECT_EQ("event1", collected_events_[0]);
   EXPECT_EQ("event2", collected_events_[1]);
 }
 
+TEST_F(TraceEventCallbackTest, TraceEventCallbackWhileFull) {
+  TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
+      TraceLog::RECORD_UNTIL_FULL);
+  do {
+    TRACE_EVENT_INSTANT0("all", "badger badger", TRACE_EVENT_SCOPE_GLOBAL);
+  } while ((notifications_received_ & TraceLog::TRACE_BUFFER_FULL) == 0);
+  TraceLog::GetInstance()->SetEventCallback(Callback);
+  TRACE_EVENT_INSTANT0("all", "a snake", TRACE_EVENT_SCOPE_GLOBAL);
+  TraceLog::GetInstance()->SetEventCallback(NULL);
+  ASSERT_EQ(1u, collected_events_.size());
+  EXPECT_EQ("a snake", collected_events_[0]);
+}
+
 // TODO(dsinclair): Continuous Tracing unit test.
 
 // Test the category filter.
 TEST_F(TraceEventTestFixture, CategoryFilter) {
   ManualTestSetUp();
 
   // Using the default filter.
   CategoryFilter default_cf = CategoryFilter(
       CategoryFilter::kDefaultCategoryFilterString);
   std::string category_filter_str = default_cf.ToString();
@@ skipping 65 matching lines @@
   EXPECT_TRUE(CategoryFilter::IsEmptyOrContainsLeadingOrTrailingWhitespace(
       "   bad_category   "));
   EXPECT_TRUE(CategoryFilter::IsEmptyOrContainsLeadingOrTrailingWhitespace(
       ""));
   EXPECT_FALSE(CategoryFilter::IsEmptyOrContainsLeadingOrTrailingWhitespace(
       "good_category"));
 }
 
 }  // namespace debug
 }  // namespace base