[tracing] Adding task information to heap profiler

base/trace_event/heap_profiler_allocation_context_tracker.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/heap_profiler_allocation_context_tracker.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/atomicops.h"
@@ skipping 14 matching lines @@
 ThreadLocalStorage::StaticSlot g_tls_alloc_ctx_tracker = TLS_INITIALIZER;
 
 // 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);
 }
 
 }  // namespace
 
-AllocationContextTracker::AllocationContextTracker() {
+AllocationContextTracker::AllocationContextTracker()
+    : current_task_file_name_(nullptr) {
   pseudo_stack_.reserve(kMaxStackDepth);
 }
+
 AllocationContextTracker::~AllocationContextTracker() {}
 
 // static
 AllocationContextTracker::InitializationState
 AllocationContextTracker::GetStateForCurrentThread() {
   auto tracker =
       static_cast<AllocationContextTracker*>(g_tls_alloc_ctx_tracker.Get());
   if (!tracker)
     return kNotInitialized;
   if (tracker == kInitializingSentinel)
@@ skipping 58 matching lines @@
   // Assert that pushes and pops are nested correctly. This DCHECK can be
   // hit if some TRACE_EVENT macro is unbalanced (a TRACE_EVENT_END* call
   // without a corresponding TRACE_EVENT_BEGIN).
   DCHECK_EQ(frame, tracker->pseudo_stack_.back())
       << "Encountered an unmatched TRACE_EVENT_END";
 
   tracker->pseudo_stack_.pop_back();
 }
 
 // static
+void AllocationContextTracker::SetThreadName(const char* name) {
+  auto tracker = AllocationContextTracker::GetThreadLocalTracker();
+
+  // The thread name is added as the first entry in the psuedo stack. This is
+  // not removed until the tls is destroyed when thread dies.
+  tracker->pseudo_stack_.insert(tracker->pseudo_stack_.begin(),
+                                static_cast<StackFrame>(name));
+}
+
+// static
+void AllocationContextTracker::SetCurrentTaskFileName(const char* file_name) {
+  AllocationContextTracker* tracker = GetThreadLocalTracker();
+  tracker->current_task_file_name_ = file_name;
+}
+
+// static
 AllocationContext AllocationContextTracker::GetContextSnapshot() {
   AllocationContextTracker* tracker = GetThreadLocalTracker();
   AllocationContext ctx;
 
   // Fill the backtrace.
   {
     auto src = tracker->pseudo_stack_.begin();
     auto dst = std::begin(ctx.backtrace.frames);
     auto src_end = tracker->pseudo_stack_.end();
     auto dst_end = std::end(ctx.backtrace.frames);
 
     // Copy as much of the bottom of the pseudo stack into the backtrace as
     // possible.
     for (; src != src_end && dst != dst_end; src++, dst++)
       *dst = *src;
 
     // If there is room for more, fill the remaining slots with empty frames.
     std::fill(dst, dst_end, nullptr);
   }
 
-  ctx.type_name = nullptr;
+  // Set the default type name to file name where the task was posted from.
+  // TODO(ssid): Fix crbug.com/594803 to add file name as 3rd dimension
+  // (component name) in the heap profiler and not piggy back on the type name.
+  ctx.type_name = tracker->current_task_file_name_;
 
   return ctx;
 }
 
 }  // namespace trace_event
 }  // namespace base