[Tracing] Add hook to PartitionAlloc for heap profiling

base/trace_event/memory_profiler_allocation_context.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_profiler_allocation_context.h"
 
 #include <algorithm>
 
 #include "base/threading/thread_local_storage.h"
 
 namespace base {
 namespace trace_event {
 
 subtle::Atomic32 AllocationContextTracker::capture_enabled_ = 0;
 
 namespace {
 ThreadLocalStorage::StaticSlot g_tls_alloc_ctx_tracker = TLS_INITIALIZER;
+
+// Returns a pointer past the end of the fixed-size array |array| of |T| of
+// length |N|, identical to C++11 |std::end|.
+template <typename T, int N>
+T* End(T(&array)[N]) {
+  return array + N;
 }
 
+}  // namespace
+
 AllocationStack::AllocationStack() {}
 AllocationStack::~AllocationStack() {}
 
+AllocationContext AllocationContext::Empty() {
+  AllocationContext context;
+
+  for (StackFrame* i = context.backtrace.frames;
+       i != End(context.backtrace.frames); i++)

[Primiano Tucci (use gerrit), 2015/10/12 16:36:45]

You can make this simpler, shorter and more readable without using the End()
template magic:

  for (size_t i = 0; i < arraysize(context.backtrace.frames); ++i)
    context.backtrace.frames[i] = nullptr

Also "i" for a non-numeric type is a very bad naming choice.
Furthermore this for loop would require extra braces around the *i = nullptr as
the for spawns across multiple lines.

[Ruud van Asseldonk, 2015/10/13 10:42:18]

Done.

+    *i = nullptr;
+
+  for (auto* i = context.fields; i != End(context.fields); i++)

[Primiano Tucci (use gerrit), 2015/10/12 16:36:45]

ditto

[Ruud van Asseldonk, 2015/10/13 10:42:18]

Done.

+    i->first = nullptr;
+
+  return context;
+}
+
 // This function is added to the TLS slot to clean up the instance when the
 // thread exits.
 void DestructAllocationContextTracker(void* alloc_ctx_tracker) {
   delete static_cast<AllocationContextTracker*>(alloc_ctx_tracker);
 }
 
 AllocationContextTracker* AllocationContextTracker::GetThreadLocalTracker() {
   auto tracker =
       static_cast<AllocationContextTracker*>(g_tls_alloc_ctx_tracker.Get());
 
@@ skipping 41 matching lines @@
   auto tracker = AllocationContextTracker::GetThreadLocalTracker();
   tracker->context_[key] = value;
 }
 
 // static
 void AllocationContextTracker::UnsetContextField(const char* key) {
   auto tracker = AllocationContextTracker::GetThreadLocalTracker();
   tracker->context_.erase(key);
 }
 
-// Returns a pointer past the end of the fixed-size array |array| of |T| of
-// length |N|, identical to C++11 |std::end|.
-template <typename T, int N>
-T* End(T(&array)[N]) {
-  return array + N;
-}
-
 // static
 AllocationContext AllocationContextTracker::GetContextSnapshot() {
   AllocationContextTracker* tracker = GetThreadLocalTracker();
   AllocationContext ctx;
 
   // Fill the backtrace.
   {
     auto src = tracker->pseudo_stack_.bottom();
     auto dst = ctx.backtrace.frames;
     auto src_end = tracker->pseudo_stack_.top();
@@ skipping 22 matching lines @@
     // If there is room for more, fill the remaining slots with nullptr keys.
     for (; dst != dst_end; dst++)
       dst->first = nullptr;
   }
 
   return ctx;
 }
 
 }  // namespace trace_event
 }  // namespace base