Enable FILTERING_MODE for tracing if event filters were given in config

content/browser/tracing/tracing_controller_impl.cc

 // Copyright (c) 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/cpu.h"
 #include "base/files/file_util.h"
 #include "base/guid.h"
 #include "base/json/string_escape.h"
@@ skipping 178 matching lines @@
 
 TracingControllerImpl::TracingControllerImpl()
     : pending_start_tracing_ack_count_(0),
       pending_stop_tracing_ack_count_(0),
       pending_trace_log_status_ack_count_(0),
       maximum_trace_buffer_usage_(0),
       approximate_event_count_(0),
       pending_memory_dump_ack_count_(0),
       failed_memory_dump_count_(0),
       pending_clock_sync_ack_count_(0),
-      is_tracing_(false) {
+      enabled_tracing_modes_(0) {
   base::trace_event::MemoryDumpManager::GetInstance()->Initialize(
       this /* delegate */, true /* is_coordinator */);
 
   // Deliberately leaked, like this class.
   base::FileTracing::SetProvider(new FileTracingProviderImpl);
 }
 
 TracingControllerImpl::~TracingControllerImpl() {
   // This is a Leaky instance.
   NOTREACHED();
@@ skipping 16 matching lines @@
     return false;
   }
 
   bool ok = StopTracing(NULL);
   DCHECK(ok);
   return true;
 }
 
 void TracingControllerImpl::SetEnabledOnFileThread(
     const TraceConfig& trace_config,
-    int mode,
     const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
-  TraceLog::GetInstance()->SetEnabled(
-      trace_config, static_cast<TraceLog::Mode>(mode));
+  TraceLog::GetInstance()->SetEnabled(trace_config, enabled_tracing_modes_);
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, callback);
 }
 
 void TracingControllerImpl::SetDisabledOnFileThread(
     const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
-  TraceLog::GetInstance()->SetDisabled();
+  DCHECK(enabled_tracing_modes_);
+  TraceLog::GetInstance()->SetDisabled(enabled_tracing_modes_);
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, callback);
 }
 
 bool TracingControllerImpl::StartTracing(
     const TraceConfig& trace_config,
     const StartTracingDoneCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(additional_tracing_agents_.empty());
 
   if (!can_start_tracing())
     return false;
-  is_tracing_ = true;
   start_tracing_done_callback_ = callback;
   start_tracing_trace_config_.reset(
       new base::trace_event::TraceConfig(trace_config));
+  enabled_tracing_modes_ = TraceLog::RECORDING_MODE;
+  if (!start_tracing_trace_config_->event_filters().empty())
+    enabled_tracing_modes_ |= TraceLog::FILTERING_MODE;
   metadata_.reset(new base::DictionaryValue());
   pending_start_tracing_ack_count_ = 0;
 
 #if defined(OS_ANDROID)
   if (pending_get_categories_done_callback_.is_null())
     TraceLog::GetInstance()->AddClockSyncMetadataEvent();
 #endif
 
   if (trace_config.IsSystraceEnabled()) {
 #if defined(ENABLE_POWER_TRACING)
@@ skipping 180 matching lines @@
 
   // Notify all child processes.
   for (TraceMessageFilterSet::iterator it = trace_message_filters_.begin();
       it != trace_message_filters_.end(); ++it) {
     it->get()->SendGetTraceLogStatus();
   }
   return true;
 }
 
 bool TracingControllerImpl::IsTracing() const {
-  return is_tracing_;
+  return !!enabled_tracing_modes_;
 }
 
 void TracingControllerImpl::AddTraceMessageFilter(
     TraceMessageFilter* trace_message_filter) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&TracingControllerImpl::AddTraceMessageFilter,
                    base::Unretained(this),
                    base::RetainedRef(trace_message_filter)));
@@ skipping 164 matching lines @@
                      base::Unretained(this)));
     }
     return;
   }
 
   if (pending_stop_tracing_ack_count_ != 0)
     return;
 
   // All acks (including from the subprocesses and the local trace) have been
   // received.
-  is_tracing_ = false;
+  enabled_tracing_modes_ = 0;
 
   // Trigger callback if one is set.
   if (!pending_get_categories_done_callback_.is_null()) {
     pending_get_categories_done_callback_.Run(known_category_groups_);
     pending_get_categories_done_callback_.Reset();
   } else if (trace_data_sink_.get()) {
     trace_data_sink_->Close();
     trace_data_sink_ = NULL;
   }
 }
@@ skipping 108 matching lines @@
     const base::trace_event::TraceConfig& trace_config,
     const StartAgentTracingCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   base::Closure on_agent_started =
       base::Bind(callback, kChromeTracingAgentName, true);
   if (!BrowserThread::PostTask(
           BrowserThread::FILE, FROM_HERE,
           base::Bind(&TracingControllerImpl::SetEnabledOnFileThread,
                      base::Unretained(this), trace_config,
-                     base::trace_event::TraceLog::RECORDING_MODE,
                      on_agent_started))) {
     // BrowserThread::PostTask fails if the threads haven't been created yet,
     // so it should be safe to just use TraceLog::SetEnabled directly.
-    base::trace_event::TraceLog::GetInstance()->SetEnabled(
-        trace_config, base::trace_event::TraceLog::RECORDING_MODE);
+    TraceLog::GetInstance()->SetEnabled(trace_config, enabled_tracing_modes_);
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, on_agent_started);
   }
 }
 
 void TracingControllerImpl::StopAgentTracing(
     const StopAgentTracingCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // Handle special case of zero child processes by immediately flushing the
   // trace log. Once the flush has completed the caller will be notified that
   // tracing has ended.
@@ skipping 266 matching lines @@
   // Schedule the next queued dump (if applicable).
   if (!queued_memory_dump_requests_.empty()) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&TracingControllerImpl::PerformNextQueuedGlobalMemoryDump,
                    base::Unretained(this)));
   }
 }
 
 }  // namespace content