| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 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 #include "content/browser/trace_controller_impl.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/command_line.h" | |
| 9 #include "base/debug/trace_event.h" | |
| 10 #include "base/string_number_conversions.h" | |
| 11 #include "content/browser/trace_message_filter.h" | |
| 12 #include "content/browser/trace_subscriber_stdio.h" | |
| 13 #include "content/common/child_process_messages.h" | |
| 14 #include "content/public/browser/browser_message_filter.h" | |
| 15 #include "content/public/common/content_switches.h" | |
| 16 | |
| 17 using base::debug::TraceLog; | |
| 18 | |
| 19 namespace content { | |
| 20 | |
| 21 namespace { | |
| 22 | |
| 23 base::LazyInstance<TraceControllerImpl>::Leaky g_controller = | |
| 24 LAZY_INSTANCE_INITIALIZER; | |
| 25 | |
| 26 class AutoStopTraceSubscriberStdio : public TraceSubscriberStdio { | |
| 27 public: | |
| 28 AutoStopTraceSubscriberStdio(const FilePath& file_path) | |
| 29 : TraceSubscriberStdio(file_path) {} | |
| 30 | |
| 31 static void EndStartupTrace(TraceSubscriberStdio* subscriber) { | |
| 32 if (!TraceControllerImpl::GetInstance()->EndTracingAsync(subscriber)) | |
| 33 delete subscriber; | |
| 34 // else, the tracing will end asynchronously in OnEndTracingComplete(). | |
| 35 } | |
| 36 | |
| 37 virtual void OnEndTracingComplete() { | |
| 38 TraceSubscriberStdio::OnEndTracingComplete(); | |
| 39 delete this; | |
| 40 // TODO(joth): this would be the time to automatically open up | |
| 41 // chrome://tracing/ and load up the trace data collected. | |
| 42 } | |
| 43 }; | |
| 44 | |
| 45 } // namespace | |
| 46 | |
| 47 TraceController* TraceController::GetInstance() { | |
| 48 return TraceControllerImpl::GetInstance(); | |
| 49 } | |
| 50 | |
| 51 TraceControllerImpl::TraceControllerImpl() : | |
| 52 subscriber_(NULL), | |
| 53 pending_end_ack_count_(0), | |
| 54 pending_bpf_ack_count_(0), | |
| 55 maximum_bpf_(0.0f), | |
| 56 is_tracing_(false), | |
| 57 is_get_categories_(false) { | |
| 58 TraceLog::GetInstance()->SetNotificationCallback( | |
| 59 base::Bind(&TraceControllerImpl::OnTraceNotification, | |
| 60 base::Unretained(this))); | |
| 61 } | |
| 62 | |
| 63 TraceControllerImpl::~TraceControllerImpl() { | |
| 64 // No need to SetNotificationCallback(nil) on the TraceLog since this is a | |
| 65 // Leaky instance. | |
| 66 NOTREACHED(); | |
| 67 } | |
| 68 | |
| 69 TraceControllerImpl* TraceControllerImpl::GetInstance() { | |
| 70 return g_controller.Pointer(); | |
| 71 } | |
| 72 | |
| 73 void TraceControllerImpl::InitStartupTracing(const CommandLine& command_line) { | |
| 74 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 75 FilePath trace_file = command_line.GetSwitchValuePath( | |
| 76 switches::kTraceStartupFile); | |
| 77 // trace_file = "none" means that startup events will show up for the next | |
| 78 // begin/end tracing (via about:tracing or AutomationProxy::BeginTracing/ | |
| 79 // EndTracing, for example). | |
| 80 if (trace_file == FilePath().AppendASCII("none")) | |
| 81 return; | |
| 82 | |
| 83 if (trace_file.empty()) { | |
| 84 // Default to saving the startup trace into the current dir. | |
| 85 trace_file = FilePath().AppendASCII("chrometrace.log"); | |
| 86 } | |
| 87 scoped_ptr<AutoStopTraceSubscriberStdio> subscriber( | |
| 88 new AutoStopTraceSubscriberStdio(trace_file)); | |
| 89 DCHECK(can_begin_tracing(subscriber.get())); | |
| 90 | |
| 91 std::string delay_str = command_line.GetSwitchValueASCII( | |
| 92 switches::kTraceStartupDuration); | |
| 93 int delay_secs = 5; | |
| 94 if (!delay_str.empty() && !base::StringToInt(delay_str, &delay_secs)) { | |
| 95 DLOG(WARNING) << "Could not parse --" << switches::kTraceStartupDuration | |
| 96 << "=" << delay_str << " defaulting to 5 (secs)"; | |
| 97 delay_secs = 5; | |
| 98 } | |
| 99 | |
| 100 OnTracingBegan(subscriber.get()); | |
| 101 BrowserThread::PostDelayedTask( | |
| 102 BrowserThread::UI, | |
| 103 FROM_HERE, | |
| 104 base::Bind(&AutoStopTraceSubscriberStdio::EndStartupTrace, | |
| 105 base::Unretained(subscriber.release())), | |
| 106 base::TimeDelta::FromSeconds(delay_secs)); | |
| 107 } | |
| 108 | |
| 109 bool TraceControllerImpl::GetKnownCategoriesAsync(TraceSubscriber* subscriber) { | |
| 110 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 111 | |
| 112 // Known categories come back from child processes with the EndTracingAck | |
| 113 // message. So to get known categories, just begin and end tracing immediately | |
| 114 // afterwards. This will ping all the child processes for categories. | |
| 115 is_get_categories_ = true; | |
| 116 bool success = BeginTracing(subscriber, "*") && | |
| 117 EndTracingAsync(subscriber); | |
| 118 is_get_categories_ = success; | |
| 119 return success; | |
| 120 } | |
| 121 | |
| 122 bool TraceControllerImpl::BeginTracing( | |
| 123 TraceSubscriber* subscriber, | |
| 124 const std::vector<std::string>& included_categories, | |
| 125 const std::vector<std::string>& excluded_categories) { | |
| 126 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 127 | |
| 128 if (!can_begin_tracing(subscriber)) | |
| 129 return false; | |
| 130 | |
| 131 // Enable tracing | |
| 132 TraceLog::GetInstance()->SetEnabled(included_categories, excluded_categories); | |
| 133 OnTracingBegan(subscriber); | |
| 134 | |
| 135 return true; | |
| 136 } | |
| 137 | |
| 138 bool TraceControllerImpl::BeginTracing(TraceSubscriber* subscriber, | |
| 139 const std::string& categories) { | |
| 140 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 141 | |
| 142 if (!can_begin_tracing(subscriber)) | |
| 143 return false; | |
| 144 | |
| 145 // Enable tracing | |
| 146 TraceLog::GetInstance()->SetEnabled(categories); | |
| 147 | |
| 148 OnTracingBegan(subscriber); | |
| 149 | |
| 150 return true; | |
| 151 } | |
| 152 | |
| 153 bool TraceControllerImpl::EndTracingAsync(TraceSubscriber* subscriber) { | |
| 154 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 155 | |
| 156 if (!can_end_tracing() || subscriber != subscriber_) | |
| 157 return false; | |
| 158 | |
| 159 // There could be a case where there are no child processes and filters_ | |
| 160 // is empty. In that case we can immediately tell the subscriber that tracing | |
| 161 // has ended. To avoid recursive calls back to the subscriber, we will just | |
| 162 // use the existing asynchronous OnEndTracingAck code. | |
| 163 // Count myself (local trace) in pending_end_ack_count_, acked below. | |
| 164 pending_end_ack_count_ = filters_.size() + 1; | |
| 165 | |
| 166 // Handle special case of zero child processes. | |
| 167 if (pending_end_ack_count_ == 1) { | |
| 168 // Ack asynchronously now, because we don't have any children to wait for. | |
| 169 std::vector<std::string> categories; | |
| 170 TraceLog::GetInstance()->GetKnownCategories(&categories); | |
| 171 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, | |
| 172 base::Bind(&TraceControllerImpl::OnEndTracingAck, | |
| 173 base::Unretained(this), categories)); | |
| 174 } | |
| 175 | |
| 176 // Notify all child processes. | |
| 177 for (FilterMap::iterator it = filters_.begin(); it != filters_.end(); ++it) { | |
| 178 it->get()->SendEndTracing(); | |
| 179 } | |
| 180 | |
| 181 return true; | |
| 182 } | |
| 183 | |
| 184 bool TraceControllerImpl::GetTraceBufferPercentFullAsync( | |
| 185 TraceSubscriber* subscriber) { | |
| 186 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 187 | |
| 188 if (!can_get_buffer_percent_full() || subscriber != subscriber_) | |
| 189 return false; | |
| 190 | |
| 191 maximum_bpf_ = 0.0f; | |
| 192 pending_bpf_ack_count_ = filters_.size() + 1; | |
| 193 | |
| 194 // Handle special case of zero child processes. | |
| 195 if (pending_bpf_ack_count_ == 1) { | |
| 196 // Ack asynchronously now, because we don't have any children to wait for. | |
| 197 float bpf = TraceLog::GetInstance()->GetBufferPercentFull(); | |
| 198 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, | |
| 199 base::Bind(&TraceControllerImpl::OnTraceBufferPercentFullReply, | |
| 200 base::Unretained(this), bpf)); | |
| 201 } | |
| 202 | |
| 203 // Message all child processes. | |
| 204 for (FilterMap::iterator it = filters_.begin(); it != filters_.end(); ++it) { | |
| 205 it->get()->SendGetTraceBufferPercentFull(); | |
| 206 } | |
| 207 | |
| 208 return true; | |
| 209 } | |
| 210 | |
| 211 bool TraceControllerImpl::SetWatchEvent(TraceSubscriber* subscriber, | |
| 212 const std::string& category_name, | |
| 213 const std::string& event_name) { | |
| 214 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 215 if (subscriber != subscriber_) | |
| 216 return false; | |
| 217 | |
| 218 watch_category_ = category_name; | |
| 219 watch_name_ = event_name; | |
| 220 | |
| 221 TraceLog::GetInstance()->SetWatchEvent(category_name, event_name); | |
| 222 for (FilterMap::iterator it = filters_.begin(); it != filters_.end(); ++it) | |
| 223 it->get()->SendSetWatchEvent(category_name, event_name); | |
| 224 | |
| 225 return true; | |
| 226 } | |
| 227 | |
| 228 bool TraceControllerImpl::CancelWatchEvent(TraceSubscriber* subscriber) { | |
| 229 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 230 if (subscriber != subscriber_) | |
| 231 return false; | |
| 232 | |
| 233 watch_category_.clear(); | |
| 234 watch_name_.clear(); | |
| 235 | |
| 236 TraceLog::GetInstance()->CancelWatchEvent(); | |
| 237 for (FilterMap::iterator it = filters_.begin(); it != filters_.end(); ++it) | |
| 238 it->get()->SendCancelWatchEvent(); | |
| 239 | |
| 240 return true; | |
| 241 } | |
| 242 | |
| 243 void TraceControllerImpl::CancelSubscriber(TraceSubscriber* subscriber) { | |
| 244 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 245 | |
| 246 if (subscriber == subscriber_) { | |
| 247 subscriber_ = NULL; | |
| 248 // End tracing if necessary. | |
| 249 if (is_tracing_ && pending_end_ack_count_ == 0) | |
| 250 EndTracingAsync(NULL); | |
| 251 } | |
| 252 } | |
| 253 | |
| 254 void TraceControllerImpl::AddFilter(TraceMessageFilter* filter) { | |
| 255 if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) { | |
| 256 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, | |
| 257 base::Bind(&TraceControllerImpl::AddFilter, base::Unretained(this), | |
| 258 make_scoped_refptr(filter))); | |
| 259 return; | |
| 260 } | |
| 261 | |
| 262 filters_.insert(filter); | |
| 263 if (is_tracing_enabled()) { | |
| 264 filter->SendBeginTracing(included_categories_, excluded_categories_); | |
| 265 if (!watch_category_.empty()) | |
| 266 filter->SendSetWatchEvent(watch_category_, watch_name_); | |
| 267 } | |
| 268 } | |
| 269 | |
| 270 void TraceControllerImpl::RemoveFilter(TraceMessageFilter* filter) { | |
| 271 if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) { | |
| 272 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, | |
| 273 base::Bind(&TraceControllerImpl::RemoveFilter, base::Unretained(this), | |
| 274 make_scoped_refptr(filter))); | |
| 275 return; | |
| 276 } | |
| 277 | |
| 278 filters_.erase(filter); | |
| 279 } | |
| 280 | |
| 281 void TraceControllerImpl::OnTracingBegan(TraceSubscriber* subscriber) { | |
| 282 is_tracing_ = true; | |
| 283 | |
| 284 subscriber_ = subscriber; | |
| 285 | |
| 286 TraceLog::GetInstance()->GetEnabledTraceCategories(&included_categories_, | |
| 287 &excluded_categories_); | |
| 288 // Notify all child processes. | |
| 289 for (FilterMap::iterator it = filters_.begin(); it != filters_.end(); ++it) { | |
| 290 it->get()->SendBeginTracing(included_categories_, excluded_categories_); | |
| 291 } | |
| 292 } | |
| 293 | |
| 294 void TraceControllerImpl::OnEndTracingAck( | |
| 295 const std::vector<std::string>& known_categories) { | |
| 296 if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) { | |
| 297 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, | |
| 298 base::Bind(&TraceControllerImpl::OnEndTracingAck, | |
| 299 base::Unretained(this), known_categories)); | |
| 300 return; | |
| 301 } | |
| 302 | |
| 303 // Merge known_categories with known_categories_ | |
| 304 known_categories_.insert(known_categories.begin(), known_categories.end()); | |
| 305 | |
| 306 if (pending_end_ack_count_ == 0) | |
| 307 return; | |
| 308 | |
| 309 if (--pending_end_ack_count_ == 0) { | |
| 310 // All acks have been received. | |
| 311 is_tracing_ = false; | |
| 312 | |
| 313 // Disable local trace. | |
| 314 TraceLog::GetInstance()->SetDisabled(); | |
| 315 | |
| 316 // During this call, our OnTraceDataCollected will be | |
| 317 // called with the last of the local trace data. Since we are on the UI | |
| 318 // thread, the call to OnTraceDataCollected will be synchronous, so we can | |
| 319 // immediately call OnEndTracingComplete below. | |
| 320 TraceLog::GetInstance()->Flush( | |
| 321 base::Bind(&TraceControllerImpl::OnTraceDataCollected, | |
| 322 base::Unretained(this))); | |
| 323 | |
| 324 // Trigger callback if one is set. | |
| 325 if (subscriber_) { | |
| 326 if (is_get_categories_) | |
| 327 subscriber_->OnKnownCategoriesCollected(known_categories_); | |
| 328 else | |
| 329 subscriber_->OnEndTracingComplete(); | |
| 330 // Clear subscriber so that others can use TraceController. | |
| 331 subscriber_ = NULL; | |
| 332 } | |
| 333 | |
| 334 is_get_categories_ = false; | |
| 335 } | |
| 336 | |
| 337 if (pending_end_ack_count_ == 1) { | |
| 338 // The last ack represents local trace, so we need to ack it now. Note that | |
| 339 // this code only executes if there were child processes. | |
| 340 std::vector<std::string> categories; | |
| 341 TraceLog::GetInstance()->GetKnownCategories(&categories); | |
| 342 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, | |
| 343 base::Bind(&TraceControllerImpl::OnEndTracingAck, | |
| 344 base::Unretained(this), categories)); | |
| 345 } | |
| 346 } | |
| 347 | |
| 348 void TraceControllerImpl::OnTraceDataCollected( | |
| 349 const scoped_refptr<base::RefCountedString>& events_str_ptr) { | |
| 350 // OnTraceDataCollected may be called from any browser thread, either by the | |
| 351 // local event trace system or from child processes via TraceMessageFilter. | |
| 352 if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) { | |
| 353 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, | |
| 354 base::Bind(&TraceControllerImpl::OnTraceDataCollected, | |
| 355 base::Unretained(this), events_str_ptr)); | |
| 356 return; | |
| 357 } | |
| 358 | |
| 359 // Drop trace events if we are just getting categories. | |
| 360 if (subscriber_ && !is_get_categories_) | |
| 361 subscriber_->OnTraceDataCollected(events_str_ptr); | |
| 362 } | |
| 363 | |
| 364 void TraceControllerImpl::OnTraceNotification(int notification) { | |
| 365 // OnTraceNotification may be called from any browser thread, either by the | |
| 366 // local event trace system or from child processes via TraceMessageFilter. | |
| 367 if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) { | |
| 368 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, | |
| 369 base::Bind(&TraceControllerImpl::OnTraceNotification, | |
| 370 base::Unretained(this), notification)); | |
| 371 return; | |
| 372 } | |
| 373 | |
| 374 if (notification & base::debug::TraceLog::TRACE_BUFFER_FULL) { | |
| 375 // EndTracingAsync may return false if tracing is already in the process | |
| 376 // of being ended. That is ok. | |
| 377 EndTracingAsync(subscriber_); | |
| 378 } | |
| 379 if (notification & base::debug::TraceLog::EVENT_WATCH_NOTIFICATION) { | |
| 380 if (subscriber_) | |
| 381 subscriber_->OnEventWatchNotification(); | |
| 382 } | |
| 383 } | |
| 384 | |
| 385 void TraceControllerImpl::OnTraceBufferPercentFullReply(float percent_full) { | |
| 386 if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) { | |
| 387 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, | |
| 388 base::Bind(&TraceControllerImpl::OnTraceBufferPercentFullReply, | |
| 389 base::Unretained(this), percent_full)); | |
| 390 return; | |
| 391 } | |
| 392 | |
| 393 if (pending_bpf_ack_count_ == 0) | |
| 394 return; | |
| 395 | |
| 396 maximum_bpf_ = (maximum_bpf_ > percent_full)? maximum_bpf_ : percent_full; | |
| 397 | |
| 398 if (--pending_bpf_ack_count_ == 0) { | |
| 399 // Trigger callback if one is set. | |
| 400 if (subscriber_) | |
| 401 subscriber_->OnTraceBufferPercentFullReply(maximum_bpf_); | |
| 402 } | |
| 403 | |
| 404 if (pending_bpf_ack_count_ == 1) { | |
| 405 // The last ack represents local trace, so we need to ack it now. Note that | |
| 406 // this code only executes if there were child processes. | |
| 407 float bpf = TraceLog::GetInstance()->GetBufferPercentFull(); | |
| 408 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, | |
| 409 base::Bind(&TraceControllerImpl::OnTraceBufferPercentFullReply, | |
| 410 base::Unretained(this), bpf)); | |
| 411 } | |
| 412 } | |
| 413 | |
| 414 } // namespace content | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 12149003:
Move tracing code in content\browser to content\browser\tracing now that there's a separate directo… (Closed)
Base URL: svn://chrome-svn/chrome/trunk/src/