Home | History | Annotate | Download | only in tracing 
      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
    919