Tracing: Add option to enable filtering in consumer tracing api

Depends on aosp/935386
This adds option for filtering output in data source config for privacy
safe mode.

BUG=925148

Change-Id: I488d38e362aba83f12be80d34b92c289d7ee34be
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1542962
Commit-Queue: ssid <ssid@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: oysteine <oysteine@chromium.org>
Cr-Commit-Position: refs/heads/master@{#646665}

services/tracing/perfetto/consumer_host_unittest.cc

@@ -17,6 +17,7 @@
 #include "base/strings/strcat.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task/post_task.h"
+#include "base/test/bind_test_util.h"
 #include "base/test/scoped_task_environment.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/system/data_pipe.h"
@@ -232,6 +233,18 @@ class ThreadedPerfettoService : public mojom::TracingSession {
     *tracing_enabled = tracing_enabled_;
   }
 
+  perfetto::DataSourceConfig GetProducerClientConfig() {
+    perfetto::DataSourceConfig config;
+    base::RunLoop wait_loop;
+    task_runner_->PostTaskAndReply(
+        FROM_HERE, base::BindLambdaForTesting([&]() {
+          config = producer_->producer_client()->data_source()->config();
+        }),
+        wait_loop.QuitClosure());
+    wait_loop.Run();
+    return config;
+  }
+
  private:
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
   std::unique_ptr<PerfettoService> perfetto_service_;
@@ -307,9 +320,17 @@ class TracingConsumerTest : public testing::Test,
     return trace_config;
   }
 
-  void EnableTracingWithDataSourceName(const std::string& data_source_name) {
-    threaded_service_->EnableTracingWithConfig(
-        GetDefaultTraceConfig(data_source_name));
+  void EnableTracingWithDataSourceName(const std::string& data_source_name,
+                                       bool enable_privacy_filtering = false) {
+    perfetto::TraceConfig config = GetDefaultTraceConfig(data_source_name);
+    if (enable_privacy_filtering) {
+      for (auto& source : *config.mutable_data_sources()) {
+        source.mutable_config()
+            ->mutable_chrome_config()
+            ->set_privacy_filtering_enabled(true);
+      }
+    }
+    threaded_service_->EnableTracingWithConfig(config);
   }
 
   bool IsTracingEnabled() {
@@ -510,4 +531,20 @@ TEST_F(TracingConsumerTest,
   EXPECT_TRUE(IsTracingEnabled());
 }
 
+TEST_F(TracingConsumerTest, PrivacyFilterConfig) {
+  EnableTracingWithDataSourceName(mojom::kTraceEventDataSourceName,
+                                  /* enable_privacy_filtering =*/true);
+
+  base::RunLoop wait_for_tracing_start;
+  threaded_perfetto_service()->CreateProducer(
+      mojom::kTraceEventDataSourceName, 10u,
+      wait_for_tracing_start.QuitClosure());
+
+  wait_for_tracing_start.Run();
+  EXPECT_TRUE(threaded_perfetto_service()
+                  ->GetProducerClientConfig()
+                  .chrome_config()
+                  .privacy_filtering_enabled());
+}
+
 }  // namespace tracing

services/tracing/perfetto/test_utils.cc

@@ -30,7 +30,7 @@ void TestDataSource::WritePacketBigly() {
   payload.get()[kLargeMessageSize - 1] = 0;
 
   std::unique_ptr<perfetto::TraceWriter> writer =
-      producer_client_->CreateTraceWriter(target_buffer_);
+      producer_client_->CreateTraceWriter(config_.target_buffer());
   CHECK(writer);
 
   writer->NewTracePacket()->set_for_testing()->set_str(payload.get(),
@@ -41,11 +41,11 @@ void TestDataSource::StartTracing(
     ProducerClient* producer_client,
     const perfetto::DataSourceConfig& data_source_config) {
   producer_client_ = producer_client;
-  target_buffer_ = data_source_config.target_buffer();
+  config_ = data_source_config;
 
   if (send_packet_count_ > 0) {
     std::unique_ptr<perfetto::TraceWriter> writer =
-        producer_client_->CreateTraceWriter(target_buffer_);
+        producer_client_->CreateTraceWriter(config_.target_buffer());
     CHECK(writer);
 
     for (size_t i = 0; i < send_packet_count_; i++) {

services/tracing/perfetto/test_utils.h

@@ -33,10 +33,12 @@ class TestDataSource : public ProducerClient::DataSourceBase {
       base::OnceClosure stop_complete_callback = base::OnceClosure()) override;
   void Flush(base::RepeatingClosure flush_complete_callback) override;
 
+  const perfetto::DataSourceConfig& config() { return config_; }
+
  private:
   ProducerClient* producer_client_ = nullptr;
   const size_t send_packet_count_;
-  uint32_t target_buffer_ = 0;
+  perfetto::DataSourceConfig config_;
 };
 
 class MockProducerClient : public ProducerClient {
@@ -159,6 +161,8 @@ class MockProducer {
 
   void WritePacketBigly(base::OnceClosure on_write_complete);
 
+  MockProducerClient* producer_client() { return producer_client_.get(); }
+
  private:
   std::unique_ptr<MockProducerClient> producer_client_;
   std::unique_ptr<MockProducerHost> producer_host_;

services/tracing/public/mojom/chrome_config_mojom_traits.cc

@@ -17,6 +17,7 @@ bool StructTraits<
     return false;
   }
   out->set_trace_config(std::move(config));
+  out->set_privacy_filtering_enabled(data.privacy_filtering_enabled());
   return true;
 }
 }  // namespace mojo

services/tracing/public/mojom/chrome_config_mojom_traits.h

@@ -23,6 +23,10 @@ class StructTraits<tracing::mojom::ChromeConfigDataView,
     return src.trace_config();
   }
 
+  static bool privacy_filtering_enabled(const perfetto::ChromeConfig& src) {
+    return src.privacy_filtering_enabled();
+  }
+
   static bool Read(tracing::mojom::ChromeConfigDataView data,
                    perfetto::ChromeConfig* out);
 };

services/tracing/public/mojom/perfetto_service.mojom

@@ -71,6 +71,10 @@ struct ChromeConfig {
   // base::trace_event::TraceConfig object rather then the json encoded string
   // used currently.
   string trace_config;
+
+  // When enabled the data source is supposed to only emit fields in the output
+  // proto that are guaranteed to not contain any sensitive data.
+  bool privacy_filtering_enabled;
 };
 
 struct DataSourceConfig {