Support for extracting user-data from activity tracking.

base/debug/activity_analyzer.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_analyzer.h"
 
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 
 namespace base {
 namespace debug {
 
 ThreadActivityAnalyzer::ThreadActivityAnalyzer(
     const ThreadActivityTracker& tracker)
-    : activity_snapshot_valid_(tracker.Snapshot(&activity_snapshot_)) {}
+    : activity_snapshot_valid_(tracker.CreateSnapshot(&activity_snapshot_)) {}
 
 ThreadActivityAnalyzer::ThreadActivityAnalyzer(void* base, size_t size)
     : ThreadActivityAnalyzer(ThreadActivityTracker(base, size)) {}
 
 ThreadActivityAnalyzer::ThreadActivityAnalyzer(
     PersistentMemoryAllocator* allocator,
     PersistentMemoryAllocator::Reference reference)
     : ThreadActivityAnalyzer(allocator->GetAsArray<char>(
                                  reference,
                                  GlobalActivityTracker::kTypeIdActivityTracker,
                                  1),
                              allocator->GetAllocSize(reference)) {}
 
 ThreadActivityAnalyzer::~ThreadActivityAnalyzer() {}
 
+void ThreadActivityAnalyzer::AddGlobalInformation(
+    GlobalActivityAnalyzer* global) {
+  if (!IsValid())
+    return;
+
+  // User-data is held at the global scope even though it's referenced an the
+  // thread scope.
+  user_data_snapshots_.clear();
+  for (auto& activity : activity_snapshot_.activity_stack) {
+    if (activity.user_data_ref) {
+      ActivityUserData::Snapshot user_data = global->GetUserDataSnapshot(
+          activity.user_data_ref, activity.user_data_id);
+      user_data_snapshots_.push_back(std::move(user_data));
+    }
+  }
+}
+
+const ActivityUserData::Snapshot& ThreadActivityAnalyzer::GetUserDataSnapshot(
+    size_t stack_index) {
+  DCHECK_GT(user_data_snapshots_.size(), stack_index);
+  return user_data_snapshots_[stack_index];
+}
+
 GlobalActivityAnalyzer::GlobalActivityAnalyzer(
     std::unique_ptr<PersistentMemoryAllocator> allocator)
     : allocator_(std::move(allocator)), allocator_iterator_(allocator_.get()) {}
 
 GlobalActivityAnalyzer::~GlobalActivityAnalyzer() {}
 
 #if !defined(OS_NACL)
 // static
 std::unique_ptr<GlobalActivityAnalyzer> GlobalActivityAnalyzer::CreateWithFile(
     const FilePath& file_path) {
@@ skipping 30 matching lines @@
 }
 
 ThreadActivityAnalyzer* GlobalActivityAnalyzer::GetAnalyzerForThread(
     const ThreadKey& key) {
   auto found = analyzers_.find(key);
   if (found == analyzers_.end())
     return nullptr;
   return found->second.get();
 }
 
+ActivityUserData::Snapshot GlobalActivityAnalyzer::GetUserDataSnapshot(
+    uint32_t ref,
+    uint32_t id) {
+  ActivityUserData::Snapshot snapshot;
+
+  void* memory = allocator_->GetAsArray<char>(
+      ref, GlobalActivityTracker::kTypeIdUserDataRecord,
+      PersistentMemoryAllocator::kSizeAny);
+  if (memory) {
+    size_t size = allocator_->GetAllocSize(ref);
+    const ActivityUserData user_data(memory, size);
+    user_data.CreateSnapshot(&snapshot);
+    if (user_data.id() != id) {
+      // This allocation has been overwritten since it was created. Return an
+      // empty snapshot because whatever was captured is incorrect.
+      snapshot.clear();
+    }
+  }
+
+  return snapshot;
+}
+
+ActivityUserData::Snapshot GlobalActivityAnalyzer::GetGlobalUserDataSnapshot() {
+  ActivityUserData::Snapshot snapshot;
+
+  PersistentMemoryAllocator::Reference ref =
+      PersistentMemoryAllocator::Iterator(allocator_.get())
+          .GetNextOfType(GlobalActivityTracker::kTypeIdGlobalDataRecord);
+  void* memory = allocator_->GetAsArray<char>(
+      ref, GlobalActivityTracker::kTypeIdGlobalDataRecord,
+      PersistentMemoryAllocator::kSizeAny);
+  if (memory) {
+    size_t size = allocator_->GetAllocSize(ref);
+    const ActivityUserData global_data(memory, size);
+    global_data.CreateSnapshot(&snapshot);
+  }
+
+  return snapshot;
+}
+
 GlobalActivityAnalyzer::ProgramLocation
 GlobalActivityAnalyzer::GetProgramLocationFromAddress(uint64_t address) {
   // TODO(bcwhite): Implement this.
   return { 0, 0 };
 }
 
 void GlobalActivityAnalyzer::PrepareAllAnalyzers() {
   // Fetch all the records. This will retrieve only ones created since the
   // last run since the PMA iterator will continue from where it left off.
   uint32_t type;
@@ skipping 20 matching lines @@
     if (!base)
       continue;
 
     // Create the analyzer on the data. This will capture a snapshot of the
     // tracker state. This can fail if the tracker is somehow corrupted or is
     // in the process of shutting down.
     std::unique_ptr<ThreadActivityAnalyzer> analyzer(new ThreadActivityAnalyzer(
         base, allocator_->GetAllocSize(tracker_ref)));
     if (!analyzer->IsValid())
       continue;
+    analyzer->AddGlobalInformation(this);
 
     // Add this analyzer to the map of known ones, indexed by a unique thread
     // identifier.
     DCHECK(!base::ContainsKey(analyzers_, analyzer->GetThreadKey()));
     analyzer->allocator_reference_ = ref;
     analyzers_[analyzer->GetThreadKey()] = std::move(analyzer);
   }
 }
 
 }  // namespace debug
 }  // namespace base