Make ProcessReaderModule and ProcessReaderThread nested classes

util/mac/process_reader.cc

 // 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 @@
     }
 
     ++*depth;
   }
 }
 
 }  // namespace
 
 namespace crashpad {
 
-ProcessReaderThread::ProcessReaderThread()
+ProcessReader::Thread::Thread()
     : thread_context(),
       float_context(),
       debug_context(),
       id(0),
       stack_region_address(0),
       stack_region_size(0),
       thread_specific_data_address(0),
       port(MACH_PORT_NULL),
       suspend_count(0),
       priority(0) {
 }
 
-ProcessReaderModule::ProcessReaderModule() : name(), address(0), timestamp(0) {
+ProcessReader::Module::Module() : name(), address(0), timestamp(0) {
 }
 
-ProcessReaderModule::~ProcessReaderModule() {
+ProcessReader::Module::~Module() {
 }
 
 ProcessReader::ProcessReader()
     : kern_proc_info_(),
       threads_(),
       modules_(),
       task_memory_(),
       task_(MACH_PORT_NULL),
       initialized_(),
       is_64_bit_(false),
       initialized_threads_(false),
       initialized_modules_(false) {
 }
 
 ProcessReader::~ProcessReader() {
-  for (const ProcessReaderThread& thread : threads_) {
+  for (const Thread& thread : threads_) {
     kern_return_t kr = mach_port_deallocate(mach_task_self(), thread.port);
     MACH_LOG_IF(ERROR, kr != KERN_SUCCESS, kr) << "mach_port_deallocate";
   }
 }
 
 bool ProcessReader::Initialize(mach_port_t task) {
   INITIALIZATION_STATE_SET_INITIALIZING(initialized_);
 
   pid_t pid;
   kern_return_t kr = pid_for_task(task, &pid);
@@ skipping 64 matching lines @@
   MachTimeValueToTimeval(task_thread_times.user_time, &thread_user_time);
   timeval thread_system_time;
   MachTimeValueToTimeval(task_thread_times.system_time, &thread_system_time);
 
   timeradd(user_time, &thread_user_time, user_time);
   timeradd(system_time, &thread_system_time, system_time);
 
   return true;
 }
 
-const std::vector<ProcessReaderThread>& ProcessReader::Threads() {
+const std::vector<ProcessReader::Thread>& ProcessReader::Threads() {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
 
   if (!initialized_threads_) {
     InitializeThreads();
   }
 
   return threads_;
 }
 
-const std::vector<ProcessReaderModule>& ProcessReader::Modules() {
+const std::vector<ProcessReader::Module>& ProcessReader::Modules() {
   INITIALIZATION_STATE_DCHECK_VALID(initialized_);
 
   if (!initialized_modules_) {
     InitializeModules();
   }
 
   return modules_;
 }
 
 void ProcessReader::InitializeThreads() {
@@ skipping 14 matching lines @@
   // by anything until they’re added to |threads_| by the loop below. Any early
   // return (or exception) that happens between here and the completion of the
   // loop below will leak thread port send rights.
   ScopedForbidReturn threads_need_owners;
 
   base::mac::ScopedMachVM threads_vm(
       reinterpret_cast<vm_address_t>(threads),
       mach_vm_round_page(thread_count * sizeof(*threads)));
 
   for (size_t index = 0; index < thread_count; ++index) {
-    ProcessReaderThread thread;
+    Thread thread;
     thread.port = threads[index];
 
 #if defined(ARCH_CPU_X86_FAMILY)
     const thread_state_flavor_t kThreadStateFlavor =
         Is64Bit() ? x86_THREAD_STATE64 : x86_THREAD_STATE32;
     mach_msg_type_number_t thread_state_count =
         Is64Bit() ? x86_THREAD_STATE64_COUNT : x86_THREAD_STATE32_COUNT;
 
     // TODO(mark): Use the AVX variants instead of the FLOAT variants? They’re
     // supported on 10.6 and later.
@@ skipping 158 matching lines @@
   if (!process_types::dyld_image_info::ReadArrayInto(this,
                                                      all_image_infos.infoArray,
                                                      image_info_vector.size(),
                                                      &image_info_vector[0])) {
     LOG(WARNING) << "could not read dyld_image_info array";
     return;
   }
 
   bool found_dyld = false;
   for (const process_types::dyld_image_info& image_info : image_info_vector) {
-    ProcessReaderModule module;
+    Module module;
     module.address = image_info.imageLoadAddress;
     module.timestamp = image_info.imageFileModDate;
     if (!task_memory_->ReadCString(image_info.imageFilePath, &module.name)) {
       LOG(WARNING) << "could not read dyld_image_info::imageFilePath";
       // Proceed anyway with an empty module name.
     }
 
     modules_.push_back(module);
 
     if (all_image_infos.version >= 2 && all_image_infos.dyldImageLoadAddress &&
@@ skipping 12 matching lines @@
   // that dyld records the timestamps of other modules when they’re loaded. (The
   // timestamp for the main executable is also not reported and appears as 0
   // even when accessed via dyld APIs, because it’s loaded by the kernel, not by
   // dyld.)
   //
   // The name can be determined, but it’s not as simple as hardcoding the
   // default "/usr/lib/dyld" because an executable could have specified anything
   // in its LC_LOAD_DYLINKER command.
   if (!found_dyld && all_image_infos.version >= 2 &&
       all_image_infos.dyldImageLoadAddress) {
-    ProcessReaderModule module;
+    Module module;
     module.address = all_image_infos.dyldImageLoadAddress;
     module.timestamp = 0;
 
     // Examine the executable’s LC_LOAD_DYLINKER load command to find the path
     // used to load dyld.
     MachOImageReader executable;
     if (all_image_infos.infoArrayCount >= 1 &&
         executable.Initialize(this, modules_[0].address, modules_[0].name) &&
         executable.FileType() == MH_EXECUTE &&
         !executable.DylinkerName().empty()) {
@@ skipping 177 matching lines @@
       // The red zone would go lower into another region in memory, but no
       // region was found. Memory can only be captured to an address as low as
       // the base address of the region already found.
       *start_address = *region_base;
     }
   }
 #endif
 }
 
 }  // namespace crashpad