src/content/browser/tracing/tracing_controller_impl.cc

   1 // Copyright (c) 2013 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 #include "content/browser/tracing/tracing_controller_impl.h"
   5
   6 #include "base/bind.h"
   7 #include "base/debug/trace_event.h"
   8 #include "base/file_util.h"
   9 #include "base/json/string_escape.h"
  10 #include "base/strings/string_number_conversions.h"
  11 #include "content/browser/tracing/trace_message_filter.h"
  12 #include "content/browser/tracing/tracing_ui.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 #if defined(OS_CHROMEOS)
  18 #include "chromeos/dbus/dbus_thread_manager.h"
  19 #include "chromeos/dbus/debug_daemon_client.h"
  20 #endif
  21
  22 #if defined(OS_WIN)
  23 #include "content/browser/tracing/etw_system_event_consumer_win.h"
  24 #endif
  25
  26 using base::debug::TraceLog;
  27
  28 namespace content {
  29
  30 namespace {
  31
  32 base::LazyInstance<TracingControllerImpl>::Leaky g_controller =
  33     LAZY_INSTANCE_INITIALIZER;
  34
  35 }  // namespace
  36
  37 TracingController* TracingController::GetInstance() {
  38   return TracingControllerImpl::GetInstance();
  39 }
  40
  41 class TracingControllerImpl::ResultFile {
  42  public:
  43   explicit ResultFile(const base::FilePath& path);
  44   void Write(const scoped_refptr<base::RefCountedString>& events_str_ptr) {
  45     BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
  46         base::Bind(&TracingControllerImpl::ResultFile::WriteTask,
  47                    base::Unretained(this), events_str_ptr));
  48   }
  49   void Close(const base::Closure& callback) {
  50     BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
  51         base::Bind(&TracingControllerImpl::ResultFile::CloseTask,
  52                    base::Unretained(this), callback));
  53   }
  54   void WriteSystemTrace(
  55       const scoped_refptr<base::RefCountedString>& events_str_ptr) {
  56     BrowserThread::PostTask(
  57         BrowserThread::FILE,
  58         FROM_HERE,
  59         base::Bind(&TracingControllerImpl::ResultFile::WriteSystemTraceTask,
  60                    base::Unretained(this), events_str_ptr));
  61   }
  62
  63   const base::FilePath& path() const { return path_; }
  64
  65  private:
  66   void OpenTask();
  67   void WriteTask(const scoped_refptr<base::RefCountedString>& events_str_ptr);
  68   void WriteSystemTraceTask(
  69       const scoped_refptr<base::RefCountedString>& events_str_ptr);
  70   void CloseTask(const base::Closure& callback);
  71
  72   FILE* file_;
  73   base::FilePath path_;
  74   bool has_at_least_one_result_;
  75   scoped_refptr<base::RefCountedString> system_trace_;
  76
  77   DISALLOW_COPY_AND_ASSIGN(ResultFile);
  78 };
  79
  80 TracingControllerImpl::ResultFile::ResultFile(const base::FilePath& path)
  81     : file_(NULL),
  82       path_(path),
  83       has_at_least_one_result_(false) {
  84   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
  85       base::Bind(&TracingControllerImpl::ResultFile::OpenTask,
  86                  base::Unretained(this)));
  87 }
  88
  89 void TracingControllerImpl::ResultFile::OpenTask() {
  90   if (path_.empty())
  91     base::CreateTemporaryFile(&path_);
  92   file_ = base::OpenFile(path_, "w");
  93   if (!file_) {
  94     LOG(ERROR) << "Failed to open " << path_.value();
  95     return;
  96   }
  97   const char* preamble = "{\"traceEvents\": [";
  98   size_t written = fwrite(preamble, strlen(preamble), 1, file_);
  99   DCHECK(written == 1);
 100 }
 101
 102 void TracingControllerImpl::ResultFile::WriteTask(
 103     const scoped_refptr<base::RefCountedString>& events_str_ptr) {
 104   if (!file_ || !events_str_ptr->data().size())
 105     return;
 106
 107   // If there is already a result in the file, then put a comma
 108   // before the next batch of results.
 109   if (has_at_least_one_result_) {
 110     size_t written = fwrite(",", 1, 1, file_);
 111     DCHECK(written == 1);
 112   }
 113   has_at_least_one_result_ = true;
 114   size_t written = fwrite(events_str_ptr->data().c_str(),
 115                           events_str_ptr->data().size(), 1,
 116                           file_);
 117   DCHECK(written == 1);
 118 }
 119
 120 void TracingControllerImpl::ResultFile::WriteSystemTraceTask(
 121     const scoped_refptr<base::RefCountedString>& events_str_ptr) {
 122   system_trace_ = events_str_ptr;
 123 }
 124
 125 void TracingControllerImpl::ResultFile::CloseTask(
 126     const base::Closure& callback) {
 127   if (!file_)
 128     return;
 129
 130   const char* trailevents = "]";
 131   size_t written = fwrite(trailevents, strlen(trailevents), 1, file_);
 132   DCHECK(written == 1);
 133
 134   if (system_trace_) {
 135 #if defined(OS_WIN)
 136     // The Windows kernel events are kept into a JSon format stored as string
 137     // and must not be escaped.
 138     std::string json_string = system_trace_->data();
 139 #else
 140     std::string json_string = base::GetQuotedJSONString(system_trace_->data());
 141 #endif
 142
 143     const char* systemTraceHead = ",\n\"systemTraceEvents\": ";
 144     written = fwrite(systemTraceHead, strlen(systemTraceHead), 1, file_);
 145     DCHECK(written == 1);
 146
 147     written = fwrite(json_string.data(), json_string.size(), 1, file_);
 148     DCHECK(written == 1);
 149
 150     system_trace_ = NULL;
 151   }
 152
 153   const char* trailout = "}";
 154   written = fwrite(trailout, strlen(trailout), 1, file_);
 155   DCHECK(written == 1);
 156   base::CloseFile(file_);
 157   file_ = NULL;
 158
 159   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, callback);
 160 }
 161
 162
 163 TracingControllerImpl::TracingControllerImpl() :
 164     pending_disable_recording_ack_count_(0),
 165     pending_capture_monitoring_snapshot_ack_count_(0),
 166     pending_trace_buffer_percent_full_ack_count_(0),
 167     maximum_trace_buffer_percent_full_(0),
 168     // Tracing may have been enabled by ContentMainRunner if kTraceStartup
 169     // is specified in command line.
 170 #if defined(OS_CHROMEOS) || defined(OS_WIN)
 171     is_system_tracing_(false),
 172 #endif
 173     is_recording_(TraceLog::GetInstance()->IsEnabled()),
 174     is_monitoring_(false) {
 175 }
 176
 177 TracingControllerImpl::~TracingControllerImpl() {
 178   // This is a Leaky instance.
 179   NOTREACHED();
 180 }
 181
 182 TracingControllerImpl* TracingControllerImpl::GetInstance() {
 183   return g_controller.Pointer();
 184 }
 185
 186 bool TracingControllerImpl::GetCategories(
 187     const GetCategoriesDoneCallback& callback) {
 188   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 189
 190   // Known categories come back from child processes with the EndTracingAck
 191   // message. So to get known categories, just begin and end tracing immediately
 192   // afterwards. This will ping all the child processes for categories.
 193   pending_get_categories_done_callback_ = callback;
 194   if (!EnableRecording("*", TracingController::Options(),
 195                        EnableRecordingDoneCallback())) {
 196     pending_get_categories_done_callback_.Reset();
 197     return false;
 198   }
 199
 200   bool ok = DisableRecording(base::FilePath(), TracingFileResultCallback());
 201   DCHECK(ok);
 202   return true;
 203 }
 204
 205 void TracingControllerImpl::SetEnabledOnFileThread(
 206     const std::string& category_filter,
 207     int mode,
 208     int trace_options,
 209     const base::Closure& callback) {
 210   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 211
 212   TraceLog::GetInstance()->SetEnabled(
 213       base::debug::CategoryFilter(category_filter),
 214       static_cast<TraceLog::Mode>(mode),
 215       static_cast<TraceLog::Options>(trace_options));
 216   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, callback);
 217 }
 218
 219 void TracingControllerImpl::SetDisabledOnFileThread(
 220     const base::Closure& callback) {
 221   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 222
 223   TraceLog::GetInstance()->SetDisabled();
 224   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, callback);
 225 }
 226
 227 bool TracingControllerImpl::EnableRecording(
 228     const std::string& category_filter,
 229     TracingController::Options options,
 230     const EnableRecordingDoneCallback& callback) {
 231   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 232
 233   if (!can_enable_recording())
 234     return false;
 235   is_recording_ = true;
 236
 237 #if defined(OS_ANDROID)
 238   if (pending_get_categories_done_callback_.is_null())
 239     TraceLog::GetInstance()->AddClockSyncMetadataEvent();
 240 #endif
 241
 242   options_ = options;
 243   int trace_options = (options & RECORD_CONTINUOUSLY) ?
 244       TraceLog::RECORD_CONTINUOUSLY : TraceLog::RECORD_UNTIL_FULL;
 245   if (options & ENABLE_SAMPLING) {
 246     trace_options |= TraceLog::ENABLE_SAMPLING;
 247   }
 248
 249   if (options & ENABLE_SYSTRACE) {
 250 #if defined(OS_CHROMEOS)
 251     DCHECK(!is_system_tracing_);
 252     chromeos::DBusThreadManager::Get()->GetDebugDaemonClient()->
 253       StartSystemTracing();
 254     is_system_tracing_ = true;
 255 #elif defined(OS_WIN)
 256     DCHECK(!is_system_tracing_);
 257     is_system_tracing_ =
 258         EtwSystemEventConsumer::GetInstance()->StartSystemTracing();
 259 #endif
 260   }
 261
 262
 263   base::Closure on_enable_recording_done_callback =
 264       base::Bind(&TracingControllerImpl::OnEnableRecordingDone,
 265                  base::Unretained(this),
 266                  category_filter, trace_options, callback);
 267   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
 268       base::Bind(&TracingControllerImpl::SetEnabledOnFileThread,
 269                  base::Unretained(this),
 270                  category_filter,
 271                  base::debug::TraceLog::RECORDING_MODE,
 272                  trace_options,
 273                  on_enable_recording_done_callback));
 274   return true;
 275 }
 276
 277 void TracingControllerImpl::OnEnableRecordingDone(
 278     const std::string& category_filter,
 279     int trace_options,
 280     const EnableRecordingDoneCallback& callback) {
 281   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 282
 283   // Notify all child processes.
 284   for (TraceMessageFilterSet::iterator it = trace_message_filters_.begin();
 285       it != trace_message_filters_.end(); ++it) {
 286     it->get()->SendBeginTracing(category_filter,
 287                                 static_cast<TraceLog::Options>(trace_options));
 288   }
 289
 290   if (!callback.is_null())
 291     callback.Run();
 292 }
 293
 294 bool TracingControllerImpl::DisableRecording(
 295     const base::FilePath& result_file_path,
 296     const TracingFileResultCallback& callback) {
 297   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 298
 299   if (!can_disable_recording())
 300     return false;
 301
 302   options_ = TracingController::Options();
 303   // Disable local trace early to avoid traces during end-tracing process from
 304   // interfering with the process.
 305   base::Closure on_disable_recording_done_callback =
 306       base::Bind(&TracingControllerImpl::OnDisableRecordingDone,
 307                  base::Unretained(this),
 308                  result_file_path, callback);
 309   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
 310       base::Bind(&TracingControllerImpl::SetDisabledOnFileThread,
 311                  base::Unretained(this),
 312                  on_disable_recording_done_callback));
 313   return true;
 314 }
 315
 316 void TracingControllerImpl::OnDisableRecordingDone(
 317     const base::FilePath& result_file_path,
 318     const TracingFileResultCallback& callback) {
 319   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 320
 321   pending_disable_recording_done_callback_ = callback;
 322
 323 #if defined(OS_ANDROID)
 324   if (pending_get_categories_done_callback_.is_null())
 325     TraceLog::GetInstance()->AddClockSyncMetadataEvent();
 326 #endif
 327
 328   if (!callback.is_null() || !result_file_path.empty())
 329     result_file_.reset(new ResultFile(result_file_path));
 330
 331   // Count myself (local trace) in pending_disable_recording_ack_count_,
 332   // acked below.
 333   pending_disable_recording_ack_count_ = trace_message_filters_.size() + 1;
 334   pending_disable_recording_filters_ = trace_message_filters_;
 335
 336 #if defined(OS_CHROMEOS) || defined(OS_WIN)
 337   if (is_system_tracing_) {
 338     // Disable system tracing.
 339     is_system_tracing_ = false;
 340     ++pending_disable_recording_ack_count_;
 341
 342 #if defined(OS_CHROMEOS)
 343     chromeos::DBusThreadManager::Get()->GetDebugDaemonClient()->
 344       RequestStopSystemTracing(
 345           base::Bind(&TracingControllerImpl::OnEndSystemTracingAcked,
 346                      base::Unretained(this)));
 347 #elif defined(OS_WIN)
 348     EtwSystemEventConsumer::GetInstance()->StopSystemTracing(
 349         base::Bind(&TracingControllerImpl::OnEndSystemTracingAcked,
 350                    base::Unretained(this)));
 351 #endif
 352   }
 353 #endif  // defined(OS_CHROMEOS) || defined(OS_WIN)
 354
 355   // Handle special case of zero child processes by immediately flushing the
 356   // trace log. Once the flush has completed the caller will be notified that
 357   // tracing has ended.
 358   if (pending_disable_recording_ack_count_ == 1) {
 359     // Flush asynchronously now, because we don't have any children to wait for.
 360     TraceLog::GetInstance()->Flush(
 361         base::Bind(&TracingControllerImpl::OnLocalTraceDataCollected,
 362                    base::Unretained(this)));
 363   }
 364
 365   // Notify all child processes.
 366   for (TraceMessageFilterSet::iterator it = trace_message_filters_.begin();
 367       it != trace_message_filters_.end(); ++it) {
 368     it->get()->SendEndTracing();
 369   }
 370 }
 371
 372 bool TracingControllerImpl::EnableMonitoring(
 373     const std::string& category_filter,
 374     TracingController::Options options,
 375     const EnableMonitoringDoneCallback& callback) {
 376   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 377
 378   if (!can_enable_monitoring())
 379     return false;
 380   OnMonitoringStateChanged(true);
 381
 382 #if defined(OS_ANDROID)
 383   TraceLog::GetInstance()->AddClockSyncMetadataEvent();
 384 #endif
 385
 386   options_ = options;
 387   int trace_options = 0;
 388   if (options & ENABLE_SAMPLING)
 389     trace_options |= TraceLog::ENABLE_SAMPLING;
 390
 391   base::Closure on_enable_monitoring_done_callback =
 392       base::Bind(&TracingControllerImpl::OnEnableMonitoringDone,
 393                  base::Unretained(this),
 394                  category_filter, trace_options, callback);
 395   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
 396       base::Bind(&TracingControllerImpl::SetEnabledOnFileThread,
 397                  base::Unretained(this),
 398                  category_filter,
 399                  base::debug::TraceLog::MONITORING_MODE,
 400                  trace_options,
 401                  on_enable_monitoring_done_callback));
 402   return true;
 403 }
 404
 405 void TracingControllerImpl::OnEnableMonitoringDone(
 406     const std::string& category_filter,
 407     int trace_options,
 408     const EnableMonitoringDoneCallback& callback) {
 409   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 410
 411   // Notify all child processes.
 412   for (TraceMessageFilterSet::iterator it = trace_message_filters_.begin();
 413       it != trace_message_filters_.end(); ++it) {
 414     it->get()->SendEnableMonitoring(category_filter,
 415         static_cast<TraceLog::Options>(trace_options));
 416   }
 417
 418   if (!callback.is_null())
 419     callback.Run();
 420 }
 421
 422 bool TracingControllerImpl::DisableMonitoring(
 423     const DisableMonitoringDoneCallback& callback) {
 424   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 425
 426   if (!can_disable_monitoring())
 427     return false;
 428
 429   options_ = TracingController::Options();
 430   base::Closure on_disable_monitoring_done_callback =
 431       base::Bind(&TracingControllerImpl::OnDisableMonitoringDone,
 432                  base::Unretained(this), callback);
 433   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
 434       base::Bind(&TracingControllerImpl::SetDisabledOnFileThread,
 435                  base::Unretained(this),
 436                  on_disable_monitoring_done_callback));
 437   return true;
 438 }
 439
 440 void TracingControllerImpl::OnDisableMonitoringDone(
 441     const DisableMonitoringDoneCallback& callback) {
 442   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 443
 444   OnMonitoringStateChanged(false);
 445
 446   // Notify all child processes.
 447   for (TraceMessageFilterSet::iterator it = trace_message_filters_.begin();
 448       it != trace_message_filters_.end(); ++it) {
 449     it->get()->SendDisableMonitoring();
 450   }
 451
 452   if (!callback.is_null())
 453     callback.Run();
 454 }
 455
 456 void TracingControllerImpl::GetMonitoringStatus(
 457     bool* out_enabled,
 458     std::string* out_category_filter,
 459     TracingController::Options* out_options) {
 460   *out_enabled = is_monitoring_;
 461   *out_category_filter =
 462       TraceLog::GetInstance()->GetCurrentCategoryFilter().ToString();
 463   *out_options = options_;
 464 }
 465
 466 bool TracingControllerImpl::CaptureMonitoringSnapshot(
 467     const base::FilePath& result_file_path,
 468     const TracingFileResultCallback& callback) {
 469   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 470
 471   if (!can_disable_monitoring())
 472     return false;
 473
 474   if (callback.is_null() && result_file_path.empty())
 475     return false;
 476
 477   pending_capture_monitoring_snapshot_done_callback_ = callback;
 478   monitoring_snapshot_file_.reset(new ResultFile(result_file_path));
 479
 480   // Count myself in pending_capture_monitoring_snapshot_ack_count_,
 481   // acked below.
 482   pending_capture_monitoring_snapshot_ack_count_ =
 483       trace_message_filters_.size() + 1;
 484   pending_capture_monitoring_filters_ = trace_message_filters_;
 485
 486   // Handle special case of zero child processes by immediately flushing the
 487   // trace log. Once the flush has completed the caller will be notified that
 488   // the capture snapshot has ended.
 489   if (pending_capture_monitoring_snapshot_ack_count_ == 1) {
 490     // Flush asynchronously now, because we don't have any children to wait for.
 491     TraceLog::GetInstance()->FlushButLeaveBufferIntact(
 492         base::Bind(&TracingControllerImpl::OnLocalMonitoringTraceDataCollected,
 493                    base::Unretained(this)));
 494   }
 495
 496   // Notify all child processes.
 497   for (TraceMessageFilterSet::iterator it = trace_message_filters_.begin();
 498       it != trace_message_filters_.end(); ++it) {
 499     it->get()->SendCaptureMonitoringSnapshot();
 500   }
 501
 502 #if defined(OS_ANDROID)
 503   TraceLog::GetInstance()->AddClockSyncMetadataEvent();
 504 #endif
 505
 506   return true;
 507 }
 508
 509 bool TracingControllerImpl::GetTraceBufferPercentFull(
 510     const GetTraceBufferPercentFullCallback& callback) {
 511   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 512
 513   if (!can_get_trace_buffer_percent_full() || callback.is_null())
 514     return false;
 515
 516   pending_trace_buffer_percent_full_callback_ = callback;
 517
 518   // Count myself in pending_trace_buffer_percent_full_ack_count_, acked below.
 519   pending_trace_buffer_percent_full_ack_count_ =
 520       trace_message_filters_.size() + 1;
 521   pending_trace_buffer_percent_full_filters_ = trace_message_filters_;
 522   maximum_trace_buffer_percent_full_ = 0;
 523
 524   // Call OnTraceBufferPercentFullReply unconditionally for the browser process.
 525   // This will result in immediate execution of the callback if there are no
 526   // child processes.
 527   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
 528       base::Bind(&TracingControllerImpl::OnTraceBufferPercentFullReply,
 529                   base::Unretained(this),
 530                   scoped_refptr<TraceMessageFilter>(),
 531                   TraceLog::GetInstance()->GetBufferPercentFull()));
 532
 533   // Notify all child processes.
 534   for (TraceMessageFilterSet::iterator it = trace_message_filters_.begin();
 535       it != trace_message_filters_.end(); ++it) {
 536     it->get()->SendGetTraceBufferPercentFull();
 537   }
 538   return true;
 539 }
 540
 541 bool TracingControllerImpl::SetWatchEvent(
 542     const std::string& category_name,
 543     const std::string& event_name,
 544     const WatchEventCallback& callback) {
 545   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 546
 547   if (callback.is_null())
 548     return false;
 549
 550   watch_category_name_ = category_name;
 551   watch_event_name_ = event_name;
 552   watch_event_callback_ = callback;
 553
 554   TraceLog::GetInstance()->SetWatchEvent(
 555       category_name, event_name,
 556       base::Bind(&TracingControllerImpl::OnWatchEventMatched,
 557                  base::Unretained(this)));
 558
 559   for (TraceMessageFilterSet::iterator it = trace_message_filters_.begin();
 560       it != trace_message_filters_.end(); ++it) {
 561     it->get()->SendSetWatchEvent(category_name, event_name);
 562   }
 563   return true;
 564 }
 565
 566 bool TracingControllerImpl::CancelWatchEvent() {
 567   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 568
 569   if (!can_cancel_watch_event())
 570     return false;
 571
 572   for (TraceMessageFilterSet::iterator it = trace_message_filters_.begin();
 573       it != trace_message_filters_.end(); ++it) {
 574     it->get()->SendCancelWatchEvent();
 575   }
 576
 577   watch_event_callback_.Reset();
 578   return true;
 579 }
 580
 581 void TracingControllerImpl::AddTraceMessageFilter(
 582     TraceMessageFilter* trace_message_filter) {
 583   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
 584     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
 585         base::Bind(&TracingControllerImpl::AddTraceMessageFilter,
 586                    base::Unretained(this),
 587                    make_scoped_refptr(trace_message_filter)));
 588     return;
 589   }
 590
 591   trace_message_filters_.insert(trace_message_filter);
 592   if (can_cancel_watch_event()) {
 593     trace_message_filter->SendSetWatchEvent(watch_category_name_,
 594                                             watch_event_name_);
 595   }
 596   if (can_disable_recording()) {
 597     trace_message_filter->SendBeginTracing(
 598         TraceLog::GetInstance()->GetCurrentCategoryFilter().ToString(),
 599         TraceLog::GetInstance()->trace_options());
 600   }
 601   if (can_disable_monitoring()) {
 602     trace_message_filter->SendEnableMonitoring(
 603         TraceLog::GetInstance()->GetCurrentCategoryFilter().ToString(),
 604         TraceLog::GetInstance()->trace_options());
 605   }
 606 }
 607
 608 void TracingControllerImpl::RemoveTraceMessageFilter(
 609     TraceMessageFilter* trace_message_filter) {
 610   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
 611     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
 612         base::Bind(&TracingControllerImpl::RemoveTraceMessageFilter,
 613                    base::Unretained(this),
 614                    make_scoped_refptr(trace_message_filter)));
 615     return;
 616   }
 617
 618   // If a filter is removed while a response from that filter is pending then
 619   // simulate the response. Otherwise the response count will be wrong and the
 620   // completion callback will never be executed.
 621   if (pending_disable_recording_ack_count_ > 0) {
 622     TraceMessageFilterSet::const_iterator it =
 623         pending_disable_recording_filters_.find(trace_message_filter);
 624     if (it != pending_disable_recording_filters_.end()) {
 625       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
 626           base::Bind(&TracingControllerImpl::OnDisableRecordingAcked,
 627                      base::Unretained(this),
 628                      make_scoped_refptr(trace_message_filter),
 629                      std::vector<std::string>()));
 630     }
 631   }
 632   if (pending_capture_monitoring_snapshot_ack_count_ > 0) {
 633     TraceMessageFilterSet::const_iterator it =
 634         pending_capture_monitoring_filters_.find(trace_message_filter);
 635     if (it != pending_capture_monitoring_filters_.end()) {
 636       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
 637           base::Bind(&TracingControllerImpl::OnCaptureMonitoringSnapshotAcked,
 638                      base::Unretained(this),
 639                      make_scoped_refptr(trace_message_filter)));
 640     }
 641   }
 642   if (pending_trace_buffer_percent_full_ack_count_ > 0) {
 643     TraceMessageFilterSet::const_iterator it =
 644         pending_trace_buffer_percent_full_filters_.find(trace_message_filter);
 645     if (it != pending_trace_buffer_percent_full_filters_.end()) {
 646       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
 647           base::Bind(&TracingControllerImpl::OnTraceBufferPercentFullReply,
 648                      base::Unretained(this),
 649                      make_scoped_refptr(trace_message_filter),
 650                      0));
 651     }
 652   }
 653
 654   trace_message_filters_.erase(trace_message_filter);
 655 }
 656
 657 void TracingControllerImpl::OnDisableRecordingAcked(
 658     TraceMessageFilter* trace_message_filter,
 659     const std::vector<std::string>& known_category_groups) {
 660   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
 661     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
 662         base::Bind(&TracingControllerImpl::OnDisableRecordingAcked,
 663                    base::Unretained(this),
 664                    make_scoped_refptr(trace_message_filter),
 665                    known_category_groups));
 666     return;
 667   }
 668
 669   // Merge known_category_groups with known_category_groups_
 670   known_category_groups_.insert(known_category_groups.begin(),
 671                                 known_category_groups.end());
 672
 673   if (pending_disable_recording_ack_count_ == 0)
 674     return;
 675
 676   if (trace_message_filter &&
 677       !pending_disable_recording_filters_.erase(trace_message_filter)) {
 678     // The response from the specified message filter has already been received.
 679     return;
 680   }
 681
 682   if (--pending_disable_recording_ack_count_ == 1) {
 683     // All acks from subprocesses have been received. Now flush the local trace.
 684     // During or after this call, our OnLocalTraceDataCollected will be
 685     // called with the last of the local trace data.
 686     TraceLog::GetInstance()->Flush(
 687         base::Bind(&TracingControllerImpl::OnLocalTraceDataCollected,
 688                    base::Unretained(this)));
 689     return;
 690   }
 691
 692   if (pending_disable_recording_ack_count_ != 0)
 693     return;
 694
 695   OnDisableRecordingComplete();
 696 }
 697
 698 void TracingControllerImpl::OnDisableRecordingComplete() {
 699   // All acks (including from the subprocesses and the local trace) have been
 700   // received.
 701   is_recording_ = false;
 702
 703   // Trigger callback if one is set.
 704   if (!pending_get_categories_done_callback_.is_null()) {
 705     pending_get_categories_done_callback_.Run(known_category_groups_);
 706     pending_get_categories_done_callback_.Reset();
 707   } else if (result_file_) {
 708     result_file_->Close(
 709         base::Bind(&TracingControllerImpl::OnResultFileClosed,
 710                    base::Unretained(this)));
 711   }
 712 }
 713
 714 void TracingControllerImpl::OnResultFileClosed() {
 715   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 716
 717   if (!result_file_)
 718     return;
 719
 720   if (!pending_disable_recording_done_callback_.is_null()) {
 721     pending_disable_recording_done_callback_.Run(result_file_->path());
 722     pending_disable_recording_done_callback_.Reset();
 723   }
 724   result_file_.reset();
 725 }
 726
 727 #if defined(OS_CHROMEOS) || defined(OS_WIN)
 728 void TracingControllerImpl::OnEndSystemTracingAcked(
 729     const scoped_refptr<base::RefCountedString>& events_str_ptr) {
 730   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 731
 732   if (result_file_)
 733     result_file_->WriteSystemTrace(events_str_ptr);
 734
 735   DCHECK(!is_system_tracing_);
 736   std::vector<std::string> category_groups;
 737   OnDisableRecordingAcked(NULL, category_groups);
 738 }
 739 #endif
 740
 741 void TracingControllerImpl::OnCaptureMonitoringSnapshotAcked(
 742     TraceMessageFilter* trace_message_filter) {
 743   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
 744     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
 745         base::Bind(&TracingControllerImpl::OnCaptureMonitoringSnapshotAcked,
 746                    base::Unretained(this),
 747                    make_scoped_refptr(trace_message_filter)));
 748     return;
 749   }
 750
 751   if (pending_capture_monitoring_snapshot_ack_count_ == 0)
 752     return;
 753
 754   if (trace_message_filter &&
 755       !pending_capture_monitoring_filters_.erase(trace_message_filter)) {
 756     // The response from the specified message filter has already been received.
 757     return;
 758   }
 759
 760   if (--pending_capture_monitoring_snapshot_ack_count_ == 1) {
 761     // All acks from subprocesses have been received. Now flush the local trace.
 762     // During or after this call, our OnLocalMonitoringTraceDataCollected
 763     // will be called with the last of the local trace data.
 764     TraceLog::GetInstance()->FlushButLeaveBufferIntact(
 765         base::Bind(&TracingControllerImpl::OnLocalMonitoringTraceDataCollected,
 766                    base::Unretained(this)));
 767     return;
 768   }
 769
 770   if (pending_capture_monitoring_snapshot_ack_count_ != 0)
 771     return;
 772
 773   if (monitoring_snapshot_file_) {
 774     monitoring_snapshot_file_->Close(
 775         base::Bind(&TracingControllerImpl::OnMonitoringSnapshotFileClosed,
 776                    base::Unretained(this)));
 777   }
 778 }
 779
 780 void TracingControllerImpl::OnMonitoringSnapshotFileClosed() {
 781   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 782
 783   if (!monitoring_snapshot_file_)
 784     return;
 785
 786   if (!pending_capture_monitoring_snapshot_done_callback_.is_null()) {
 787     pending_capture_monitoring_snapshot_done_callback_.Run(
 788         monitoring_snapshot_file_->path());
 789     pending_capture_monitoring_snapshot_done_callback_.Reset();
 790   }
 791   monitoring_snapshot_file_.reset();
 792 }
 793
 794 void TracingControllerImpl::OnTraceDataCollected(
 795     const scoped_refptr<base::RefCountedString>& events_str_ptr) {
 796   // OnTraceDataCollected may be called from any browser thread, either by the
 797   // local event trace system or from child processes via TraceMessageFilter.
 798   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
 799     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
 800         base::Bind(&TracingControllerImpl::OnTraceDataCollected,
 801                    base::Unretained(this), events_str_ptr));
 802     return;
 803   }
 804
 805   if (result_file_)
 806     result_file_->Write(events_str_ptr);
 807 }
 808
 809 void TracingControllerImpl::OnMonitoringTraceDataCollected(
 810     const scoped_refptr<base::RefCountedString>& events_str_ptr) {
 811   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
 812     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
 813         base::Bind(&TracingControllerImpl::OnMonitoringTraceDataCollected,
 814                    base::Unretained(this), events_str_ptr));
 815     return;
 816   }
 817
 818   if (monitoring_snapshot_file_)
 819     monitoring_snapshot_file_->Write(events_str_ptr);
 820 }
 821
 822 void TracingControllerImpl::OnLocalTraceDataCollected(
 823     const scoped_refptr<base::RefCountedString>& events_str_ptr,
 824     bool has_more_events) {
 825   if (events_str_ptr->data().size())
 826     OnTraceDataCollected(events_str_ptr);
 827
 828   if (has_more_events)
 829     return;
 830
 831   // Simulate an DisableRecordingAcked for the local trace.
 832   std::vector<std::string> category_groups;
 833   TraceLog::GetInstance()->GetKnownCategoryGroups(&category_groups);
 834   OnDisableRecordingAcked(NULL, category_groups);
 835 }
 836
 837 void TracingControllerImpl::OnLocalMonitoringTraceDataCollected(
 838     const scoped_refptr<base::RefCountedString>& events_str_ptr,
 839     bool has_more_events) {
 840   if (events_str_ptr->data().size())
 841     OnMonitoringTraceDataCollected(events_str_ptr);
 842
 843   if (has_more_events)
 844     return;
 845
 846   // Simulate an CaptureMonitoringSnapshotAcked for the local trace.
 847   OnCaptureMonitoringSnapshotAcked(NULL);
 848 }
 849
 850 void TracingControllerImpl::OnTraceBufferPercentFullReply(
 851     TraceMessageFilter* trace_message_filter,
 852     float percent_full) {
 853   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
 854     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
 855         base::Bind(&TracingControllerImpl::OnTraceBufferPercentFullReply,
 856                    base::Unretained(this),
 857                    make_scoped_refptr(trace_message_filter),
 858                    percent_full));
 859     return;
 860   }
 861
 862   if (pending_trace_buffer_percent_full_ack_count_ == 0)
 863     return;
 864
 865   if (trace_message_filter &&
 866       !pending_trace_buffer_percent_full_filters_.erase(trace_message_filter)) {
 867     // The response from the specified message filter has already been received.
 868     return;
 869   }
 870
 871   maximum_trace_buffer_percent_full_ =
 872       std::max(maximum_trace_buffer_percent_full_, percent_full);
 873
 874   if (--pending_trace_buffer_percent_full_ack_count_ == 0) {
 875     // Trigger callback if one is set.
 876     pending_trace_buffer_percent_full_callback_.Run(
 877         maximum_trace_buffer_percent_full_);
 878     pending_trace_buffer_percent_full_callback_.Reset();
 879   }
 880 }
 881
 882 void TracingControllerImpl::OnWatchEventMatched() {
 883   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
 884     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
 885         base::Bind(&TracingControllerImpl::OnWatchEventMatched,
 886                    base::Unretained(this)));
 887     return;
 888   }
 889
 890   if (!watch_event_callback_.is_null())
 891     watch_event_callback_.Run();
 892 }
 893
 894 void TracingControllerImpl::RegisterTracingUI(TracingUI* tracing_ui) {
 895   DCHECK(tracing_uis_.find(tracing_ui) == tracing_uis_.end());
 896   tracing_uis_.insert(tracing_ui);
 897 }
 898
 899 void TracingControllerImpl::UnregisterTracingUI(TracingUI* tracing_ui) {
 900   std::set<TracingUI*>::iterator it = tracing_uis_.find(tracing_ui);
 901   DCHECK(it != tracing_uis_.end());
 902   tracing_uis_.erase(it);
 903 }
 904
 905 void TracingControllerImpl::OnMonitoringStateChanged(bool is_monitoring) {
 906   if (is_monitoring_ == is_monitoring)
 907     return;
 908
 909   is_monitoring_ = is_monitoring;
 910 #if !defined(OS_ANDROID)
 911   for (std::set<TracingUI*>::iterator it = tracing_uis_.begin();
 912        it != tracing_uis_.end(); it++) {
 913     (*it)->OnMonitoringStateChanged(is_monitoring);
 914   }
 915 #endif
 916 }
 917
 918 }  // namespace content