Make ProcessReaderModule and ProcessReaderThread nested classes

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 14 matching lines @@
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "build/build_config.h"
 #include "util/mach/task_memory.h"
 #include "util/misc/initialization_state_dcheck.h"
 
 namespace crashpad {
 
-//! \brief Contains information about a thread that belongs to a task (process).
-struct ProcessReaderThread {
-#if defined(ARCH_CPU_X86_FAMILY)
-  union ThreadContext {
-    x86_thread_state64_t t64;
-    x86_thread_state32_t t32;
-  };
-  union FloatContext {
-    x86_float_state64_t f64;
-    x86_float_state32_t f32;
-  };
-  union DebugContext {
-    x86_debug_state64_t d64;
-    x86_debug_state32_t d32;
-  };
-#endif
-
-  ProcessReaderThread();
-  ~ProcessReaderThread() {}
-
-  ThreadContext thread_context;
-  FloatContext float_context;
-  DebugContext debug_context;
-  uint64_t id;
-  mach_vm_address_t stack_region_address;
-  mach_vm_size_t stack_region_size;
-  mach_vm_address_t thread_specific_data_address;
-  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:
+  //! \brief Contains information about a thread that belongs to a task
+  //!     (process).
+  struct Thread {
+#if defined(ARCH_CPU_X86_FAMILY)
+    union ThreadContext {
+      x86_thread_state64_t t64;
+      x86_thread_state32_t t32;
+    };
+    union FloatContext {
+      x86_float_state64_t f64;
+      x86_float_state32_t f32;
+    };
+    union DebugContext {
+      x86_debug_state64_t d64;
+      x86_debug_state32_t d32;
+    };
+#endif
+
+    Thread();
+    ~Thread() {}
+
+    ThreadContext thread_context;
+    FloatContext float_context;
+    DebugContext debug_context;
+    uint64_t id;
+    mach_vm_address_t stack_region_address;
+    mach_vm_size_t stack_region_size;
+    mach_vm_address_t thread_specific_data_address;
+    mach_port_t port;
+    int suspend_count;
+    int priority;
+  };
+
+  //! \brief Contains information about a module loaded into a process.
+  struct Module {
+    Module();
+    ~Module();
+
+    //! \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;
+  };
+
   ProcessReader();
   ~ProcessReader();
 
   //! \brief Initializes this object. This method must be called before any
   //!     other.
   //!
   //! \param[in] task A send right to the target task’s task port. This object
   //!     does not take ownership of the send right.
   //!
   //! \return `true` on success, indicating that this object will respond
@@ skipping 21 matching lines @@
   //! \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). The first element (at
   //!     index `0`) corresponds to the main thread.
-  const std::vector<ProcessReaderThread>& Threads();
+  const std::vector<Thread>& Threads();
 
   //! \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();
+  const std::vector<Module>& 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 46 matching lines @@
   //!     by the initial values of \a region_base and \a region_size. The red
   //!     zone will only be allowed to extend out of the region described by
   //!     these initial values if the user tag is appropriate for stack memory
   //!     and the expanded region has the same user tag value.
   void LocateRedZone(mach_vm_address_t* start_address,
                      mach_vm_address_t* region_base,
                      mach_vm_address_t* region_size,
                      unsigned int user_tag);
 
   kinfo_proc kern_proc_info_;
-  std::vector<ProcessReaderThread> threads_;  // owns send rights
-  std::vector<ProcessReaderModule> modules_;
+  std::vector<Thread> threads_;  // owns send rights
+  std::vector<Module> modules_;
   scoped_ptr<TaskMemory> task_memory_;
   mach_port_t task_;  // weak
   InitializationStateDcheck initialized_;
 
   // This shadows a bit in kern_proc_info_, but it’s accessed so frequently that
   // it’s given a first-class field to save a few bit operations on each access.
   bool is_64_bit_;
 
   bool initialized_threads_;
   bool initialized_modules_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcessReader);
 };
 
 }  // namespace crashpad
 
 #endif  // CRASHPAD_UTIL_MAC_PROCESS_READER_H_