Added a trace option for whitewashing trace args against a known-PII-less list.

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 104 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)> EventFilterPredicate;
+  void AppendAsJSON(std::string* out,
+                    const EventFilterPredicate& event_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_args_whitelist(false) {}
 
   explicit TraceOptions(TraceRecordMode record_mode)
       : record_mode(record_mode),
         enable_sampling(false),
-        enable_systrace(false) {}
+        enable_systrace(false),
+        enable_args_whitelist(false) {}

[nduca, 2015/05/01 03:09:03]

Should devtools protocol support this enable_args_whitelist? i was good to lg
the rest of this patch except for my indecision around whether anytime we add a
trace option we should update devtools protocol to accept it.

i had originally requested that the enable_Args_whitelist changew as a separate
patch so that i could add pavel to the codereview to ask for his advice.

i'd still kinda like to do that. we could add him to this total patch, but the
"proper" thing to do codereview wise is to have a patch that is one logical
thought at a time. in this case, we still have two thoughts in the patch: one
about predicate, one about the new option. so thats making this hard to give
good review to.

help, need advice on how to proceed.

 
   // |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_args_whitelist;
 };
 
 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 SetEventFilterPredicate(
+      const TraceEvent::EventFilterPredicate& event_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 165 matching lines @@
   void CheckIfBufferIsFullWhileLocked();
   void SetDisabledWhileLocked();
 
   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(
+  void ConvertTraceEventsToTraceFormat(
       scoped_ptr<TraceBuffer> logged_events,
-      const TraceLog::OutputCallback& flush_output_callback);
+      const TraceLog::OutputCallback& flush_output_callback,
+      const TraceEvent::EventFilterPredicate& event_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 kInternalEnableArgsWhitelist;
 
   // 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 43 matching lines @@
   // need to know the life time of the message loops.
   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_;
+  TraceEvent::EventFilterPredicate event_filter_predicate_;
   scoped_refptr<MessageLoopProxy> flush_message_loop_proxy_;
   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_