[Sampling profiler] Make ModuleCache::Module a reference type

This is a reland of 8f219b08 and
9de3faa3 merged into a single change,
with test fixes.

* Changes ModuleCache::Module from a value type to a reference type,
  with ModuleCache maintaining ownership of the Module. ModuleCache
  needs to own its Modules to properly support Windows, which reference
  counts its modules. ModuleCache is retained as a struct to minimize
  the size of this change, but will be changed to a class in a later CL.

* Moves the parallel module caching implementation for Windows into
  ModuleCache. This is required to ensure the referenced modules outlive
  the references to them.  The parallel implementation will be merged
  with the existing module caching implementation over the course of
  later refactoring CLs.

Bug: 931418
Change-Id: Ic58afbf4f7bd48a91d0191a37b623b63501c8fa7
Reviewed-on: https://chromium-review.googlesource.com/c/1483393Reviewed-by: oysteine <oysteine@chromium.org>
Reviewed-by: Scott Violet <sky@chromium.org>
Commit-Queue: Scott Violet <sky@chromium.org>
Auto-Submit: Mike Wittman <wittman@chromium.org>
Cr-Commit-Position: refs/heads/master@{#634872}

base/profiler/native_stack_sampler_mac.cc

@@ -409,11 +409,12 @@ std::vector<Frame> NativeStackSamplerMac::RecordStackFrames(
     return HasValidRbp(unwind_cursor, new_stack_top);
   };
 
-  WalkStack(thread_state,
-            [&frames](uintptr_t frame_ip, ModuleCache::Module module) {
-              frames.emplace_back(frame_ip, std::move(module));
-            },
-            continue_predicate);
+  WalkStack(
+      thread_state,
+      [&frames](uintptr_t frame_ip, const ModuleCache::Module* module) {
+        frames.emplace_back(frame_ip, module);
+      },
+      continue_predicate);
 
   return frames;
 }
@@ -444,8 +445,8 @@ bool NativeStackSamplerMac::WalkStackFromContext(
     // libunwind adds the expected stack size, it will look for the return
     // address in the wrong place. This check should ensure that we bail before
     // trying to deref a bad IP obtained this way in the previous frame.
-    const ModuleCache::Module& module = module_cache_->GetModuleForAddress(rip);
-    if (!module.is_valid)
+    const ModuleCache::Module* module = module_cache_->GetModuleForAddress(rip);
+    if (!module->is_valid)
       return false;
 
     callback(static_cast<uintptr_t>(rip), module);

base/profiler/native_stack_sampler_win.cc

@@ -427,24 +427,22 @@ class NativeStackSamplerWin : public NativeStackSampler {
 
   win::ScopedHandle thread_handle_;
 
+  ModuleCache* module_cache_;
+
   NativeStackSamplerTestDelegate* const test_delegate_;
 
   // The stack base address corresponding to |thread_handle_|.
   const void* const thread_stack_base_address_;
 
-  // The module objects, indexed by the module handle.
-  std::map<HMODULE, ModuleCache::Module> module_cache_;
-
   DISALLOW_COPY_AND_ASSIGN(NativeStackSamplerWin);
 };
 
 NativeStackSamplerWin::NativeStackSamplerWin(
     win::ScopedHandle thread_handle,
-    // Ignored for now, until we can switch the internal module cache to use
-    // this one.
     ModuleCache* module_cache,
     NativeStackSamplerTestDelegate* test_delegate)
     : thread_handle_(thread_handle.Take()),
+      module_cache_(module_cache),
       test_delegate_(test_delegate),
       thread_stack_base_address_(
           GetThreadEnvironmentBlock(thread_handle_.Get())->Tib.StackBase) {}
@@ -452,7 +450,6 @@ NativeStackSamplerWin::NativeStackSamplerWin(
 NativeStackSamplerWin::~NativeStackSamplerWin() {}
 
 void NativeStackSamplerWin::ProfileRecordingStarting() {
-  module_cache_.clear();
 }
 
 std::vector<Frame> NativeStackSamplerWin::RecordStackFrames(
@@ -489,26 +486,8 @@ std::vector<Frame> NativeStackSamplerWin::CreateFrames(
   frames.reserve(stack.size());
 
   for (const auto& frame : stack) {
-    auto frame_ip = reinterpret_cast<uintptr_t>(frame.instruction_pointer);
-
-    HMODULE module_handle = frame.module.Get();
-    if (!module_handle) {
-      frames.emplace_back(frame_ip, ModuleCache::Module());
-      continue;
-    }
-
-    auto loc = module_cache_.find(module_handle);
-    if (loc != module_cache_.end()) {
-      frames.emplace_back(frame_ip, loc->second);
-      continue;
-    }
-
-    ModuleCache::Module module =
-        ModuleCache::CreateModuleForHandle(module_handle);
-    if (module.is_valid)
-      module_cache_.insert(std::make_pair(module_handle, module));
-
-    frames.emplace_back(frame_ip, std::move(module));
+    frames.emplace_back(reinterpret_cast<uintptr_t>(frame.instruction_pointer),
+                        module_cache_->GetModuleForHandle(frame.module.Get()));
   }
 
   return frames;

base/profiler/stack_sampling_profiler.cc

@@ -50,8 +50,8 @@ const int kNullProfilerId = -1;
 // StackSamplingProfiler::Frame -------------------------------------
 
 StackSamplingProfiler::Frame::Frame(uintptr_t instruction_pointer,
-                                    ModuleCache::Module module)
-    : instruction_pointer(instruction_pointer), module(std::move(module)) {}
+                                    const ModuleCache::Module* module)
+    : instruction_pointer(instruction_pointer), module(module) {}
 
 StackSamplingProfiler::Frame::~Frame() = default;
 

base/profiler/stack_sampling_profiler.h

@@ -58,14 +58,14 @@ class BASE_EXPORT StackSamplingProfiler {
   // This struct is only used for sampling data transfer from NativeStackSampler
   // to ProfileBuilder.
   struct BASE_EXPORT Frame {
-    Frame(uintptr_t instruction_pointer, ModuleCache::Module module);
+    Frame(uintptr_t instruction_pointer, const ModuleCache::Module* module);
     ~Frame();
 
     // The sampled instruction pointer within the function.
     uintptr_t instruction_pointer;
 
     // The module information.
-    ModuleCache::Module module;
+    const ModuleCache::Module* module;
   };
 
   // Represents parameters that configure the sampling.

base/sampling_heap_profiler/module_cache.cc

@@ -4,6 +4,8 @@
 
 #include "base/sampling_heap_profiler/module_cache.h"
 
+#include <utility>
+
 #include "base/no_destructor.h"
 
 namespace base {
@@ -30,29 +32,29 @@ ModuleCache::Module::~Module() = default;
 ModuleCache::ModuleCache() = default;
 ModuleCache::~ModuleCache() = default;
 
-const ModuleCache::Module& ModuleCache::GetModuleForAddress(uintptr_t address) {
+const ModuleCache::Module* ModuleCache::GetModuleForAddress(uintptr_t address) {
   static NoDestructor<Module> invalid_module;
   auto it = modules_cache_map_.upper_bound(address);
   if (it != modules_cache_map_.begin()) {
     DCHECK(!modules_cache_map_.empty());
     --it;
-    Module& module = it->second;
-    if (address < module.base_address + module.size)
+    const Module* module = it->second.get();
+    if (address < module->base_address + module->size)
       return module;
   }
 
-  auto module = CreateModuleForAddress(address);
-  if (!module.is_valid)
-    return *invalid_module;
-  return modules_cache_map_.emplace(module.base_address, std::move(module))
-      .first->second;
+  std::unique_ptr<Module> module = CreateModuleForAddress(address);
+  if (!module->is_valid)
+    return invalid_module.get();
+  return modules_cache_map_.emplace(module->base_address, std::move(module))
+      .first->second.get();
 }
 
 std::vector<const ModuleCache::Module*> ModuleCache::GetModules() const {
   std::vector<const Module*> result;
   result.reserve(modules_cache_map_.size());
   for (const auto& it : modules_cache_map_)
-    result.push_back(&it.second);
+    result.push_back(it.second.get());
   return result;
 }
 

base/sampling_heap_profiler/module_cache.h

@@ -6,6 +6,7 @@
 #define BASE_SAMPLING_HEAP_PROFILER_MODULE_CACHE_H_
 
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -35,6 +36,9 @@ class BASE_EXPORT ModuleCache {
            size_t size);
     ~Module();
 
+    Module(const Module&) = delete;
+    Module& operator=(const Module&) = delete;
+
     // Points to the base address of the module.
     uintptr_t base_address;
 
@@ -60,7 +64,10 @@ class BASE_EXPORT ModuleCache {
   ModuleCache();
   ~ModuleCache();
 
-  const Module& GetModuleForAddress(uintptr_t address);
+  // Gets the module containing |address| or an invalid module if |address| is
+  // not within a module. The returned module remains owned by and has the same
+  // lifetime as the ModuleCache object.
+  const Module* GetModuleForAddress(uintptr_t address);
   std::vector<const Module*> GetModules() const;
 
  private:
@@ -69,7 +76,7 @@ class BASE_EXPORT ModuleCache {
 
   // Creates a Module object for the specified memory address. If the address
   // does not belong to a module returns an invalid module.
-  static Module CreateModuleForAddress(uintptr_t address);
+  static std::unique_ptr<Module> CreateModuleForAddress(uintptr_t address);
   friend class NativeStackSamplerMac;
 
 #if defined(OS_MACOSX)
@@ -80,11 +87,16 @@ class BASE_EXPORT ModuleCache {
 #endif
 
 #if defined(OS_WIN)
-  static Module CreateModuleForHandle(HMODULE module_handle);
+  const Module* GetModuleForHandle(HMODULE module_handle);
+  static std::unique_ptr<Module> CreateModuleForHandle(HMODULE module_handle);
   friend class NativeStackSamplerWin;
+
+  // The module objects, indexed by the module handle.
+  // TODO(wittman): Merge this state into modules_cache_map_ and remove
+  std::map<HMODULE, std::unique_ptr<Module>> win_module_cache_;
 #endif
 
-  std::map<uintptr_t, Module> modules_cache_map_;
+  std::map<uintptr_t, std::unique_ptr<Module>> modules_cache_map_;
 };
 
 }  // namespace base

base/sampling_heap_profiler/module_cache_mac.cc

@@ -64,13 +64,15 @@ std::string GetUniqueId(const void* module_addr) {
 }  // namespace
 
 // static
-ModuleCache::Module ModuleCache::CreateModuleForAddress(uintptr_t address) {
+std::unique_ptr<ModuleCache::Module> ModuleCache::CreateModuleForAddress(
+    uintptr_t address) {
   Dl_info inf;
   if (!dladdr(reinterpret_cast<const void*>(address), &inf))
-    return Module();
+    return std::make_unique<Module>();
   auto base_module_address = reinterpret_cast<uintptr_t>(inf.dli_fbase);
-  return Module(base_module_address, GetUniqueId(inf.dli_fbase),
-                FilePath(inf.dli_fname), GetModuleTextSize(inf.dli_fbase));
+  return std::make_unique<Module>(
+      base_module_address, GetUniqueId(inf.dli_fbase), FilePath(inf.dli_fname),
+      GetModuleTextSize(inf.dli_fbase));
 }
 
 size_t ModuleCache::GetModuleTextSize(const void* module_addr) {

base/sampling_heap_profiler/module_cache_posix.cc

@@ -7,9 +7,10 @@
 namespace base {
 
 // static
-ModuleCache::Module ModuleCache::CreateModuleForAddress(uintptr_t address) {
+std::unique_ptr<ModuleCache::Module> ModuleCache::CreateModuleForAddress(
+    uintptr_t address) {
   // TODO(alph): Implement it.
-  return Module();
+  return std::make_unique<Module>();
 }
 
 }  // namespace base

base/sampling_heap_profiler/module_cache_unittest.cc

@@ -28,28 +28,28 @@ TEST_F(ModuleCacheTest, MAYBE_ModuleCache) {
   uintptr_t ptr1 = reinterpret_cast<uintptr_t>(&AFunctionForTest);
   uintptr_t ptr2 = ptr1 + 1;
   ModuleCache cache;
-  const ModuleCache::Module& module1 = cache.GetModuleForAddress(ptr1);
-  const ModuleCache::Module& module2 = cache.GetModuleForAddress(ptr2);
-  EXPECT_EQ(&module1, &module2);
-  EXPECT_TRUE(module1.is_valid);
-  EXPECT_GT(module1.size, 0u);
-  EXPECT_LE(module1.base_address, ptr1);
-  EXPECT_GT(module1.base_address + module1.size, ptr2);
+  const ModuleCache::Module* module1 = cache.GetModuleForAddress(ptr1);
+  const ModuleCache::Module* module2 = cache.GetModuleForAddress(ptr2);
+  EXPECT_EQ(module1, module2);
+  EXPECT_TRUE(module1->is_valid);
+  EXPECT_GT(module1->size, 0u);
+  EXPECT_LE(module1->base_address, ptr1);
+  EXPECT_GT(module1->base_address + module1->size, ptr2);
 }
 
 TEST_F(ModuleCacheTest, MAYBE_ModulesList) {
   ModuleCache cache;
   uintptr_t ptr = reinterpret_cast<uintptr_t>(&AFunctionForTest);
-  const ModuleCache::Module& module = cache.GetModuleForAddress(ptr);
-  EXPECT_TRUE(module.is_valid);
+  const ModuleCache::Module* module = cache.GetModuleForAddress(ptr);
+  EXPECT_TRUE(module->is_valid);
   EXPECT_EQ(1u, cache.GetModules().size());
-  EXPECT_EQ(&module, cache.GetModules().front());
+  EXPECT_EQ(module, cache.GetModules().front());
 }
 
 TEST_F(ModuleCacheTest, InvalidModule) {
   ModuleCache cache;
-  const ModuleCache::Module& invalid_module = cache.GetModuleForAddress(1);
-  EXPECT_FALSE(invalid_module.is_valid);
+  const ModuleCache::Module* invalid_module = cache.GetModuleForAddress(1);
+  EXPECT_FALSE(invalid_module->is_valid);
 }
 
 }  // namespace

base/sampling_heap_profiler/module_cache_win.cc

@@ -7,6 +7,7 @@
 #include <objbase.h>
 #include <psapi.h>
 
+#include "base/no_destructor.h"
 #include "base/process/process_handle.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
@@ -66,35 +67,59 @@ void GetDebugInfoForModule(HMODULE module_handle,
 }  // namespace
 
 // static
-ModuleCache::Module ModuleCache::CreateModuleForAddress(uintptr_t address) {
+std::unique_ptr<ModuleCache::Module> ModuleCache::CreateModuleForAddress(
+    uintptr_t address) {
   HMODULE module_handle = nullptr;
   if (!::GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
                            reinterpret_cast<LPCTSTR>(address),
                            &module_handle)) {
     DCHECK_EQ(ERROR_MOD_NOT_FOUND, static_cast<int>(::GetLastError()));
-    return Module();
+    return std::make_unique<Module>();
   }
-  Module module = CreateModuleForHandle(module_handle);
+  std::unique_ptr<Module> module = CreateModuleForHandle(module_handle);
   ::CloseHandle(module_handle);
   return module;
 }
 
+const ModuleCache::Module* ModuleCache::GetModuleForHandle(
+    HMODULE module_handle) {
+  static NoDestructor<ModuleCache::Module> invalid_module;
+
+  if (!module_handle)
+    return invalid_module.get();
+
+  auto loc = win_module_cache_.find(module_handle);
+  if (loc != win_module_cache_.end())
+    return loc->second.get();
+
+  std::unique_ptr<ModuleCache::Module> module =
+      ModuleCache::CreateModuleForHandle(module_handle);
+  if (module->is_valid) {
+    const auto result = win_module_cache_.insert(
+        std::make_pair(module_handle, std::move(module)));
+    return result.first->second.get();
+  }
+  return invalid_module.get();
+}
+
 // static
-ModuleCache::Module ModuleCache::CreateModuleForHandle(HMODULE module_handle) {
+std::unique_ptr<ModuleCache::Module> ModuleCache::CreateModuleForHandle(
+    HMODULE module_handle) {
   FilePath pdb_name;
   std::string build_id;
   GetDebugInfoForModule(module_handle, &build_id, &pdb_name);
   if (build_id.empty())
-    return Module();
+    return std::make_unique<Module>();
 
   MODULEINFO module_info;
   if (!::GetModuleInformation(GetCurrentProcessHandle(), module_handle,
                               &module_info, sizeof(module_info))) {
-    return Module();
+    return std::make_unique<Module>();
   }
 
-  return Module(reinterpret_cast<uintptr_t>(module_info.lpBaseOfDll), build_id,
-                pdb_name, module_info.SizeOfImage);
+  return std::make_unique<Module>(
+      reinterpret_cast<uintptr_t>(module_info.lpBaseOfDll), build_id, pdb_name,
+      module_info.SizeOfImage);
 }
 
 }  // namespace base

chrome/common/heap_profiler_controller.cc

@@ -130,7 +130,7 @@ void HeapProfilerController::RetrieveAndSendSnapshot() {
     frames.reserve(sample.stack.size());
     for (const void* frame : sample.stack) {
       uintptr_t address = reinterpret_cast<uintptr_t>(frame);
-      const base::ModuleCache::Module& module =
+      const base::ModuleCache::Module* module =
           module_cache.GetModuleForAddress(address);
       frames.emplace_back(address, module);
     }

components/metrics/call_stack_profile_builder.cc

@@ -91,22 +91,21 @@ void CallStackProfileBuilder::OnSampleCompleted(
     // keep the frame information even if its module is invalid so we have
     // visibility into how often this issue is happening on the server.
     CallStackProfile::Location* location = stack.add_frame();
-    if (!frame.module.is_valid)
+    if (!frame.module->is_valid)
       continue;
 
     // Dedup modules.
-    const base::ModuleCache::Module& module = frame.module;
-    auto module_loc = module_index_.find(module.base_address);
+    auto module_loc = module_index_.find(frame.module);
     if (module_loc == module_index_.end()) {
-      modules_.push_back(module);
+      modules_.push_back(frame.module);
       size_t index = modules_.size() - 1;
-      module_loc = module_index_.emplace(module.base_address, index).first;
+      module_loc = module_index_.emplace(frame.module, index).first;
     }
 
     // Write CallStackProfile::Location protobuf message.
     ptrdiff_t module_offset =
         reinterpret_cast<const char*>(frame.instruction_pointer) -
-        reinterpret_cast<const char*>(module.base_address);
+        reinterpret_cast<const char*>(frame.module->base_address);
     DCHECK_GE(module_offset, 0);
     location->set_address(static_cast<uint64_t>(module_offset));
     location->set_module_id_index(module_loc->second);
@@ -165,11 +164,11 @@ void CallStackProfileBuilder::OnProfileCompleted(
   call_stack_profile->set_sampling_period_ms(sampling_period.InMilliseconds());
 
   // Write CallStackProfile::ModuleIdentifier protobuf message.
-  for (const auto& module : modules_) {
+  for (const auto* module : modules_) {
     CallStackProfile::ModuleIdentifier* module_id =
         call_stack_profile->add_module_id();
-    module_id->set_build_id(module.id);
-    module_id->set_name_md5_prefix(HashModuleFilename(module.filename));
+    module_id->set_build_id(module->id);
+    module_id->set_name_md5_prefix(HashModuleFilename(module->filename));
   }
 
   PassProfilesToMetricsProvider(std::move(sampled_profile_));

components/metrics/call_stack_profile_builder.h

@@ -120,11 +120,11 @@ class CallStackProfileBuilder
   // The indexes of stacks, indexed by stack's address.
   std::map<const CallStackProfile::Stack*, int, StackComparer> stack_index_;
 
-  // The indexes of modules, indexed by module's base_address.
-  std::unordered_map<uintptr_t, size_t> module_index_;
+  // The indexes of modules in the modules_ vector below..
+  std::unordered_map<const base::ModuleCache::Module*, size_t> module_index_;
 
   // The distinct modules in the current profile.
-  std::vector<base::ModuleCache::Module> modules_;
+  std::vector<const base::ModuleCache::Module*> modules_;
 
   // Callback made when sampling a profile completes.
   base::OnceClosure completed_callback_;

components/metrics/call_stack_profile_builder_unittest.cc

@@ -86,15 +86,15 @@ TEST(CallStackProfileBuilderTest, ProfilingCompleted) {
 
   const uintptr_t module_base_address1 = 0x1000;
   Module module1 = {module_base_address1, "1", module_path};
-  Frame frame1 = {module_base_address1 + 0x10, module1};
+  Frame frame1 = {module_base_address1 + 0x10, &module1};
 
   const uintptr_t module_base_address2 = 0x1100;
   Module module2 = {module_base_address2, "2", module_path};
-  Frame frame2 = {module_base_address2 + 0x10, module2};
+  Frame frame2 = {module_base_address2 + 0x10, &module2};
 
   const uintptr_t module_base_address3 = 0x1010;
   Module module3 = {module_base_address3, "3", module_path};
-  Frame frame3 = {module_base_address3 + 0x10, module3};
+  Frame frame3 = {module_base_address3 + 0x10, &module3};
 
   std::vector<Frame> frames1 = {frame1, frame2};
   std::vector<Frame> frames2 = {frame3};
@@ -166,11 +166,11 @@ TEST(CallStackProfileBuilderTest, StacksDeduped) {
 
   const uintptr_t module_base_address1 = 0x1000;
   Module module1 = {module_base_address1, "1", module_path};
-  Frame frame1 = {module_base_address1 + 0x10, module1};
+  Frame frame1 = {module_base_address1 + 0x10, &module1};
 
   const uintptr_t module_base_address2 = 0x1100;
   Module module2 = {module_base_address2, "2", module_path};
-  Frame frame2 = {module_base_address2 + 0x10, module2};
+  Frame frame2 = {module_base_address2 + 0x10, &module2};
 
   std::vector<Frame> frames = {frame1, frame2};
 
@@ -212,11 +212,11 @@ TEST(CallStackProfileBuilderTest, StacksNotDeduped) {
 
   const uintptr_t module_base_address1 = 0x1000;
   Module module1 = {module_base_address1, "1", module_path};
-  Frame frame1 = {module_base_address1 + 0x10, module1};
+  Frame frame1 = {module_base_address1 + 0x10, &module1};
 
   const uintptr_t module_base_address2 = 0x1100;
   Module module2 = {module_base_address2, "2", module_path};
-  Frame frame2 = {module_base_address2 + 0x10, module2};
+  Frame frame2 = {module_base_address2 + 0x10, &module2};
 
   std::vector<Frame> frames1 = {frame1};
   std::vector<Frame> frames2 = {frame2};
@@ -252,7 +252,7 @@ TEST(CallStackProfileBuilderTest, Modules) {
 
   const uintptr_t module_base_address1 = 0x1000;
   Module module1;  // module1 has no information hence invalid.
-  Frame frame1 = {module_base_address1 + 0x10, module1};
+  Frame frame1 = {module_base_address1 + 0x10, &module1};
 
   const uintptr_t module_base_address2 = 0x1100;
 #if defined(OS_WIN)
@@ -263,7 +263,7 @@ TEST(CallStackProfileBuilderTest, Modules) {
   base::FilePath module_path("/some/path/to/chrome");
 #endif
   Module module2 = {module_base_address2, "2", module_path};
-  Frame frame2 = {module_base_address2 + 0x10, module2};
+  Frame frame2 = {module_base_address2 + 0x10, &module2};
 
   std::vector<Frame> frames = {frame1, frame2};
 
@@ -311,11 +311,9 @@ TEST(CallStackProfileBuilderTest, DedupModules) {
   base::FilePath module_path("/some/path/to/chrome");
 #endif
 
-  Module module1 = {module_base_address, "1", module_path};
-  Frame frame1 = {module_base_address + 0x10, module1};
-
-  Module module2 = {module_base_address, "1", module_path};
-  Frame frame2 = {module_base_address + 0x20, module2};
+  Module module = {module_base_address, "1", module_path};
+  Frame frame1 = {module_base_address + 0x10, &module};
+  Frame frame2 = {module_base_address + 0x20, &module};
 
   std::vector<Frame> frames = {frame1, frame2};
 
@@ -334,8 +332,8 @@ TEST(CallStackProfileBuilderTest, DedupModules) {
   ASSERT_EQ(1, profile.stack_size());
   ASSERT_EQ(2, profile.stack(0).frame_size());
 
-  // Since module1 and module2 have the same base address, they are considered
-  // the same module and therefore deduped.
+  // The two frames share the same module, which should be deduped in the
+  // output.
   ASSERT_TRUE(profile.stack(0).frame(0).has_module_id_index());
   EXPECT_EQ(0, profile.stack(0).frame(0).module_id_index());
   ASSERT_TRUE(profile.stack(0).frame(0).has_address());
@@ -372,7 +370,7 @@ TEST(CallStackProfileBuilderTest, WorkIds) {
 #endif
 
   Module module = {0x1000, "1", module_path};
-  Frame frame = {0x1000 + 0x10, module};
+  Frame frame = {0x1000 + 0x10, &module};
 
   // Id 0 means the message loop hasn't been started yet, so the sample should
   // not have continued_work set.
@@ -429,7 +427,7 @@ TEST(CallStackProfileBuilderTest, MetadataRecorder) {
 #endif
 
   Module module = {0x1000, "1", module_path};
-  Frame frame = {0x1000 + 0x10, module};
+  Frame frame = {0x1000 + 0x10, &module};
 
   metadata_recorder.current_value = 5;
   profile_builder->OnSampleCompleted({frame});

components/tracing/common/native_stack_sampler_android.cc

@@ -4,6 +4,8 @@
 
 #include "components/tracing/common/native_stack_sampler_android.h"
 
+#include "base/no_destructor.h"
+#include "base/sampling_heap_profiler/module_cache.h"
 #include "base/trace_event/trace_event.h"
 
 namespace tracing {
@@ -22,6 +24,7 @@ std::vector<base::StackSamplingProfiler::Frame>
 NativeStackSamplerAndroid::RecordStackFrames(
     StackBuffer* stack_buffer,
     base::StackSamplingProfiler::ProfileBuilder* profile_builder) {
+  static base::NoDestructor<base::ModuleCache::Module> invalid_module;
   if (!unwinder_.is_initialized()) {
     // May block on disk access. This function is executed on the profiler
     // thread, so this will only block profiling execution.
@@ -36,7 +39,7 @@ NativeStackSamplerAndroid::RecordStackFrames(
   for (size_t i = 0; i < depth; ++i) {
     // TODO(ssid): Add support for obtaining modules here.
     frames.emplace_back(reinterpret_cast<uintptr_t>(pcs[i]),
-                        base::ModuleCache::Module());
+                        invalid_module.get());
   }
   return frames;
 }

components/tracing/common/tracing_sampler_profiler.cc

@@ -110,12 +110,12 @@ class TracingProfileBuilder
       if (frame_name.empty())
         frame_name = "Unknown";
 #else
-      module_name = frame.module.filename.BaseName().MaybeAsASCII();
+      module_name = frame.module->filename.BaseName().MaybeAsASCII();
       frame_name = GetFrameNameFromOffsetAddr(frame.instruction_pointer -
-                                              frame.module.base_address);
+                                              frame.module->base_address);
 #endif
       base::StringAppendF(&result, "%s - %s [%s]\n", frame_name.c_str(),
-                          module_name.c_str(), frame.module.id.c_str());
+                          module_name.c_str(), frame.module->id.c_str());
     }
 
     TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("cpu_profiler"),