memory-infra: Move dump level check to observer and rename session state

base/trace_event/memory_tracing_observer.cc

 // Copyright 2017 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/memory_tracing_observer.h"
 
+#include "base/memory/ptr_util.h"
 #include "base/trace_event/memory_dump_manager.h"
 #include "base/trace_event/trace_event_argument.h"
 
 namespace base {
 namespace trace_event {
 
 namespace {
 
 const int kTraceEventNumArgs = 1;
 const char* kTraceEventArgNames[] = {"dumps"};
@@ skipping 32 matching lines @@
 
   // Initialize the TraceLog for the current thread. This is to avoids that the
   // TraceLog memory dump provider is registered lazily during the MDM Enable()
   TraceLog::GetInstance()->InitializeThreadLocalEventBufferIfSupported();
 
   const TraceConfig& trace_config =
       TraceLog::GetInstance()->GetCurrentTraceConfig();
   const TraceConfig::MemoryDumpConfig& memory_dump_config =
       trace_config.memory_dump_config();
 
+  memory_dump_config_ =
+      MakeUnique<TraceConfig::MemoryDumpConfig>(memory_dump_config);
+
   memory_dump_manager_->Enable(memory_dump_config);
 }
 
 void MemoryTracingObserver::OnTraceLogDisabled() {
   memory_dump_manager_->Disable();
+  memory_dump_config_.reset();
 }
 
 bool MemoryTracingObserver::AddDumpToTraceIfEnabled(
     const MemoryDumpRequestArgs* req_args,
     const ProcessId pid,
     const ProcessMemoryDump* process_memory_dump) {
   // If tracing has been disabled early out to avoid the cost of serializing the
   // dump then ignoring the result.
   if (!IsMemoryInfraTracingEnabled())
     return false;
+  // If the dump mode is too detailed don't add to trace to avoid accidentally
+  // including PII.
+  if (!IsDumpModeAllowed(req_args->level_of_detail))
+    return false;
 
   CHECK_NE(MemoryDumpType::SUMMARY_ONLY, req_args->dump_type);
 
   const uint64_t dump_guid = req_args->dump_guid;
 
   std::unique_ptr<TracedValue> traced_value(new TracedValue);
   process_memory_dump->AsValueInto(traced_value.get());
   traced_value->SetString("level_of_detail", MemoryDumpLevelOfDetailToString(
                                                  req_args->level_of_detail));
   const char* const event_name = MemoryDumpTypeToString(req_args->dump_type);
 
   std::unique_ptr<ConvertableToTraceFormat> event_value(
       std::move(traced_value));
   TRACE_EVENT_API_ADD_TRACE_EVENT_WITH_PROCESS_ID(
       TRACE_EVENT_PHASE_MEMORY_DUMP,
       TraceLog::GetCategoryGroupEnabled(MemoryDumpManager::kTraceCategory),
       event_name, trace_event_internal::kGlobalScope, dump_guid, pid,
       kTraceEventNumArgs, kTraceEventArgNames, kTraceEventArgTypes,
       nullptr /* arg_values */, &event_value, TRACE_EVENT_FLAG_HAS_ID);
 
   return true;
 }
 
+bool MemoryTracingObserver::IsDumpModeAllowed(
+    MemoryDumpLevelOfDetail dump_mode) const {
+  if (!memory_dump_config_)
+    return false;
+  return memory_dump_config_->allowed_dump_modes.count(dump_mode) != 0;
+}
+
 }  // namespace trace_event
 }  // namespace base