[Tracing] Add metadata filter

content/browser/tracing/tracing_controller_impl_data_sinks.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/tracing_controller_impl.h"
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/json/json_writer.h"
+#include "base/strings/pattern.h"
 #include "content/public/browser/browser_thread.h"
 #include "third_party/zlib/zlib.h"
 
 namespace content {
 
 namespace {
 
 class StringTraceDataEndpoint : public TracingController::TraceDataEndpoint {
  public:
   typedef base::Callback<void(scoped_ptr<const base::DictionaryValue>,
@@ skipping 117 matching lines @@
   }
 
   void SetPowerTrace(const std::string& data) override { power_trace_ = data; }
 
   void Close() override {
     AddTraceChunkAndPassToEndpoint("]");
     if (!system_trace_.empty())
       AddTraceChunkAndPassToEndpoint(",\"systemTraceEvents\": " +
                                      system_trace_);
     std::string metadataJSON;
-    if (base::JSONWriter::Write(GetMetadata(), &metadataJSON) &&
+    if (base::JSONWriter::Write(*GetMetadataCopy(), &metadataJSON) &&
         !metadataJSON.empty())
       AddTraceChunkAndPassToEndpoint(",\"metadata\": " + metadataJSON);
     if (!power_trace_.empty()) {
       AddTraceChunkAndPassToEndpoint(",\"powerTraceAsString\": " +
                                      power_trace_);
     }
 
     AddTraceChunkAndPassToEndpoint("}");
 
-    scoped_ptr<const base::DictionaryValue> metadata(GetMetadata().DeepCopy());
-    endpoint_->ReceiveTraceFinalContents(metadata.Pass(), trace_);
+    endpoint_->ReceiveTraceFinalContents(GetMetadataCopy(), trace_);
   }
 
  private:
   ~StringTraceDataSink() override {}
 
   scoped_refptr<TracingController::TraceDataEndpoint> endpoint_;
   std::string trace_;
   std::string system_trace_;
   std::string power_trace_;
 
@@ skipping 103 matching lines @@
 
     if (compressed_trace_data_.empty())
       AddTraceChunkAndCompressOnFileThread("{\"traceEvents\":[", false);
 
     AddTraceChunkAndCompressOnFileThread("]", false);
     if (!system_trace_.empty()) {
       AddTraceChunkAndCompressOnFileThread(
           ",\"systemTraceEvents\": " + system_trace_, false);
     }
     std::string metadataJSON;
-    if (base::JSONWriter::Write(GetMetadata(), &metadataJSON) &&
+    if (base::JSONWriter::Write(*GetMetadataCopy(), &metadataJSON) &&
         !metadataJSON.empty()) {
       AddTraceChunkAndCompressOnFileThread(",\"metadata\": " + metadataJSON,
                                            false);
     }
     if (!power_trace_.empty()) {
       AddTraceChunkAndCompressOnFileThread(
           ",\"powerTraceAsString\": " + power_trace_, false);
     }
     AddTraceChunkAndCompressOnFileThread("}", true);
 
     deflateEnd(stream_.get());
     stream_.reset();
 
-    scoped_ptr<const base::DictionaryValue> metadata(GetMetadata().DeepCopy());
-    endpoint_->ReceiveTraceFinalContents(metadata.Pass(),
+    endpoint_->ReceiveTraceFinalContents(GetMetadataCopy(),
                                          compressed_trace_data_);
   }
 
   scoped_refptr<TracingController::TraceDataEndpoint> endpoint_;
   scoped_ptr<z_stream> stream_;
   bool already_tried_open_;
   std::string compressed_trace_data_;
   std::string system_trace_;
   std::string power_trace_;
 
   DISALLOW_COPY_AND_ASSIGN(CompressedStringTraceDataSink);
 };
 
+const char* kMetadataWhitelist[] = {

[oystein (OOO til 10th of July), 2015/12/07 22:43:51]

Hmm, it'd be nice if the whitelists were all living in the same spot.

How about: Instead of passing a predicate down to the TraceLog and checking for
that before invoking this filtering, what we pass down from chrome/ is a
singleton implementation of something like:

class TracingFilter {
public
  virtual  bool IsArgsWhitelisted(const char* category_group_name, const char*
event_name) = 0;
  virtual bool IsMetadataWhitelisted(const char* metadata_name) = 0;
};

Then the separate whitelists and filtering functions can all live happily
together. 

[Zhen Wang, 2015/12/07 23:23:27]

Discussed offline, will try the following way:
- TracingController asks ChromeTracingDelegate for the metadata predicate.
- ChromeTracingDelegate asks trace_event_args_whitelist for the actual  metadata
whitelist.

+  "command_line",
+  "cpu-*",
+  "field-trials",
+  "gpu-*",
+  "highres-ticks",
+  "network-type",
+  "num-cpus",
+  "os-*",
+  "physical-memory",
+  "product-version",
+  "user-agent"
+};
+
 }  // namespace
 
+TracingController::TraceDataSink::TraceDataSink()
+    : requires_anonymized_metadata_(false) {
+}
+
 void TracingController::TraceDataSink::AddMetadata(
     const base::DictionaryValue& data) {
   metadata_.MergeDictionary(&data);
 }
 
-const base::DictionaryValue&
-    TracingController::TraceDataSink::GetMetadata() const {
-  return metadata_;
+void TracingController::TraceDataSink::EnableMetadataFilter() {
+  requires_anonymized_metadata_ = true;
+}
+
+scoped_ptr<const base::DictionaryValue>
+    TracingController::TraceDataSink::GetMetadataCopy() const {
+  if (!requires_anonymized_metadata_)
+    return scoped_ptr<const base::DictionaryValue>(metadata_.DeepCopy()).Pass();
+
+  scoped_ptr<base::DictionaryValue> metadata_copy(new base::DictionaryValue);
+  for (base::DictionaryValue::Iterator it(metadata_); !it.IsAtEnd();
+       it.Advance()) {
+    bool whitelisted = false;
+    for (auto key : kMetadataWhitelist) {
+      if (base::MatchPattern(it.key(), key)) {
+        whitelisted = true;
+        break;
+      }
+    }
+    if (whitelisted)
+      metadata_copy->Set(it.key(), it.value().DeepCopy());
+    else
+      metadata_copy->SetString(it.key(), "__stripped__");
+  }
+  return metadata_copy.Pass();
 }
 
 scoped_refptr<TracingController::TraceDataSink>
 TracingController::CreateStringSink(
     const base::Callback<void(scoped_ptr<const base::DictionaryValue>,
                               base::RefCountedString*)>& callback) {
   return new StringTraceDataSink(new StringTraceDataEndpoint(callback));
 }
 
 scoped_refptr<TracingController::TraceDataSink>
@@ skipping 16 matching lines @@
   return new StringTraceDataEndpoint(callback);
 }
 
 scoped_refptr<TracingController::TraceDataEndpoint>
 TracingController::CreateFileEndpoint(const base::FilePath& file_path,
                                       const base::Closure& callback) {
   return new FileTraceDataEndpoint(file_path, callback);
 }
 
 }  // namespace content