Support storing information about what modules are loaded in the process.

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"
@@ skipping 13 matching lines @@
 
 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),
+                                 PersistentMemoryAllocator::kSizeAny),
                              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 at the
@@ skipping 107 matching lines @@
     const char* message = allocator_->GetAsArray<char>(
         ref, GlobalActivityTracker::kTypeIdGlobalLogMessage,
         PersistentMemoryAllocator::kSizeAny);
     if (message)
       messages.push_back(message);
   }
 
   return messages;
 }
 
+std::vector<GlobalActivityTracker::ModuleInfo>
+GlobalActivityAnalyzer::GetModules() {
+  std::vector<GlobalActivityTracker::ModuleInfo> modules;
+
+  PersistentMemoryAllocator::Iterator iter(allocator_.get());
+  const GlobalActivityTracker::ModuleInfoRecord* record;
+  while (
+      (record =
+           iter.GetNextOfObject<GlobalActivityTracker::ModuleInfoRecord>()) !=
+      nullptr) {
+    GlobalActivityTracker::ModuleInfo info;
+    if (record->DecodeTo(&info, allocator_->GetAllocSize(
+                                    allocator_->GetAsReference(record)))) {
+      modules.push_back(std::move(info));
+    }
+  }
+
+  return modules;
+}
+
 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 32 matching lines @@
     // 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