Enable storing last-dispatched exception per-thread.

base/debug/activity_tracker.cc

 // Copyright 2016 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/debug/activity_tracker.h"
 
 #include <algorithm>
 #include <limits>
 #include <utility>
 
 #include "base/atomic_sequence_num.h"
+#include "base/atomicops.h"
 #include "base/debug/stack_trace.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/memory_mapped_file.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/pending_task.h"
 #include "base/pickle.h"
 #include "base/process/process.h"
 #include "base/process/process_handle.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
@@ skipping 19 matching lines @@
 // A constant used to indicate that module information is changing.
 const uint32_t kModuleInformationChanging = 0x80000000;
 
 // The key used to record process information.
 const char kProcessPhaseDataKey[] = "process-phase";
 
 // An atomically incrementing number, used to check for recreations of objects
 // in the same memory space.
 StaticAtomicSequenceNumber g_next_id;
 
+// An reusable user-data sink that just discards all data saved to it.
+LazyInstance<ActivityUserData>::Leaky g_data_sink;
+
+// A pointer to an AcitivyUserData object that can used when handing exceptions.

[manzagop (departed), 2017/02/27 16:05:16]

typo: AcitivyUserData, handing

[bcwhite, 2017/03/14 12:53:26]

Done.

+// This is an AtomicWord because std::atomic creates global ctors & dtors.
+subtle::AtomicWord g_exception_data = 0;
+
 union ThreadRef {
   int64_t as_id;
 #if defined(OS_WIN)
   // On Windows, the handle itself is often a pseudo-handle with a common
   // value meaning "this thread" and so the thread-id is used. The former
   // can be converted to a thread-id with a system call.
   PlatformThreadId as_tid;
 #elif defined(OS_POSIX)
   // On Posix, the handle is always a unique identifier so no conversion
   // needs to be done. However, it's value is officially opaque so there
@@ skipping 244 matching lines @@
 // thus clang requires explicit out-of-line constructors and destructors even
 // when they do nothing.
 ActivityUserData::ValueInfo::ValueInfo() {}
 ActivityUserData::ValueInfo::ValueInfo(ValueInfo&&) = default;
 ActivityUserData::ValueInfo::~ValueInfo() {}
 ActivityUserData::MemoryHeader::MemoryHeader() {}
 ActivityUserData::MemoryHeader::~MemoryHeader() {}
 ActivityUserData::FieldHeader::FieldHeader() {}
 ActivityUserData::FieldHeader::~FieldHeader() {}
 
+ActivityUserData::ActivityUserData() : ActivityUserData(nullptr, 0) {}
+
 ActivityUserData::ActivityUserData(void* memory, size_t size)
     : memory_(reinterpret_cast<char*>(memory)),
       available_(RoundDownToAlignment(size, kMemoryAlignment)),
       header_(reinterpret_cast<MemoryHeader*>(memory)) {
   // It's possible that no user data is being stored.
   if (!memory_)
     return;
 
   static_assert(0 == sizeof(MemoryHeader) % kMemoryAlignment, "invalid header");
-  DCHECK_LT(sizeof(MemoryHeader), available_);
-  if (header_->owner.data_id.load(std::memory_order_acquire) == 0)
-    header_->owner.Release_Initialize();
-  memory_ += sizeof(MemoryHeader);
-  available_ -= sizeof(MemoryHeader);
-
-  // If there is already data present, load that. This allows the same class
-  // to be used for analysis through snapshots.
-  ImportExistingData();
+  Initialize();
 }
 
 ActivityUserData::~ActivityUserData() {}
 
+void ActivityUserData::Reset() {

[manzagop (departed), 2017/02/27 16:05:16]

DCHECK memory_/header_ or early exit.

[bcwhite, 2017/03/14 12:53:26]

Done.

+  // Clear the memory in an atomic manner.

[manzagop (departed), 2017/02/27 16:05:16]

ActivityUserData is either used in a thread affine way or behind a lock. Why
can't you just memset?

[bcwhite, 2017/03/14 12:53:26]

It's written with thread affinity but another (analyzer) thread could also be
reading it.  Comment added.

+  std::atomic<int>* data = reinterpret_cast<std::atomic<int>*>(header_);
+  const uint32_t words = (reinterpret_cast<uintptr_t>(memory_) -
+                          reinterpret_cast<uintptr_t>(header_)) /
+                         sizeof(int);
+  for (uint32_t i = 0; i < words; ++i) {
+    data->store(0, std::memory_order_release);
+    ++data;
+  }
+
+  values_.clear();

[manzagop (departed), 2017/02/27 16:05:16]

Also reset memory_ and available_?

[bcwhite, 2017/03/14 12:53:25]

Oops!  Done.

+  Initialize();
+}
+
 bool ActivityUserData::CreateSnapshot(Snapshot* output_snapshot) const {
   DCHECK(output_snapshot);
   DCHECK(output_snapshot->empty());
 
   // Find any new data that may have been added by an active instance of this
   // class that is adding records.
   ImportExistingData();
 
   for (const auto& entry : values_) {
     TypedValue value;
@@ skipping 155 matching lines @@
 void ActivityUserData::SetReference(StringPiece name,
                                     ValueType type,
                                     const void* memory,
                                     size_t size) {
   ReferenceRecord rec;
   rec.address = reinterpret_cast<uintptr_t>(memory);
   rec.size = size;
   Set(name, type, &rec, sizeof(rec));
 }
 
+void ActivityUserData::Initialize() {

[manzagop (departed), 2017/02/27 16:05:16]

DCHECK memory_ or early return.

[bcwhite, 2017/03/14 12:53:26]

Done.

+  DCHECK_LT(sizeof(MemoryHeader), available_);
+  if (header_->owner.data_id.load(std::memory_order_acquire) == 0)
+    header_->owner.Release_Initialize();
+  memory_ += sizeof(MemoryHeader);
+  available_ -= sizeof(MemoryHeader);
+
+  // If there is already data present, load that. This allows the same class
+  // to be used for analysis through snapshots.
+  ImportExistingData();

[manzagop (departed), 2017/02/27 16:05:16]

Worth skipping the import when just initialized?

[bcwhite, 2017/03/14 12:53:26]

Not really since the first read will cause it to exit.

+}
+
 void ActivityUserData::ImportExistingData() const {
   while (available_ > sizeof(FieldHeader)) {
     FieldHeader* header = reinterpret_cast<FieldHeader*>(memory_);
     ValueType type =
         static_cast<ValueType>(header->type.load(std::memory_order_acquire));
     if (type == END_OF_VALUES)
       return;
     if (header->record_size > available_)
       return;
 
@@ skipping 24 matching lines @@
 // This information is kept for every thread that is tracked. It is filled
 // the very first time the thread is seen. All fields must be of exact sizes
 // so there is no issue moving between 32 and 64-bit builds.
 struct ThreadActivityTracker::Header {
   // Defined in .h for analyzer access. Increment this if structure changes!
   static constexpr uint32_t kPersistentTypeId =
       GlobalActivityTracker::kTypeIdActivityTracker;
 
   // Expected size for 32/64-bit check.
   static constexpr size_t kExpectedInstanceSize =
-      OwningProcess::kExpectedInstanceSize + 72;
+      OwningProcess::kExpectedInstanceSize + Activity::kExpectedInstanceSize +
+      72;
 
   // This information uniquely identifies a process.
   OwningProcess owner;
 
   // The thread-id (thread_ref.as_id) to which this data belongs. This number
   // is not guaranteed to mean anything but combined with the process-id from
   // OwningProcess is unique among all active trackers.
   ThreadRef thread_ref;
 
   // The start-time and start-ticks when the data was created. Each activity
   // record has a |time_internal| value that can be converted to a "wall time"
   // with these two values.
   int64_t start_time;
   int64_t start_ticks;
 
   // The number of Activity slots (spaces that can hold an Activity) that
   // immediately follow this structure in memory.
   uint32_t stack_slots;
 
   // Some padding to keep everything 64-bit aligned.
   uint32_t padding;
 
   // The current depth of the stack. This may be greater than the number of
   // slots. If the depth exceeds the number of slots, the newest entries
   // won't be recorded.
   std::atomic<uint32_t> current_depth;
 
-  // A memory location used to indicate if changes have been made to the stack
+  // A memory location used to indicate if changes have been made to the data
   // that would invalidate an in-progress read of its contents. The active
   // tracker will zero the value whenever something gets popped from the
   // stack. A monitoring tracker can write a non-zero value here, copy the
   // stack contents, and read the value to know, if it is still non-zero, that
   // the contents didn't change while being copied. This can handle concurrent
   // snapshot operations only if each snapshot writes a different bit (which
   // is not the current implementation so no parallel snapshots allowed).
-  std::atomic<uint32_t> stack_unchanged;
+  std::atomic<uint32_t> data_unchanged;
+
+  // The last "exception" activity. This can't be stored on the stack because
+  // that could get popped as things unwind.
+  Activity last_exception;
 
   // The name of the thread (up to a maximum length). Dynamic-length names
   // are not practical since the memory has to come from the same persistent
   // allocator that holds this structure and to which this object has no
   // reference.
   char thread_name[32];
 };
 
 ThreadActivityTracker::Snapshot::Snapshot() {}
 ThreadActivityTracker::Snapshot::~Snapshot() {}
@@ skipping 57 matching lines @@
   // Provided memory should either be completely initialized or all zeros.
   if (header_->owner.data_id.load(std::memory_order_relaxed) == 0) {
     // This is a new file. Double-check other fields and then initialize.
     DCHECK_EQ(0, header_->owner.process_id);
     DCHECK_EQ(0, header_->owner.create_stamp);
     DCHECK_EQ(0, header_->thread_ref.as_id);
     DCHECK_EQ(0, header_->start_time);
     DCHECK_EQ(0, header_->start_ticks);
     DCHECK_EQ(0U, header_->stack_slots);
     DCHECK_EQ(0U, header_->current_depth.load(std::memory_order_relaxed));
-    DCHECK_EQ(0U, header_->stack_unchanged.load(std::memory_order_relaxed));
+    DCHECK_EQ(0U, header_->data_unchanged.load(std::memory_order_relaxed));
     DCHECK_EQ(0, stack_[0].time_internal);
     DCHECK_EQ(0U, stack_[0].origin_address);
     DCHECK_EQ(0U, stack_[0].call_stack[0]);
     DCHECK_EQ(0U, stack_[0].data.task.sequence_id);
 
 #if defined(OS_WIN)
     header_->thread_ref.as_tid = PlatformThread::CurrentId();
 #elif defined(OS_POSIX)
     header_->thread_ref.as_handle =
         PlatformThread::CurrentHandle().platform_handle();
@@ skipping 93 matching lines @@
   // Validate that everything is running correctly.
   DCHECK_EQ(id, depth);
 
   // A thread-checker creates a lock to check the thread-id which means
   // re-entry into this code if lock acquisitions are being tracked.
   DCHECK(stack_[depth].activity_type == Activity::ACT_LOCK_ACQUIRE ||
          thread_checker_.CalledOnValidThread());
 
   // The stack has shrunk meaning that some other thread trying to copy the
   // contents for reporting purposes could get bad data. That thread would
-  // have written a non-zero value into |stack_unchanged|; clearing it here
+  // have written a non-zero value into |data_unchanged|; clearing it here
   // will let that thread detect that something did change. This needs to
   // happen after the atomic |depth| operation above so a "release" store
   // is required.
-  header_->stack_unchanged.store(0, std::memory_order_release);
+  header_->data_unchanged.store(0, std::memory_order_release);
 }
 
 std::unique_ptr<ActivityUserData> ThreadActivityTracker::GetUserData(
     ActivityId id,
     ActivityTrackerMemoryAllocator* allocator) {
-  // User-data is only stored for activities actually held in the stack.
-  if (id < stack_slots_) {
-    // Don't allow user data for lock acquisition as recursion may occur.
-    if (stack_[id].activity_type == Activity::ACT_LOCK_ACQUIRE) {
-      NOTREACHED();
-      return MakeUnique<ActivityUserData>(nullptr, 0);
-    }
-
-    // Get (or reuse) a block of memory and create a real UserData object
-    // on it.
-    PersistentMemoryAllocator::Reference ref = allocator->GetObjectReference();
-    void* memory =
-        allocator->GetAsArray<char>(ref, PersistentMemoryAllocator::kSizeAny);
-    if (memory) {
-      std::unique_ptr<ActivityUserData> user_data =
-          MakeUnique<ActivityUserData>(memory, kUserDataSize);
-      stack_[id].user_data_ref = ref;
-      stack_[id].user_data_id = user_data->id();
-      return user_data;
-    }
+  // Don't allow user data for lock acquisition as recursion may occur.
+  if (stack_[id].activity_type == Activity::ACT_LOCK_ACQUIRE) {
+    NOTREACHED();
+    return MakeUnique<ActivityUserData>();
   }
 
-  // Return a dummy object that will still accept (but ignore) Set() calls.
-  return MakeUnique<ActivityUserData>(nullptr, 0);
+  // User-data is only stored for activities actually held in the stack.
+  if (id >= stack_slots_)
+    return MakeUnique<ActivityUserData>();
+
+  // Create and return a real UserData object.
+  return CreateUserDataForActivity(&stack_[id], allocator);
 }
 
 bool ThreadActivityTracker::HasUserData(ActivityId id) {
   // User-data is only stored for activities actually held in the stack.
   return (id < stack_slots_ && stack_[id].user_data_ref);
 }
 
 void ThreadActivityTracker::ReleaseUserData(
     ActivityId id,
     ActivityTrackerMemoryAllocator* allocator) {
   // User-data is only stored for activities actually held in the stack.
   if (id < stack_slots_ && stack_[id].user_data_ref) {
     allocator->ReleaseObjectReference(stack_[id].user_data_ref);
     stack_[id].user_data_ref = 0;
   }
+  // Release user-data for an exception.

[manzagop (departed), 2017/02/27 16:05:16]

Does this clear the exception data as soon as we pop an activity?

[bcwhite, 2017/03/14 12:53:26]

No.  That is held completely independent of the activity stack, inside the
thread "Header" structure.

+  if (header_->last_exception.user_data_ref) {
+    exception_data.reset();
+    allocator->ReleaseObjectReference(header_->last_exception.user_data_ref);
+    header_->last_exception.user_data_ref = 0;
+  }
+}
+
+ActivityUserData& ThreadActivityTracker::ExceptionActivity(
+    const void* program_counter,
+    const void* origin,
+    Activity::Type type,
+    const ActivityData& data) {
+  // A thread-checker creates a lock to check the thread-id which means
+  // re-entry into this code if lock acquisitions are being tracked.
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  // If there was a previous exception, release its user-data.
+  if (header_->last_exception.user_data_ref) {
+    header_->last_exception.user_data_ref = 0;

[manzagop (departed), 2017/02/27 16:05:16]

This doesn't release the reference?

[bcwhite, 2017/03/14 12:53:26]

Yes.  I hadn't finished the conversion from the first attempt when I had to
leave that Friday but wanted to show the basic idea.  Finishing it now.

+  }
+
+  // Fill the reusable exception activity.
+  Activity::FillFrom(&header_->last_exception, program_counter, origin, type,
+                     data);
+
+  // The data has changed meaning that some other thread trying to copy the
+  // contents for reporting purposes could get bad data.
+  header_->data_unchanged.store(0, std::memory_order_relaxed);
+
+  // Re-use any existing user-data structure.

[manzagop (departed), 2017/02/27 16:05:16]

How do the exception ref and data id get set?

[bcwhite, 2017/03/14 12:53:26]

The data_id is set when the user-data object was originally created, or below
during Reset().

+  if (exception_data) {
+    exception_data->Reset();
+    return *exception_data;
+  }
+
+  // Get the reserved "exception data" storage, if exists.

[manzagop (departed), 2017/02/27 16:05:15]

IIUC only the first excepting thread can have data?

[bcwhite, 2017/03/14 12:53:26]

I'll refill the g_exception_data from time to time -- haven't worked out exactly
when.

+  exception_data.reset(reinterpret_cast<ActivityUserData*>(
+      subtle::NoBarrier_AtomicExchange(&g_exception_data, 0)));
+  if (!exception_data)
+    return g_data_sink.Get();
+  return *exception_data;
 }
 
 bool ThreadActivityTracker::IsValid() const {
   if (header_->owner.data_id.load(std::memory_order_acquire) == 0 ||
       header_->owner.process_id == 0 || header_->thread_ref.as_id == 0 ||
       header_->start_time == 0 || header_->start_ticks == 0 ||
       header_->stack_slots != stack_slots_ ||
       header_->thread_name[sizeof(header_->thread_name) - 1] != '\0') {
     return false;
   }
@@ skipping 24 matching lines @@
 
   for (int attempt = 0; attempt < kMaxAttempts; ++attempt) {
     // Remember the data IDs to ensure nothing is replaced during the snapshot
     // operation. Use "acquire" so that all the non-atomic fields of the
     // structure are valid (at least at the current moment in time).
     const uint32_t starting_id =
         header_->owner.data_id.load(std::memory_order_acquire);
     const int64_t starting_process_id = header_->owner.process_id;
     const int64_t starting_thread_id = header_->thread_ref.as_id;
 
-    // Write a non-zero value to |stack_unchanged| so it's possible to detect
+    // Write a non-zero value to |data_unchanged| so it's possible to detect
     // at the end that nothing has changed since copying the data began. A
     // "cst" operation is required to ensure it occurs before everything else.
     // Using "cst" memory ordering is relatively expensive but this is only
     // done during analysis so doesn't directly affect the worker threads.
-    header_->stack_unchanged.store(1, std::memory_order_seq_cst);
+    header_->data_unchanged.store(1, std::memory_order_seq_cst);
 
     // Fetching the current depth also "acquires" the contents of the stack.
     depth = header_->current_depth.load(std::memory_order_acquire);
     uint32_t count = std::min(depth, stack_slots_);
     output_snapshot->activity_stack.resize(count);
     if (count > 0) {
       // Copy the existing contents. Memcpy is used for speed.
       memcpy(&output_snapshot->activity_stack[0], stack_,
              count * sizeof(Activity));
     }
 
+    // Capture the last exception.
+    memcpy(&output_snapshot->last_exception, &header_->last_exception,
+           sizeof(Activity));
+
+    // TODO(bcwhite): Snapshot other things here.
+
     // Retry if something changed during the copy. A "cst" operation ensures
     // it must happen after all the above operations.
-    if (!header_->stack_unchanged.load(std::memory_order_seq_cst))
+    if (!header_->data_unchanged.load(std::memory_order_seq_cst))
       continue;
 
     // Stack copied. Record it's full depth.
     output_snapshot->activity_stack_depth = depth;
 
-    // TODO(bcwhite): Snapshot other things here.
-
     // Get the general thread information.
     output_snapshot->thread_name =
         std::string(header_->thread_name, sizeof(header_->thread_name) - 1);
     output_snapshot->thread_id = header_->thread_ref.as_id;
     output_snapshot->process_id = header_->owner.process_id;
 
     // All characters of the thread-name buffer were copied so as to not break
     // if the trailing NUL were missing. Now limit the length if the actual
     // name is shorter.
     output_snapshot->thread_name.resize(
@@ skipping 15 matching lines @@
 
     // Change all the timestamps in the activities from "ticks" to "wall" time.
     const Time start_time = Time::FromInternalValue(header_->start_time);
     const int64_t start_ticks = header_->start_ticks;
     for (Activity& activity : output_snapshot->activity_stack) {
       activity.time_internal =
           (start_time +
            TimeDelta::FromInternalValue(activity.time_internal - start_ticks))
               .ToInternalValue();
     }
+    output_snapshot->last_exception.time_internal =
+        (start_time +
+         TimeDelta::FromInternalValue(
+             output_snapshot->last_exception.time_internal - start_ticks))
+            .ToInternalValue();
 
     // Success!
     return true;
   }
 
   // Too many attempts.
   return false;
 }
 
 const void* ThreadActivityTracker::GetBaseAddress() {
@@ skipping 11 matching lines @@
                                                int64_t* out_stamp) {
   const Header* header = reinterpret_cast<const Header*>(memory);
   return OwningProcess::GetOwningProcessId(&header->owner, out_id, out_stamp);
 }
 
 // static
 size_t ThreadActivityTracker::SizeForStackDepth(int stack_depth) {
   return static_cast<size_t>(stack_depth) * sizeof(Activity) + sizeof(Header);
 }
 
+std::unique_ptr<ActivityUserData>
+ThreadActivityTracker::CreateUserDataForActivity(
+    Activity* activity,
+    ActivityTrackerMemoryAllocator* allocator) {
+  DCHECK_EQ(0U, activity->user_data_ref);
+
+  PersistentMemoryAllocator::Reference ref = allocator->GetObjectReference();
+  void* memory = allocator->GetAsArray<char>(ref, kUserDataSize);
+  if (memory) {
+    std::unique_ptr<ActivityUserData> user_data =
+        MakeUnique<ActivityUserData>(memory, kUserDataSize);
+    activity->user_data_ref = ref;
+    activity->user_data_id = user_data->id();
+    return user_data;
+  }
+
+  // Return a dummy object that will still accept (but ignore) Set() calls.
+  return MakeUnique<ActivityUserData>();
+}
+
 // The instantiation of the GlobalActivityTracker object.
 // The object held here will obviously not be destructed at process exit
 // but that's best since PersistentMemoryAllocator objects (that underlie
 // GlobalActivityTracker objects) are explicitly forbidden from doing anything
 // essential at exit anyway due to the fact that they depend on data managed
 // elsewhere and which could be destructed first. An AtomicWord is used instead
 // of std::atomic because the latter can create global ctors and dtors.
 subtle::AtomicWord GlobalActivityTracker::g_tracker_ = 0;
 
 GlobalActivityTracker::ModuleInfo::ModuleInfo() {}
@@ skipping 133 matching lines @@
 }
 
 ActivityUserData& GlobalActivityTracker::ScopedThreadActivity::user_data() {
   if (!user_data_) {
     if (tracker_) {
       GlobalActivityTracker* global = GlobalActivityTracker::Get();
       AutoLock lock(global->user_data_allocator_lock_);
       user_data_ =
           tracker_->GetUserData(activity_id_, &global->user_data_allocator_);
     } else {
-      user_data_ = MakeUnique<ActivityUserData>(nullptr, 0);
+      user_data_ = MakeUnique<ActivityUserData>();
     }
   }
   return *user_data_;
 }
 
 GlobalActivityTracker::ThreadSafeUserData::ThreadSafeUserData(void* memory,
                                                               size_t size)
     : ActivityUserData(memory, size) {}
 
 GlobalActivityTracker::ThreadSafeUserData::~ThreadSafeUserData() {}
@@ skipping 411 matching lines @@
 
   // Remove the destructed tracker from the set of known ones.
   DCHECK_LE(1, thread_tracker_count_.load(std::memory_order_relaxed));
   thread_tracker_count_.fetch_sub(1, std::memory_order_relaxed);
 
   // Release this memory for re-use at a later time.
   base::AutoLock autolock(thread_tracker_allocator_lock_);
   thread_tracker_allocator_.ReleaseObjectReference(mem_reference);
 }
 
+ActivityUserData& GlobalActivityTracker::RecordExceptionImpl(
+    const void* pc,
+    const void* origin) {
+  ThreadActivityTracker* tracker = GetTrackerForCurrentThread();

[manzagop (departed), 2017/02/27 16:05:16]

Comment on why we don't use GetOrCreate and why it's ok.

[bcwhite, 2017/03/14 12:53:26]

Done.

+  if (!tracker)
+    return g_data_sink.Get();
+
+  return tracker->ExceptionActivity(pc, origin, Activity::ACT_EXCEPTION,
+                                    ActivityData::ForGeneric(0, 0));
+}
+
+void GlobalActivityTracker::ReserveExceptionData() {
+  if (subtle::NoBarrier_Load(&g_exception_data))
+    return;
+
+  ActivityUserData* exception_data = new ActivityUserData(...);

[manzagop (departed), 2017/02/27 16:05:16]

...?

[bcwhite, 2017/03/14 12:53:26]

"..." is a C++11 feature that automatically creates an object based on the
developers wishes without requiring it to be be explicitly written out.  Quite
handy.

+  subtle::AtomicWord prev_data = subtle::NoBarrier_AtomicExchange(
+      &g_exception_data, reinterpret_cast<uintptr_t>(exception_data));
+
+  // Handle case of two threads doing the same thing at the same time.
+  if (prev_data)
+    delete reinterpret_cast<ActivityUserData*>(prev_data);
+}
+
 // static
 void GlobalActivityTracker::OnTLSDestroy(void* value) {
   delete reinterpret_cast<ManagedActivityTracker*>(value);
 }
 
 ScopedActivity::ScopedActivity(const void* program_counter,
                                uint8_t action,
                                uint32_t id,
                                int32_t info)
     : GlobalActivityTracker::ScopedThreadActivity(
@@ skipping 70 matching lines @@
     : GlobalActivityTracker::ScopedThreadActivity(
           program_counter,
           nullptr,
           Activity::ACT_PROCESS_WAIT,
           ActivityData::ForProcess(process->Pid()),
           /*lock_allowed=*/true) {}
 #endif
 
 }  // namespace debug
 }  // namespace base