Use task_t, thread_t, and exception_handler_t uniformly

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 136 matching lines @@
 
   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);
 
-  mach_port_t thread_self = MachThreadSelf();
+  thread_t thread_self = MachThreadSelf();
   EXPECT_EQ(thread_self, threads[0].port);
 
   EXPECT_EQ(0, threads[0].suspend_count);
 }
 
 class TestThreadPool {
  public:
   struct ThreadExpectation {
     mach_vm_address_t stack_address;
     int suspend_count;
   };
 
   TestThreadPool() : thread_infos_() {
   }
 
   // Resumes suspended threads, signals each thread’s exit semaphore asking it
   // to exit, and joins each thread, blocking until they have all exited.
   ~TestThreadPool() {
     for (ThreadInfo* thread_info : thread_infos_) {
-      mach_port_t thread_port = pthread_mach_thread_np(thread_info->pthread);
+      thread_t thread_port = pthread_mach_thread_np(thread_info->pthread);
       while (thread_info->suspend_count > 0) {
         kern_return_t kr = thread_resume(thread_port);
         EXPECT_EQ(KERN_SUCCESS, kr) << MachErrorMessage(kr, "thread_resume");
         --thread_info->suspend_count;
       }
     }
 
     for (const ThreadInfo* thread_info : thread_infos_) {
       dispatch_semaphore_signal(thread_info->exit_semaphore);
     }
@@ skipping 25 matching lines @@
       long rv = dispatch_semaphore_wait(thread_info->ready_semaphore,
                                         DISPATCH_TIME_FOREVER);
       ASSERT_EQ(0, rv);
     }
 
     // If present, suspend the thread at indices 1 through 3 the same number of
     // times as their index. This tests reporting of suspend counts.
     for (size_t thread_index = 1;
          thread_index < thread_infos_.size() && thread_index < 4;
          ++thread_index) {
-      mach_port_t thread_port =
+      thread_t thread_port =
           pthread_mach_thread_np(thread_infos_[thread_index]->pthread);
       for (size_t suspend_count = 0;
            suspend_count < thread_index;
            ++suspend_count) {
         kern_return_t kr = thread_suspend(thread_port);
         EXPECT_EQ(KERN_SUCCESS, kr) << MachErrorMessage(kr, "thread_suspend");
         if (kr == KERN_SUCCESS) {
           ++thread_infos_[thread_index]->suspend_count;
         }
       }
@@ skipping 178 matching lines @@
 
   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.
-  mach_port_t thread_self = MachThreadSelf();
+  thread_t thread_self = MachThreadSelf();
   bool found_thread_self = false;
   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);
 }
@@ skipping 329 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ProcessReaderModulesChild);
 };
 
 TEST(ProcessReader, ChildModules) {
   ProcessReaderModulesChild process_reader_modules_child;
   process_reader_modules_child.Run();
 }
 
 }  // namespace