Use TracingController for startup tracing

content/browser/tracing/trace_controller_impl.cc

 // Copyright (c) 2012 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/trace_controller_impl.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/strings/string_number_conversions.h"
 #include "components/tracing/tracing_messages.h"
 #include "content/browser/tracing/trace_message_filter.h"
 #include "content/browser/tracing/trace_subscriber_stdio.h"
 #include "content/common/child_process_messages.h"
 #include "content/public/browser/browser_message_filter.h"
 #include "content/public/common/content_switches.h"
 
 using base::debug::TraceLog;
 
 namespace content {
 
 namespace {
 
 base::LazyInstance<TraceControllerImpl>::Leaky g_controller =
     LAZY_INSTANCE_INITIALIZER;
 
-class AutoStopTraceSubscriberStdio : public TraceSubscriberStdio {
- public:
-  AutoStopTraceSubscriberStdio(const base::FilePath& file_path)
-      : TraceSubscriberStdio(file_path,
-                             FILE_TYPE_PROPERTY_LIST,
-                             false) {}
-
-  static void EndStartupTrace(AutoStopTraceSubscriberStdio* subscriber) {
-    if (!TraceControllerImpl::GetInstance()->EndTracingAsync(subscriber))
-      delete subscriber;
-    // else, the tracing will end asynchronously in OnEndTracingComplete().
-  }
-
-  virtual void OnEndTracingComplete() OVERRIDE {
-    TraceSubscriberStdio::OnEndTracingComplete();
-    delete this;
-    // TODO(joth): this would be the time to automatically open up
-    // chrome://tracing/ and load up the trace data collected.
-  }
-};
-
 }  // namespace
 
 TraceController* TraceController::GetInstance() {
   return TraceControllerImpl::GetInstance();
 }
 
 TraceControllerImpl::TraceControllerImpl() :
     subscriber_(NULL),
     pending_end_ack_count_(0),
     pending_bpf_ack_count_(0),
     maximum_bpf_(0.0f),
     is_tracing_(false),
-    is_tracing_startup_(false),
     is_get_category_groups_(false),
     category_filter_(
         base::debug::CategoryFilter::kDefaultCategoryFilterString) {
   TraceLog::GetInstance()->SetNotificationCallback(
       base::Bind(&TraceControllerImpl::OnTraceNotification,
                  base::Unretained(this)));
 }
 
 TraceControllerImpl::~TraceControllerImpl() {
   // No need to SetNotificationCallback(nil) on the TraceLog since this is a
   // Leaky instance.
   NOTREACHED();
 }
 
 TraceControllerImpl* TraceControllerImpl::GetInstance() {
   return g_controller.Pointer();
 }
 
-void TraceControllerImpl::InitStartupTracing(const CommandLine& command_line) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  base::FilePath trace_file = command_line.GetSwitchValuePath(
-      switches::kTraceStartupFile);
-  // trace_file = "none" means that startup events will show up for the next
-  // begin/end tracing (via about:tracing or AutomationProxy::BeginTracing/
-  // EndTracing, for example).
-  if (trace_file == base::FilePath().AppendASCII("none"))
-    return;
-
-  if (trace_file.empty()) {
-    // Default to saving the startup trace into the current dir.
-    trace_file = base::FilePath().AppendASCII("chrometrace.log");
-  }
-  scoped_ptr<AutoStopTraceSubscriberStdio> subscriber(
-      new AutoStopTraceSubscriberStdio(trace_file));
-  DCHECK(can_begin_tracing(subscriber.get()));
-
-  std::string delay_str = command_line.GetSwitchValueASCII(
-      switches::kTraceStartupDuration);
-  int delay_secs = 5;
-  if (!delay_str.empty() && !base::StringToInt(delay_str, &delay_secs)) {
-    DLOG(WARNING) << "Could not parse --" << switches::kTraceStartupDuration
-        << "=" << delay_str << " defaulting to 5 (secs)";
-    delay_secs = 5;
-  }
-
-  is_tracing_startup_ = true;
-  OnTracingBegan(subscriber.get());
-  BrowserThread::PostDelayedTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(&AutoStopTraceSubscriberStdio::EndStartupTrace,
-                 base::Unretained(subscriber.release())),
-      base::TimeDelta::FromSeconds(delay_secs));
-}
-
 bool TraceControllerImpl::GetKnownCategoryGroupsAsync(
     TraceSubscriber* subscriber) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Known categories come back from child processes with the EndTracingAck
   // message. So to get known categories, just begin and end tracing immediately
   // afterwards. This will ping all the child processes for categories.
   is_get_category_groups_ = true;
   bool success = BeginTracing(subscriber, "*",
                               TraceLog::GetInstance()->trace_options()) &&
@@ skipping 26 matching lines @@
 
 bool TraceControllerImpl::EndTracingAsync(TraceSubscriber* subscriber) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!can_end_tracing() || subscriber != subscriber_)
     return false;
 
   // Disable local trace early to avoid traces during end-tracing process from
   // interfering with the process.
   TraceLog::GetInstance()->SetDisabled();
-  is_tracing_startup_ = false;
 
 #if defined(OS_ANDROID)
   if (!is_get_category_groups_)
     TraceLog::GetInstance()->AddClockSyncMetadataEvent();
 #endif
 
   // 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 OnEndTracingAck code.
@@ skipping 92 matching lines @@
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&TraceControllerImpl::AddFilter, base::Unretained(this),
                    make_scoped_refptr(filter)));
     return;
   }
 
   filters_.insert(filter);
   if (is_tracing_enabled()) {
     std::string cf_str = category_filter_.ToString();
-    filter->SendBeginTracing(cf_str, trace_options_, is_tracing_startup_);
+    filter->SendBeginTracing(cf_str, trace_options_);
     if (!watch_category_.empty())
       filter->SendSetWatchEvent(watch_category_, watch_name_);
   }
 }
 
 void TraceControllerImpl::RemoveFilter(TraceMessageFilter* filter) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&TraceControllerImpl::RemoveFilter, base::Unretained(this),
                    make_scoped_refptr(filter)));
     return;
   }
 
   filters_.erase(filter);
 }
 
 void TraceControllerImpl::OnTracingBegan(TraceSubscriber* subscriber) {
   is_tracing_ = true;
 
   subscriber_ = subscriber;
 
   category_filter_ = TraceLog::GetInstance()->GetCurrentCategoryFilter();
   trace_options_ = TraceLog::GetInstance()->trace_options();
 
   // Notify all child processes.
   for (FilterMap::iterator it = filters_.begin(); it != filters_.end(); ++it) {
-    it->get()->SendBeginTracing(category_filter_.ToString(), trace_options_,
-                                is_tracing_startup_);
+    it->get()->SendBeginTracing(category_filter_.ToString(), trace_options_);
   }
 }
 
 void TraceControllerImpl::OnEndTracingAck(
     const std::vector<std::string>& known_category_groups) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&TraceControllerImpl::OnEndTracingAck,
                    base::Unretained(this), known_category_groups));
     return;
@@ skipping 109 matching lines @@
     // The last ack represents local trace, so we need to ack it now. Note that
     // this code only executes if there were child processes.
     float bpf = TraceLog::GetInstance()->GetBufferPercentFull();
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
         base::Bind(&TraceControllerImpl::OnTraceBufferPercentFullReply,
                    base::Unretained(this), bpf));
   }
 }
 
 }  // namespace content