[tracing] Don't register tracing-related allocations.

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 11 matching lines @@
 
 subtle::Atomic32 AllocationContextTracker::capture_mode_ =
     static_cast<int32_t>(AllocationContextTracker::CaptureMode::DISABLED);
 
 namespace {
 
 const size_t kMaxStackDepth = 128u;
 const size_t kMaxTaskDepth = 16u;
 AllocationContextTracker* const kInitializingSentinel =
     reinterpret_cast<AllocationContextTracker*>(-1);
-const char kTracingOverhead[] = "tracing_overhead";
 
 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);
 }
 
 // Cannot call ThreadIdNameManager::GetName because it holds a lock and causes
@@ skipping 107 matching lines @@
   // on an empty stack.
   if (task_contexts_.empty())
     return;
 
   DCHECK_EQ(context, task_contexts_.back())
       << "Encountered an unmatched context end";
   task_contexts_.pop_back();
 }
 
 // static
-AllocationContext AllocationContextTracker::GetContextSnapshot() {
-  AllocationContext ctx;
-
-  if (ignore_scope_depth_) {
-    ctx.backtrace.frames[0] = StackFrame::FromTraceEventName(kTracingOverhead);
-    ctx.type_name = kTracingOverhead;
-    ctx.backtrace.frame_count = 1;
-    return ctx;
-  }
+bool AllocationContextTracker::GetContextSnapshot(AllocationContext* ctx) {
+  if (ignore_scope_depth_)
+    return false;
 
   CaptureMode mode = static_cast<CaptureMode>(
       subtle::NoBarrier_Load(&capture_mode_));
 
-  auto* backtrace = std::begin(ctx.backtrace.frames);
-  auto* backtrace_end = std::end(ctx.backtrace.frames);
+  auto* backtrace = std::begin(ctx->backtrace.frames);
+  auto* backtrace_end = std::end(ctx->backtrace.frames);
 
   if (!thread_name_) {
     // Ignore the string allocation made by GetAndLeakThreadName to avoid
     // reentrancy.
     ignore_scope_depth_++;
     thread_name_ = GetAndLeakThreadName();
     ANNOTATE_LEAKING_OBJECT_PTR(thread_name_);
     DCHECK(thread_name_);
     ignore_scope_depth_--;
   }
@@ skipping 44 matching lines @@
             0 :
             frame_count - backtrace_capacity;
         for (size_t i = frame_count; i > top_frame_index;) {
           const void* frame = frames[--i];
           *backtrace++ = StackFrame::FromProgramCounter(frame);
         }
         break;
       }
   }
 
-  ctx.backtrace.frame_count = backtrace - std::begin(ctx.backtrace.frames);
+  ctx->backtrace.frame_count = backtrace - std::begin(ctx->backtrace.frames);
 
   // 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.
   if (!task_contexts_.empty()) {
-    ctx.type_name = task_contexts_.back();
+    ctx->type_name = task_contexts_.back();
   } else if (!pseudo_stack_.empty()) {
     // If task context was unavailable, then the category names are taken from
     // trace events.
-    ctx.type_name = pseudo_stack_.back().trace_event_category;
+    ctx->type_name = pseudo_stack_.back().trace_event_category;
+  } else {
+    ctx->type_name = nullptr;
   }
 
-  return ctx;
+  return true;
 }
 
 }  // namespace trace_event
 }  // namespace base