Internalize JSON chunk management to trace_event.h API.

base/debug/trace_event.h

 // 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.
 
 // Trace events are for tracking application performance.
 //
 // Events are issued against categories. Whereas LOG's
 // categories are statically defined, TRACE categories are created
 // implicitly with a string. For example:
 //   TRACE_EVENT_INSTANT0("MY_SUBSYSTEM", "SomeImportantEvent")
@@ skipping 497 matching lines @@
   TimeTicks timestamp_;
   TraceEventPhase phase_;
   const TraceCategory* category_;
   const char* name_;
   const char* arg_names_[kTraceMaxNumArgs];
   TraceValue arg_values_[kTraceMaxNumArgs];
   scoped_refptr<base::RefCountedString> parameter_copy_storage_;
 };
 
 
+// TraceResultBuffer collects and merges trace fragments returned by TraceLog.
+// Add all the trace event fragments with AddFragment and then call GetJSON to
+// retrieve the full set of trace events in JSON format.
+class TraceResultBuffer {
+ public:
+  TraceResultBuffer();
+  ~TraceResultBuffer();
+
+  void AddFragment(const std::string& trace_fragment);

[nduca, 2011/10/20 00:28:03]

Brownie points: typedef TraceFragment so nobody sees the type except
TraceResultBuffer? 

[jbates, 2011/10/20 22:18:49]

I wanted to do this as well, but I didn't want to add the IPC struct Traits code
in this CL.

[nduca, 2011/10/20 23:20:05]

I realize its work, but we both agree its the right thing to do.

I'd love to pep-talk you into doing this, because I'm not gonna insist on it
from a procedural point of view. Its just silly to file a crbug for this, and it
smells funny.

[jbates, 2011/10/20 23:55:13]

Yup, we agree it's a good design, but low priority compared to the other issues
on my plate.

+
+  void GetJSON(std::string* json_trace_output);
+
+ private:
+  std::vector<std::string> fragments_;
+};
+
+
 class BASE_EXPORT TraceLog {
  public:
   // Flags for passing to AddTraceEvent.
   enum EventFlags {
     EVENT_FLAG_NONE = 0,
     EVENT_FLAG_COPY = 1<<0
   };
 
   static TraceLog* GetInstance();
 
@@ skipping 14 matching lines @@
   // Disable tracing for all categories.
   void SetDisabled();
   // Helper method to enable/disable tracing for all categories.
   void SetEnabled(bool enabled);
   bool IsEnabled() { return enabled_; }
 
   float GetBufferPercentFull() const;
 
   // When enough events are collected, they are handed (in bulk) to
   // the output callback. If no callback is set, the output will be
-  // silently dropped. The callback must be thread safe.
+  // silently dropped. The callback must be thread safe. The string format is
+  // undefined. Use TraceResultBuffer to convert one or more trace strings to
+  // JSON.
   typedef RefCountedData<std::string> RefCountedString;
   typedef base::Callback<void(scoped_refptr<RefCountedString>)> OutputCallback;
   void SetOutputCallback(const OutputCallback& cb);
 
   // The trace buffer does not flush dynamically, so when it fills up,
   // subsequent trace events will be dropped. This callback is generated when
   // the trace buffer is full. The callback must be thread safe.
   typedef base::Callback<void(void)> BufferFullCallback;
   void SetBufferFullCallback(const BufferFullCallback& cb);
 
@@ skipping 135 matching lines @@
   Data* p_data_;
   Data data_;
 };
 
 }  // namespace internal
 
 }  // namespace debug
 }  // namespace base
 
 #endif  // BASE_DEBUG_TRACE_EVENT_H_