[Tracing] Add metadata filter

content/browser/tracing/tracing_controller_browsertest.cc

 // Copyright 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 "base/files/file_util.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/run_loop.h"
+#include "base/strings/pattern.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/tracing_controller.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/shell/browser/shell.h"
 
 using base::trace_event::RECORD_CONTINUOUSLY;
 using base::trace_event::RECORD_UNTIL_FULL;
 using base::trace_event::TraceConfig;
 
 namespace content {
 
+namespace {
+
+const char* kMetadataWhitelist[] = {
+  "cpu-brand",
+  "network-type",
+  "os-name",
+  "user-agent"
+};
+
+bool IsMetadataWhitelisted(const std::string& metadata_name) {
+  for (auto key : kMetadataWhitelist) {
+    if (base::MatchPattern(metadata_name, key)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool IsTraceEventArgsWhitelisted(
+    const char* category_group_name,
+    const char* event_name,
+    base::trace_event::ArgumentNameFilterPredicate* arg_filter) {
+  if (base::MatchPattern(category_group_name, "benchmark") &&
+      base::MatchPattern(event_name, "whitelisted")) {
+    return true;
+  }
+  return false;
+}
+
+}  // namespace
+
 class TracingControllerTestEndpoint
     : public TracingController::TraceDataEndpoint {
  public:
   TracingControllerTestEndpoint(
       base::Callback<void(scoped_ptr<const base::DictionaryValue>,
                           base::RefCountedString*)> done_callback)
       : done_callback_(done_callback) {}
 
   void ReceiveTraceChunk(const std::string& chunk) override {
     EXPECT_FALSE(chunk.empty());
@@ skipping 53 matching lines @@
     enable_recording_done_callback_count_++;
     quit_callback.Run();
   }
 
   void StopTracingStringDoneCallbackTest(
       base::Closure quit_callback,
       scoped_ptr<const base::DictionaryValue> metadata,
       base::RefCountedString* data) {
     disable_recording_done_callback_count_++;
     last_metadata_.reset(metadata.release());
+    last_data_ = data->data();
     EXPECT_TRUE(data->size() > 0);
     quit_callback.Run();
   }
 
   void StopTracingFileDoneCallbackTest(base::Closure quit_callback,
                                             const base::FilePath& file_path) {
     disable_recording_done_callback_count_++;
     EXPECT_TRUE(PathExists(file_path));
     int64 file_size;
     base::GetFileSize(file_path, &file_size);
@@ skipping 52 matching lines @@
   }
 
   base::FilePath last_actual_monitoring_file_path() const {
     return last_actual_monitoring_file_path_;
   }
 
   const base::DictionaryValue* last_metadata() const {
     return last_metadata_.get();
   }
 
+  const std::string& last_data() const {
+    return last_data_;
+  }
+
   void TestStartAndStopTracingString() {
     Navigate(shell());
 
     TracingController* controller = TracingController::GetInstance();
 
     {
       base::RunLoop run_loop;
       TracingController::StartTracingDoneCallback callback =
           base::Bind(&TracingControllerTest::StartTracingDoneCallbackTest,
                      base::Unretained(this),
@@ skipping 13 matching lines @@
           base::Unretained(this),
           run_loop.QuitClosure());
       bool result = controller->StopTracing(
           TracingController::CreateStringSink(callback));
       ASSERT_TRUE(result);
       run_loop.Run();
       EXPECT_EQ(disable_recording_done_callback_count(), 1);
     }
   }
 
+  void TestStartAndStopTracingStringWithFilter() {
+    Navigate(shell());
+
+    base::trace_event::TraceLog::GetInstance()->SetArgumentFilterPredicate(
+        base::Bind(&IsTraceEventArgsWhitelisted));
+    TracingController* controller = TracingController::GetInstance();
+
+    {
+      base::RunLoop run_loop;
+      TracingController::StartTracingDoneCallback callback =
+          base::Bind(&TracingControllerTest::StartTracingDoneCallbackTest,
+                     base::Unretained(this),
+                     run_loop.QuitClosure());
+
+      TraceConfig config = TraceConfig();
+      config.EnableArgumentFilter();
+
+      bool result = controller->StartTracing(config, callback);
+      ASSERT_TRUE(result);
+      run_loop.Run();
+      EXPECT_EQ(enable_recording_done_callback_count(), 1);
+    }
+
+    {
+      base::RunLoop run_loop;
+      base::Callback<void(scoped_ptr<const base::DictionaryValue>,
+                          base::RefCountedString*)> callback = base::Bind(
+          &TracingControllerTest::StopTracingStringDoneCallbackTest,
+          base::Unretained(this),
+          run_loop.QuitClosure());
+
+      scoped_refptr<TracingController::TraceDataSink> trace_data_sink =
+          TracingController::CreateStringSink(callback);
+
+      trace_data_sink->SetMetadataFilterPredicate(
+          base::Bind(&IsMetadataWhitelisted));
+      base::DictionaryValue metadata;
+      metadata.SetString("not-whitelisted", "this_not_found");
+      trace_data_sink->AddMetadata(metadata);
+
+      bool result = controller->StopTracing(trace_data_sink);
+      ASSERT_TRUE(result);
+      run_loop.Run();
+      EXPECT_EQ(disable_recording_done_callback_count(), 1);
+    }
+  }
+
   void TestStartAndStopTracingCompressed() {
     Navigate(shell());
 
     TracingController* controller = TracingController::GetInstance();
 
     {
       base::RunLoop run_loop;
       TracingController::StartTracingDoneCallback callback =
           base::Bind(&TracingControllerTest::StartTracingDoneCallbackTest,
                      base::Unretained(this), run_loop.QuitClosure());
@@ skipping 167 matching lines @@
  private:
   int get_categories_done_callback_count_;
   int enable_recording_done_callback_count_;
   int disable_recording_done_callback_count_;
   int enable_monitoring_done_callback_count_;
   int disable_monitoring_done_callback_count_;
   int capture_monitoring_snapshot_done_callback_count_;
   base::FilePath last_actual_recording_file_path_;
   base::FilePath last_actual_monitoring_file_path_;
   scoped_ptr<const base::DictionaryValue> last_metadata_;
+  std::string last_data_;
 };
 
 IN_PROC_BROWSER_TEST_F(TracingControllerTest, GetCategories) {
   Navigate(shell());
 
   TracingController* controller = TracingController::GetInstance();
 
   base::RunLoop run_loop;
   TracingController::GetCategoriesDoneCallback callback =
       base::Bind(&TracingControllerTest::GetCategoriesDoneCallbackTest,
@@ skipping 20 matching lines @@
   last_metadata()->GetString("user-agent", &user_agent);
   EXPECT_TRUE(user_agent.length() > 0);
   std::string os_name;
   last_metadata()->GetString("os-name", &os_name);
   EXPECT_TRUE(os_name.length() > 0);
   std::string cpu_brand;
   last_metadata()->GetString("cpu-brand", &cpu_brand);
   EXPECT_TRUE(cpu_brand.length() > 0);
 }
 
+IN_PROC_BROWSER_TEST_F(TracingControllerTest, NotWhitelistedMetadataStripped) {
+  TestStartAndStopTracingStringWithFilter();
+  // Check that a number of important keys exist in the metadata dictionary.
+  EXPECT_TRUE(last_metadata() != NULL);
+  std::string cpu_brand;
+  last_metadata()->GetString("cpu-brand", &cpu_brand);
+  EXPECT_TRUE(cpu_brand.length() > 0);
+  EXPECT_TRUE(cpu_brand != "__stripped__");
+  std::string network_type;
+  last_metadata()->GetString("network-type", &network_type);
+  EXPECT_TRUE(network_type.length() > 0);
+  EXPECT_TRUE(network_type != "__stripped__");
+  std::string os_name;
+  last_metadata()->GetString("os-name", &os_name);
+  EXPECT_TRUE(os_name.length() > 0);
+  EXPECT_TRUE(os_name != "__stripped__");
+  std::string user_agent;
+  last_metadata()->GetString("user-agent", &user_agent);
+  EXPECT_TRUE(user_agent.length() > 0);
+  EXPECT_TRUE(user_agent != "__stripped__");
+
+  // Check that the not whitelisted metadata is stripped.
+  std::string not_whitelisted;
+  last_metadata()->GetString("not-whitelisted", &not_whitelisted);
+  EXPECT_TRUE(not_whitelisted.length() > 0);
+  EXPECT_TRUE(not_whitelisted == "__stripped__");
+
+  // Also check the string data.
+  EXPECT_TRUE(last_data().size() > 0);
+  EXPECT_TRUE(last_data().find("cpu-brand") != std::string::npos);
+  EXPECT_TRUE(last_data().find("network-type") != std::string::npos);
+  EXPECT_TRUE(last_data().find("os-name") != std::string::npos);
+  EXPECT_TRUE(last_data().find("user-agent") != std::string::npos);
+
+  EXPECT_TRUE(last_data().find("not-whitelisted") != std::string::npos);
+  EXPECT_TRUE(last_data().find("this_not_found") == std::string::npos);
+}
+
 IN_PROC_BROWSER_TEST_F(TracingControllerTest,
                        EnableAndStopTracingWithFilePath) {
   base::FilePath file_path;
   base::CreateTemporaryFile(&file_path);
   TestStartAndStopTracingFile(file_path);
   EXPECT_EQ(file_path.value(), last_actual_recording_file_path().value());
 }
 
 IN_PROC_BROWSER_TEST_F(TracingControllerTest,
                        EnableAndStopTracingWithCompression) {
@@ skipping 55 matching lines @@
       trace_config,
       TracingController::StartMonitoringDoneCallback()));
   controller->CaptureMonitoringSnapshot(NULL);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(controller->StopMonitoring(
       TracingController::StopMonitoringDoneCallback()));
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace content