[sampling heap profiler] Report modules through protocol.

To allow external symbolization the profile has to include modules info.

BUG=803276
TBR=pfeldman@chromium.org

Change-Id: I0802678210e07ec89a2d2e5eae9a02f7d5dc1568
Reviewed-on: https://chromium-review.googlesource.com/1147525Reviewed-by: Alexei Filippov <alph@chromium.org>
Reviewed-by: Pavel Feldman <pfeldman@chromium.org>
Reviewed-by: Mike Wittman <wittman@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Commit-Queue: Alexei Filippov <alph@chromium.org>
Cr-Commit-Position: refs/heads/master@{#581323}

base/sampling_heap_profiler/module_cache.cc

@@ -30,4 +30,12 @@ const ModuleCache::Module& ModuleCache::GetModuleForAddress(uintptr_t address) {
       .first->second;
 }
 
+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);
+  return result;
+}
+
 }  // namespace base

base/sampling_heap_profiler/module_cache.h

@@ -6,6 +6,7 @@
 #define BASE_SAMPLING_HEAP_PROFILER_MODULE_CACHE_H_
 
 #include <map>
+#include <vector>
 
 #include "base/profiler/stack_sampling_profiler.h"
 
@@ -19,6 +20,7 @@ class BASE_EXPORT ModuleCache {
   ~ModuleCache();
 
   const Module& GetModuleForAddress(uintptr_t address);
+  std::vector<const Module*> GetModules() const;
 
  private:
   std::map<uintptr_t, Module> modules_cache_map_;

base/sampling_heap_profiler/module_cache_unittest.cc

@@ -19,8 +19,10 @@ int AFunctionForTest() {
 // addresses within the module.
 #if defined(OS_MACOSX) && !defined(OS_IOS)
 #define MAYBE_ModuleCache ModuleCache
+#define MAYBE_ModulesList ModulesList
 #else
 #define MAYBE_ModuleCache DISABLED_ModuleCache
+#define MAYBE_ModulesList DISABLED_ModulesList
 #endif
 TEST_F(ModuleCacheTest, MAYBE_ModuleCache) {
   uintptr_t ptr1 = reinterpret_cast<uintptr_t>(&AFunctionForTest);
@@ -34,6 +36,15 @@ TEST_F(ModuleCacheTest, MAYBE_ModuleCache) {
   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);
+  EXPECT_EQ(1u, cache.GetModules().size());
+  EXPECT_EQ(&module, cache.GetModules().front());
+}
+
 TEST_F(ModuleCacheTest, InvalidModule) {
   ModuleCache cache;
   const ModuleCache::Module& invalid_module = cache.GetModuleForAddress(1);

content/browser/devtools/protocol/memory_handler.cc

@@ -4,7 +4,10 @@
 
 #include "content/browser/devtools/protocol/memory_handler.h"
 
+#include <cinttypes>
+
 #include "base/memory/memory_pressure_listener.h"
+#include "base/sampling_heap_profiler/module_cache.h"
 #include "base/sampling_heap_profiler/sampling_heap_profiler.h"
 #include "base/strings/stringprintf.h"
 #include "content/public/browser/render_process_host.h"
@@ -33,6 +36,7 @@ void MemoryHandler::SetRenderer(int process_host_id,
 
 Response MemoryHandler::GetBrowserSamplingProfile(
     std::unique_ptr<Memory::SamplingProfile>* out_profile) {
+  base::ModuleCache module_cache;
   std::unique_ptr<Array<Memory::SamplingProfileNode>> samples =
       Array<Memory::SamplingProfileNode>::create();
   std::vector<base::SamplingHeapProfiler::Sample> raw_samples =
@@ -40,8 +44,11 @@ Response MemoryHandler::GetBrowserSamplingProfile(
 
   for (auto& sample : raw_samples) {
     std::unique_ptr<Array<String>> stack = Array<String>::create();
-    for (auto* frame : sample.stack)
-      stack->addItem(base::StringPrintf("%p", frame));
+    for (const void* frame : sample.stack) {
+      uintptr_t address = reinterpret_cast<uintptr_t>(frame);
+      module_cache.GetModuleForAddress(address);  // Populates module_cache.
+      stack->addItem(base::StringPrintf("0x%" PRIxPTR, address));
+    }
     samples->addItem(Memory::SamplingProfileNode::Create()
                          .SetSize(sample.size)
                          .SetTotal(sample.total)
@@ -49,8 +56,23 @@ Response MemoryHandler::GetBrowserSamplingProfile(
                          .Build());
   }
 
-  *out_profile =
-      Memory::SamplingProfile::Create().SetSamples(std::move(samples)).Build();
+  std::unique_ptr<Array<Memory::Module>> modules =
+      Array<Memory::Module>::create();
+  for (const auto* module : module_cache.GetModules()) {
+    modules->addItem(Memory::Module::Create()
+                         .SetName(base::StringPrintf(
+                             "%" PRIsFP, module->filename.value().c_str()))
+                         .SetUuid(module->id)
+                         .SetBaseAddress(base::StringPrintf(
+                             "0x%" PRIxPTR, module->base_address))
+                         .SetSize(static_cast<double>(module->size))
+                         .Build());
+  }
+
+  *out_profile = Memory::SamplingProfile::Create()
+                     .SetSamples(std::move(samples))
+                     .SetModules(std::move(modules))
+                     .Build();
   return Response::OK();
 }
 

third_party/blink/renderer/core/inspector/DEPS

 include_rules = [
     "+base/time/time_override.h",
+    "+base/sampling_heap_profiler/module_cache.h",
     "+base/sampling_heap_profiler/sampling_heap_profiler.h",
     # for base::GetUniqueIdForProcess
     "+base/process/process_handle.h",

third_party/blink/renderer/core/inspector/browser_protocol.pdl

@@ -3414,6 +3414,20 @@ experimental domain Memory
   type SamplingProfile extends object
     properties
       array of SamplingProfileNode samples
+      array of Module modules
+
+  # Executable module information
+  type Module extends object
+    properties
+      # Name of the module.
+      string name
+      # UUID of the module.
+      string uuid
+      # Base address where the module is loaded into memory. Encoded as a decimal
+      # or hexadecimal (0x prefixed) string.
+      string baseAddress
+      # Size of the module in bytes.
+      number size
 
 # Network domain allows tracking network activities of the page. It exposes information about http,
 # file, data and other requests and responses, their headers, bodies, timing, etc.

third_party/blink/renderer/core/inspector/inspector_memory_agent.cc

@@ -33,6 +33,7 @@
 #include <cstdio>
 
 #include "base/debug/stack_trace.h"
+#include "base/sampling_heap_profiler/module_cache.h"
 #include "base/sampling_heap_profiler/sampling_heap_profiler.h"
 #include "build/build_config.h"
 #include "third_party/blink/renderer/core/frame/local_frame_client.h"
@@ -110,6 +111,7 @@ Response InspectorMemoryAgent::getSamplingProfile(
 
 std::unique_ptr<protocol::Memory::SamplingProfile>
 InspectorMemoryAgent::GetSamplingProfileById(uint32_t id) {
+  base::ModuleCache module_cache;
   std::unique_ptr<protocol::Array<protocol::Memory::SamplingProfileNode>>
       samples =
           protocol::Array<protocol::Memory::SamplingProfileNode>::create();
@@ -119,6 +121,10 @@ InspectorMemoryAgent::GetSamplingProfileById(uint32_t id) {
   for (auto& it : raw_samples) {
     std::unique_ptr<protocol::Array<protocol::String>> stack =
         protocol::Array<protocol::String>::create();
+    for (const void* frame : it.stack) {
+      uintptr_t address = reinterpret_cast<uintptr_t>(frame);
+      module_cache.GetModuleForAddress(address);  // Populates module_cache.
+    }
     std::vector<std::string> source_stack = Symbolize(it.stack);
     for (auto& it2 : source_stack)
       stack->addItem(it2.c_str());
@@ -145,8 +151,21 @@ InspectorMemoryAgent::GetSamplingProfileById(uint32_t id) {
                          .build());
   }
 
+  std::unique_ptr<protocol::Array<protocol::Memory::Module>> modules =
+      protocol::Array<protocol::Memory::Module>::create();
+  for (const auto* module : module_cache.GetModules()) {
+    modules->addItem(
+        protocol::Memory::Module::create()
+            .setName(module->filename.value().c_str())
+            .setUuid(module->id.c_str())
+            .setBaseAddress(String::Format("0x%" PRIxPTR, module->base_address))
+            .setSize(static_cast<double>(module->size))
+            .build());
+  }
+
   return protocol::Memory::SamplingProfile::create()
       .setSamples(std::move(samples))
+      .setModules(std::move(modules))
       .build();
 }
 
@@ -175,21 +194,19 @@ std::vector<std::string> InspectorMemoryAgent::Symbolize(
         line.substr(space_pos == std::string::npos ? 0 : space_pos + 1);
     symbols_cache_.insert(addresses_to_symbolize[i], name);
   }
+#endif
 
-  std::vector<std::string> result;
-  for (void* address : addresses)
-    result.push_back(symbols_cache_.at(address));
-
-  return result;
-#else
   std::vector<std::string> result;
   for (void* address : addresses) {
     char buffer[20];
-    std::snprintf(buffer, sizeof(buffer), "%p", address);
-    result.push_back(buffer);
+    std::snprintf(buffer, sizeof(buffer), "0x%" PRIxPTR,
+                  reinterpret_cast<uintptr_t>(address));
+    if (symbols_cache_.Contains(address))
+      result.push_back(std::string(buffer) + " " + symbols_cache_.at(address));
+    else
+      result.push_back(buffer);
   }
   return result;
-#endif
 }
 
 }  // namespace blink

third_party/blink/tools/audit_non_blink_usage.py

@@ -307,6 +307,7 @@ _CONFIG = [
     {
         'paths': ['third_party/blink/renderer/core/inspector/inspector_memory_agent.cc'],
         'allowed': [
+            'base::ModuleCache',
             'base::SamplingHeapProfiler',
         ],
     },