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