[tracing] Add native allocation tracing mode.

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 218 matching lines @@
       tid_dumping_heap_ == PlatformThread::CurrentId())
     return;
 
   // AllocationContextTracker will return nullptr when called re-reentrantly.
   // This is the case of GetInstanceForCurrentThread() being called for the
   // first time, which causes a new() inside the tracker which re-enters the
   // heap profiler, in which case we just want to early out.
   auto tracker = AllocationContextTracker::GetInstanceForCurrentThread();
   if (!tracker)
     return;
-  AllocationContext context = tracker->GetContextSnapshot();
 
   AutoLock lock(allocation_register_lock_);
   if (!allocation_register_)
     return;
 
+  AllocationContext context = tracker->GetContextSnapshot();

[Primiano Tucci (use gerrit), 2016/04/07 15:51:57]

why moving this?
The point of this being before the lock is that you don't need to stall all the
threads that are doing a malloc while you do the stack unwinding.
If you are worried about hitting the NOTREACHED() in the NOT_ENABLED case, as I
told above, remove the NOTREACHED() and let it happen.
I'd not be too much obsessed about dealing with the corner cases on tracing
enabled (as long as we don't return garbage) and prefer performances.

   allocation_register_->Insert(address, size, context);
 }
 
 void MallocDumpProvider::RemoveAllocation(void* address) {
   // No re-entrancy is expected here as none of the calls below should
   // cause a free()-s (|allocation_register_| does its own heap management).
   if (tid_dumping_heap_ != kInvalidThreadId &&
       tid_dumping_heap_ == PlatformThread::CurrentId())
     return;
   AutoLock lock(allocation_register_lock_);
   if (!allocation_register_)
     return;
   allocation_register_->Remove(address);
 }
 
 }  // namespace trace_event
 }  // namespace base