1 // Copyright 2015 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #ifndef BASE_TRACE_EVENT_TRACE_BUFFER_H_
6 #define BASE_TRACE_EVENT_TRACE_BUFFER_H_
7 
8 #include <stddef.h>
9 #include <stdint.h>
10 
11 #include "base/base_export.h"
12 #include "base/trace_event/trace_event.h"
13 #include "base/trace_event/trace_event_impl.h"
14 
15 namespace base {
16 
17 namespace trace_event {
18 
19 // TraceBufferChunk is the basic unit of TraceBuffer.
20 class BASE_EXPORT TraceBufferChunk {
21  public:
22   explicit TraceBufferChunk(uint32_t seq);
23   ~TraceBufferChunk();
24 
25   void Reset(uint32_t new_seq);
26   TraceEvent* AddTraceEvent(size_t* event_index);
IsFull()27   bool IsFull() const { return next_free_ == kTraceBufferChunkSize; }
28 
seq()29   uint32_t seq() const { return seq_; }
capacity()30   size_t capacity() const { return kTraceBufferChunkSize; }
size()31   size_t size() const { return next_free_; }
32 
GetEventAt(size_t index)33   TraceEvent* GetEventAt(size_t index) {
34     DCHECK(index < size());
35     return &chunk_[index];
36   }
GetEventAt(size_t index)37   const TraceEvent* GetEventAt(size_t index) const {
38     DCHECK(index < size());
39     return &chunk_[index];
40   }
41 
42   scoped_ptr<TraceBufferChunk> Clone() const;
43 
44   void EstimateTraceMemoryOverhead(TraceEventMemoryOverhead* overhead);
45 
46   // These values must be kept consistent with the numbers of bits of
47   // chunk_index and event_index fields in TraceEventHandle
48   // (in trace_event_impl.h).
49   static const size_t kMaxChunkIndex = (1u << 26) - 1;
50   static const size_t kTraceBufferChunkSize = 64;
51 
52  private:
53   size_t next_free_;
54   scoped_ptr<TraceEventMemoryOverhead> cached_overhead_estimate_;
55   TraceEvent chunk_[kTraceBufferChunkSize];
56   uint32_t seq_;
57 };
58 
59 // TraceBuffer holds the events as they are collected.
60 class BASE_EXPORT TraceBuffer {
61  public:
~TraceBuffer()62   virtual ~TraceBuffer() {}
63 
64   virtual scoped_ptr<TraceBufferChunk> GetChunk(size_t* index) = 0;
65   virtual void ReturnChunk(size_t index,
66                            scoped_ptr<TraceBufferChunk> chunk) = 0;
67 
68   virtual bool IsFull() const = 0;
69   virtual size_t Size() const = 0;
70   virtual size_t Capacity() const = 0;
71   virtual TraceEvent* GetEventByHandle(TraceEventHandle handle) = 0;
72 
73   // For iteration. Each TraceBuffer can only be iterated once.
74   virtual const TraceBufferChunk* NextChunk() = 0;
75 
76   virtual scoped_ptr<TraceBuffer> CloneForIteration() const = 0;
77 
78   // Computes an estimate of the size of the buffer, including all the retained
79   // objects.
80   virtual void EstimateTraceMemoryOverhead(
81       TraceEventMemoryOverhead* overhead) = 0;
82 
83   static TraceBuffer* CreateTraceBufferRingBuffer(size_t max_chunks);
84   static TraceBuffer* CreateTraceBufferVectorOfSize(size_t max_chunks);
85 };
86 
87 // TraceResultBuffer collects and converts trace fragments returned by TraceLog
88 // to JSON output.
89 class BASE_EXPORT TraceResultBuffer {
90  public:
91   typedef base::Callback<void(const std::string&)> OutputCallback;
92 
93   // If you don't need to stream JSON chunks out efficiently, and just want to
94   // get a complete JSON string after calling Finish, use this struct to collect
95   // JSON trace output.
96   struct BASE_EXPORT SimpleOutput {
97     OutputCallback GetCallback();
98     void Append(const std::string& json_string);
99 
100     // Do what you want with the json_output_ string after calling
101     // TraceResultBuffer::Finish.
102     std::string json_output;
103   };
104 
105   TraceResultBuffer();
106   ~TraceResultBuffer();
107 
108   // Set callback. The callback will be called during Start with the initial
109   // JSON output and during AddFragment and Finish with following JSON output
110   // chunks. The callback target must live past the last calls to
111   // TraceResultBuffer::Start/AddFragment/Finish.
112   void SetOutputCallback(const OutputCallback& json_chunk_callback);
113 
114   // Start JSON output. This resets all internal state, so you can reuse
115   // the TraceResultBuffer by calling Start.
116   void Start();
117 
118   // Call AddFragment 0 or more times to add trace fragments from TraceLog.
119   void AddFragment(const std::string& trace_fragment);
120 
121   // When all fragments have been added, call Finish to complete the JSON
122   // formatted output.
123   void Finish();
124 
125  private:
126   OutputCallback output_callback_;
127   bool append_comma_;
128 };
129 
130 }  // namespace trace_event
131 }  // namespace base
132 
133 #endif  // BASE_TRACE_EVENT_TRACE_BUFFER_H_
134