tracing: add dump provider for malloc heap profiler

components/tracing/docs/heap_profiler_internals.md

 # Heap Profiler Internals
 
 This document describes how the heap profiler works and how to add heap
 profiling support to your allocator. If you just want to know how to use it,
 see [Heap Profiling with MemoryInfra](heap_profiler.md)
 
 [TOC]
 
 ## Overview
 
 The heap profiler consists of tree main components:
 
  * **The Context Tracker**: Responsible for providing context (pseudo stack
    backtrace) when an allocation occurs.
  * **The Allocation Register**: A specialized hash table that stores allocation
    details by address.
  * **The Heap Dump Writer**: Extracts the most important information from a set
    of recorded allocations and converts it into a format that can be dumped into
    the trace log.
 
 These components are designed to work well together, but to be usable
 independently as well.
 
 When there is a way to get notified of all allocations and frees, this is the
 normal flow:
 
  1. When an allocation occurs, call
-    [`AllocationContextTracker::GetContextSnapshot()`][context-tracker]
+    [`AllocationContextTracker::GetInstanceForCurrentThread()->GetContextSnapshot()`][context-tracker]
     to get an [`AllocationContext`][alloc-context].
  2. Insert that context together with the address and size into an
     [`AllocationRegister`][alloc-register] by calling `Insert()`.
  3. When memory is freed, remove it from the register with `Remove()`.
  4. On memory dump, collect the allocations from the register, call
     [`ExportHeapDump()`][export-heap-dump], and add the generated heap dump to
     the memory dump.
 
 [context-tracker]:  https://chromium.googlesource.com/chromium/src/+/master/base/trace_event/heap_profiler_allocation_context_tracker.h
 [alloc-context]:    https://chromium.googlesource.com/chromium/src/+/master/base/trace_event/heap_profiler_allocation_context.h
@@ skipping 75 matching lines @@
 
   // Kept as pointer because |AllocationRegister| allocates a lot of virtual
   // address space when constructed, so only construct it when heap profiling is
   // enabled.
   scoped_ptr<AllocationRegister> allocation_register_;
   Lock allocation_register_lock_;
 
   static FooDumpProvider* GetInstance();
 
   void InsertAllocation(void* address, size_t size) {
-    AllocationContext context = AllocationContextTracker::GetContextSnapshot();
+    AllocationContext context = AllocationContextTracker::GetInstanceForCurrentThread()->GetContextSnapshot();
     AutoLock lock(allocation_register_lock_);
     allocation_register_->Insert(address, size, context);
   }
 
   void RemoveAllocation(void* address) {
     AutoLock lock(allocation_register_lock_);
     allocation_register_->Remove(address);
   }
 
   // Will be called as early as possible by the memory dump manager.
@@ skipping 40 matching lines @@
     return true;
   }
 };
 
 ```
 
 *** aside
 The implementation for `malloc` is more complicated because it needs to deal
 with reentrancy.
 ***