Use TracingController for startup tracing

content/browser/tracing/tracing_controller_impl.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/tracing/tracing_controller_impl.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/json/string_escape.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 95 matching lines @@
   file_util::CloseFile(file_);
   file_ = NULL;
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, callback);
 }
 
 
 TracingControllerImpl::TracingControllerImpl() :
     pending_disable_recording_ack_count_(0),
     pending_capture_monitoring_snapshot_ack_count_(0),
-    is_recording_(false),
+    // Tracing may have been enabled by ContentMainRunner if kTraceStartup
+    // is specified in command line.
+    is_recording_(TraceLog::GetInstance()->IsEnabled()),
     is_monitoring_(false),
-    trace_options_(TraceLog::RECORD_UNTIL_FULL),
     category_filter_(
         base::debug::CategoryFilter::kDefaultCategoryFilterString) {
 }
 
 TracingControllerImpl::~TracingControllerImpl() {
   // This is a Leaky instance.
   NOTREACHED();
 }
 
 TracingControllerImpl* TracingControllerImpl::GetInstance() {
@@ skipping 21 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!can_enable_recording())
     return false;
 
 #if defined(OS_ANDROID)
   if (pending_get_categories_done_callback_.is_null())
     TraceLog::GetInstance()->AddClockSyncMetadataEvent();
 #endif
 
-  trace_options_ = TraceLog::GetInstance()->trace_options();
-  TraceLog::GetInstance()->SetEnabled(filter, trace_options_);
+  TraceLog::Options trace_options = TraceLog::GetInstance()->trace_options();
+  TraceLog::GetInstance()->SetEnabled(filter, trace_options);
 
   is_recording_ = true;
   category_filter_ = TraceLog::GetInstance()->GetCurrentCategoryFilter();
 
   // Notify all child processes.
   for (FilterMap::iterator it = filters_.begin(); it != filters_.end(); ++it) {
-    it->get()->SendBeginTracing(
-        category_filter_.ToString(), trace_options_, false);
+    it->get()->SendBeginTracing(category_filter_.ToString(), trace_options);
   }
 
   if (!callback.is_null())
     callback.Run();
   return true;
 }
 
 bool TracingControllerImpl::DisableRecording(
     const base::FilePath& result_file_path,
     const TracingFileResultCallback& callback) {
@@ skipping 52 matching lines @@
   is_monitoring_ = true;
 
 #if defined(OS_ANDROID)
   TraceLog::GetInstance()->AddClockSyncMetadataEvent();
 #endif
 
   int monitoring_tracing_options = 0;
   if (options & ENABLE_SAMPLING)
     monitoring_tracing_options |= base::debug::TraceLog::MONITOR_SAMPLING;
 
+  TraceLog::GetInstance()->SetEnabled(
+      filter, base::debug::TraceLog::Options(monitoring_tracing_options));
+
   // Notify all child processes.
   for (FilterMap::iterator it = filters_.begin(); it != filters_.end(); ++it) {
     it->get()->SendEnableMonitoring(filter.ToString(),
         base::debug::TraceLog::Options(monitoring_tracing_options));
   }
 
   if (!callback.is_null())
     callback.Run();
   return true;
 }
 
 bool TracingControllerImpl::DisableMonitoring(
     const DisableMonitoringDoneCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!can_disable_monitoring())
     return false;
   is_monitoring_ = false;
 
+  TraceLog::GetInstance()->SetDisabled();
+
   // Notify all child processes.
   for (FilterMap::iterator it = filters_.begin(); it != filters_.end(); ++it) {
     it->get()->SendDisableMonitoring();
   }
 
   if (!callback.is_null())
     callback.Run();
   return true;
 }
 
 void TracingControllerImpl::GetMonitoringStatus(
     bool* out_enabled,
     base::debug::CategoryFilter* out_filter,
     TracingController::Options* out_options) {
   NOTIMPLEMENTED();
 }
 
 void TracingControllerImpl::CaptureMonitoringSnapshot(
     const base::FilePath& result_file_path,
     const TracingFileResultCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!can_disable_monitoring())
     return;
 
+  if (callback.is_null() && result_file_path.empty())
+    return;
+
   pending_capture_monitoring_snapshot_done_callback_ = callback;
-
-  if (!callback.is_null() || !result_file_path.empty())
-    monitoring_snapshot_file_.reset(new ResultFile(result_file_path));
+  monitoring_snapshot_file_.reset(new ResultFile(result_file_path));
 
   // There could be a case where there are no child processes and filters_
   // is empty. In that case we can immediately tell the subscriber that tracing
   // has ended. To avoid recursive calls back to the subscriber, we will just
   // use the existing asynchronous OnCaptureMonitoringSnapshotAcked code.
   // Count myself in pending_capture_monitoring_snapshot_ack_count_,
   // acked below.
   pending_capture_monitoring_snapshot_ack_count_ = filters_.size() + 1;
 
   // Handle special case of zero child processes.
@@ skipping 18 matching lines @@
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&TracingControllerImpl::AddFilter, base::Unretained(this),
                    make_scoped_refptr(filter)));
     return;
   }
 
   filters_.insert(filter);
   if (can_disable_recording()) {
     std::string cf_str = category_filter_.ToString();
-    filter->SendBeginTracing(cf_str, trace_options_, false);
+    filter->SendBeginTracing(cf_str, TraceLog::GetInstance()->trace_options());
   }
 }
 
 void TracingControllerImpl::RemoveFilter(TraceMessageFilter* filter) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&TracingControllerImpl::RemoveFilter, base::Unretained(this),
                    make_scoped_refptr(filter)));
     return;
   }
@@ skipping 118 matching lines @@
 
 void TracingControllerImpl::OnMonitoringTraceDataCollected(
     const scoped_refptr<base::RefCountedString>& events_str_ptr) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&TracingControllerImpl::OnMonitoringTraceDataCollected,
                    base::Unretained(this), events_str_ptr));
     return;
   }
 
-  if (!monitoring_snapshot_file_)
+  if (monitoring_snapshot_file_)
     monitoring_snapshot_file_->Write(events_str_ptr);
 }
 
 void TracingControllerImpl::OnLocalTraceDataCollected(
     const scoped_refptr<base::RefCountedString>& events_str_ptr,
     bool has_more_events) {
   if (events_str_ptr->data().size())
     OnTraceDataCollected(events_str_ptr);
 
   if (has_more_events)
@@ skipping 12 matching lines @@
     OnMonitoringTraceDataCollected(events_str_ptr);
 
   if (has_more_events)
     return;
 
   // Simulate an CaptureMonitoringSnapshotAcked for the local trace.
   OnCaptureMonitoringSnapshotAcked();
 }
 
 }  // namespace content