Refactor MachMultiprocess

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 49 matching lines @@
 }
 
 const char kTestMemory[] = "Read me from another process";
 
 class ProcessReaderChild final : public MachMultiprocess {
  public:
   ProcessReaderChild() : MachMultiprocess() {}
 
   ~ProcessReaderChild() {}
 
- protected:
-  void Parent() override {
+ private:
+  void MachMultiprocessParent() override {
     ProcessReader process_reader;
     ASSERT_TRUE(process_reader.Initialize(ChildTask()));
 
 #if !defined(ARCH_CPU_64_BITS)
     EXPECT_FALSE(process_reader.Is64Bit());
 #else
     EXPECT_TRUE(process_reader.Is64Bit());
 #endif
 
     EXPECT_EQ(getpid(), process_reader.ParentProcessID());
@@ skipping 11 matching lines @@
     EXPECT_EQ(kTestMemory, read_string);
 
     // 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';
     rv = WriteFD(write_fd, &c, 1);
     ASSERT_EQ(1, rv) << ErrnoMessage("write");
   }
 
-  void Child() override {
+  void MachMultiprocessChild() override {
     int write_fd = WritePipeFD();
 
     mach_vm_address_t address =
         reinterpret_cast<mach_vm_address_t>(kTestMemory);
     int rv = WriteFD(write_fd, &address, sizeof(address));
     ASSERT_EQ(static_cast<ssize_t>(sizeof(address)), rv)
         << ErrnoMessage("write");
 
     // Wait for the parent to say that it’s OK to exit.
     int read_fd = ReadPipeFD();
     char c;
     rv = ReadFD(read_fd, &c, 1);
     ASSERT_EQ(1, rv) << ErrnoMessage("read");
   }
 
- private:
   DISALLOW_COPY_AND_ASSIGN(ProcessReaderChild);
 };
 
 TEST(ProcessReader, ChildBasic) {
   ProcessReaderChild process_reader_child;
   process_reader_child.Run();
 }
 
 // Returns a thread ID given a pthread_t. This wraps pthread_threadid_np() but
 // that function has a cumbersome interface because it returns a success value.
@@ skipping 297 matching lines @@
 
 class ProcessReaderThreadedChild final : public MachMultiprocess {
  public:
   explicit ProcessReaderThreadedChild(size_t thread_count)
       : MachMultiprocess(),
         thread_count_(thread_count) {
   }
 
   ~ProcessReaderThreadedChild() {}
 
- protected:
-  void Parent() override {
+ private:
+  void MachMultiprocessParent() override {
     ProcessReader process_reader;
     ASSERT_TRUE(process_reader.Initialize(ChildTask()));
 
     int read_fd = ReadPipeFD();
 
     // Build a map of all expected threads, keyed by each thread’s ID, and with
     // addresses that should lie somewhere within each thread’s stack as values.
     // These IDs and addresses all come from the child process via the pipe.
     ThreadMap thread_map;
     for (size_t thread_index = 0;
@@ skipping 30 matching lines @@
     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';
     int rv = WriteFD(write_fd, &c, 1);
     ASSERT_EQ(1, rv) << ErrnoMessage("write");
   }
 
-  void Child() override {
+  void MachMultiprocessChild() override {
     TestThreadPool thread_pool;
     thread_pool.StartThreads(thread_count_);
     if (testing::Test::HasFatalFailure()) {
       return;
     }
 
     int write_fd = WritePipeFD();
 
     // This thread isn’t part of the thread pool, but the parent will be able
     // to inspect it. Write an entry for it.
@@ skipping 43 matching lines @@
           << ErrnoMessage("write");
     }
 
     // Wait for the parent to say that it’s OK to exit.
     int read_fd = ReadPipeFD();
     char c;
     rv = ReadFD(read_fd, &c, 1);
     ASSERT_EQ(1, rv) << ErrnoMessage("read");
   }
 
- private:
   size_t thread_count_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcessReaderThreadedChild);
 };
 
 TEST(ProcessReader, ChildOneThread) {
   // The main thread plus zero child threads equals one thread.
   const size_t kChildThreads = 0;
   ProcessReaderThreadedChild process_reader_threaded_child(kChildThreads);
   process_reader_threaded_child.Run();
 }
 
 TEST(ProcessReader, ChildSeveralThreads) {
   const size_t kChildThreads = 64;
   ProcessReaderThreadedChild process_reader_threaded_child(kChildThreads);
   process_reader_threaded_child.Run();
 }
 
 }  // namespace