Hooked the trace event argument whitelist up to the background_trace_manager

content/browser/tracing/background_tracing_manager_browsertest.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 "base/bind.h"
+#include "base/trace_event/trace_event.h"
 #include "content/public/browser/background_tracing_manager.h"
 #include "content/public/browser/background_tracing_preemptive_config.h"
 #include "content/public/browser/background_tracing_reactive_config.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/public/test/test_utils.h"
 
 namespace content {
 
 class BackgroundTracingManagerBrowserTest : public ContentBrowserTest {
  public:
   BackgroundTracingManagerBrowserTest() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BackgroundTracingManagerBrowserTest);
 };
 
 class BackgroundTracingManagerUploadConfigWrapper {
  public:
   BackgroundTracingManagerUploadConfigWrapper(const base::Closure& callback)
       : callback_(callback), receive_count_(0) {
     receive_callback_ =
         base::Bind(&BackgroundTracingManagerUploadConfigWrapper::Upload,
                    base::Unretained(this));
   }
 
-  void Upload(const base::RefCountedString* file_contents,
+  void Upload(const scoped_refptr<base::RefCountedString>& file_contents,
               base::Callback<void()> done_callback) {
     receive_count_ += 1;
+    EXPECT_TRUE(file_contents);
+    last_file_contents_ = file_contents;
 
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::Bind(done_callback));
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::Bind(callback_));
   }
 
+  bool TraceHasMatchingString(const char* str) {
+    const std::string& json = last_file_contents_->data();
+    return json.find(str) != std::string::npos;
+  }
+
   int get_receive_count() const { return receive_count_; }
 
   const BackgroundTracingManager::ReceiveCallback& get_receive_callback()
       const {
     return receive_callback_;
   }
 
  private:
   BackgroundTracingManager::ReceiveCallback receive_callback_;
   base::Closure callback_;
   int receive_count_;
+  scoped_refptr<base::RefCountedString> last_file_contents_;
 };
 
 void StartedFinalizingCallback(base::Closure callback,
                                bool expected,
                                bool value) {
   EXPECT_EQ(expected, value);
   if (!callback.is_null())
     callback.Run();
 }
 
@@ skipping 11 matching lines @@
   return config.Pass();
 }
 
 void SetupBackgroundTracingManager() {
   content::BackgroundTracingManager::GetInstance()
       ->InvalidateTriggerHandlesForTesting();
 }
 
 void DisableScenarioWhenIdle() {
   BackgroundTracingManager::GetInstance()->SetActiveScenario(
-      NULL, BackgroundTracingManager::ReceiveCallback(), false);
+      NULL, BackgroundTracingManager::ReceiveCallback(), base::Closure(),
+      false);
 }
 
 // This tests that the endpoint receives the final trace data.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
                        ReceiveTraceFinalContentsOnTrigger) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
     scoped_ptr<BackgroundTracingPreemptiveConfig> config =
         CreatePreemptiveConfig();
 
     BackgroundTracingManager::TriggerHandle handle =
         BackgroundTracingManager::GetInstance()->RegisterTriggerType("test");
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
-        config.Pass(), upload_config_wrapper.get_receive_callback(), true);
+        config.Pass(), upload_config_wrapper.get_receive_callback(),
+        base::Closure(), true);
 
     BackgroundTracingManager::GetInstance()->WhenIdle(
         base::Bind(&DisableScenarioWhenIdle));
 
     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
         handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
 
     run_loop.Run();
 
     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1);
@@ skipping 11 matching lines @@
         run_loop.QuitClosure());
 
     scoped_ptr<BackgroundTracingPreemptiveConfig> config =
         CreatePreemptiveConfig();
 
     content::BackgroundTracingManager::TriggerHandle handle =
         content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
             "test");
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
-        config.Pass(), upload_config_wrapper.get_receive_callback(), true);
+        config.Pass(), upload_config_wrapper.get_receive_callback(),
+        base::Closure(), true);
 
     BackgroundTracingManager::GetInstance()->WhenIdle(
         base::Bind(&DisableScenarioWhenIdle));
 
     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
         handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
         handle, base::Bind(&StartedFinalizingCallback, base::Closure(), false));
 
     run_loop.Run();
 
     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1);
   }
 }
 
+// This tests that non-whitelisted args get stripped if required.
+IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
+                       NoWhitelistedArgsStripped) {

[shatch, 2015/05/22 22:25:05]

Should you write 2 tests, enabled and disabled. Since that trace_options in the
impl didn't seem to be used, would have shown up.

[oystein (OOO til 10th of July), 2015/05/27 22:13:32]

Test improved now, would've caught it.

+  {
+    SetupBackgroundTracingManager();
+
+    base::RunLoop upload_run_loop;
+    BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
+        upload_run_loop.QuitClosure());
+
+    scoped_ptr<BackgroundTracingPreemptiveConfig> config =
+        CreatePreemptiveConfig();
+    config->compress_trace = false;
+
+    content::BackgroundTracingManager::TriggerHandle handle =
+        content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
+            "test");
+
+    base::RunLoop enable_run_loop;
+    BackgroundTracingManager::GetInstance()->SetActiveScenario(
+        config.Pass(), upload_config_wrapper.get_receive_callback(),
+        enable_run_loop.QuitClosure(), true);
+
+    enable_run_loop.Run();
+    // NavigateToURL(shell(), GetTestUrl("", "title.html"));

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

nit: Get rid of this.

[oystein (OOO til 10th of July), 2015/05/27 22:13:33]

Done.

+
+    TRACE_EVENT1("__metadata", "thread_name", "my_thread_name", 1);
+    TRACE_EVENT1("__metadata", "process_name", "my_process_name", 1);
+
+    BackgroundTracingManager::GetInstance()->WhenIdle(
+        base::Bind(&DisableScenarioWhenIdle));
+
+    BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
+        handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
+
+    upload_run_loop.Run();
+
+    EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1);
+    EXPECT_TRUE(upload_config_wrapper.TraceHasMatchingString("__metadata"));
+    EXPECT_TRUE(upload_config_wrapper.TraceHasMatchingString("my_thread_name"));
+    EXPECT_TRUE(
+        !upload_config_wrapper.TraceHasMatchingString("my_process_name"));
+  }
+}
+
 // This tests multiple triggers still only gathers once.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
                        CallMultipleTriggersOnlyGatherOnce) {
   {
     SetupBackgroundTracingManager();
 
     base::RunLoop run_loop;
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         run_loop.QuitClosure());
 
     scoped_ptr<BackgroundTracingPreemptiveConfig> config =
         CreatePreemptiveConfig();
 
     BackgroundTracingPreemptiveConfig::MonitoringRule rule;
     rule.type =
         BackgroundTracingPreemptiveConfig::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED;
     rule.named_trigger_info.trigger_name = "test1";
     config->configs.push_back(rule);
 
     rule.named_trigger_info.trigger_name = "test2";
     config->configs.push_back(rule);
 
     BackgroundTracingManager::TriggerHandle handle1 =
         BackgroundTracingManager::GetInstance()->RegisterTriggerType("test1");
     BackgroundTracingManager::TriggerHandle handle2 =
         BackgroundTracingManager::GetInstance()->RegisterTriggerType("test2");
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
-        config.Pass(), upload_config_wrapper.get_receive_callback(), true);
+        config.Pass(), upload_config_wrapper.get_receive_callback(),
+        base::Closure(), true);
 
     BackgroundTracingManager::GetInstance()->WhenIdle(
         base::Bind(&DisableScenarioWhenIdle));
 
     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
         handle1, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
         handle2,
         base::Bind(&StartedFinalizingCallback, base::Closure(), false));
 
@@ skipping 41 matching lines @@
         (base::Closure()));
 
     scoped_ptr<BackgroundTracingPreemptiveConfig> config =
         CreatePreemptiveConfig();
 
     content::BackgroundTracingManager::TriggerHandle handle =
         content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
             "does_not_exist");
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
-        config.Pass(), upload_config_wrapper.get_receive_callback(), true);
+        config.Pass(), upload_config_wrapper.get_receive_callback(),
+        base::Closure(), true);
 
     BackgroundTracingManager::GetInstance()->WhenIdle(
         base::Bind(&DisableScenarioWhenIdle));
 
     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
         handle,
         base::Bind(&StartedFinalizingCallback, run_loop.QuitClosure(), false));
 
     run_loop.Run();
 
@@ skipping 15 matching lines @@
         CreatePreemptiveConfig();
 
     content::BackgroundTracingManager::TriggerHandle handle =
         content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
             "test");
 
     content::BackgroundTracingManager::GetInstance()
         ->InvalidateTriggerHandlesForTesting();
 
     BackgroundTracingManager::GetInstance()->SetActiveScenario(
-        config.Pass(), upload_config_wrapper.get_receive_callback(), true);
+        config.Pass(), upload_config_wrapper.get_receive_callback(),
+        base::Closure(), true);
 
     BackgroundTracingManager::GetInstance()->WhenIdle(
         base::Bind(&DisableScenarioWhenIdle));
 
     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
         handle,
         base::Bind(&StartedFinalizingCallback, run_loop.QuitClosure(), false));
 
     run_loop.Run();
 
@@ skipping 14 matching lines @@
         new content::BackgroundTracingPreemptiveConfig());
 
     BackgroundTracingPreemptiveConfig::MonitoringRule rule;
     rule.type = BackgroundTracingPreemptiveConfig::
         MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE;
     rule.histogram_trigger_info.histogram_name_to_trigger_on = "fake";
     rule.histogram_trigger_info.histogram_bin_to_trigger_on = 0;
     config->configs.push_back(rule);
 
     bool result = BackgroundTracingManager::GetInstance()->SetActiveScenario(
-        config.Pass(), upload_config_wrapper.get_receive_callback(), true);
+        config.Pass(), upload_config_wrapper.get_receive_callback(),
+        base::Closure(), true);
 
     EXPECT_FALSE(result);
   }
 }
 
 // This tests that reactive mode configs will fail.
 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
                        DoesNotAllowReactiveConfig) {
   {
     SetupBackgroundTracingManager();
 
     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
         (base::Closure()));
 
     scoped_ptr<BackgroundTracingConfig> config(
         new BackgroundTracingReactiveConfig());
 
     bool result = BackgroundTracingManager::GetInstance()->SetActiveScenario(
-        config.Pass(), upload_config_wrapper.get_receive_callback(), true);
+        config.Pass(), upload_config_wrapper.get_receive_callback(),
+        base::Closure(), true);
 
     EXPECT_FALSE(result);
   }
 }
 
 }  // namespace content