[memory-infra] Add api to enable heap profiling in MemoryDumpManager

base/trace_event/memory_dump_manager.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 "base/trace_event/memory_dump_manager.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/allocator/features.h"
@@ skipping 142 matching lines @@
 
 // static
 void MemoryDumpManager::SetInstanceForTesting(MemoryDumpManager* instance) {
   g_instance_for_testing = instance;
 }
 
 MemoryDumpManager::MemoryDumpManager()
     : memory_tracing_enabled_(0),
       tracing_process_id_(kInvalidTracingProcessId),
       dumper_registrations_ignored_for_testing_(false),
-      heap_profiling_enabled_(false) {
+      heap_profiling_state_(HeapProfilingState::DISABLED) {
   g_next_guid.GetNext();  // Make sure that first guid is not zero.
 
   // At this point the command line may not be initialized but we try to
   // enable the heap profiler to capture allocations as soon as possible.
   EnableHeapProfilingIfNeeded();
 
   strict_thread_check_blacklist_.insert(std::begin(kStrictThreadCheckBlacklist),
                                         std::end(kStrictThreadCheckBlacklist));
 }
 
 MemoryDumpManager::~MemoryDumpManager() {
   TraceLog::GetInstance()->RemoveEnabledStateObserver(this);
 }
 
 void MemoryDumpManager::EnableHeapProfilingIfNeeded() {
-  if (heap_profiling_enabled_)
+  AutoLock lock(lock_);
+  if (heap_profiling_state_ != HeapProfilingState::DISABLED)
     return;
 
   if (!CommandLine::InitializedForCurrentProcess() ||
       !CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableHeapProfiling))
     return;
 
   std::string profiling_mode = CommandLine::ForCurrentProcess()
       ->GetSwitchValueASCII(switches::kEnableHeapProfiling);
   if (profiling_mode == "") {
-    AllocationContextTracker::SetCaptureMode(
+    EnableHeapProfilingLocked(
         AllocationContextTracker::CaptureMode::PSEUDO_STACK);
 #if HAVE_TRACE_STACK_FRAME_POINTERS && \
     (BUILDFLAG(ENABLE_PROFILING) || !defined(NDEBUG))
   } else if (profiling_mode == switches::kEnableHeapProfilingModeNative) {
     // We need frame pointers for native tracing to work, and they are
     // enabled in profiling and debug builds.
-    AllocationContextTracker::SetCaptureMode(
+    EnableHeapProfilingLocked(
         AllocationContextTracker::CaptureMode::NATIVE_STACK);
 #endif
 #if BUILDFLAG(ENABLE_MEMORY_TASK_PROFILER)
   } else if (profiling_mode == switches::kEnableHeapProfilingTaskProfiler) {
     // Enable heap tracking, which in turn enables capture of heap usage
     // tracking in tracked_objects.cc.
     if (!base::debug::ThreadHeapUsageTracker::IsHeapTrackingEnabled())
       base::debug::ThreadHeapUsageTracker::EnableHeapTracking();
 #endif
   } else {
     CHECK(false) << "Invalid mode '" << profiling_mode << "' for "
                << switches::kEnableHeapProfiling << " flag.";
   }
+}
 
-  for (auto mdp : dump_providers_)
-    mdp->dump_provider->OnHeapProfilingEnabled(true);
-  heap_profiling_enabled_ = true;
+void MemoryDumpManager::EnableHeapProfiling(
+    AllocationContextTracker::CaptureMode capture_mode) {
+  CHECK_NE(AllocationContextTracker::CaptureMode::NATIVE_STACK, capture_mode)
+      << "Native mode can be enabled only by command line flag";
+  AutoLock lock(lock_);
+  EnableHeapProfilingLocked(capture_mode);
+}
+
+void MemoryDumpManager::EnableHeapProfilingLocked(
+    AllocationContextTracker::CaptureMode capture_mode) {
+  // Do not enable heap profiling if tracing is enabled, since session_state_
+  // will not be initialized.
+  if (capture_mode != AllocationContextTracker::CaptureMode::DISABLED &&
+      subtle::NoBarrier_Load(&memory_tracing_enabled_)) {
+    return;
+  }
+
+  switch (capture_mode) {
+    case AllocationContextTracker::CaptureMode::PSEUDO_STACK:
+    case AllocationContextTracker::CaptureMode::NATIVE_STACK:
+    case AllocationContextTracker::CaptureMode::BACKGROUND:
+      if (heap_profiling_state_ != HeapProfilingState::DISABLED)
+        return;
+      heap_profiling_state_ = HeapProfilingState::ENABLED;
+      break;
+    case AllocationContextTracker::CaptureMode::DISABLED:
+      heap_profiling_state_ = HeapProfilingState::DISABLED_PERMANENTLY;
+      break;
+  }
+  AllocationContextTracker::SetCaptureMode(capture_mode);
+  for (auto mdp : dump_providers_) {
+    mdp->dump_provider->OnHeapProfilingEnabled(heap_profiling_state_ ==
+                                               HeapProfilingState::ENABLED);
+  }
 }
 
 void MemoryDumpManager::Initialize(
     std::unique_ptr<MemoryDumpManagerDelegate> delegate) {
   {
     AutoLock lock(lock_);
     DCHECK(delegate);
     DCHECK(!delegate_);
     delegate_ = std::move(delegate);
-    EnableHeapProfilingIfNeeded();
   }
+  EnableHeapProfilingIfNeeded();
 
 // Enable the core dump providers.
 #if defined(MALLOC_MEMORY_TRACING_SUPPORTED)
   RegisterDumpProvider(MallocDumpProvider::GetInstance(), "Malloc", nullptr);
 #endif
 
 #if defined(OS_ANDROID)
   RegisterDumpProvider(JavaHeapDumpProvider::GetInstance(), "JavaHeap",
                        nullptr);
 #endif
@@ skipping 97 matching lines @@
     // The list of polling MDPs is populated OnTraceLogEnabled(). This code
     // deals with the case of a MDP capable of fast polling that is registered
     // after the OnTraceLogEnabled()
     if (options.is_fast_polling_supported && dump_thread_) {
       dump_thread_->task_runner()->PostTask(
           FROM_HERE, Bind(&MemoryDumpManager::RegisterPollingMDPOnDumpThread,
                           Unretained(this), mdpinfo));
     }
   }
 
-  if (heap_profiling_enabled_)
+  if (heap_profiling_state_ == HeapProfilingState::ENABLED)
     mdp->OnHeapProfilingEnabled(true);
 }
 
 void MemoryDumpManager::UnregisterDumpProvider(MemoryDumpProvider* mdp) {
   UnregisterDumpProviderInternal(mdp, false /* delete_async */);
 }
 
 void MemoryDumpManager::UnregisterAndDeleteDumpProviderSoon(
     std::unique_ptr<MemoryDumpProvider> mdp) {
   UnregisterDumpProviderInternal(mdp.release(), true /* delete_async */);
@@ skipping 491 matching lines @@
 
   const TraceConfig& trace_config =
       TraceLog::GetInstance()->GetCurrentTraceConfig();
   const TraceConfig::MemoryDumpConfig& memory_dump_config =
       trace_config.memory_dump_config();
   scoped_refptr<MemoryDumpSessionState> session_state =
       new MemoryDumpSessionState;
   session_state->SetAllowedDumpModes(memory_dump_config.allowed_dump_modes);
   session_state->set_heap_profiler_breakdown_threshold_bytes(
       memory_dump_config.heap_profiler_options.breakdown_threshold_bytes);
-  if (heap_profiling_enabled_) {
+  if (heap_profiling_state_ == HeapProfilingState::ENABLED) {
     // If heap profiling is enabled, the stack frame deduplicator and type name
     // deduplicator will be in use. Add a metadata events to write the frames
     // and type IDs.
     session_state->SetStackFrameDeduplicator(
         WrapUnique(new StackFrameDeduplicator));
 
     session_state->SetTypeNameDeduplicator(
         WrapUnique(new TypeNameDeduplicator));
 
     TRACE_EVENT_API_ADD_METADATA_EVENT(
@@ skipping 142 matching lines @@
   if (iter == process_dumps.end()) {
     std::unique_ptr<ProcessMemoryDump> new_pmd(
         new ProcessMemoryDump(session_state, dump_args));
     iter = process_dumps.insert(std::make_pair(pid, std::move(new_pmd))).first;
   }
   return iter->second.get();
 }
 
 }  // namespace trace_event
 }  // namespace base