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

base/trace_event/trace_event_impl.cc

 // 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.
 
 #include "base/trace_event/trace_event_impl.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/base_switches.h"
@@ skipping 50 matching lines @@
 // trace.
 const int kOverheadReportThresholdInMicroseconds = 50;
 
 // String options that can be used to initialize TraceOptions.
 const char kRecordUntilFull[] = "record-until-full";
 const char kRecordContinuously[] = "record-continuously";
 const char kRecordAsMuchAsPossible[] = "record-as-much-as-possible";
 const char kTraceToConsole[] = "trace-to-console";
 const char kEnableSampling[] = "enable-sampling";
 const char kEnableSystrace[] = "enable-systrace";
+const char kEnableArgsWhitelist[] = "enable-args-whitelist";
 
 // Controls the number of trace events we will buffer in-memory
 // before throwing them away.
 const size_t kTraceBufferChunkSize = TraceBufferChunk::kTraceBufferChunkSize;
 const size_t kTraceEventVectorBigBufferChunks =
     512000000 / kTraceBufferChunkSize;
 const size_t kTraceEventVectorBufferChunks = 256000 / kTraceBufferChunkSize;
 const size_t kTraceEventRingBufferChunks = kTraceEventVectorBufferChunks / 4;
 const size_t kTraceEventBufferSizeInBytes = 100 * 1024;
 // Can store results for 30 seconds with 1 ms sampling interval.
@@ skipping 926 matching lines @@
     } else if (*iter == kRecordContinuously) {
       record_mode = RECORD_CONTINUOUSLY;
     } else if (*iter == kTraceToConsole) {
       record_mode = ECHO_TO_CONSOLE;
     } else if (*iter == kRecordAsMuchAsPossible) {
       record_mode = RECORD_AS_MUCH_AS_POSSIBLE;
     } else if (*iter == kEnableSampling) {
       enable_sampling = true;
     } else if (*iter == kEnableSystrace) {
       enable_systrace = true;
+    } else if (*iter == kEnableArgsWhitelist) {
+      enable_args_whitelist = true;
     } else {
       return false;
     }
   }
   return true;
 }
 
 std::string TraceOptions::ToString() const {
   std::string ret;
   switch (record_mode) {
     case RECORD_UNTIL_FULL:
       ret = kRecordUntilFull;
       break;
     case RECORD_CONTINUOUSLY:
       ret = kRecordContinuously;
       break;
     case ECHO_TO_CONSOLE:
       ret = kTraceToConsole;
       break;
     case RECORD_AS_MUCH_AS_POSSIBLE:
       ret = kRecordAsMuchAsPossible;
       break;
     default:
       NOTREACHED();
   }
   if (enable_sampling)
     ret = ret + "," + kEnableSampling;
   if (enable_systrace)
     ret = ret + "," + kEnableSystrace;
+  if (enable_args_whitelist)
+    ret = ret + "," + kEnableArgsWhitelist;
   return ret;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // TraceLog
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 class TraceLog::ThreadLocalEventBuffer
@@ skipping 437 matching lines @@
 
   {
     AutoLock lock(lock_);
     dispatching_to_observer_list_ = false;
   }
 }
 
 void TraceLog::SetEventFilterPredicate(
     const TraceEvent::EventFilterPredicate& event_filter_predicate) {
   AutoLock lock(lock_);
+  DCHECK(!event_filter_predicate.is_null());
   event_filter_predicate_ = event_filter_predicate;
 }
 
 TraceLog::InternalTraceOptions TraceLog::GetInternalOptionsFromTraceOptions(
     const TraceOptions& options) {
   InternalTraceOptions ret =
       options.enable_sampling ? kInternalEnableSampling : kInternalNone;
+  if (options.enable_args_whitelist)
+    ret |= kInternalEnableArgsWhitelist;
   switch (options.record_mode) {
     case RECORD_UNTIL_FULL:
       return ret | kInternalRecordUntilFull;
     case RECORD_CONTINUOUSLY:
       return ret | kInternalRecordContinuously;
     case ECHO_TO_CONSOLE:
       return ret | kInternalEchoToConsole;
     case RECORD_AS_MUCH_AS_POSSIBLE:
       return ret | kInternalRecordAsMuchAsPossible;
   }
   NOTREACHED();
   return kInternalNone;
 }
 
 CategoryFilter TraceLog::GetCurrentCategoryFilter() {
   AutoLock lock(lock_);
   return category_filter_;
 }
 
 TraceOptions TraceLog::GetCurrentTraceOptions() const {
   TraceOptions ret;
   InternalTraceOptions option = trace_options();
   ret.enable_sampling = (option & kInternalEnableSampling) != 0;
+  ret.enable_args_whitelist = (option & kInternalEnableArgsWhitelist) != 0;
   if (option & kInternalRecordUntilFull)
     ret.record_mode = RECORD_UNTIL_FULL;
   else if (option & kInternalRecordContinuously)
     ret.record_mode = RECORD_CONTINUOUSLY;
   else if (option & kInternalEchoToConsole)
     ret.record_mode = ECHO_TO_CONSOLE;
   else if (option & kInternalRecordAsMuchAsPossible)
     ret.record_mode = RECORD_AS_MUCH_AS_POSSIBLE;
   else
     NOTREACHED();
@@ skipping 1123 matching lines @@
 }
 
 ScopedTraceBinaryEfficient::~ScopedTraceBinaryEfficient() {
   if (*category_group_enabled_) {
     TRACE_EVENT_API_UPDATE_TRACE_EVENT_DURATION(category_group_enabled_,
                                                 name_, event_handle_);
   }
 }
 
 }  // namespace trace_event_internal