Hooked the trace event argument whitelist up to the background_trace_manager

content/browser/tracing/background_tracing_manager_impl.cc

 // Copyright 2015 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/background_tracing_manager_impl.h"
 
 #include "base/macros.h"
 #include "content/public/browser/background_tracing_preemptive_config.h"
 #include "content/public/browser/background_tracing_reactive_config.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 75 matching lines @@
         BackgroundTracingPreemptiveConfig::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED)
       return false;
   }
 
   return true;
 }
 
 bool BackgroundTracingManagerImpl::SetActiveScenario(
     scoped_ptr<BackgroundTracingConfig> config,
     const BackgroundTracingManager::ReceiveCallback& receive_callback,
+    const base::Closure& enabled_callback,
     bool requires_anonymized_data) {
   CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (is_tracing_)
     return false;
 
   if (!IsSupportedConfig(config.get()))
     return false;
 
   // No point in tracing if there's nowhere to send it.
   if (config && receive_callback.is_null())
     return false;
 
   config_ = config.Pass();
   receive_callback_ = receive_callback;
   requires_anonymized_data_ = requires_anonymized_data;
 
-  EnableRecordingIfConfigNeedsIt();
+  EnableRecordingIfConfigNeedsIt(enabled_callback);
 
   return true;
 }
 
-void BackgroundTracingManagerImpl::EnableRecordingIfConfigNeedsIt() {
+void BackgroundTracingManagerImpl::EnableRecordingIfConfigNeedsIt(
+    const base::Closure& enabled_callback) {
   if (!config_)
     return;
 
   if (config_->mode == BackgroundTracingConfig::PREEMPTIVE_TRACING_MODE) {
     EnableRecording(GetCategoryFilterForCategoryPreset(
-        static_cast<BackgroundTracingPreemptiveConfig*>(config_.get())
-            ->category_preset));
+                        static_cast<BackgroundTracingPreemptiveConfig*>(
+                            config_.get())->category_preset),
+                    enabled_callback);
   } else {
     // TODO(simonhatch): Implement reactive tracing path.
     NOTREACHED();
   }
 }
 
 bool BackgroundTracingManagerImpl::IsAbleToTriggerTracing(
     TriggerHandle handle) const {
   if (!config_)
     return false;
@@ skipping 86 matching lines @@
            trigger_handles_.begin();
        it != trigger_handles_.end(); ++it)
     trigger_names->push_back(it->second);
 }
 
 void BackgroundTracingManagerImpl::InvalidateTriggerHandlesForTesting() {
   trigger_handles_.clear();
 }
 
 void BackgroundTracingManagerImpl::EnableRecording(
-    base::trace_event::CategoryFilter category_filter) {
+    base::trace_event::CategoryFilter category_filter,
+    const base::Closure& enabled_callback) {
+  base::trace_event::TraceOptions trace_options(
+      base::trace_event::RECORD_CONTINUOUSLY);
+  trace_options.enable_argument_filter = requires_anonymized_data_;

[shatch, 2015/05/22 22:21:37]

Am I taking crazy pills, or is this not actually used.

   is_tracing_ = TracingController::GetInstance()->EnableRecording(
       category_filter,
       base::trace_event::TraceOptions(base::trace_event::RECORD_CONTINUOUSLY),
-      TracingController::EnableRecordingDoneCallback());
+      enabled_callback);
 }
 
 void BackgroundTracingManagerImpl::OnFinalizeStarted(
     scoped_refptr<base::RefCountedString> file_contents) {
   CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   if (!receive_callback_.is_null())
     receive_callback_.Run(
-        file_contents.get(),
+        file_contents,
         base::Bind(&BackgroundTracingManagerImpl::OnFinalizeComplete,
                    base::Unretained(this)));
 }
 
 void BackgroundTracingManagerImpl::OnFinalizeComplete() {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&BackgroundTracingManagerImpl::OnFinalizeComplete,
                    base::Unretained(this)));
     return;
   }
 
   CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   is_gathering_ = false;
 
   if (!idle_callback_.is_null())
     idle_callback_.Run();
 
   // Now that a trace has completed, we may need to enable recording again.
-  EnableRecordingIfConfigNeedsIt();
+  EnableRecordingIfConfigNeedsIt(base::Closure());
 }
 
 void BackgroundTracingManagerImpl::BeginFinalizing(
     StartedFinalizingCallback callback) {
   is_gathering_ = true;
   is_tracing_ = false;
 
-  content::TracingController::GetInstance()->DisableRecording(
-      content::TracingController::CreateCompressedStringSink(
-          data_endpoint_wrapper_));
+  scoped_refptr<TracingControllerImpl::TraceDataSink> trace_data_sink;
+  if (config_->compress_trace) {
+    trace_data_sink = content::TracingController::CreateCompressedStringSink(
+        data_endpoint_wrapper_);
+  } else {
+    trace_data_sink =
+        content::TracingController::CreateStringSink(data_endpoint_wrapper_);
+  }
+
+  content::TracingController::GetInstance()->DisableRecording(trace_data_sink);
 
   if (!callback.is_null())
     callback.Run(true);
 }
 
 base::trace_event::CategoryFilter
 BackgroundTracingManagerImpl::GetCategoryFilterForCategoryPreset(
     BackgroundTracingConfig::CategoryPreset preset) const {
   switch (preset) {
     case BackgroundTracingConfig::CategoryPreset::BENCHMARK:
@@ skipping 16 matching lines @@
   return NULL;
 }
 
 void BackgroundTracingConfig::IntoDict(const BackgroundTracingConfig* config,
                                        base::DictionaryValue* dict) {
   // TODO(simonhatch): Implement this.
   CHECK(false);
 }
 
 }  // namspace content