Implement basic support for Windows module emission.

components/tracing/common/process_metrics_memory_dump_provider_unittest.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 <stdint.h>
 
 #include <memory>
 
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
 #include "base/process/process_metrics.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "base/trace_event/process_memory_maps.h"
 #include "base/trace_event/process_memory_totals.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_MACOSX)
 #include <libgen.h>
 #include <mach-o/dyld.h>
 #endif
 
+#if defined(OS_WIN)
+#include <base/strings/sys_string_conversions.h>
+#endif
+
 namespace tracing {
 
 #if defined(OS_LINUX) || defined(OS_ANDROID)
 namespace {
 const char kTestSmaps1[] =
     "00400000-004be000 r-xp 00000000 fc:01 1234              /file/1\n"
     "Size:                760 kB\n"
     "Rss:                 296 kB\n"
     "Pss:                 162 kB\n"
     "Shared_Clean:        228 kB\n"
@@ skipping 232 matching lines @@
   mdp.PollFastMemoryTotal(&value);
   EXPECT_EQ(100 * page_size, value);
 
   mdp.SuspendFastMemoryPolling();
   EXPECT_FALSE(mdp.fast_polling_statm_fd_.is_valid());
 #else
   mdp.SuspendFastMemoryPolling();
 #endif
 }
 
+#if defined(OS_WIN)
+
+void DummyFunction() {}
+
+TEST(ProcessMetricsMemoryDumpProviderTest, TestWinModuleReading) {
+  using VMRegion = base::trace_event::ProcessMemoryMaps::VMRegion;
+
+  ProcessMetricsMemoryDumpProvider mdp(base::kNullProcessId);
+  base::trace_event::MemoryDumpArgs args;
+  base::trace_event::ProcessMemoryDump dump(nullptr, args);
+  ASSERT_TRUE(mdp.DumpProcessMemoryMaps(args, &dump));
+  ASSERT_TRUE(dump.has_process_mmaps());
+
+  wchar_t module_name[MAX_PATH];
+  DWORD result = GetModuleFileName(nullptr, module_name, MAX_PATH);
+  ASSERT_TRUE(result);
+  std::string executable_name = base::SysWideToNativeMB(module_name);
+
+  HMODULE module_containing_dummy = nullptr;
+  uintptr_t dummy_function_address =
+      reinterpret_cast<uintptr_t>(&DummyFunction);
+  result = GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
+                             reinterpret_cast<LPCWSTR>(dummy_function_address),
+                             &module_containing_dummy);
+  ASSERT_TRUE(result);
+  result = GetModuleFileName(nullptr, module_name, MAX_PATH);
+  ASSERT_TRUE(result);
+  std::string module_containing_dummy_name =
+      base::SysWideToNativeMB(module_name);
+
+  bool found_components_unittests = false;

[Wez, 2017/02/23 23:35:03]

nit: Suggest renaming this to found_executable, since you called it
executable_name, above.

[erikchen, 2017/02/24 17:32:48]

Done.

+  bool found_region_with_dummy = false;
+  for (const VMRegion& region : dump.process_mmaps()->vm_regions()) {
+    EXPECT_NE(0u, region.start_address);
+    EXPECT_NE(0u, region.size_in_bytes);
+
+    if (region.mapped_file.find(executable_name) != std::string::npos)
+      found_components_unittests = true;
+
+    if (dummy_function_address >= region.start_address &&
+        dummy_function_address < region.start_address + region.size_in_bytes) {
+      found_region_with_dummy = true;
+      EXPECT_EQ(module_containing_dummy_name, region.mapped_file);
+    }
+  }
+  EXPECT_TRUE(found_components_unittests);
+  EXPECT_TRUE(found_region_with_dummy);
+}
+#endif
+
 #if defined(OS_MACOSX)
 TEST(ProcessMetricsMemoryDumpProviderTest, TestMachOReading) {
   using VMRegion = base::trace_event::ProcessMemoryMaps::VMRegion;
   ProcessMetricsMemoryDumpProvider mdp(base::kNullProcessId);
   base::trace_event::MemoryDumpArgs args;
   base::trace_event::ProcessMemoryDump dump(nullptr, args);
   ASSERT_TRUE(mdp.DumpProcessMemoryMaps(args, &dump));
   ASSERT_TRUE(dump.has_process_mmaps());
   uint32_t size = 100;
   char full_path[size];
@@ skipping 46 matching lines @@
   uint64_t last_address = 0;
   for (const VMRegion& region : regions) {
     EXPECT_GE(region.start_address, last_address);
     last_address = region.start_address + region.size_in_bytes;
   }
 }
 
 #endif  // defined(OS_MACOSX)
 
 }  // namespace tracing