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

base/trace_event/memory_dump_manager.h

 // 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.
 
 #ifndef BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_H_
 #define BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 108 matching lines @@
   void RequestGlobalDump(MemoryDumpType dump_type,
                          MemoryDumpLevelOfDetail level_of_detail);
 
   // TraceLog::EnabledStateObserver implementation.
   void OnTraceLogEnabled() override;
   void OnTraceLogDisabled() override;
 
   // Enable heap profiling if kEnableHeapProfiling is specified.
   void EnableHeapProfilingIfNeeded();
 
+  // Enable heap profiling with specified |capture_mode|. Disabling heap
+  // profiler will disable it permanently and cannot be enabled again.
+  void EnableHeapProfiling(AllocationContextTracker::CaptureMode capture_mode);
+
   // Returns true if the dump mode is allowed for current tracing session.
   bool IsDumpModeAllowed(MemoryDumpLevelOfDetail dump_mode);
 
   // Lets tests see if a dump provider is registered.
   bool IsDumpProviderRegisteredForTesting(MemoryDumpProvider*);
 
   // Returns the MemoryDumpSessionState object, which is shared by all the
   // ProcessMemoryDump and MemoryAllocatorDump instances through all the tracing
   // session lifetime.
   const scoped_refptr<MemoryDumpSessionState>& session_state_for_testing()
@@ skipping 200 matching lines @@
   void UnregisterDumpProviderInternal(MemoryDumpProvider* mdp,
                                       bool take_mdp_ownership_and_delete_async);
 
   // Adds / removes provider that supports polling to
   // |dump_providers_for_polling_|.
   void RegisterPollingMDPOnDumpThread(
       scoped_refptr<MemoryDumpProviderInfo> mdpinfo);
   void UnregisterPollingMDPOnDumpThread(
       scoped_refptr<MemoryDumpProviderInfo> mdpinfo);
 
+  // Helper to enable heap profiling.
+  void EnableHeapProfilingLocked(
+      AllocationContextTracker::CaptureMode capture_mode);
+
   // An ordererd set of registered MemoryDumpProviderInfo(s), sorted by task
   // runner affinity (MDPs belonging to the same task runners are adjacent).
   MemoryDumpProviderInfo::OrderedSet dump_providers_;
 
   // A copy of mdpinfo list that support polling. It must be accessed only on
   // the dump thread if dump thread exists.
   MemoryDumpProviderInfo::OrderedSet dump_providers_for_polling_;
 
   // Shared among all the PMDs to keep state scoped to the tracing session.
   scoped_refptr<MemoryDumpSessionState> session_state_;
@@ skipping 17 matching lines @@
   // affinity.
   std::unique_ptr<Thread> dump_thread_;
 
   // The unique id of the child process. This is created only for tracing and is
   // expected to be valid only when tracing is enabled.
   uint64_t tracing_process_id_;
 
   // When true, calling |RegisterMemoryDumpProvider| is a no-op.
   bool dumper_registrations_ignored_for_testing_;
 
-  // Whether new memory dump providers should be told to enable heap profiling.
-  bool heap_profiling_enabled_;
+  // Heap profiling can be enabled and disabled only once in the process.
+  // New memory dump providers should be told to enable heap profiling if state
+  // is ENABLED.
+  enum class HeapProfilingState { DISABLED, ENABLED, DISABLED_PERMANENTLY };
+  HeapProfilingState heap_profiling_state_;
 
   DISALLOW_COPY_AND_ASSIGN(MemoryDumpManager);
 };
 
 // The delegate is supposed to be long lived (read: a Singleton) and thread
 // safe (i.e. should expect calls from any thread and handle thread hopping).
 class BASE_EXPORT MemoryDumpManagerDelegate {
  public:
   MemoryDumpManagerDelegate() {}
   virtual ~MemoryDumpManagerDelegate() {}
@@ skipping 10 matching lines @@
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MemoryDumpManagerDelegate);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_H_