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 "base/time/time.h"
 #include "content/public/browser/background_tracing_preemptive_config.h"
 #include "content/public/browser/background_tracing_reactive_config.h"
@@ skipping 112 matching lines @@
         return false;
     }
   }
 
   return true;
 }
 
 bool BackgroundTracingManagerImpl::SetActiveScenario(
     scoped_ptr<BackgroundTracingConfig> config,
     const BackgroundTracingManager::ReceiveCallback& receive_callback,
-    bool requires_anonymized_data) {
+    DataFiltering data_filtering) {
   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;
+  requires_anonymized_data_ = (data_filtering == ANONYMIZE_DATA);
 
   EnableRecordingIfConfigNeedsIt();
 
   return true;
 }
 
 void BackgroundTracingManagerImpl::EnableRecordingIfConfigNeedsIt() {
   if (!config_)
     return;
 
@@ skipping 131 matching lines @@
   for (std::map<TriggerHandle, std::string>::iterator it =
            trigger_handles_.begin();
        it != trigger_handles_.end(); ++it)
     trigger_names->push_back(it->second);
 }
 
 void BackgroundTracingManagerImpl::InvalidateTriggerHandlesForTesting() {
   trigger_handles_.clear();
 }
 
+void BackgroundTracingManagerImpl::SetTracingEnabledCallbackForTesting(
+    const base::Closure& callback) {
+  tracing_enabled_callback_for_testing_ = callback;
+};
+
 void BackgroundTracingManagerImpl::FireTimerForTesting() {
   tracing_timer_->FireTimerForTesting();
 }
 
 void BackgroundTracingManagerImpl::EnableRecording(
     std::string category_filter_str,
     base::trace_event::TraceRecordMode record_mode) {
+  base::trace_event::TraceConfig trace_config(category_filter_str, record_mode);
+  if (requires_anonymized_data_)
+    trace_config.EnableArgumentFilter();
+
   is_tracing_ = TracingController::GetInstance()->EnableRecording(
-      base::trace_event::TraceConfig(category_filter_str, record_mode),
-      TracingController::EnableRecordingDoneCallback());
+      trace_config, tracing_enabled_callback_for_testing_);
 }
 
 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)));
@@ skipping 33 matching lines @@
              "disabled-by-default-toplevel.flow,"
              "disabled-by-default-ipc.flow";
     case BackgroundTracingConfig::CategoryPreset::BENCHMARK_DEEP:
       return "*,disabled-by-default-blink.debug.layout";
   }
   NOTREACHED();
   return "";
 }
 
 }  // namspace content