Avoid emptry tracing callbacks when possible.

base/trace_event/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 <math.h>
 #include <cstdlib>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
@@ skipping 68 matching lines @@
 
   void BeginSpecificTrace(const std::string& filter) {
     event_watch_notification_ = 0;
     TraceLog::GetInstance()->SetEnabled(
         CategoryFilter(filter),
         TraceLog::RECORDING_MODE,
         TraceOptions());
   }
 
   void EndTraceAndFlush() {
+    num_flush_callbacks_ = 0;
     WaitableEvent flush_complete_event(false, false);
     EndTraceAndFlushAsync(&flush_complete_event);
     flush_complete_event.Wait();
   }
 
   // Used when testing thread-local buffers which requires the thread initiating
   // flush to have a message loop.
   void EndTraceAndFlushInThreadWithMessageLoop() {
     WaitableEvent flush_complete_event(false, false);
     Thread flush_thread("flush");
@@ skipping 44 matching lines @@
     old_thread_name_ = NULL;
     // We want our singleton torn down after each test.
     TraceLog::DeleteForTesting();
   }
 
   char* old_thread_name_;
   ListValue trace_parsed_;
   TraceResultBuffer trace_buffer_;
   TraceResultBuffer::SimpleOutput json_output_;
   int event_watch_notification_;
+  size_t num_flush_callbacks_;
 
  private:
   // We want our singleton torn down after each test.
   ShadowingAtExitManager at_exit_manager_;
   Lock lock_;
 };
 
 void TraceEventTestFixture::OnTraceDataCollected(
     WaitableEvent* flush_complete_event,
     const scoped_refptr<base::RefCountedString>& events_str,
     bool has_more_events) {
+  num_flush_callbacks_++;
+  if (num_flush_callbacks_ > 1) {
+    EXPECT_FALSE(events_str->data().empty());
+  }
   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));
 
@@ skipping 895 matching lines @@
       CategoryFilter("*"),
       TraceLog::RECORDING_MODE,
       TraceOptions());
   ASSERT_TRUE(IsNewTrace());
   ASSERT_FALSE(IsNewTrace());
 
   // Cleanup.
   EndTraceAndFlush();
 }
 
+TEST_F(TraceEventTestFixture, TestTraceFlush) {
+  size_t min_traces = 1;
+  size_t max_traces = 1;
+  do {
+    max_traces *= 2;
+    TraceLog::GetInstance()->SetEnabled(
+        CategoryFilter("*"),
+        TraceLog::RECORDING_MODE,
+        TraceOptions());
+    for (size_t i = 0; i < max_traces; i++) {
+      TRACE_EVENT_INSTANT0("x", "y", TRACE_EVENT_SCOPE_THREAD);
+    }
+    EndTraceAndFlush();
+  } while (num_flush_callbacks_ < 2);
+
+  while (min_traces + 50 <  max_traces) {
+    size_t traces = (min_traces + max_traces) / 2;
+    TraceLog::GetInstance()->SetEnabled(
+        CategoryFilter("*"),
+        TraceLog::RECORDING_MODE,
+        TraceOptions());
+    for (size_t i = 0; i < traces; i++) {
+      TRACE_EVENT_INSTANT0("x", "y", TRACE_EVENT_SCOPE_THREAD);
+    }
+    EndTraceAndFlush();
+    if (num_flush_callbacks_ < 2) {
+      min_traces = traces - 10;
+    } else {
+      max_traces = traces + 10;
+    }
+  }
+

[dsinclair, 2015/05/25 13:51:11]

This test is .... complicated. Can we simplify it? What, exactly, is it trying
to test?

[hubbe, 2015/06/10 21:55:32]

It's trying to make sure that we don't create an empty callback right when we go
from N bytes to N+1 bytes of callback data. Unfortunately N is unknown....

+  for (size_t traces = min_traces; traces < max_traces; traces++) {
+    TraceLog::GetInstance()->SetEnabled(
+        CategoryFilter("*"),
+        TraceLog::RECORDING_MODE,
+        TraceOptions());
+    for (size_t i = 0; i < traces; i++) {
+      TRACE_EVENT_INSTANT0("x", "y", TRACE_EVENT_SCOPE_THREAD);
+    }
+    EndTraceAndFlush();
+  }
+}
 
 // Test that categories work.
 TEST_F(TraceEventTestFixture, Categories) {
   // Test that categories that are used can be retrieved whether trace was
   // enabled or disabled when the trace event was encountered.
   TRACE_EVENT_INSTANT0("c1", "name", TRACE_EVENT_SCOPE_THREAD);
   TRACE_EVENT_INSTANT0("c2", "name", TRACE_EVENT_SCOPE_THREAD);
   BeginTrace();
   TRACE_EVENT_INSTANT0("c3", "name", TRACE_EVENT_SCOPE_THREAD);
   TRACE_EVENT_INSTANT0("c4", "name", TRACE_EVENT_SCOPE_THREAD);
@@ skipping 1986 matching lines @@
         EXPECT_EQ(original_option.record_mode, new_options.record_mode);
         EXPECT_EQ(original_option.enable_sampling, new_options.enable_sampling);
         EXPECT_EQ(original_option.enable_systrace, new_options.enable_systrace);
       }
     }
   }
 }
 
 }  // namespace trace_event
 }  // namespace base