Support for extracting user-data from activity tracking.

base/debug/activity_analyzer.h

 // 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.
 
 #ifndef BASE_DEBUG_ACTIVITY_ANALYZER_H_
 #define BASE_DEBUG_ACTIVITY_ANALYZER_H_
 
 #include <map>
 #include <memory>
 #include <set>
 #include <string>
 
 #include "base/base_export.h"
 #include "base/debug/activity_tracker.h"
 
 namespace base {
 namespace debug {
 
+class GlobalActivityAnalyzer;
+
 // This class provides analysis of data captured from a ThreadActivityTracker.
 // When created, it takes a snapshot of the data held by the tracker and
 // makes that information available to other code.
 class BASE_EXPORT ThreadActivityAnalyzer {
  public:
   // This class provides keys that uniquely identify a thread, even across
   // multiple processes.
   class ThreadKey {
    public:
     ThreadKey(int64_t pid, int64_t tid) : pid_(pid), tid_(tid) {}
@@ skipping 23 matching lines @@
   ThreadActivityAnalyzer(void* base, size_t size);
 
   // Creates an analyzer for a block of memory held within a persistent-memory
   // |allocator| at the given |reference|. A snapshot is taken immediately and
   // the memory is not referenced again.
   ThreadActivityAnalyzer(PersistentMemoryAllocator* allocator,
                          PersistentMemoryAllocator::Reference reference);
 
   ~ThreadActivityAnalyzer();
 
+  // Adds information from the global analyzer.
+  void AddGlobalInformation(GlobalActivityAnalyzer* global);
+
   // Returns true iff the contained data is valid. Results from all other
   // methods are undefined if this returns false.
   bool IsValid() { return activity_snapshot_valid_; }
 
   // Gets the name of the thread.
   const std::string& GetThreadName() {
     return activity_snapshot_.thread_name;
   }
 
   // Gets the TheadKey for this thread.
   ThreadKey GetThreadKey() {
     return ThreadKey(activity_snapshot_.process_id,
                      activity_snapshot_.thread_id);
   }
 
+  // Gets the user-data snapshot for an activity based on its index in the
+  // |activity_stack| field of the ActivitySnapshot. Ownership stays with
+  // this instance.
+  const ActivityUserData::Snapshot& GetUserDataSnapshot(size_t stack_index);
+
   const ActivitySnapshot& activity_snapshot() { return activity_snapshot_; }
 
  private:
   friend class GlobalActivityAnalyzer;
 
   // The snapshot of the activity tracker taken at the moment of construction.
   ActivitySnapshot activity_snapshot_;
 
   // Flag indicating if the snapshot data is valid.
   bool activity_snapshot_valid_;
 
+  // Copy of user-data associated with the stack. This is captured and held
+  // because the data may change if used on a live system.
+  std::vector<ActivityUserData::Snapshot> user_data_snapshots_;
+
   // A reference into a persistent memory allocator, used by the global
   // analyzer to know where this tracker came from.
   PersistentMemoryAllocator::Reference allocator_reference_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadActivityAnalyzer);
 };
 
 
 // This class manages analyzers for all known processes and threads as stored
 // in a persistent memory allocator. It supports retrieval of them through
@@ skipping 27 matching lines @@
   // Iterates over all known valid analyzers or returns null if there are no
   // more. Ownership stays with the global analyzer object and all existing
   // analyzer pointers are invalidated when GetFirstAnalyzer() is called.
   ThreadActivityAnalyzer* GetFirstAnalyzer();
   ThreadActivityAnalyzer* GetNextAnalyzer();
 
   // Gets the analyzer for a specific thread or null if there is none.
   // Ownership stays with the global analyzer object.
   ThreadActivityAnalyzer* GetAnalyzerForThread(const ThreadKey& key);
 
+  // Extract user data based on a reference and its identifier.
+  ActivityUserData::Snapshot GetUserDataSnapshot(uint32_t ref, uint32_t id);
+
+  // Extract the global user data.
+  ActivityUserData::Snapshot GetGlobalUserDataSnapshot();
+
   // Gets the corresponding "program location" for a given "program counter".
   // This will return {0,0} if no mapping could be found.
   ProgramLocation GetProgramLocationFromAddress(uint64_t address);
 
  private:
   using AnalyzerMap =
       std::map<ThreadKey, std::unique_ptr<ThreadActivityAnalyzer>>;
 
   // Finds, creates, and indexes analyzers for all known processes and threads.
   void PrepareAllAnalyzers();
@@ skipping 14 matching lines @@
   // first/next iteration.
   AnalyzerMap::iterator analyzers_iterator_;
 
   DISALLOW_COPY_AND_ASSIGN(GlobalActivityAnalyzer);
 };
 
 }  // namespace debug
 }  // namespace base
 
 #endif  // BASE_DEBUG_ACTIVITY_ANALYZER_H_