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

base/trace_event/malloc_dump_provider.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/malloc_dump_provider.h"
 
 #include <stddef.h>
 
 #include "base/allocator/allocator_extension.h"
 #include "base/allocator/allocator_shim.h"
@@ skipping 268 matching lines @@
     other_dump->AddScalar(MemoryAllocatorDump::kNameSize,
                           MemoryAllocatorDump::kUnitsBytes,
                           resident_size - allocated_objects_size);
   }
 
   // Heap profiler dumps.
   if (!heap_profiler_enabled_)
     return true;
 
   // The dumps of the heap profiler should be created only when heap profiling
-  // was enabled (--enable-heap-profiling) AND a DETAILED dump is requested.
-  // However, when enabled, the overhead of the heap profiler should be always
-  // reported to avoid oscillations of the malloc total in LIGHT dumps.
+  // was enabled with any mode AND a DETAILED dump is requested or heap
+  // profiling was enabled with BACKGROUND mode AND BACKGROUND dump is
+  // requested. However, when enabled, the overhead of the heap profiler should
+  // be always reported to avoid oscillations of the malloc total in LIGHT
+  // dumps.
 
   tid_dumping_heap_ = PlatformThread::CurrentId();
   // At this point the Insert/RemoveAllocation hooks will ignore this thread.
   // Enclosing all the temporariy data structures in a scope, so that the heap
   // profiler does not see unabalanced malloc/free calls from these containers.
   {
     TraceEventMemoryOverhead overhead;
     hash_map<AllocationContext, AllocationMetrics> metrics_by_context;
     {
       AutoLock lock(allocation_register_lock_);
       if (allocation_register_) {
-        if (args.level_of_detail == MemoryDumpLevelOfDetail::DETAILED) {
+        if (args.level_of_detail == MemoryDumpLevelOfDetail::DETAILED ||
+            (args.level_of_detail == MemoryDumpLevelOfDetail::BACKGROUND &&
+             AllocationContextTracker::capture_mode() ==
+                 AllocationContextTracker::CaptureMode::BACKGROUND)) {
           for (const auto& alloc_size : *allocation_register_) {
             AllocationMetrics& metrics = metrics_by_context[alloc_size.context];
             metrics.size += alloc_size.size;
             metrics.count++;
           }
         }
         allocation_register_->EstimateTraceMemoryOverhead(&overhead);
       }
     }  // lock(allocation_register_lock_)
     pmd->DumpHeapUsage(metrics_by_context, overhead, "malloc");
@@ skipping 55 matching lines @@
       tid_dumping_heap_ == PlatformThread::CurrentId())
     return;
   AutoLock lock(allocation_register_lock_);
   if (!allocation_register_)
     return;
   allocation_register_->Remove(address);
 }
 
 }  // namespace trace_event
 }  // namespace base