Add analyzer support for multiple processes.

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>
 
@@ skipping 49 matching lines @@
   // 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
   // is no one correct way to convert it to a numerical identifier.
   PlatformThreadHandle::Handle as_handle;
 #endif
 };
 
-// Get the next non-zero identifier. It is only unique within a process.
+// Gets the next non-zero identifier. It is only unique within a process.
 uint32_t GetNextDataId() {
   uint32_t id;
   while ((id = g_next_id.GetNext()) == 0)
     ;
   return id;
 }
 
+// Gets the current process-id, either from the GlobalActivityTracker if it
+// exists (where the PID can be defined for testing) or from the system if
+// there isn't such.
+int64_t GetProcessId() {
+  GlobalActivityTracker* global = GlobalActivityTracker::Get();
+  if (global)
+    return global->process_id();
+  return GetCurrentProcId();
+}
+
 // Finds and reuses a specific allocation or creates a new one.
 PersistentMemoryAllocator::Reference AllocateFrom(
     PersistentMemoryAllocator* allocator,
     uint32_t from_type,
     size_t size,
     uint32_t to_type) {
   PersistentMemoryAllocator::Iterator iter(allocator);
   PersistentMemoryAllocator::Reference ref;
   while ((ref = iter.GetNextOfType(from_type)) != 0) {
     DCHECK_LE(size, allocator->GetAllocSize(ref));
@@ skipping 19 matching lines @@
 // Converts "tick" timing into wall time.
 Time WallTimeFromTickTime(int64_t ticks_start, int64_t ticks, Time time_start) {
   return time_start + TimeDelta::FromInternalValue(ticks - ticks_start);
 }
 
 }  // namespace
 
 OwningProcess::OwningProcess() {}
 OwningProcess::~OwningProcess() {}
 
-void OwningProcess::Release_Initialize() {
+void OwningProcess::Release_Initialize(int64_t pid) {
   uint32_t old_id = data_id.load(std::memory_order_acquire);
   DCHECK_EQ(0U, old_id);
-  process_id = GetCurrentProcId();
+  process_id = pid != 0 ? pid : GetProcessId();
   create_stamp = Time::Now().ToInternalValue();
   data_id.store(GetNextDataId(), std::memory_order_release);
 }
 
-void OwningProcess::SetOwningProcessIdForTesting(ProcessId pid, int64_t stamp) {
+void OwningProcess::SetOwningProcessIdForTesting(int64_t pid, int64_t stamp) {
   DCHECK_NE(0U, data_id);
   process_id = pid;
   create_stamp = stamp;
 }
 
 // static
 bool OwningProcess::GetOwningProcessId(const void* memory,
-                                       ProcessId* out_id,
+                                       int64_t* out_id,
                                        int64_t* out_stamp) {
   const OwningProcess* info = reinterpret_cast<const OwningProcess*>(memory);
   uint32_t id = info->data_id.load(std::memory_order_acquire);
   if (id == 0)
     return false;
 
-  *out_id = static_cast<ProcessId>(info->process_id);
+  *out_id = info->process_id;
   *out_stamp = info->create_stamp;
   return id == info->data_id.load(std::memory_order_seq_cst);
 }
 
 // It doesn't matter what is contained in this (though it will be all zeros)
 // as only the address of it is important.
 const ActivityData kNullActivityData = {};
 
 ActivityData ActivityData::ForThread(const PlatformThreadHandle& handle) {
   ThreadRef thread_ref;
@@ skipping 164 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() : ActivityUserData(nullptr, 0, -1) {}
 
-ActivityUserData::ActivityUserData(void* memory, size_t size)
+ActivityUserData::ActivityUserData(void* memory, size_t size, int64_t pid)
     : memory_(reinterpret_cast<char*>(memory)),
       available_(RoundDownToAlignment(size, kMemoryAlignment)),
-      header_(reinterpret_cast<MemoryHeader*>(memory)) {
+      header_(reinterpret_cast<MemoryHeader*>(memory)),
+      orig_data_id(0),
+      orig_process_id(0),
+      orig_create_stamp(0) {
   // 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();
+    header_->owner.Release_Initialize(pid);
   memory_ += sizeof(MemoryHeader);
   available_ -= sizeof(MemoryHeader);
 
+  // Make a copy of identifying information for later comparison.
+  *const_cast<uint32_t*>(&orig_data_id) =
+      header_->owner.data_id.load(std::memory_order_acquire);
+  *const_cast<int64_t*>(&orig_process_id) = header_->owner.process_id;
+  *const_cast<int64_t*>(&orig_create_stamp) = header_->owner.create_stamp;
+
   // If there is already data present, load that. This allows the same class
   // to be used for analysis through snapshots.
   ImportExistingData();
 }
 
 ActivityUserData::~ActivityUserData() {}
 
 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();
 
+  // Add all the values to the snapshot.
   for (const auto& entry : values_) {
     TypedValue value;
+    const size_t size = entry.second.size_ptr->load(std::memory_order_acquire);
     value.type_ = entry.second.type;
-    DCHECK_GE(entry.second.extent,
-              entry.second.size_ptr->load(std::memory_order_relaxed));
+    DCHECK_GE(entry.second.extent, size);
 
     switch (entry.second.type) {
       case RAW_VALUE:
       case STRING_VALUE:
         value.long_value_ =
-            std::string(reinterpret_cast<char*>(entry.second.memory),
-                        entry.second.size_ptr->load(std::memory_order_relaxed));
+            std::string(reinterpret_cast<char*>(entry.second.memory), size);
         break;
       case RAW_VALUE_REFERENCE:
       case STRING_VALUE_REFERENCE: {
         ReferenceRecord* ref =
             reinterpret_cast<ReferenceRecord*>(entry.second.memory);
         value.ref_value_ = StringPiece(
             reinterpret_cast<char*>(static_cast<uintptr_t>(ref->address)),
             static_cast<size_t>(ref->size));
       } break;
       case BOOL_VALUE:
       case CHAR_VALUE:
         value.short_value_ = *reinterpret_cast<char*>(entry.second.memory);
         break;
       case SIGNED_VALUE:
       case UNSIGNED_VALUE:
         value.short_value_ = *reinterpret_cast<uint64_t*>(entry.second.memory);
         break;
       case END_OF_VALUES:  // Included for completeness purposes.
         NOTREACHED();
     }
     auto inserted = output_snapshot->insert(
         std::make_pair(entry.second.name.as_string(), std::move(value)));
     DCHECK(inserted.second);  // True if inserted, false if existed.
   }
 
+  // Another import attempt will validate that the underlying memory has not
+  // been reused for another purpose. Entries added since the first import
+  // will be ignored here but will be returned if another snapshot is created.
+  ImportExistingData();
+  if (!memory_) {
+    output_snapshot->clear();
+    return false;
+  }
+
+  // Successful snapshot.
   return true;
 }
 
 const void* ActivityUserData::GetBaseAddress() const {
   // The |memory_| pointer advances as elements are written but the |header_|
   // value is always at the start of the block so just return that.
   return header_;
 }
 
-void ActivityUserData::SetOwningProcessIdForTesting(ProcessId pid,
+void ActivityUserData::SetOwningProcessIdForTesting(int64_t pid,
                                                     int64_t stamp) {
   if (!header_)
     return;
   header_->owner.SetOwningProcessIdForTesting(pid, stamp);
 }
 
 // static
 bool ActivityUserData::GetOwningProcessId(const void* memory,
-                                          ProcessId* out_id,
+                                          int64_t* out_id,
                                           int64_t* out_stamp) {
   const MemoryHeader* header = reinterpret_cast<const MemoryHeader*>(memory);
   return OwningProcess::GetOwningProcessId(&header->owner, out_id, out_stamp);
 }
 
 void ActivityUserData::Set(StringPiece name,
                            ValueType type,
                            const void* memory,
                            size_t size) {
   DCHECK_GE(std::numeric_limits<uint8_t>::max(), name.length());
@@ skipping 94 matching lines @@
                                     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::ImportExistingData() const {
+  // It's possible that no user data is being stored.
+  if (!memory_)
+    return;
+
   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;
 
     size_t value_offset = RoundUpToAlignment(
@@ skipping 11 matching lines @@
     info.memory = memory_ + value_offset;
     info.size_ptr = &header->value_size;
     info.extent = header->record_size - value_offset;
 
     StringPiece key(info.name);
     values_.insert(std::make_pair(key, std::move(info)));
 
     memory_ += header->record_size;
     available_ -= header->record_size;
   }
+
+  // Check if memory has been completely reused.
+  if (header_->owner.data_id.load(std::memory_order_acquire) != orig_data_id ||
+      header_->owner.process_id != orig_process_id ||
+      header_->owner.create_stamp != orig_create_stamp) {
+    memory_ = nullptr;
+    values_.clear();
+  }
 }
 
 // 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;
 
@@ skipping 320 matching lines @@
   // during the time-sensitive snapshot operation. It is shrunk once the
   // actual size is known.
   output_snapshot->activity_stack.reserve(stack_slots_);
 
   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_create_stamp = header_->owner.create_stamp;
     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 |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_->data_unchanged.store(1, std::memory_order_seq_cst);
 
@@ skipping 17 matching lines @@
     // it must happen after all the above operations.
     if (!header_->data_unchanged.load(std::memory_order_seq_cst))
       continue;
 
     // Stack copied. Record it's full depth.
     output_snapshot->activity_stack_depth = depth;
 
     // Get the general thread information.
     output_snapshot->thread_name =
         std::string(header_->thread_name, sizeof(header_->thread_name) - 1);
+    output_snapshot->create_stamp = header_->owner.create_stamp;
     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(
         strlen(output_snapshot->thread_name.c_str()));
 
     // If the data ID has changed then the tracker has exited and the memory
     // reused by a new one. Try again.
     if (header_->owner.data_id.load(std::memory_order_seq_cst) != starting_id ||
+        output_snapshot->create_stamp != starting_create_stamp ||
         output_snapshot->process_id != starting_process_id ||
         output_snapshot->thread_id != starting_thread_id) {
       continue;
     }
 
     // Only successful if the data is still valid once everything is done since
     // it's possible for the thread to end somewhere in the middle and all its
     // values become garbage.
     if (!IsValid())
       return false;
@@ skipping 17 matching lines @@
   }
 
   // Too many attempts.
   return false;
 }
 
 const void* ThreadActivityTracker::GetBaseAddress() {
   return header_;
 }
 
-void ThreadActivityTracker::SetOwningProcessIdForTesting(ProcessId pid,
+void ThreadActivityTracker::SetOwningProcessIdForTesting(int64_t pid,
                                                          int64_t stamp) {
   header_->owner.SetOwningProcessIdForTesting(pid, stamp);
 }
 
 // static
 bool ThreadActivityTracker::GetOwningProcessId(const void* memory,
-                                               ProcessId* out_id,
+                                               int64_t* out_id,
                                                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);
 }
 
@@ skipping 170 matching lines @@
       user_data_ =
           tracker_->GetUserData(activity_id_, &global->user_data_allocator_);
     } else {
       user_data_ = MakeUnique<ActivityUserData>();
     }
   }
   return *user_data_;
 }
 
 GlobalActivityTracker::ThreadSafeUserData::ThreadSafeUserData(void* memory,
-                                                              size_t size)
-    : ActivityUserData(memory, size) {}
+                                                              size_t size,
+                                                              int64_t pid)
+    : ActivityUserData(memory, size, pid) {}
 
 GlobalActivityTracker::ThreadSafeUserData::~ThreadSafeUserData() {}
 
 void GlobalActivityTracker::ThreadSafeUserData::Set(StringPiece name,
                                                     ValueType type,
                                                     const void* memory,
                                                     size_t size) {
   AutoLock lock(data_lock_);
   ActivityUserData::Set(name, type, memory, size);
 }
 
 GlobalActivityTracker::ManagedActivityTracker::ManagedActivityTracker(
     PersistentMemoryAllocator::Reference mem_reference,
     void* base,
     size_t size)
     : ThreadActivityTracker(base, size),
       mem_reference_(mem_reference),
       mem_base_(base) {}
 
 GlobalActivityTracker::ManagedActivityTracker::~ManagedActivityTracker() {
   // The global |g_tracker_| must point to the owner of this class since all
   // objects of this type must be destructed before |g_tracker_| can be changed
   // (something that only occurs in tests).
   DCHECK(g_tracker_);
   GlobalActivityTracker::Get()->ReturnTrackerMemory(this);
 }
 
 void GlobalActivityTracker::CreateWithAllocator(
     std::unique_ptr<PersistentMemoryAllocator> allocator,
-    int stack_depth) {
+    int stack_depth,
+    int64_t process_id) {
   // There's no need to do anything with the result. It is self-managing.
   GlobalActivityTracker* global_tracker =
-      new GlobalActivityTracker(std::move(allocator), stack_depth);
+      new GlobalActivityTracker(std::move(allocator), stack_depth, process_id);
   // Create a tracker for this thread since it is known.
   global_tracker->CreateTrackerForCurrentThread();
 }
 
 #if !defined(OS_NACL)
 // static
 void GlobalActivityTracker::CreateWithFile(const FilePath& file_path,
                                            size_t size,
                                            uint64_t id,
                                            StringPiece name,
                                            int stack_depth) {
   DCHECK(!file_path.empty());
   DCHECK_GE(static_cast<uint64_t>(std::numeric_limits<int64_t>::max()), size);
 
   // Create and map the file into memory and make it globally available.
   std::unique_ptr<MemoryMappedFile> mapped_file(new MemoryMappedFile());
   bool success =
       mapped_file->Initialize(File(file_path,
                                    File::FLAG_CREATE_ALWAYS | File::FLAG_READ |
                                    File::FLAG_WRITE | File::FLAG_SHARE_DELETE),
                               {0, static_cast<int64_t>(size)},
                               MemoryMappedFile::READ_WRITE_EXTEND);
   DCHECK(success);
   CreateWithAllocator(MakeUnique<FilePersistentMemoryAllocator>(
                           std::move(mapped_file), size, id, name, false),
-                      stack_depth);
+                      stack_depth, 0);
 }
 #endif  // !defined(OS_NACL)
 
 // static
 void GlobalActivityTracker::CreateWithLocalMemory(size_t size,
                                                   uint64_t id,
                                                   StringPiece name,
-                                                  int stack_depth) {
+                                                  int stack_depth,
+                                                  int64_t process_id) {
   CreateWithAllocator(
-      MakeUnique<LocalPersistentMemoryAllocator>(size, id, name), stack_depth);
+      MakeUnique<LocalPersistentMemoryAllocator>(size, id, name), stack_depth,
+      process_id);
 }
 
+// static
+void GlobalActivityTracker::SetForTesting(
+    std::unique_ptr<GlobalActivityTracker> tracker) {
+  CHECK(!subtle::NoBarrier_Load(&g_tracker_));
+  subtle::Release_Store(&g_tracker_,
+                        reinterpret_cast<uintptr_t>(tracker.release()));
+}
+
+// static
+std::unique_ptr<GlobalActivityTracker>
+GlobalActivityTracker::ReleaseForTesting() {
+  GlobalActivityTracker* tracker = Get();
+  if (!tracker)
+    return nullptr;
+
+  // Thread trackers assume that the global tracker is present for some
+  // operations so ensure that there aren't any.
+  tracker->ReleaseTrackerForCurrentThreadForTesting();
+  DCHECK_EQ(0, tracker->thread_tracker_count_.load(std::memory_order_relaxed));
+
+  subtle::Release_Store(&g_tracker_, 0);
+  return WrapUnique(tracker);
+};
+
 ThreadActivityTracker* GlobalActivityTracker::CreateTrackerForCurrentThread() {
   DCHECK(!this_thread_tracker_.Get());
 
   PersistentMemoryAllocator::Reference mem_reference;
 
   {
     base::AutoLock autolock(thread_tracker_allocator_lock_);
     mem_reference = thread_tracker_allocator_.GetObjectReference();
   }
 
@@ skipping 36 matching lines @@
   int old_count = thread_tracker_count_.fetch_add(1, std::memory_order_relaxed);
 
   UMA_HISTOGRAM_ENUMERATION("ActivityTracker.ThreadTrackers.Count",
                             old_count + 1, kMaxThreadCount);
   return tracker;
 }
 
 void GlobalActivityTracker::ReleaseTrackerForCurrentThreadForTesting() {
   ThreadActivityTracker* tracker =
       reinterpret_cast<ThreadActivityTracker*>(this_thread_tracker_.Get());
-  if (tracker)
+  if (tracker) {
+    this_thread_tracker_.Set(nullptr);
     delete tracker;
+  }
 }
 
 void GlobalActivityTracker::SetBackgroundTaskRunner(
     const scoped_refptr<TaskRunner>& runner) {
   AutoLock lock(global_tracker_lock_);
   background_task_runner_ = runner;
 }
 
 void GlobalActivityTracker::SetProcessExitCallback(
     ProcessExitCallback callback) {
   AutoLock lock(global_tracker_lock_);
   process_exit_callback_ = callback;
 }
 
 void GlobalActivityTracker::RecordProcessLaunch(
     ProcessId process_id,
     const FilePath::StringType& cmd) {
-  DCHECK_NE(GetCurrentProcId(), process_id);
+  const int64_t pid = process_id;
+  DCHECK_NE(GetProcessId(), pid);
+  DCHECK_NE(0, pid);
 
   base::AutoLock lock(global_tracker_lock_);
-  if (base::ContainsKey(known_processes_, process_id)) {
+  if (base::ContainsKey(known_processes_, pid)) {
     // TODO(bcwhite): Measure this in UMA.
     NOTREACHED() << "Process #" << process_id
                  << " was previously recorded as \"launched\""
                  << " with no corresponding exit.";
-    known_processes_.erase(process_id);
+    known_processes_.erase(pid);
   }
 
 #if defined(OS_WIN)
-  known_processes_.insert(std::make_pair(process_id, UTF16ToUTF8(cmd)));
+  known_processes_.insert(std::make_pair(pid, UTF16ToUTF8(cmd)));
 #else
-  known_processes_.insert(std::make_pair(process_id, cmd));
+  known_processes_.insert(std::make_pair(pid, cmd));
 #endif
 }
 
 void GlobalActivityTracker::RecordProcessLaunch(
     ProcessId process_id,
     const FilePath::StringType& exe,
     const FilePath::StringType& args) {
+  const int64_t pid = process_id;
   if (exe.find(FILE_PATH_LITERAL(" "))) {
-    RecordProcessLaunch(process_id,
-                        FilePath::StringType(FILE_PATH_LITERAL("\"")) + exe +
-                            FILE_PATH_LITERAL("\" ") + args);
+    RecordProcessLaunch(pid, FilePath::StringType(FILE_PATH_LITERAL("\"")) +
+                                 exe + FILE_PATH_LITERAL("\" ") + args);
   } else {
-    RecordProcessLaunch(process_id, exe + FILE_PATH_LITERAL(' ') + args);
+    RecordProcessLaunch(pid, exe + FILE_PATH_LITERAL(' ') + args);
   }
 }
 
 void GlobalActivityTracker::RecordProcessExit(ProcessId process_id,
                                               int exit_code) {
-  DCHECK_NE(GetCurrentProcId(), process_id);
+  const int64_t pid = process_id;
+  DCHECK_NE(GetProcessId(), pid);
+  DCHECK_NE(0, pid);
 
   scoped_refptr<TaskRunner> task_runner;
   std::string command_line;
   {
     base::AutoLock lock(global_tracker_lock_);
     task_runner = background_task_runner_;
-    auto found = known_processes_.find(process_id);
+    auto found = known_processes_.find(pid);
     if (found != known_processes_.end()) {
       command_line = std::move(found->second);
       known_processes_.erase(found);
     } else {
       DLOG(ERROR) << "Recording exit of unknown process #" << process_id;
     }
   }
 
   // Use the current time to differentiate the process that just exited
   // from any that might be created in the future with the same ID.
   int64_t now_stamp = Time::Now().ToInternalValue();
 
   // The persistent allocator is thread-safe so run the iteration and
   // adjustments on a worker thread if one was provided.
   if (task_runner && !task_runner->RunsTasksOnCurrentThread()) {
     task_runner->PostTask(
         FROM_HERE,
-        Bind(&GlobalActivityTracker::CleanupAfterProcess, Unretained(this),
-             process_id, now_stamp, exit_code, Passed(&command_line)));
+        Bind(&GlobalActivityTracker::CleanupAfterProcess, Unretained(this), pid,
+             now_stamp, exit_code, Passed(&command_line)));
     return;
   }
 
-  CleanupAfterProcess(process_id, now_stamp, exit_code,
-                      std::move(command_line));
+  CleanupAfterProcess(pid, now_stamp, exit_code, std::move(command_line));
 }
 
 void GlobalActivityTracker::SetProcessPhase(ProcessPhase phase) {
   process_data().SetInt(kProcessPhaseDataKey, phase);
 }
 
-void GlobalActivityTracker::CleanupAfterProcess(ProcessId process_id,
+void GlobalActivityTracker::CleanupAfterProcess(int64_t process_id,
                                                 int64_t exit_stamp,
                                                 int exit_code,
                                                 std::string&& command_line) {
   // The process may not have exited cleanly so its necessary to go through
   // all the data structures it may have allocated in the persistent memory
   // segment and mark them as "released". This will allow them to be reused
   // later on.
 
   PersistentMemoryAllocator::Iterator iter(allocator_.get());
   PersistentMemoryAllocator::Reference ref;
 
   ProcessExitCallback process_exit_callback;
   {
     AutoLock lock(global_tracker_lock_);
     process_exit_callback = process_exit_callback_;
   }
   if (process_exit_callback) {
     // Find the processes user-data record so the process phase can be passed
     // to the callback.
     ActivityUserData::Snapshot process_data_snapshot;
     while ((ref = iter.GetNextOfType(kTypeIdProcessDataRecord)) != 0) {
       const void* memory = allocator_->GetAsArray<char>(
           ref, kTypeIdProcessDataRecord, PersistentMemoryAllocator::kSizeAny);
-      ProcessId found_id;
+      int64_t found_id;
       int64_t create_stamp;
       if (ActivityUserData::GetOwningProcessId(memory, &found_id,
                                                &create_stamp)) {
         if (found_id == process_id && create_stamp < exit_stamp) {
           const ActivityUserData process_data(const_cast<void*>(memory),
                                               allocator_->GetAllocSize(ref));
           process_data.CreateSnapshot(&process_data_snapshot);
           break;  // No need to look for any others.
         }
       }
@@ skipping 16 matching lines @@
   // Find all allocations associated with the exited process and free them.
   uint32_t type;
   while ((ref = iter.GetNext(&type)) != 0) {
     switch (type) {
       case kTypeIdActivityTracker:
       case kTypeIdUserDataRecord:
       case kTypeIdProcessDataRecord:
       case ModuleInfoRecord::kPersistentTypeId: {
         const void* memory = allocator_->GetAsArray<char>(
             ref, type, PersistentMemoryAllocator::kSizeAny);
-        ProcessId found_id;
+        int64_t found_id;
         int64_t create_stamp;
 
         // By convention, the OwningProcess structure is always the first
         // field of the structure so there's no need to handle all the
         // cases separately.
         if (OwningProcess::GetOwningProcessId(memory, &found_id,
                                               &create_stamp)) {
           // Only change the type to be "free" if the process ID matches and
           // the creation time is before the exit time (so PID re-use doesn't
           // cause the erasure of something that is in-use). Memory is cleared
@@ skipping 47 matching lines @@
 }
 
 void GlobalActivityTracker::RecordFieldTrial(const std::string& trial_name,
                                              StringPiece group_name) {
   const std::string key = std::string("FieldTrial.") + trial_name;
   global_data_.SetString(key, group_name);
 }
 
 GlobalActivityTracker::GlobalActivityTracker(
     std::unique_ptr<PersistentMemoryAllocator> allocator,
-    int stack_depth)
+    int stack_depth,
+    int64_t process_id)
     : allocator_(std::move(allocator)),
       stack_memory_size_(ThreadActivityTracker::SizeForStackDepth(stack_depth)),
+      process_id_(process_id == 0 ? GetCurrentProcId() : process_id),
       this_thread_tracker_(&OnTLSDestroy),
       thread_tracker_count_(0),
       thread_tracker_allocator_(allocator_.get(),
                                 kTypeIdActivityTracker,
                                 kTypeIdActivityTrackerFree,
                                 stack_memory_size_,
                                 kCachedThreadMemories,
                                 /*make_iterable=*/true),
       user_data_allocator_(allocator_.get(),
                            kTypeIdUserDataRecord,
                            kTypeIdUserDataRecordFree,
                            kUserDataSize,
                            kCachedUserDataMemories,
                            /*make_iterable=*/true),
       process_data_(allocator_->GetAsArray<char>(
                         AllocateFrom(allocator_.get(),
                                      kTypeIdProcessDataRecordFree,
                                      kProcessDataSize,
                                      kTypeIdProcessDataRecord),
                         kTypeIdProcessDataRecord,
                         kProcessDataSize),
-                    kProcessDataSize),
+                    kProcessDataSize,
+                    process_id_),
       global_data_(
           allocator_->GetAsArray<char>(
               allocator_->Allocate(kGlobalDataSize, kTypeIdGlobalDataRecord),
               kTypeIdGlobalDataRecord,
               kGlobalDataSize),
-          kGlobalDataSize) {
-  // Ensure the passed memory is valid and empty (iterator finds nothing).
-  uint32_t type;
-  DCHECK(!PersistentMemoryAllocator::Iterator(allocator_.get()).GetNext(&type));
+          kGlobalDataSize,
+          process_id_) {
+  DCHECK_NE(0, process_id_);
 
   // Ensure that there is no other global object and then make this one such.
   DCHECK(!g_tracker_);
   subtle::Release_Store(&g_tracker_, reinterpret_cast<uintptr_t>(this));
 
   // The data records must be iterable in order to be found by an analyzer.
   allocator_->MakeIterable(allocator_->GetAsReference(
       process_data_.GetBaseAddress(), kTypeIdProcessDataRecord));
   allocator_->MakeIterable(allocator_->GetAsReference(
       global_data_.GetBaseAddress(), kTypeIdGlobalDataRecord));
 
   // Note that this process has launched.
   SetProcessPhase(PROCESS_LAUNCHED);
 
   // Fetch and record all activated field trials.
   FieldTrial::ActiveGroups active_groups;
   FieldTrialList::GetActiveFieldTrialGroups(&active_groups);
   for (auto& group : active_groups)
     RecordFieldTrial(group.trial_name, group.group_name);
 }
 
 GlobalActivityTracker::~GlobalActivityTracker() {
-  DCHECK_EQ(Get(), this);
+  DCHECK(Get() == nullptr || Get() == this);
   DCHECK_EQ(0, thread_tracker_count_.load(std::memory_order_relaxed));
   subtle::Release_Store(&g_tracker_, 0);
 }
 
 void GlobalActivityTracker::ReturnTrackerMemory(
     ManagedActivityTracker* tracker) {
   PersistentMemoryAllocator::Reference mem_reference = tracker->mem_reference_;
   void* mem_base = tracker->mem_base_;
   DCHECK(mem_reference);
   DCHECK(mem_base);
@@ skipping 107 matching lines @@
     : GlobalActivityTracker::ScopedThreadActivity(
           program_counter,
           nullptr,
           Activity::ACT_PROCESS_WAIT,
           ActivityData::ForProcess(process->Pid()),
           /*lock_allowed=*/true) {}
 #endif
 
 }  // namespace debug
 }  // namespace base