Implement basic support for Windows module emission.

components/tracing/common/process_metrics_memory_dump_provider.cc

 // Copyright 2015 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 "components/tracing/common/process_metrics_memory_dump_provider.h"
 
 #include <fcntl.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 20 matching lines @@
 #include <mach/shared_region.h>
 #include <sys/param.h>
 
 #include <mach-o/dyld_images.h>
 #include <mach-o/loader.h>
 #include <mach/mach.h>
 
 #include "base/numerics/safe_math.h"
 #endif  // defined(OS_MACOSX)
 
+#if defined(OS_WIN)
+#include <psapi.h>
+#include <tchar.h>
+#include <windows.h>
+
+#include <base/strings/sys_string_conversions.h>
+#endif
+
 namespace tracing {
 
 namespace {
 
 base::LazyInstance<
     std::map<base::ProcessId,
              std::unique_ptr<ProcessMetricsMemoryDumpProvider>>>::Leaky
     g_dump_providers_map = LAZY_INSTANCE_INITIALIZER;
 
 #if defined(OS_LINUX) || defined(OS_ANDROID)
@@ skipping 175 matching lines @@
     base::ScopedFILE smaps_file(fopen(file_name.c_str(), "r"));
     res = ReadLinuxProcSmapsFile(smaps_file.get(), pmd->process_mmaps());
   }
 
   if (res)
     pmd->set_has_process_mmaps();
   return res;
 }
 #endif  // defined(OS_LINUX) || defined(OS_ANDROID)
 
+#if defined(OS_WIN)
+bool ProcessMetricsMemoryDumpProvider::DumpProcessMemoryMaps(
+    const base::trace_event::MemoryDumpArgs& args,
+    base::trace_event::ProcessMemoryDump* pmd) {
+  // Fetch handles to each of the modules loaded in this process. The process
+  // itself retains ownership of the returned handles.
+  DWORD requested_module_count = 1024;
+  DWORD result_module_count = 0;
+  std::vector<HMODULE> modules;
+  while (true) {
+    modules.resize(requested_module_count);
+    DWORD output_size = 0;
+    BOOL result = ::EnumProcessModules(::GetCurrentProcess(), modules.data(),
+                                       requested_module_count * sizeof(HMODULE),
+                                       &output_size);
+    if (!result)
+      return false;
+    result_module_count = output_size / sizeof(HMODULE);

[etienneb, 2017/02/23 21:11:36]

The way we were used to handle these racy windows Enumeration API is by always
growing the size of the resulting output_size.

That way, the while (true) { } must end one day (line:253).

And, why not using: 
 
https://cs.chromium.org/chromium/src/base/win/win_util.cc?q=EnumProcessModule...

  bool GetLoadedModulesSnapshot(HANDLE process, std::vector<HMODULE>* snapshot)
{

[erikchen, 2017/02/23 21:33:33]

Sorry, I don't understand what you mean. AFAICT, the code I wrote is almost
identical to the code in win_util, but without a limit of 5 retries.
Didn't realize it existed. Switched to it.

[etienneb, 2017/02/24 16:37:15]

I'm fine with the switch. thx.

+
+    if (result_module_count <= requested_module_count)
+      break;
+
+    // Try again. Add a small buffer, since ::EnumProcessModules can be racy.
+    requested_module_count = result_module_count + 5;
+  }
+
+  // Query the base address for each module, and attach it to the dump.
+  for (DWORD i = 0; i < result_module_count; ++i) {
+    wchar_t module_name[MAX_PATH];
+    BOOL result = ::GetModuleFileName(modules[i], module_name, MAX_PATH);
+    if (!result)
+      continue;
+
+    MODULEINFO module_info;
+    result = ::GetModuleInformation(::GetCurrentProcess(), modules[i],
+                                    &module_info, sizeof(MODULEINFO));
+    if (!result)
+      continue;
+    base::trace_event::ProcessMemoryMaps::VMRegion region;
+    region.size_in_bytes = module_info.SizeOfImage;
+    region.mapped_file = base::SysWideToNativeMB(module_name);
+    region.start_address = reinterpret_cast<uint64_t>(module_info.lpBaseOfDll);
+    pmd->process_mmaps()->AddVMRegion(region);
+  }
+  if (!pmd->process_mmaps()->vm_regions().empty())
+    pmd->set_has_process_mmaps();
+  return true;
+}
+#endif  // defined(OS_WIN)
+
 #if defined(OS_MACOSX)
 
 namespace {
 
 using VMRegion = base::trace_event::ProcessMemoryMaps::VMRegion;
 
 bool IsAddressInSharedRegion(uint64_t address) {
   return address >= SHARED_REGION_BASE_X86_64 &&
          address < (SHARED_REGION_BASE_X86_64 + SHARED_REGION_SIZE_X86_64);
 }
@@ skipping 294 matching lines @@
 
 ProcessMetricsMemoryDumpProvider::~ProcessMetricsMemoryDumpProvider() {}
 
 // Called at trace dump point time. Creates a snapshot of the memory maps for
 // the current process.
 bool ProcessMetricsMemoryDumpProvider::OnMemoryDump(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   bool res = DumpProcessTotals(args, pmd);
 
-#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_MACOSX)
   if (args.level_of_detail ==
       base::trace_event::MemoryDumpLevelOfDetail::DETAILED)
     res &= DumpProcessMemoryMaps(args, pmd);
-#endif  // defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_MACOSX)
   return res;
 }
 
 bool ProcessMetricsMemoryDumpProvider::DumpProcessTotals(
     const base::trace_event::MemoryDumpArgs& args,
     base::trace_event::ProcessMemoryDump* pmd) {
   const uint64_t rss_bytes = rss_bytes_for_testing
                                  ? rss_bytes_for_testing
                                  : process_metrics_->GetWorkingSetSize();
 
@@ skipping 82 matching lines @@
 #endif
 }
 
 void ProcessMetricsMemoryDumpProvider::SuspendFastMemoryPolling() {
 #if defined(OS_LINUX) || defined(OS_ANDROID)
   fast_polling_statm_fd_.reset();
 #endif
 }
 
 }  // namespace tracing