Add AlignedVector and use it for vector<MEMORY_BASIC_INFORMATION64>

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,
@@ skipping 41 matching lines @@
     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<MEMORY_BASIC_INFORMATION64>& memory_info =
+  const ProcessInfo::MemoryBasicInformation64Vector& memory_info =
       process_info.MemoryInfo();
   bool found_region = false;
   for (const auto& mi : memory_info) {
     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;
@@ skipping 119 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<MEMORY_BASIC_INFORMATION64> memory_info;
+  ProcessInfo::MemoryBasicInformation64Vector memory_info;
   MEMORY_BASIC_INFORMATION64 mbi = {0};
 
   mbi.BaseAddress = 0;
   mbi.RegionSize = 10;
   mbi.State = MEM_FREE;
   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<MEMORY_BASIC_INFORMATION64> memory_info;
+  ProcessInfo::MemoryBasicInformation64Vector memory_info;
   MEMORY_BASIC_INFORMATION64 mbi = {0};
 
   mbi.BaseAddress = 0;
   mbi.RegionSize = 10;
   mbi.State = MEM_COMMIT;
   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<MEMORY_BASIC_INFORMATION64> memory_info;
+  ProcessInfo::MemoryBasicInformation64Vector memory_info;
   MEMORY_BASIC_INFORMATION64 mbi = {0};
 
   mbi.BaseAddress = 0;
   mbi.RegionSize = 10;
   mbi.State = MEM_COMMIT;
   memory_info.push_back(mbi);
 
   mbi.BaseAddress = 10;
   mbi.RegionSize = 20;
   mbi.State = MEM_FREE;
   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<MEMORY_BASIC_INFORMATION64> memory_info;
+  ProcessInfo::MemoryBasicInformation64Vector memory_info;
   MEMORY_BASIC_INFORMATION64 mbi = {0};
 
   mbi.BaseAddress = 0;
   mbi.RegionSize = 10;
   mbi.State = MEM_FREE;
   memory_info.push_back(mbi);
 
   mbi.BaseAddress = 10;
   mbi.RegionSize = 20;
   mbi.State = MEM_COMMIT;
   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<MEMORY_BASIC_INFORMATION64> memory_info;
+  ProcessInfo::MemoryBasicInformation64Vector memory_info;
   MEMORY_BASIC_INFORMATION64 mbi = {0};
 
   mbi.BaseAddress = 0;
   mbi.RegionSize = 10;
   mbi.State = MEM_RESERVE;
   memory_info.push_back(mbi);
 
   mbi.BaseAddress = 10;
   mbi.RegionSize = 20;
   mbi.State = MEM_COMMIT;
   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<MEMORY_BASIC_INFORMATION64> memory_info;
+  ProcessInfo::MemoryBasicInformation64Vector 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(mbi);
 
   mbi.BaseAddress = 10;
   mbi.RegionSize = 20;
   mbi.State = MEM_COMMIT;
   mbi.Protect = 0;
   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<MEMORY_BASIC_INFORMATION64> memory_info;
+  ProcessInfo::MemoryBasicInformation64Vector 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(mbi);
 
   mbi.BaseAddress = 10;
   mbi.RegionSize = 20;
   mbi.State = MEM_COMMIT;
   mbi.Protect = 0;
   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<MEMORY_BASIC_INFORMATION64> memory_info;
+  ProcessInfo::MemoryBasicInformation64Vector memory_info;
   MEMORY_BASIC_INFORMATION64 mbi = {0};
 
   mbi.BaseAddress = 0;
   mbi.RegionSize = 10;
   mbi.State = MEM_FREE;
   memory_info.push_back(mbi);
 
   mbi.BaseAddress = 10;
   mbi.RegionSize = 2;
   mbi.State = MEM_COMMIT;
   memory_info.push_back(mbi);
 
   mbi.BaseAddress = 12;
   mbi.RegionSize = 5;
   mbi.State = MEM_COMMIT;
   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<MEMORY_BASIC_INFORMATION64> memory_info;
+  ProcessInfo::MemoryBasicInformation64Vector memory_info;
   MEMORY_BASIC_INFORMATION64 mbi = {0};
 
   mbi.BaseAddress = 0;
   mbi.RegionSize = 10;
   mbi.State = MEM_COMMIT;
   memory_info.push_back(mbi);
 
   mbi.BaseAddress = 10;
   mbi.RegionSize = 5;
   mbi.State = MEM_FREE;
   memory_info.push_back(mbi);
 
   mbi.BaseAddress = 15;
   mbi.RegionSize = 100;
   mbi.State = MEM_COMMIT;
   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<MEMORY_BASIC_INFORMATION64> memory_info;
+  ProcessInfo::MemoryBasicInformation64Vector memory_info;
   MEMORY_BASIC_INFORMATION64 mbi = {0};
 
   mbi.BaseAddress = 10;
   mbi.RegionSize = 10;
   mbi.State = MEM_COMMIT;
   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<MEMORY_BASIC_INFORMATION64> memory_info;
+  ProcessInfo::MemoryBasicInformation64Vector memory_info;
   MEMORY_BASIC_INFORMATION64 mbi = {0};
 
   mbi.BaseAddress = 10;
   mbi.RegionSize = 10;
   mbi.State = MEM_COMMIT;
   memory_info.push_back(mbi);
 
   std::vector<CheckedRange<WinVMAddress, WinVMSize>> result =
       GetReadableRangesOfMemoryMap(
           CheckedRange<WinVMAddress, WinVMSize>(15, 100), memory_info);
@@ skipping 197 matching lines @@
   EXPECT_TRUE(
       info.LoggingRangeIsFullyReadable(CheckedRange<WinVMAddress, WinVMSize>(
           reinterpret_cast<WinVMAddress>(safe_memory.get()), kAllocationSize)));
   EXPECT_FALSE(info.LoggingRangeIsFullyReadable(
       CheckedRange<WinVMAddress, WinVMSize>(0, 1024)));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad