Added a whitelist for trace events that are known to be PII-less.

base/trace_event/trace_event_impl.h

 // Copyright (c) 2012 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.
 
 
 #ifndef BASE_TRACE_EVENT_TRACE_EVENT_IMPL_H_
 #define BASE_TRACE_EVENT_TRACE_EVENT_IMPL_H_
 
 #include <stack>
 #include <string>
@@ skipping 105 matching lines @@
       const unsigned char* arg_types,
       const unsigned long long* arg_values,
       const scoped_refptr<ConvertableToTraceFormat>* convertable_values,
       unsigned char flags);
 
   void Reset();
 
   void UpdateDuration(const TimeTicks& now, const TimeTicks& thread_now);
 
   // Serialize event data to JSON
-  void AppendAsJSON(std::string* out) const;
+  typedef base::Callback<bool(const char* category_group_name,
+                              const char* event_name)> ArgumentFilterPredicate;
+  void AppendAsJSON(
+      std::string* out,
+      const ArgumentFilterPredicate& argument_filter_predicate) const;
   void AppendPrettyPrinted(std::ostringstream* out) const;
 
   static void AppendValueAsJSON(unsigned char type,
                                 TraceValue value,
                                 std::string* out);
 
   TimeTicks timestamp() const { return timestamp_; }
   TimeTicks thread_timestamp() const { return thread_timestamp_; }
   char phase() const { return phase_; }
   int thread_id() const { return thread_id_; }
@@ skipping 240 matching lines @@
   ECHO_TO_CONSOLE,
 
   // Record until the trace buffer is full, but with a huge buffer size.
   RECORD_AS_MUCH_AS_POSSIBLE
 };
 
 struct BASE_EXPORT TraceOptions {
   TraceOptions()
       : record_mode(RECORD_UNTIL_FULL),
         enable_sampling(false),
-        enable_systrace(false) {}
+        enable_systrace(false),
+        enable_argument_filter(false) {}
 
   explicit TraceOptions(TraceRecordMode record_mode)
       : record_mode(record_mode),
         enable_sampling(false),
-        enable_systrace(false) {}
+        enable_systrace(false),
+        enable_argument_filter(false) {}
 
   // |options_string| is a comma-delimited list of trace options.
   // Possible options are: "record-until-full", "record-continuously",
   // "trace-to-console", "enable-sampling" and "enable-systrace".
   // The first 3 options are trace recoding modes and hence
   // mutually exclusive. If more than one trace recording modes appear in the
   // options_string, the last one takes precedence. If none of the trace
   // recording mode is specified, recording mode is RECORD_UNTIL_FULL.
   //
   // The trace option will first be reset to the default option
@@ skipping 10 matching lines @@
   // will set ECHO_TO_CONSOLE as the recording mode.
   //
   // Returns true on success.
   bool SetFromString(const std::string& options_string);
 
   std::string ToString() const;
 
   TraceRecordMode record_mode;
   bool enable_sampling;
   bool enable_systrace;
+  bool enable_argument_filter;
 };
 
 struct BASE_EXPORT TraceLogStatus {
   TraceLogStatus();
   ~TraceLogStatus();
   size_t event_capacity;
   size_t event_count;
 };
 
 class BASE_EXPORT TraceLog {
@@ skipping 93 matching lines @@
                                 int num_args,
                                 const char* const arg_names[],
                                 const unsigned char arg_types[],
                                 const unsigned long long arg_values[],
                                 unsigned char flags);
 
   // Enable tracing for EventCallback.
   void SetEventCallbackEnabled(const CategoryFilter& category_filter,
                                EventCallback cb);
   void SetEventCallbackDisabled();
+  void SetArgumentFilterPredicate(
+      const TraceEvent::ArgumentFilterPredicate& argument_filter_predicate);
 
   // Flush all collected events to the given output callback. The callback will
   // be called one or more times either synchronously or asynchronously from
   // the current thread with IPC-bite-size chunks. The string format is
   // undefined. Use TraceResultBuffer to convert one or more trace strings to
   // JSON. The callback can be null if the caller doesn't want any data.
   // Due to the implementation of thread-local buffers, flush can't be
   // done when tracing is enabled. If called when tracing is enabled, the
   // callback will be called directly with (empty_string, false) to indicate
   // the end of this unsuccessful flush. Flush does the serialization
@@ skipping 167 matching lines @@
 
   TraceEvent* GetEventByHandleInternal(TraceEventHandle handle,
                                        OptionalAutoLock* lock);
 
   // |generation| is used in the following callbacks to check if the callback
   // is called for the flush of the current |logged_events_|.
   void FlushCurrentThread(int generation);
   // Usually it runs on a different thread.
   static void ConvertTraceEventsToTraceFormat(
       scoped_ptr<TraceBuffer> logged_events,
-      const TraceLog::OutputCallback& flush_output_callback);
+      const TraceLog::OutputCallback& flush_output_callback,
+      const TraceEvent::ArgumentFilterPredicate& argument_filter_predicate);
   void FinishFlush(int generation);
   void OnFlushTimeout(int generation);
 
   int generation() const {
     return static_cast<int>(subtle::NoBarrier_Load(&generation_));
   }
   bool CheckGeneration(int generation) const {
     return generation == this->generation();
   }
   void UseNextTraceBuffer();
 
   TimeTicks OffsetNow() const {
     return OffsetTimestamp(TimeTicks::NowFromSystemTraceTime());
   }
   TimeTicks OffsetTimestamp(const TimeTicks& timestamp) const {
     return timestamp - time_offset_;
   }
 
   // Internal representation of trace options since we store the currently used
   // trace option as an AtomicWord.
   static const InternalTraceOptions kInternalNone;
   static const InternalTraceOptions kInternalRecordUntilFull;
   static const InternalTraceOptions kInternalRecordContinuously;
   static const InternalTraceOptions kInternalEchoToConsole;
   static const InternalTraceOptions kInternalEnableSampling;
   static const InternalTraceOptions kInternalRecordAsMuchAsPossible;
+  static const InternalTraceOptions kInternalEnableArgumentFilter;
 
   // This lock protects TraceLog member accesses (except for members protected
   // by thread_info_lock_) from arbitrary threads.
   mutable Lock lock_;
   // This lock protects accesses to thread_names_, thread_event_start_times_
   // and thread_colors_.
   Lock thread_info_lock_;
   Mode mode_;
   int num_traces_recorded_;
   scoped_ptr<TraceBuffer> logged_events_;
@@ skipping 44 matching lines @@
   hash_set<MessageLoop*> thread_message_loops_;
 
   // For events which can't be added into the thread local buffer, e.g. events
   // from threads without a message loop.
   scoped_ptr<TraceBufferChunk> thread_shared_chunk_;
   size_t thread_shared_chunk_index_;
 
   // Set when asynchronous Flush is in progress.
   OutputCallback flush_output_callback_;
   scoped_refptr<SingleThreadTaskRunner> flush_task_runner_;
+  TraceEvent::ArgumentFilterPredicate argument_filter_predicate_;
   subtle::AtomicWord generation_;
   bool use_worker_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(TraceLog);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_TRACE_EVENT_IMPL_H_