Implement (and test) ProcessReader::Modules()

util/mac/process_reader.h

 // Copyright 2014 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 51 matching lines @@
   mach_port_t port;
   int suspend_count;
   int priority;
 };
 
 //! \brief Contains information about a module loaded into a process.
 struct ProcessReaderModule {
   ProcessReaderModule();
   ~ProcessReaderModule();
 
+  //! \brief The pathname used to load the module from disk.
   std::string name;
+
+  //! \brief The address where the base of the module is loaded in the remote
+  //!     process.
   mach_vm_address_t address;
+
+  //! \brief The module’s timestamp.
+  //!
+  //! This field will be `0` if its value cannot be determined. It can only be
+  //! determined for images that are loaded by dyld, so it will be `0` for the
+  //! main executable and for dyld itself.
   time_t timestamp;
 };
 
 //! \brief Accesses information about another process, identified by a Mach
 //!     task.
 class ProcessReader {
  public:
   ProcessReader();
   ~ProcessReader();
 
@@ skipping 26 matching lines @@
   //!     in system mode.
   //!
   //! \return `true` on success, `false` on failure, with a warning logged. On
   //!     failure, \a user_time and \a system_time will be set to represent no
   //!     time spent executing code in user or system mode.
   bool CPUTimes(timeval* user_time, timeval* system_time) const;
 
   //! \return Accesses the memory of the target task.
   TaskMemory* Memory() { return task_memory_.get(); }
 
-  //! \return The threads that are in the task (process).
+  //! \return The threads that are in the task (process). The first element (at
+  //!     index `0`) corresponds to the main thread.
   const std::vector<ProcessReaderThread>& Threads();
 
-  //! \return The modules loaded in the process.
+  //! \return The modules loaded in the process. The first element (at index
+  //!     `0`) corresponds to the main executable, and the final element
+  //!     corresponds to the dynamic loader, dyld.
   const std::vector<ProcessReaderModule>& Modules();
 
  private:
   //! Performs lazy initialization of the \a threads_ vector on behalf of
   //! Threads().
   void InitializeThreads();
 
   //! Performs lazy initialization of the \a modules_ vector on behalf of
   //! Modules().
   void InitializeModules();
@@ skipping 66 matching lines @@
 
   bool initialized_threads_;
   bool initialized_modules_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcessReader);
 };
 
 }  // namespace crashpad
 
 #endif  // CRASHPAD_UTIL_MAC_PROCESS_READER_H_