win: make CrashpadInfo retrievable

util/win/process_info.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 113 matching lines @@
   if (!ReadUnicodeString(process,
                          process_parameters.CommandLine,
                          &process_info->command_line_)) {
     return false;
   }
 
   process_types::PEB_LDR_DATA<Traits> peb_ldr_data;
   if (!ReadStruct(process, peb.Ldr, &peb_ldr_data))
     return false;
 
-  std::wstring module;
   process_types::LDR_DATA_TABLE_ENTRY<Traits> ldr_data_table_entry;
 
   // Include the first module in the memory order list to get our the main
   // executable's name, as it's not included in initialization order below.
   if (!ReadStruct(process,
                   reinterpret_cast<uintptr_t>(
                       reinterpret_cast<const char*>(
                           peb_ldr_data.InMemoryOrderModuleList.Flink) -
                       offsetof(process_types::LDR_DATA_TABLE_ENTRY<Traits>,
                                InMemoryOrderLinks)),
                   &ldr_data_table_entry)) {
     return false;
   }
-  if (!ReadUnicodeString(process, ldr_data_table_entry.FullDllName, &module))
+  ProcessInfo::Module module;
+  if (!ReadUnicodeString(
+          process, ldr_data_table_entry.FullDllName, &module.name)) {
     return false;
+  }
+  module.dll_base = ldr_data_table_entry.DllBase;
+  module.timestamp = ldr_data_table_entry.TimeDateStamp;
   process_info->modules_.push_back(module);
 
   // Walk the PEB LDR structure (doubly-linked list) to get the list of loaded
   // modules. We use this method rather than EnumProcessModules to get the
   // modules in initialization order rather than memory order.
   Traits::Pointer last = peb_ldr_data.InInitializationOrderModuleList.Blink;
   for (Traits::Pointer cur = peb_ldr_data.InInitializationOrderModuleList.Flink;
        ;
        cur = ldr_data_table_entry.InInitializationOrderLinks.Flink) {
     // |cur| is the pointer to the LIST_ENTRY embedded in the
     // LDR_DATA_TABLE_ENTRY, in the target process's address space. So we need
     // to read from the target, and also offset back to the beginning of the
     // structure.
     if (!ReadStruct(process,
                     reinterpret_cast<uintptr_t>(
                         reinterpret_cast<const char*>(cur) -
                         offsetof(process_types::LDR_DATA_TABLE_ENTRY<Traits>,
                                  InInitializationOrderLinks)),
                     &ldr_data_table_entry)) {
       break;
     }
-    // TODO(scottmg): Capture TimeDateStamp, Checksum, etc. too?
-    if (!ReadUnicodeString(process, ldr_data_table_entry.FullDllName, &module))
+    // TODO(scottmg): Capture Checksum, etc. too?
+    if (!ReadUnicodeString(
+            process, ldr_data_table_entry.FullDllName, &module.name)) {
       break;
+    }
+    module.dll_base = ldr_data_table_entry.DllBase;
+    module.timestamp = ldr_data_table_entry.TimeDateStamp;
     process_info->modules_.push_back(module);
     if (cur == last)
       break;
   }
 
   return true;
 }
 
+ProcessInfo::Module::Module() : name(), timestamp(0) {

[Mark Mentovai, 2015/04/29 19:37:16]

dll_base(0)

[scottmg, 2015/04/30 03:31:32]

Done.

+}
+
+ProcessInfo::Module::~Module() {
+}
+
 ProcessInfo::ProcessInfo()
     : process_id_(),
       inherited_from_process_id_(),
       command_line_(),
       modules_(),
       is_64_bit_(false),
       is_wow64_(false),
       initialized_() {
 }
 
@@ skipping 110 matching lines @@
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   return inherited_from_process_id_;
 }
 
 bool ProcessInfo::CommandLine(std::wstring* command_line) const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   *command_line = command_line_;
   return true;
 }
 
-bool ProcessInfo::Modules(std::vector<std::wstring>* modules) const {
+bool ProcessInfo::Modules(std::vector<Module>* modules) const {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
   *modules = modules_;
   return true;
 }
 
 }  // namespace crashpad