Make ProcessReaderModule and ProcessReaderThread nested classes

util/mac/process_reader_test.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 126 matching lines @@
   uint64_t thread_id;
   int rv = pthread_threadid_np(pthread, &thread_id);
   CHECK_EQ(rv, 0);
   return thread_id;
 }
 
 TEST(ProcessReader, SelfOneThread) {
   ProcessReader process_reader;
   ASSERT_TRUE(process_reader.Initialize(mach_task_self()));
 
-  const std::vector<ProcessReaderThread>& threads = process_reader.Threads();
+  const std::vector<ProcessReader::Thread>& threads = process_reader.Threads();
 
   // If other tests ran in this process previously, threads may have been
   // created and may still be running. This check must look for at least one
   // thread, not exactly one thread.
   ASSERT_GE(threads.size(), 1u);
 
   EXPECT_EQ(PthreadToThreadID(pthread_self()), threads[0].id);
 
   base::mac::ScopedMachSendRight thread_self(mach_thread_self());
   EXPECT_EQ(thread_self, threads[0].port);
@@ skipping 150 matching lines @@
 
 typedef std::map<uint64_t, TestThreadPool::ThreadExpectation> ThreadMap;
 
 // Verifies that all of the threads in |threads|, obtained from ProcessReader,
 // agree with the expectation in |thread_map|. If |tolerate_extra_threads| is
 // true, |threads| is allowed to contain threads that are not listed in
 // |thread_map|. This is useful when testing situations where code outside of
 // the test’s control (such as system libraries) may start threads, or may have
 // started threads prior to a test’s execution.
 void ExpectSeveralThreads(ThreadMap* thread_map,
-                          const std::vector<ProcessReaderThread>& threads,
+                          const std::vector<ProcessReader::Thread>& threads,
                           const bool tolerate_extra_threads) {
   if (tolerate_extra_threads) {
     ASSERT_GE(threads.size(), thread_map->size());
   } else {
     ASSERT_EQ(thread_map->size(), threads.size());
   }
 
   for (size_t thread_index = 0; thread_index < threads.size(); ++thread_index) {
-    const ProcessReaderThread& thread = threads[thread_index];
+    const ProcessReader::Thread& thread = threads[thread_index];
     mach_vm_address_t thread_stack_region_end =
         thread.stack_region_address + thread.stack_region_size;
 
     const auto& iterator = thread_map->find(thread.id);
     if (!tolerate_extra_threads) {
       // Make sure that the thread is in the expectation map.
       ASSERT_NE(thread_map->end(), iterator);
     }
 
     if (iterator != thread_map->end()) {
@@ skipping 12 matching lines @@
     // with any other thread’s. Each thread should have a unique value for its
     // ID and port, and each should have its own stack that doesn’t touch any
     // other thread’s stack.
     for (size_t other_thread_index = 0;
          other_thread_index < threads.size();
          ++other_thread_index) {
       if (thread_index == other_thread_index) {
         continue;
       }
 
-      const ProcessReaderThread& other_thread = threads[other_thread_index];
+      const ProcessReader::Thread& other_thread = threads[other_thread_index];
 
       EXPECT_NE(thread.id, other_thread.id);
       EXPECT_NE(thread.port, other_thread.port);
 
       mach_vm_address_t other_thread_stack_region_end =
           other_thread.stack_region_address + other_thread.stack_region_size;
       EXPECT_FALSE(
           thread.stack_region_address >= other_thread.stack_region_address &&
           thread.stack_region_address < other_thread_stack_region_end);
       EXPECT_FALSE(
@@ skipping 31 matching lines @@
   thread_map[self_thread_id] = expectation;
   for (size_t thread_index = 0; thread_index < kChildThreads; ++thread_index) {
     uint64_t thread_id = thread_pool.GetThreadInfo(thread_index, &expectation);
 
     // There can’t be any duplicate thread IDs.
     EXPECT_EQ(0u, thread_map.count(thread_id));
 
     thread_map[thread_id] = expectation;
   }
 
-  const std::vector<ProcessReaderThread>& threads = process_reader.Threads();
+  const std::vector<ProcessReader::Thread>& threads = process_reader.Threads();
 
   // Other tests that have run previously may have resulted in the creation of
   // threads that still exist, so pass true for |tolerate_extra_threads|.
   ExpectSeveralThreads(&thread_map, threads, true);
 
   // When testing in-process, verify that when this thread shows up in the
   // vector, it has the expected thread port, and that this thread port only
   // shows up once.
   base::mac::ScopedMachSendRight thread_self(mach_thread_self());
   bool found_thread_self = false;
-  for (const ProcessReaderThread& thread : threads) {
+  for (const ProcessReader::Thread& thread : threads) {
     if (thread.port == thread_self) {
       EXPECT_FALSE(found_thread_self);
       found_thread_self = true;
       EXPECT_EQ(self_thread_id, thread.id);
     }
   }
   EXPECT_TRUE(found_thread_self);
 }
 
 class ProcessReaderThreadedChild final : public MachMultiprocess {
@@ skipping 36 matching lines @@
                   sizeof(expectation.suspend_count));
       ASSERT_EQ(static_cast<ssize_t>(sizeof(expectation.suspend_count)), rv)
           << ErrnoMessage("read");
 
       // There can’t be any duplicate thread IDs.
       EXPECT_EQ(0u, thread_map.count(thread_id));
 
       thread_map[thread_id] = expectation;
     }
 
-    const std::vector<ProcessReaderThread>& threads = process_reader.Threads();
+    const std::vector<ProcessReader::Thread>& threads = process_reader.Threads();
 
     // The child shouldn’t have any threads other than its main thread and the
     // ones it created in its pool, so pass false for |tolerate_extra_threads|.
     ExpectSeveralThreads(&thread_map, threads, false);
 
     // Tell the child that it’s OK to exit. The child needed to be kept alive
     // until the parent finished working with it.
     int write_fd = WritePipeFD();
     char c = '\0';
     ssize_t rv = WriteFD(write_fd, &c, 1);
@@ skipping 80 matching lines @@
   const size_t kChildThreads = 64;
   ProcessReaderThreadedChild process_reader_threaded_child(kChildThreads);
   process_reader_threaded_child.Run();
 }
 
 TEST(ProcessReader, SelfModules) {
   ProcessReader process_reader;
   ASSERT_TRUE(process_reader.Initialize(mach_task_self()));
 
   uint32_t dyld_image_count = _dyld_image_count();
-  const std::vector<ProcessReaderModule>& modules = process_reader.Modules();
+  const std::vector<ProcessReader::Module>& modules = process_reader.Modules();
 
   // There needs to be at least an entry for the main executable, for a dylib,
   // and for dyld.
   ASSERT_GE(modules.size(), 3u);
 
   // dyld_image_count doesn’t include an entry for dyld itself, but |modules|
   // does.
   ASSERT_EQ(dyld_image_count + 1, modules.size());
 
   for (uint32_t index = 0; index < dyld_image_count; ++index) {
@@ skipping 40 matching lines @@
  public:
   ProcessReaderModulesChild() : MachMultiprocess() {}
 
   ~ProcessReaderModulesChild() {}
 
  private:
   void MachMultiprocessParent() override {
     ProcessReader process_reader;
     ASSERT_TRUE(process_reader.Initialize(ChildTask()));
 
-    const std::vector<ProcessReaderModule>& modules = process_reader.Modules();
+    const std::vector<ProcessReader::Module>& modules =
+        process_reader.Modules();
 
     // There needs to be at least an entry for the main executable, for a dylib,
     // and for dyld.
     ASSERT_GE(modules.size(), 3u);
 
     int read_fd = ReadPipeFD();
 
     uint32_t expect_modules;
     ssize_t rv = ReadFD(read_fd, &expect_modules, sizeof(expect_modules));
     ASSERT_EQ(static_cast<ssize_t>(sizeof(expect_modules)), rv)
@@ skipping 107 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ProcessReaderModulesChild);
 };
 
 TEST(ProcessReader, ChildModules) {
   ProcessReaderModulesChild process_reader_modules_child;
   process_reader_modules_child.Run();
 }
 
 }  // namespace