Mostly-boilerplate to add MemoryMapSnapshot

snapshot/win/process_snapshot_win.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 "snapshot/win/process_snapshot_win.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
+#include "snapshot/win/memory_snapshot_win.h"
 #include "snapshot/win/module_snapshot_win.h"
 #include "util/win/registration_protocol_win.h"
 #include "util/win/time.h"
 
 namespace crashpad {
 
 ProcessSnapshotWin::ProcessSnapshotWin()
     : ProcessSnapshot(),
       system_(),
       threads_(),
       modules_(),
       exception_(),
+      memory_map_(),
       process_reader_(),
       report_id_(),
       client_id_(),
       annotations_simple_map_(),
       snapshot_time_(),
       initialized_() {
 }
 
 ProcessSnapshotWin::~ProcessSnapshotWin() {
 }
@@ skipping 10 matching lines @@
   system_.Initialize(&process_reader_);
 
   if (process_reader_.Is64Bit())
     InitializePebData<process_types::internal::Traits64>();
   else
     InitializePebData<process_types::internal::Traits32>();
 
   InitializeThreads();
   InitializeModules();
 
+  for (const MEMORY_BASIC_INFORMATION64& mbi :
+       process_reader_.GetProcessInfo().MemoryInfo()) {
+    memory_map_.push_back(new internal::MemoryMapRegionSnapshotWin(mbi));
+  }
+
   INITIALIZATION_STATE_SET_VALID(initialized_);
   return true;
 }
 
 bool ProcessSnapshotWin::InitializeException(
     WinVMAddress exception_information_address) {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   DCHECK(!exception_);
 
   ExceptionInformation exception_information;
@@ skipping 107 matching lines @@
   for (internal::ModuleSnapshotWin* module : modules_) {
     modules.push_back(module);
   }
   return modules;
 }
 
 const ExceptionSnapshot* ProcessSnapshotWin::Exception() const {
   return exception_.get();
 }
 
+std::vector<const MemoryMapRegionSnapshot*> ProcessSnapshotWin::MemoryMap()
+    const {
+  std::vector<const MemoryMapRegionSnapshot*> memory_map;
+  for (const auto& item : memory_map_)
+    memory_map.push_back(item);
+  return memory_map;
+}
+
 std::vector<const MemorySnapshot*> ProcessSnapshotWin::ExtraMemory() const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   std::vector<const MemorySnapshot*> extra_memory;
   for (const auto& peb_memory : peb_memory_)
     extra_memory.push_back(peb_memory);
   return extra_memory;
 }
 
 void ProcessSnapshotWin::InitializeThreads() {
   const std::vector<ProcessReaderWin::Thread>& process_reader_threads =
@@ skipping 178 matching lines @@
       static_cast<unsigned int>(bytes_read / sizeof(env_block[0])));
   const wchar_t terminator[] = { 0, 0 };
   size_t at = env_block.find(std::wstring(terminator, arraysize(terminator)));
   if (at != std::wstring::npos)
     env_block.resize(at + arraysize(terminator));
 
   return env_block.size() * sizeof(env_block[0]);
 }
 
 }  // namespace crashpad