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"
+#include "third_party/zlib/zlib.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);
 
+    size_t compressed_length = file_contents->data().length();
+    const size_t output_buffer_length = 10 * 1024 * 1024;
+    std::vector<char> output_str(output_buffer_length);
+
+    z_stream stream = {0};
+    stream.total_in = stream.avail_in = compressed_length;
+    stream.total_out = stream.avail_out = output_buffer_length;
+    stream.next_in = (Bytef*)&file_contents->data()[0];
+    stream.next_out = (Bytef*)&output_str[0];
+
+    stream.zalloc = Z_NULL;
+    stream.zfree = Z_NULL;
+    stream.opaque = Z_NULL;
+
+    int result = inflateInit2(&stream, 16 + MAX_WBITS);
+    EXPECT_EQ(Z_OK, result);
+    result = inflate(&stream, Z_FINISH);
+    bool success = (result != Z_STREAM_ERROR);
+    inflateEnd(&stream);
+    EXPECT_TRUE(success);
+
+    last_file_contents_ = &output_str[0];
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::Bind(done_callback));
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::Bind(callback_));
   }
 
+  bool TraceHasMatchingString(const char* str) {
+    return last_file_contents_.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_;
+  std::string 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(), false);
 
     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(), false);
 
     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);
   }
 }
 
+namespace {
+
+bool IsTraceEventArgsWhitelisted(const char* category_group_name,
+                                 const char* event_name) {
+  if (MatchPattern(category_group_name, "benchmark") &&
+      MatchPattern(event_name, "whitelisted")) {
+    return true;
+  }
+
+  return false;
+}
+
+}  // namespace
+
+// This tests that non-whitelisted args get stripped if required.
+IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
+                       NoWhitelistedArgsStripped) {
+  {
+    SetupBackgroundTracingManager();
+
+    base::trace_event::TraceLog::GetInstance()->SetArgumentFilterPredicate(
+        base::Bind(&IsTraceEventArgsWhitelisted));
+
+    base::RunLoop wait_for_upload;
+    BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
+        wait_for_upload.QuitClosure());
+
+    scoped_ptr<BackgroundTracingPreemptiveConfig> config =
+        CreatePreemptiveConfig();
+
+    content::BackgroundTracingManager::TriggerHandle handle =
+        content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
+            "test");
+
+    base::RunLoop wait_for_activated;
+    BackgroundTracingManager::GetInstance()->SetActiveScenario(
+        config.Pass(), upload_config_wrapper.get_receive_callback(),
+        wait_for_activated.QuitClosure(), true);
+
+    wait_for_activated.Run();
+
+    TRACE_EVENT1("benchmark", "whitelisted", "find_this", 1);
+    TRACE_EVENT1("benchmark", "not_whitelisted", "this_not_found", 1);
+
+    BackgroundTracingManager::GetInstance()->WhenIdle(
+        base::Bind(&DisableScenarioWhenIdle));
+
+    BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
+        handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
+
+    wait_for_upload.Run();
+
+    EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1);
+    EXPECT_TRUE(upload_config_wrapper.TraceHasMatchingString("{"));
+    EXPECT_TRUE(upload_config_wrapper.TraceHasMatchingString("find_this"));
+    EXPECT_TRUE(
+        !upload_config_wrapper.TraceHasMatchingString("this_not_found"));
+  }
+}
+
+// This tests subprocesses (like a navigating renderer) which gets told to
+// provide a argument-filtered trace and has no predicate in place to do the
+// filtering (in this case, only the browser process gets it set), will crash
+// rather than return potential PII.

[dsinclair, 2015/06/01 15:09:37]

We crash the process? That seems .... bad?

[oystein (OOO til 10th of July), 2015/06/01 18:23:38]

It's a CHECK() in the childprocess; shouldn't ever happen, this is just a
safeguard in case someone removes it and we start getting PII data.

+IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
+                       CrashWhenSubprocessWithoutArgumentFilter) {
+  {
+    SetupBackgroundTracingManager();
+
+    base::trace_event::TraceLog::GetInstance()->SetArgumentFilterPredicate(
+        base::Bind(&IsTraceEventArgsWhitelisted));
+
+    base::RunLoop wait_for_upload;
+    BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
+        wait_for_upload.QuitClosure());
+
+    scoped_ptr<BackgroundTracingPreemptiveConfig> config =
+        CreatePreemptiveConfig();
+
+    content::BackgroundTracingManager::TriggerHandle handle =
+        content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
+            "test");
+
+    base::RunLoop wait_for_activated;
+    BackgroundTracingManager::GetInstance()->SetActiveScenario(
+        config.Pass(), upload_config_wrapper.get_receive_callback(),
+        wait_for_activated.QuitClosure(), true);
+
+    wait_for_activated.Run();
+
+    NavigateToURL(shell(), GetTestUrl("", "about:blank"));
+
+    BackgroundTracingManager::GetInstance()->WhenIdle(
+        base::Bind(&DisableScenarioWhenIdle));
+
+    BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
+        handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
+
+    wait_for_upload.Run();
+
+    EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1);
+    // We should *not* receive anything at all from the renderer,
+    // the process should've crashed rather than letting that happen.
+    EXPECT_TRUE(
+        !upload_config_wrapper.TraceHasMatchingString("CrRendererMain"));
+  }
+}
+
 // 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(), false);
 
     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(), false);
 
     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(), false);
 
     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(), false);
 
     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(), false);
 
     EXPECT_FALSE(result);
   }
 }
 
 }  // namespace content