1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
// Copyright 2013 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.
#ifndef CONTENT_PUBLIC_BROWSER_TRACING_CONTROLLER_H_
#define CONTENT_PUBLIC_BROWSER_TRACING_CONTROLLER_H_
#include <set>
#include <string>
#include "base/callback.h"
#include "base/memory/ref_counted.h"
#include "base/trace_event/trace_event.h"
#include "content/common/content_export.h"
namespace content {
class TracingController;
// TracingController is used on the browser processes to enable/disable
// trace status and collect trace data. Only the browser UI thread is allowed
// to interact with the TracingController object. All callbacks are called on
// the UI thread.
class TracingController {
public:
CONTENT_EXPORT static TracingController* GetInstance();
// An interface for trace data consumer. An implemnentation of this interface
// is passed to either DisableTracing() or CaptureMonitoringSnapshot() and
// receives the trace data followed by a notification that all child processes
// have completed tracing and the data collection is over.
// All methods are called on the UI thread.
// Close method will be called exactly once and no methods will be
// called after that.
class CONTENT_EXPORT TraceDataSink
: public base::RefCountedThreadSafe<TraceDataSink> {
public:
virtual void AddTraceChunk(const std::string& chunk) {}
virtual void SetSystemTrace(const std::string& data) {}
virtual void Close() {}
protected:
friend class base::RefCountedThreadSafe<TraceDataSink>;
virtual ~TraceDataSink() {}
};
// Create a trace sink that may be supplied to DisableRecording or
// CaptureMonitoringSnapshot to capture the trace data as a string.
CONTENT_EXPORT static scoped_refptr<TraceDataSink> CreateStringSink(
const base::Callback<void(base::RefCountedString*)>& callback);
// Create a trace sink that may be supplied to DisableRecording or
// CaptureMonitoringSnapshot to dump the trace data to a file.
CONTENT_EXPORT static scoped_refptr<TraceDataSink> CreateFileSink(
const base::FilePath& file_path,
const base::Closure& callback);
// Get a set of category groups. The category groups can change as
// new code paths are reached.
//
// Once all child processes have acked to the GetCategories request,
// GetCategoriesDoneCallback is called back with a set of category
// groups.
typedef base::Callback<void(const std::set<std::string>&)>
GetCategoriesDoneCallback;
virtual bool GetCategories(
const GetCategoriesDoneCallback& callback) = 0;
// Start recording on all processes.
//
// Recording begins immediately locally, and asynchronously on child processes
// as soon as they receive the EnableRecording request.
//
// Once all child processes have acked to the EnableRecording request,
// EnableRecordingDoneCallback will be called back.
//
// |category_filter| is a filter to control what category groups should be
// traced. A filter can have an optional '-' prefix to exclude category groups
// that contain a matching category. Having both included and excluded
// category patterns in the same list would not be supported.
//
// Examples: "test_MyTest*",
// "test_MyTest*,test_OtherStuff",
// "-excluded_category1,-excluded_category2"
//
// |options| controls what kind of tracing is enabled.
typedef base::Callback<void()> EnableRecordingDoneCallback;
virtual bool EnableRecording(
const base::debug::CategoryFilter& category_filter,
const base::debug::TraceOptions& trace_options,
const EnableRecordingDoneCallback& callback) = 0;
// Stop recording on all processes.
//
// Child processes typically are caching trace data and only rarely flush
// and send trace data back to the browser process. That is because it may be
// an expensive operation to send the trace data over IPC, and we would like
// to avoid much runtime overhead of tracing. So, to end tracing, we must
// asynchronously ask all child processes to flush any pending trace data.
//
// Once all child processes have acked to the DisableRecording request,
// TracingFileResultCallback will be called back with a file that contains
// the traced data.
//
// If |trace_data_sink| is not null, it will receive chunks of trace data
// as a comma-separated sequences of JSON-stringified events, followed by
// a notification that the trace collection is finished.
//
virtual bool DisableRecording(
const scoped_refptr<TraceDataSink>& trace_data_sink) = 0;
// Start monitoring on all processes.
//
// Monitoring begins immediately locally, and asynchronously on child
// processes as soon as they receive the EnableMonitoring request.
//
// Once all child processes have acked to the EnableMonitoring request,
// EnableMonitoringDoneCallback will be called back.
//
// |category_filter| is a filter to control what category groups should be
// traced.
//
// |options| controls what kind of tracing is enabled.
typedef base::Callback<void()> EnableMonitoringDoneCallback;
virtual bool EnableMonitoring(
const base::debug::CategoryFilter& category_filter,
const base::debug::TraceOptions& trace_options,
const EnableMonitoringDoneCallback& callback) = 0;
// Stop monitoring on all processes.
//
// Once all child processes have acked to the DisableMonitoring request,
// DisableMonitoringDoneCallback is called back.
typedef base::Callback<void()> DisableMonitoringDoneCallback;
virtual bool DisableMonitoring(
const DisableMonitoringDoneCallback& callback) = 0;
// Get the current monitoring configuration.
virtual void GetMonitoringStatus(
bool* out_enabled,
base::debug::CategoryFilter* out_category_filter,
base::debug::TraceOptions* out_trace_options) = 0;
// Get the current monitoring traced data.
//
// Child processes typically are caching trace data and only rarely flush
// and send trace data back to the browser process. That is because it may be
// an expensive operation to send the trace data over IPC, and we would like
// to avoid much runtime overhead of tracing. So, to end tracing, we must
// asynchronously ask all child processes to flush any pending trace data.
//
// Once all child processes have acked to the CaptureMonitoringSnapshot
// request, TracingFileResultCallback will be called back with a file that
// contains the traced data.
//
// If |trace_data_sink| is not null, it will receive chunks of trace data
// as a comma-separated sequences of JSON-stringified events, followed by
// a notification that the trace collection is finished.
virtual bool CaptureMonitoringSnapshot(
const scoped_refptr<TraceDataSink>& trace_data_sink) = 0;
// Get the maximum across processes of trace buffer percent full state.
// When the TraceBufferUsage value is determined, the callback is
// called.
typedef base::Callback<void(float, size_t)> GetTraceBufferUsageCallback;
virtual bool GetTraceBufferUsage(
const GetTraceBufferUsageCallback& callback) = 0;
// |callback| will will be called every time the given event occurs on any
// process.
typedef base::Callback<void()> WatchEventCallback;
virtual bool SetWatchEvent(const std::string& category_name,
const std::string& event_name,
const WatchEventCallback& callback) = 0;
// Cancel the watch event. If tracing is enabled, this may race with the
// watch event callback.
virtual bool CancelWatchEvent() = 0;
protected:
virtual ~TracingController() {}
};
} // namespace content
#endif // CONTENT_PUBLIC_BROWSER_TRACING_CONTROLLER_H_
|
