Use MEMORY_BASIC_INFORMATION64 rather than a custom MemoryInfo

util/win/process_info_test.cc

 // Copyright 2015 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "util/win/process_info.h"
 
-#include <imagehlp.h>
+#include <dbghelp.h>
 #include <intrin.h>
 #include <wchar.h>
 
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "build/build_config.h"
 #include "gtest/gtest.h"
 #include "test/paths.h"
 #include "test/win/child_launcher.h"
 #include "util/file/file_io.h"
 #include "util/misc/uuid.h"
 #include "util/win/scoped_handle.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
 const wchar_t kNtdllName[] = L"\\ntdll.dll";
 
-time_t GetTimestampForModule(HMODULE module) {
-  char filename[MAX_PATH];
-  // `char` and GetModuleFileNameA because ImageLoad is ANSI only.
-  if (!GetModuleFileNameA(module, filename, arraysize(filename)))
-    return 0;
-  LOADED_IMAGE* loaded_image = ImageLoad(filename, nullptr);
-  return loaded_image->FileHeader->FileHeader.TimeDateStamp;
-}
-
 bool IsProcessWow64(HANDLE process_handle) {
   static decltype(IsWow64Process)* is_wow64_process =
       reinterpret_cast<decltype(IsWow64Process)*>(
           GetProcAddress(LoadLibrary(L"kernel32.dll"), "IsWow64Process"));
   if (!is_wow64_process)
     return false;
   BOOL is_wow64;
   if (!is_wow64_process(process_handle, &is_wow64)) {
     PLOG(ERROR) << "IsWow64Process";
     return false;
   }
   return is_wow64;
 }
 
 void VerifyAddressInInCodePage(const ProcessInfo& process_info,
                                WinVMAddress code_address) {
   // Make sure the child code address is an code page address with the right
   // information.
-  const std::vector<ProcessInfo::MemoryInfo>& memory_info =
-      process_info.MemoryInformation();
+  const std::vector<MEMORY_BASIC_INFORMATION64>& memory_info =
+      process_info.MemoryInfo();
   bool found_region = false;
   for (const auto& mi : memory_info) {
-    if (mi.base_address <= code_address &&
-        mi.base_address + mi.region_size > code_address) {
-      EXPECT_EQ(MEM_COMMIT, mi.state);
-      EXPECT_EQ(PAGE_EXECUTE_READ, mi.protect);
-      EXPECT_EQ(MEM_IMAGE, mi.type);
+    if (mi.BaseAddress <= code_address &&
+        mi.BaseAddress + mi.RegionSize > code_address) {
+      EXPECT_EQ(MEM_COMMIT, mi.State);
+      EXPECT_EQ(PAGE_EXECUTE_READ, mi.Protect);
+      EXPECT_EQ(MEM_IMAGE, mi.Type);
       EXPECT_FALSE(found_region);
       found_region = true;
     }
   }
   EXPECT_TRUE(found_region);
 }
 
 TEST(ProcessInfo, Self) {
   ProcessInfo process_info;
   ASSERT_TRUE(process_info.Initialize(GetCurrentProcess()));
@@ skipping 20 matching lines @@
   ASSERT_GE(modules.size(), 2u);
   const wchar_t kSelfName[] = L"\\crashpad_util_test.exe";
   ASSERT_GE(modules[0].name.size(), wcslen(kSelfName));
   EXPECT_EQ(kSelfName,
             modules[0].name.substr(modules[0].name.size() - wcslen(kSelfName)));
   ASSERT_GE(modules[1].name.size(), wcslen(kNtdllName));
   EXPECT_EQ(
       kNtdllName,
       modules[1].name.substr(modules[1].name.size() - wcslen(kNtdllName)));
 
-  EXPECT_EQ(modules[0].dll_base,
-            reinterpret_cast<uintptr_t>(GetModuleHandle(nullptr)));
-  EXPECT_EQ(modules[1].dll_base,
-            reinterpret_cast<uintptr_t>(GetModuleHandle(L"ntdll.dll")));
+  EXPECT_EQ(reinterpret_cast<uintptr_t>(GetModuleHandle(nullptr)),
+            modules[0].dll_base);
+  EXPECT_EQ(reinterpret_cast<uintptr_t>(GetModuleHandle(L"ntdll.dll")),
+            modules[1].dll_base);
 
   EXPECT_GT(modules[0].size, 0);
   EXPECT_GT(modules[1].size, 0);
 
-  EXPECT_EQ(modules[0].timestamp,
-            GetTimestampForModule(GetModuleHandle(nullptr)));
+  EXPECT_EQ(GetTimestampForLoadedLibrary(GetModuleHandle(nullptr)),
+            modules[0].timestamp);
   // System modules are forced to particular stamps and the file header values
   // don't match the on-disk times. Just make sure we got some data here.
   EXPECT_GT(modules[1].timestamp, 0);
 
   // Find something we know is a code address and confirm expected memory
   // information settings.
   VerifyAddressInInCodePage(process_info,
                             reinterpret_cast<WinVMAddress>(_ReturnAddress()));
 }
 
@@ skipping 61 matching lines @@
 TEST(ProcessInfo, OtherProcessWOW64) {
 #ifndef NDEBUG
   TestOtherProcess(FILE_PATH_LITERAL("..\\..\\out\\Debug"));
 #else
   TestOtherProcess(FILE_PATH_LITERAL("..\\..\\out\\Release"));
 #endif
 }
 #endif  // ARCH_CPU_64_BITS
 
 TEST(ProcessInfo, AccessibleRangesNone) {
-  std::vector<ProcessInfo::MemoryInfo> memory_info;
-  MEMORY_BASIC_INFORMATION mbi = {0};
+  std::vector<MEMORY_BASIC_INFORMATION64> memory_info;
+  MEMORY_BASIC_INFORMATION64 mbi = {0};
 
   mbi.BaseAddress = 0;
   mbi.RegionSize = 10;
   mbi.State = MEM_FREE;
-  memory_info.push_back(ProcessInfo::MemoryInfo(mbi));
+  memory_info.push_back(mbi);
 
   std::vector<CheckedRange<WinVMAddress, WinVMSize>> result =
       GetReadableRangesOfMemoryMap(CheckedRange<WinVMAddress, WinVMSize>(2, 4),
                                    memory_info);
 
   EXPECT_TRUE(result.empty());
 }
 
 TEST(ProcessInfo, AccessibleRangesOneInside) {
-  std::vector<ProcessInfo::MemoryInfo> memory_info;
-  MEMORY_BASIC_INFORMATION mbi = {0};
+  std::vector<MEMORY_BASIC_INFORMATION64> memory_info;
+  MEMORY_BASIC_INFORMATION64 mbi = {0};
 
   mbi.BaseAddress = 0;
   mbi.RegionSize = 10;
   mbi.State = MEM_COMMIT;
-  memory_info.push_back(ProcessInfo::MemoryInfo(mbi));
+  memory_info.push_back(mbi);
 
   std::vector<CheckedRange<WinVMAddress, WinVMSize>> result =
       GetReadableRangesOfMemoryMap(CheckedRange<WinVMAddress, WinVMSize>(2, 4),
                                    memory_info);
 
   ASSERT_EQ(1u, result.size());
   EXPECT_EQ(2, result[0].base());
   EXPECT_EQ(4, result[0].size());
 }
 
 TEST(ProcessInfo, AccessibleRangesOneTruncatedSize) {
-  std::vector<ProcessInfo::MemoryInfo> memory_info;
-  MEMORY_BASIC_INFORMATION mbi = {0};
+  std::vector<MEMORY_BASIC_INFORMATION64> memory_info;
+  MEMORY_BASIC_INFORMATION64 mbi = {0};
 
   mbi.BaseAddress = 0;
   mbi.RegionSize = 10;
   mbi.State = MEM_COMMIT;
-  memory_info.push_back(ProcessInfo::MemoryInfo(mbi));
+  memory_info.push_back(mbi);
 
-  mbi.BaseAddress = reinterpret_cast<void*>(10);
+  mbi.BaseAddress = 10;
   mbi.RegionSize = 20;
   mbi.State = MEM_FREE;
-  memory_info.push_back(ProcessInfo::MemoryInfo(mbi));
+  memory_info.push_back(mbi);
 
   std::vector<CheckedRange<WinVMAddress, WinVMSize>> result =
       GetReadableRangesOfMemoryMap(CheckedRange<WinVMAddress, WinVMSize>(5, 10),
                                    memory_info);
 
   ASSERT_EQ(1u, result.size());
   EXPECT_EQ(5, result[0].base());
   EXPECT_EQ(5, result[0].size());
 }
 
 TEST(ProcessInfo, AccessibleRangesOneMovedStart) {
-  std::vector<ProcessInfo::MemoryInfo> memory_info;
-  MEMORY_BASIC_INFORMATION mbi = {0};
+  std::vector<MEMORY_BASIC_INFORMATION64> memory_info;
+  MEMORY_BASIC_INFORMATION64 mbi = {0};
 
   mbi.BaseAddress = 0;
   mbi.RegionSize = 10;
   mbi.State = MEM_FREE;
-  memory_info.push_back(ProcessInfo::MemoryInfo(mbi));
+  memory_info.push_back(mbi);
 
-  mbi.BaseAddress = reinterpret_cast<void*>(10);
+  mbi.BaseAddress = 10;
   mbi.RegionSize = 20;
   mbi.State = MEM_COMMIT;
-  memory_info.push_back(ProcessInfo::MemoryInfo(mbi));
+  memory_info.push_back(mbi);
 
   std::vector<CheckedRange<WinVMAddress, WinVMSize>> result =
       GetReadableRangesOfMemoryMap(CheckedRange<WinVMAddress, WinVMSize>(5, 10),
                                    memory_info);
 
   ASSERT_EQ(1u, result.size());
   EXPECT_EQ(10, result[0].base());
   EXPECT_EQ(5, result[0].size());
 }
 
 TEST(ProcessInfo, ReserveIsInaccessible) {
-  std::vector<ProcessInfo::MemoryInfo> memory_info;
-  MEMORY_BASIC_INFORMATION mbi = {0};
+  std::vector<MEMORY_BASIC_INFORMATION64> memory_info;
+  MEMORY_BASIC_INFORMATION64 mbi = {0};
 
   mbi.BaseAddress = 0;
   mbi.RegionSize = 10;
   mbi.State = MEM_RESERVE;
-  memory_info.push_back(ProcessInfo::MemoryInfo(mbi));
+  memory_info.push_back(mbi);
 
-  mbi.BaseAddress = reinterpret_cast<void*>(10);
+  mbi.BaseAddress = 10;
   mbi.RegionSize = 20;
   mbi.State = MEM_COMMIT;
-  memory_info.push_back(ProcessInfo::MemoryInfo(mbi));
+  memory_info.push_back(mbi);
 
   std::vector<CheckedRange<WinVMAddress, WinVMSize>> result =
       GetReadableRangesOfMemoryMap(CheckedRange<WinVMAddress, WinVMSize>(5, 10),
                                    memory_info);
 
   ASSERT_EQ(1u, result.size());
   EXPECT_EQ(10, result[0].base());
   EXPECT_EQ(5, result[0].size());
 }
 
 TEST(ProcessInfo, PageGuardIsInaccessible) {
-  std::vector<ProcessInfo::MemoryInfo> memory_info;
-  MEMORY_BASIC_INFORMATION mbi = {0};
+  std::vector<MEMORY_BASIC_INFORMATION64> memory_info;
+  MEMORY_BASIC_INFORMATION64 mbi = {0};
 
   mbi.BaseAddress = 0;
   mbi.RegionSize = 10;
   mbi.State = MEM_COMMIT;
   mbi.Protect = PAGE_GUARD;
-  memory_info.push_back(ProcessInfo::MemoryInfo(mbi));
+  memory_info.push_back(mbi);
 
-  mbi.BaseAddress = reinterpret_cast<void*>(10);
+  mbi.BaseAddress = 10;
   mbi.RegionSize = 20;
   mbi.State = MEM_COMMIT;
   mbi.Protect = 0;
-  memory_info.push_back(ProcessInfo::MemoryInfo(mbi));
+  memory_info.push_back(mbi);
 
   std::vector<CheckedRange<WinVMAddress, WinVMSize>> result =
       GetReadableRangesOfMemoryMap(CheckedRange<WinVMAddress, WinVMSize>(5, 10),
                                    memory_info);
 
   ASSERT_EQ(1u, result.size());
   EXPECT_EQ(10, result[0].base());
   EXPECT_EQ(5, result[0].size());
 }
 
 TEST(ProcessInfo, PageNoAccessIsInaccessible) {
-  std::vector<ProcessInfo::MemoryInfo> memory_info;
-  MEMORY_BASIC_INFORMATION mbi = {0};
+  std::vector<MEMORY_BASIC_INFORMATION64> memory_info;
+  MEMORY_BASIC_INFORMATION64 mbi = {0};
 
   mbi.BaseAddress = 0;
   mbi.RegionSize = 10;
   mbi.State = MEM_COMMIT;
   mbi.Protect = PAGE_NOACCESS;
-  memory_info.push_back(ProcessInfo::MemoryInfo(mbi));
+  memory_info.push_back(mbi);
 
-  mbi.BaseAddress = reinterpret_cast<void*>(10);
+  mbi.BaseAddress = 10;
   mbi.RegionSize = 20;
   mbi.State = MEM_COMMIT;
   mbi.Protect = 0;
-  memory_info.push_back(ProcessInfo::MemoryInfo(mbi));
+  memory_info.push_back(mbi);
 
   std::vector<CheckedRange<WinVMAddress, WinVMSize>> result =
       GetReadableRangesOfMemoryMap(CheckedRange<WinVMAddress, WinVMSize>(5, 10),
                                    memory_info);
 
   ASSERT_EQ(1u, result.size());
   EXPECT_EQ(10, result[0].base());
   EXPECT_EQ(5, result[0].size());
 }
 
 TEST(ProcessInfo, AccessibleRangesCoalesced) {
-  std::vector<ProcessInfo::MemoryInfo> memory_info;
-  MEMORY_BASIC_INFORMATION mbi = {0};
+  std::vector<MEMORY_BASIC_INFORMATION64> memory_info;
+  MEMORY_BASIC_INFORMATION64 mbi = {0};
 
   mbi.BaseAddress = 0;
   mbi.RegionSize = 10;
   mbi.State = MEM_FREE;
-  memory_info.push_back(ProcessInfo::MemoryInfo(mbi));
+  memory_info.push_back(mbi);
 
-  mbi.BaseAddress = reinterpret_cast<void*>(10);
+  mbi.BaseAddress = 10;
   mbi.RegionSize = 2;
   mbi.State = MEM_COMMIT;
-  memory_info.push_back(ProcessInfo::MemoryInfo(mbi));
+  memory_info.push_back(mbi);
 
-  mbi.BaseAddress = reinterpret_cast<void*>(12);
+  mbi.BaseAddress = 12;
   mbi.RegionSize = 5;
   mbi.State = MEM_COMMIT;
-  memory_info.push_back(ProcessInfo::MemoryInfo(mbi));
+  memory_info.push_back(mbi);
 
   std::vector<CheckedRange<WinVMAddress, WinVMSize>> result =
       GetReadableRangesOfMemoryMap(CheckedRange<WinVMAddress, WinVMSize>(11, 4),
                                    memory_info);
 
   ASSERT_EQ(1u, result.size());
   EXPECT_EQ(11, result[0].base());
   EXPECT_EQ(4, result[0].size());
 }
 
 TEST(ProcessInfo, AccessibleRangesMiddleUnavailable) {
-  std::vector<ProcessInfo::MemoryInfo> memory_info;
-  MEMORY_BASIC_INFORMATION mbi = {0};
+  std::vector<MEMORY_BASIC_INFORMATION64> memory_info;
+  MEMORY_BASIC_INFORMATION64 mbi = {0};
 
   mbi.BaseAddress = 0;
   mbi.RegionSize = 10;
   mbi.State = MEM_COMMIT;
-  memory_info.push_back(ProcessInfo::MemoryInfo(mbi));
+  memory_info.push_back(mbi);
 
-  mbi.BaseAddress = reinterpret_cast<void*>(10);
+  mbi.BaseAddress = 10;
   mbi.RegionSize = 5;
   mbi.State = MEM_FREE;
-  memory_info.push_back(ProcessInfo::MemoryInfo(mbi));
+  memory_info.push_back(mbi);
 
-  mbi.BaseAddress = reinterpret_cast<void*>(15);
+  mbi.BaseAddress = 15;
   mbi.RegionSize = 100;
   mbi.State = MEM_COMMIT;
-  memory_info.push_back(ProcessInfo::MemoryInfo(mbi));
+  memory_info.push_back(mbi);
 
   std::vector<CheckedRange<WinVMAddress, WinVMSize>> result =
       GetReadableRangesOfMemoryMap(CheckedRange<WinVMAddress, WinVMSize>(5, 45),
                                    memory_info);
 
   ASSERT_EQ(2u, result.size());
   EXPECT_EQ(5, result[0].base());
   EXPECT_EQ(5, result[0].size());
   EXPECT_EQ(15, result[1].base());
   EXPECT_EQ(35, result[1].size());
 }
 
 TEST(ProcessInfo, RequestedBeforeMap) {
-  std::vector<ProcessInfo::MemoryInfo> memory_info;
-  MEMORY_BASIC_INFORMATION mbi = {0};
+  std::vector<MEMORY_BASIC_INFORMATION64> memory_info;
+  MEMORY_BASIC_INFORMATION64 mbi = {0};
 
-  mbi.BaseAddress = reinterpret_cast<void*>(10);
+  mbi.BaseAddress = 10;
   mbi.RegionSize = 10;
   mbi.State = MEM_COMMIT;
-  memory_info.push_back(ProcessInfo::MemoryInfo(mbi));
+  memory_info.push_back(mbi);
 
   std::vector<CheckedRange<WinVMAddress, WinVMSize>> result =
       GetReadableRangesOfMemoryMap(CheckedRange<WinVMAddress, WinVMSize>(5, 10),
                                    memory_info);
 
   ASSERT_EQ(1u, result.size());
   EXPECT_EQ(10, result[0].base());
   EXPECT_EQ(5, result[0].size());
 }
 
 TEST(ProcessInfo, RequestedAfterMap) {
-  std::vector<ProcessInfo::MemoryInfo> memory_info;
-  MEMORY_BASIC_INFORMATION mbi = {0};
+  std::vector<MEMORY_BASIC_INFORMATION64> memory_info;
+  MEMORY_BASIC_INFORMATION64 mbi = {0};
 
-  mbi.BaseAddress = reinterpret_cast<void*>(10);
+  mbi.BaseAddress = 10;
   mbi.RegionSize = 10;
   mbi.State = MEM_COMMIT;
-  memory_info.push_back(ProcessInfo::MemoryInfo(mbi));
+  memory_info.push_back(mbi);
 
   std::vector<CheckedRange<WinVMAddress, WinVMSize>> result =
       GetReadableRangesOfMemoryMap(
           CheckedRange<WinVMAddress, WinVMSize>(15, 100), memory_info);
 
   ASSERT_EQ(1u, result.size());
   EXPECT_EQ(15, result[0].base());
   EXPECT_EQ(5, result[0].size());
 }
 
@@ skipping 65 matching lines @@
   EXPECT_FALSE(ReadProcessMemory(current_process,
                                  reserve_region,
                                  into.get(),
                                  kBlockSize * 6,
                                  &bytes_read));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad