OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 #include "content/browser/tracing/tracing_controller_impl.h" | 4 #include "content/browser/tracing/tracing_controller_impl.h" |
5 | 5 |
6 #include "base/bind.h" | 6 #include "base/bind.h" |
7 #include "base/files/file_util.h" | 7 #include "base/files/file_util.h" |
8 #include "base/json/json_writer.h" | 8 #include "base/json/json_writer.h" |
9 #include "base/strings/pattern.h" | 9 #include "base/strings/pattern.h" |
10 #include "content/public/browser/browser_thread.h" | 10 #include "content/public/browser/browser_thread.h" |
11 #include "third_party/zlib/zlib.h" | 11 #include "third_party/zlib/zlib.h" |
12 | 12 |
13 namespace content { | 13 namespace content { |
14 | 14 |
15 namespace { | 15 namespace { |
16 | 16 |
| 17 const char kChromeTraceLabel[] = "traceEvents"; |
| 18 const char kMetadataTraceLabel[] = "metadata"; |
| 19 |
17 class StringTraceDataEndpoint : public TracingController::TraceDataEndpoint { | 20 class StringTraceDataEndpoint : public TracingController::TraceDataEndpoint { |
18 public: | 21 public: |
19 typedef base::Callback<void(scoped_ptr<const base::DictionaryValue>, | 22 typedef base::Callback<void(scoped_ptr<const base::DictionaryValue>, |
20 base::RefCountedString*)> CompletionCallback; | 23 base::RefCountedString*)> CompletionCallback; |
21 | 24 |
22 explicit StringTraceDataEndpoint(CompletionCallback callback) | 25 explicit StringTraceDataEndpoint(CompletionCallback callback) |
23 : completion_callback_(callback) {} | 26 : completion_callback_(callback) {} |
24 | 27 |
25 void ReceiveTraceFinalContents( | 28 void ReceiveTraceFinalContents( |
26 scoped_ptr<const base::DictionaryValue> metadata, | 29 scoped_ptr<const base::DictionaryValue> metadata, |
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
111 | 114 |
112 class StringTraceDataSink : public TracingController::TraceDataSink { | 115 class StringTraceDataSink : public TracingController::TraceDataSink { |
113 public: | 116 public: |
114 explicit StringTraceDataSink( | 117 explicit StringTraceDataSink( |
115 scoped_refptr<TracingController::TraceDataEndpoint> endpoint) | 118 scoped_refptr<TracingController::TraceDataEndpoint> endpoint) |
116 : endpoint_(endpoint) {} | 119 : endpoint_(endpoint) {} |
117 | 120 |
118 void AddTraceChunk(const std::string& chunk) override { | 121 void AddTraceChunk(const std::string& chunk) override { |
119 std::string trace_string; | 122 std::string trace_string; |
120 if (trace_.empty()) | 123 if (trace_.empty()) |
121 trace_string = "{\"traceEvents\":["; | 124 trace_string = "{\"" + std::string(kChromeTraceLabel) + "\":["; |
122 else | 125 else |
123 trace_string = ","; | 126 trace_string = ","; |
124 trace_string += chunk; | 127 trace_string += chunk; |
125 | 128 |
126 AddTraceChunkAndPassToEndpoint(trace_string); | 129 AddTraceChunkAndPassToEndpoint(trace_string); |
127 } | 130 } |
128 | 131 |
129 void AddTraceChunkAndPassToEndpoint(const std::string& chunk) { | 132 void AddTraceChunkAndPassToEndpoint(const std::string& chunk) { |
130 trace_ += chunk; | 133 trace_ += chunk; |
131 | 134 |
132 endpoint_->ReceiveTraceChunk(chunk); | 135 endpoint_->ReceiveTraceChunk(chunk); |
133 } | 136 } |
134 | 137 |
135 void SetSystemTrace(const std::string& data) override { | |
136 system_trace_ = data; | |
137 } | |
138 | |
139 void SetPowerTrace(const std::string& data) override { power_trace_ = data; } | |
140 | |
141 void Close() override { | 138 void Close() override { |
142 AddTraceChunkAndPassToEndpoint("]"); | 139 AddTraceChunkAndPassToEndpoint("]"); |
143 if (!system_trace_.empty()) | 140 |
144 AddTraceChunkAndPassToEndpoint(",\"systemTraceEvents\": " + | 141 for (auto const &it : GetAgentTrace()) |
145 system_trace_); | 142 AddTraceChunkAndPassToEndpoint(",\"" + it.first + "\": " + it.second); |
| 143 |
146 std::string metadataJSON; | 144 std::string metadataJSON; |
147 if (base::JSONWriter::Write(*GetMetadataCopy(), &metadataJSON) && | 145 if (base::JSONWriter::Write(*GetMetadataCopy(), &metadataJSON) && |
148 !metadataJSON.empty()) | 146 !metadataJSON.empty()) { |
149 AddTraceChunkAndPassToEndpoint(",\"metadata\": " + metadataJSON); | 147 AddTraceChunkAndPassToEndpoint( |
150 if (!power_trace_.empty()) { | 148 ",\"" + std::string(kMetadataTraceLabel) + "\": " + metadataJSON); |
151 AddTraceChunkAndPassToEndpoint(",\"powerTraceAsString\": " + | |
152 power_trace_); | |
153 } | 149 } |
154 | 150 |
155 AddTraceChunkAndPassToEndpoint("}"); | 151 AddTraceChunkAndPassToEndpoint("}"); |
156 | 152 |
157 endpoint_->ReceiveTraceFinalContents(GetMetadataCopy(), trace_); | 153 endpoint_->ReceiveTraceFinalContents(GetMetadataCopy(), trace_); |
158 } | 154 } |
159 | 155 |
160 private: | 156 private: |
161 ~StringTraceDataSink() override {} | 157 ~StringTraceDataSink() override {} |
162 | 158 |
163 scoped_refptr<TracingController::TraceDataEndpoint> endpoint_; | 159 scoped_refptr<TracingController::TraceDataEndpoint> endpoint_; |
164 std::string trace_; | 160 std::string trace_; |
165 std::string system_trace_; | |
166 std::string power_trace_; | |
167 | 161 |
168 DISALLOW_COPY_AND_ASSIGN(StringTraceDataSink); | 162 DISALLOW_COPY_AND_ASSIGN(StringTraceDataSink); |
169 }; | 163 }; |
170 | 164 |
171 class CompressedStringTraceDataSink : public TracingController::TraceDataSink { | 165 class CompressedStringTraceDataSink : public TracingController::TraceDataSink { |
172 public: | 166 public: |
173 explicit CompressedStringTraceDataSink( | 167 explicit CompressedStringTraceDataSink( |
174 scoped_refptr<TracingController::TraceDataEndpoint> endpoint) | 168 scoped_refptr<TracingController::TraceDataEndpoint> endpoint) |
175 : endpoint_(endpoint), already_tried_open_(false) {} | 169 : endpoint_(endpoint), already_tried_open_(false) {} |
176 | 170 |
177 void AddTraceChunk(const std::string& chunk) override { | 171 void AddTraceChunk(const std::string& chunk) override { |
178 std::string tmp = chunk; | 172 std::string tmp = chunk; |
179 scoped_refptr<base::RefCountedString> chunk_ptr = | 173 scoped_refptr<base::RefCountedString> chunk_ptr = |
180 base::RefCountedString::TakeString(&tmp); | 174 base::RefCountedString::TakeString(&tmp); |
181 BrowserThread::PostTask( | 175 BrowserThread::PostTask( |
182 BrowserThread::FILE, FROM_HERE, | 176 BrowserThread::FILE, FROM_HERE, |
183 base::Bind(&CompressedStringTraceDataSink::AddTraceChunkOnFileThread, | 177 base::Bind(&CompressedStringTraceDataSink::AddTraceChunkOnFileThread, |
184 this, chunk_ptr)); | 178 this, chunk_ptr)); |
185 } | 179 } |
186 | 180 |
187 void SetSystemTrace(const std::string& data) override { | |
188 system_trace_ = data; | |
189 } | |
190 | |
191 void SetPowerTrace(const std::string& data) override { power_trace_ = data; } | |
192 | |
193 void Close() override { | 181 void Close() override { |
194 BrowserThread::PostTask( | 182 BrowserThread::PostTask( |
195 BrowserThread::FILE, FROM_HERE, | 183 BrowserThread::FILE, FROM_HERE, |
196 base::Bind(&CompressedStringTraceDataSink::CloseOnFileThread, this)); | 184 base::Bind(&CompressedStringTraceDataSink::CloseOnFileThread, this)); |
197 } | 185 } |
198 | 186 |
199 private: | 187 private: |
200 ~CompressedStringTraceDataSink() override {} | 188 ~CompressedStringTraceDataSink() override {} |
201 | 189 |
202 bool OpenZStreamOnFileThread() { | 190 bool OpenZStreamOnFileThread() { |
(...skipping 17 matching lines...) Expand all Loading... |
220 8, // memLevel = 8 is default. | 208 8, // memLevel = 8 is default. |
221 Z_DEFAULT_STRATEGY); | 209 Z_DEFAULT_STRATEGY); |
222 return result == 0; | 210 return result == 0; |
223 } | 211 } |
224 | 212 |
225 void AddTraceChunkOnFileThread( | 213 void AddTraceChunkOnFileThread( |
226 const scoped_refptr<base::RefCountedString> chunk_ptr) { | 214 const scoped_refptr<base::RefCountedString> chunk_ptr) { |
227 DCHECK_CURRENTLY_ON(BrowserThread::FILE); | 215 DCHECK_CURRENTLY_ON(BrowserThread::FILE); |
228 std::string trace; | 216 std::string trace; |
229 if (compressed_trace_data_.empty()) | 217 if (compressed_trace_data_.empty()) |
230 trace = "{\"traceEvents\":["; | 218 trace = "{\"" + std::string(kChromeTraceLabel) + "\":["; |
231 else | 219 else |
232 trace = ","; | 220 trace = ","; |
233 trace += chunk_ptr->data(); | 221 trace += chunk_ptr->data(); |
234 AddTraceChunkAndCompressOnFileThread(trace, false); | 222 AddTraceChunkAndCompressOnFileThread(trace, false); |
235 } | 223 } |
236 | 224 |
237 void AddTraceChunkAndCompressOnFileThread(const std::string& chunk, | 225 void AddTraceChunkAndCompressOnFileThread(const std::string& chunk, |
238 bool finished) { | 226 bool finished) { |
239 DCHECK_CURRENTLY_ON(BrowserThread::FILE); | 227 DCHECK_CURRENTLY_ON(BrowserThread::FILE); |
240 if (!OpenZStreamOnFileThread()) | 228 if (!OpenZStreamOnFileThread()) |
(...skipping 21 matching lines...) Expand all Loading... |
262 endpoint_->ReceiveTraceChunk(compressed_chunk); | 250 endpoint_->ReceiveTraceChunk(compressed_chunk); |
263 } | 251 } |
264 } while (stream_->avail_out == 0); | 252 } while (stream_->avail_out == 0); |
265 } | 253 } |
266 | 254 |
267 void CloseOnFileThread() { | 255 void CloseOnFileThread() { |
268 DCHECK_CURRENTLY_ON(BrowserThread::FILE); | 256 DCHECK_CURRENTLY_ON(BrowserThread::FILE); |
269 if (!OpenZStreamOnFileThread()) | 257 if (!OpenZStreamOnFileThread()) |
270 return; | 258 return; |
271 | 259 |
272 if (compressed_trace_data_.empty()) | 260 if (compressed_trace_data_.empty()) { |
273 AddTraceChunkAndCompressOnFileThread("{\"traceEvents\":[", false); | 261 AddTraceChunkAndCompressOnFileThread( |
| 262 "{\"" + std::string(kChromeTraceLabel) + "\":[", false); |
| 263 } |
| 264 AddTraceChunkAndCompressOnFileThread("]", false); |
274 | 265 |
275 AddTraceChunkAndCompressOnFileThread("]", false); | 266 for (auto const &it : GetAgentTrace()) { |
276 if (!system_trace_.empty()) { | |
277 AddTraceChunkAndCompressOnFileThread( | 267 AddTraceChunkAndCompressOnFileThread( |
278 ",\"systemTraceEvents\": " + system_trace_, false); | 268 ",\"" + it.first + "\": " + it.second, false); |
279 } | 269 } |
| 270 |
280 std::string metadataJSON; | 271 std::string metadataJSON; |
281 if (base::JSONWriter::Write(*GetMetadataCopy(), &metadataJSON) && | 272 if (base::JSONWriter::Write(*GetMetadataCopy(), &metadataJSON) && |
282 !metadataJSON.empty()) { | 273 !metadataJSON.empty()) { |
283 AddTraceChunkAndCompressOnFileThread(",\"metadata\": " + metadataJSON, | |
284 false); | |
285 } | |
286 if (!power_trace_.empty()) { | |
287 AddTraceChunkAndCompressOnFileThread( | 274 AddTraceChunkAndCompressOnFileThread( |
288 ",\"powerTraceAsString\": " + power_trace_, false); | 275 ",\"" + std::string(kMetadataTraceLabel) + "\": " + metadataJSON, |
| 276 false); |
289 } | 277 } |
290 AddTraceChunkAndCompressOnFileThread("}", true); | 278 AddTraceChunkAndCompressOnFileThread("}", true); |
291 | 279 |
292 deflateEnd(stream_.get()); | 280 deflateEnd(stream_.get()); |
293 stream_.reset(); | 281 stream_.reset(); |
294 | 282 |
295 endpoint_->ReceiveTraceFinalContents(GetMetadataCopy(), | 283 endpoint_->ReceiveTraceFinalContents(GetMetadataCopy(), |
296 compressed_trace_data_); | 284 compressed_trace_data_); |
297 } | 285 } |
298 | 286 |
299 scoped_refptr<TracingController::TraceDataEndpoint> endpoint_; | 287 scoped_refptr<TracingController::TraceDataEndpoint> endpoint_; |
300 scoped_ptr<z_stream> stream_; | 288 scoped_ptr<z_stream> stream_; |
301 bool already_tried_open_; | 289 bool already_tried_open_; |
302 std::string compressed_trace_data_; | 290 std::string compressed_trace_data_; |
303 std::string system_trace_; | |
304 std::string power_trace_; | |
305 | 291 |
306 DISALLOW_COPY_AND_ASSIGN(CompressedStringTraceDataSink); | 292 DISALLOW_COPY_AND_ASSIGN(CompressedStringTraceDataSink); |
307 }; | 293 }; |
308 | 294 |
309 } // namespace | 295 } // namespace |
310 | 296 |
311 TracingController::TraceDataSink::TraceDataSink() {} | 297 TracingController::TraceDataSink::TraceDataSink() {} |
312 | 298 |
313 TracingController::TraceDataSink::~TraceDataSink() {} | 299 TracingController::TraceDataSink::~TraceDataSink() {} |
314 | 300 |
| 301 void TracingController::TraceDataSink::AddAgentTrace( |
| 302 const std::string& trace_label, |
| 303 const std::string& trace_data) { |
| 304 DCHECK(additional_tracing_agent_trace_.find(trace_label) == |
| 305 additional_tracing_agent_trace_.end()); |
| 306 additional_tracing_agent_trace_[trace_label] = trace_data; |
| 307 } |
| 308 |
| 309 const std::map<std::string, std::string>& |
| 310 TracingController::TraceDataSink::GetAgentTrace() const { |
| 311 return additional_tracing_agent_trace_; |
| 312 } |
| 313 |
315 void TracingController::TraceDataSink::AddMetadata( | 314 void TracingController::TraceDataSink::AddMetadata( |
316 const base::DictionaryValue& data) { | 315 const base::DictionaryValue& data) { |
317 metadata_.MergeDictionary(&data); | 316 metadata_.MergeDictionary(&data); |
318 } | 317 } |
319 | 318 |
320 void TracingController::TraceDataSink::SetMetadataFilterPredicate( | 319 void TracingController::TraceDataSink::SetMetadataFilterPredicate( |
321 const MetadataFilterPredicate& metadata_filter_predicate) { | 320 const MetadataFilterPredicate& metadata_filter_predicate) { |
322 metadata_filter_predicate_ = metadata_filter_predicate; | 321 metadata_filter_predicate_ = metadata_filter_predicate; |
323 } | 322 } |
324 | 323 |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
365 return new StringTraceDataEndpoint(callback); | 364 return new StringTraceDataEndpoint(callback); |
366 } | 365 } |
367 | 366 |
368 scoped_refptr<TracingController::TraceDataEndpoint> | 367 scoped_refptr<TracingController::TraceDataEndpoint> |
369 TracingController::CreateFileEndpoint(const base::FilePath& file_path, | 368 TracingController::CreateFileEndpoint(const base::FilePath& file_path, |
370 const base::Closure& callback) { | 369 const base::Closure& callback) { |
371 return new FileTraceDataEndpoint(file_path, callback); | 370 return new FileTraceDataEndpoint(file_path, callback); |
372 } | 371 } |
373 | 372 |
374 } // namespace content | 373 } // namespace content |
OLD | NEW |