Add ConstThreadState to mach_extensions.h and use it everywhere

util/mach/exc_server_variants_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,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "util/mach/exc_server_variants.h"
 
 #include <mach/mach.h>
 #include <signal.h>
 #include <string.h>
 
 #include "base/strings/stringprintf.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "test/mac/mach_errors.h"
 #include "test/mac/mach_multiprocess.h"
 #include "util/mach/exception_behaviors.h"
-#include "util/mach/mach_extensions.h"
 #include "util/mach/mach_message.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
 using testing::DefaultValue;
 using testing::Eq;
 using testing::Pointee;
 using testing::Return;
@@ skipping 410 matching lines @@
     EXPECT_EQ(MIG_BAD_ID, RetCode);
   }
 };
 
 class MockUniversalMachExcServer : public UniversalMachExcServer::Interface {
  public:
   struct ConstExceptionCodes {
     const mach_exception_data_type_t* code;
     mach_msg_type_number_t code_count;
   };
-  struct ThreadState {
+  struct ThreadStateAndCount {
     thread_state_t state;
     mach_msg_type_number_t* state_count;
   };
-  struct ConstThreadState {
-    const natural_t* state;
+  struct ConstThreadStateAndCount {
+    ConstThreadState state;
     mach_msg_type_number_t* state_count;
   };
 
   // UniversalMachExcServer::Interface:
 
   // CatchMachException is the method to mock, but it has 13 parameters, and
   // gmock can only mock methods with up to 10 parameters. Coalesce some related
   // parameters together into structs, and call a mocked method.
   virtual kern_return_t CatchMachException(
       exception_behavior_t behavior,
       exception_handler_t exception_port,
       thread_t thread,
       task_t task,
       exception_type_t exception,
       const mach_exception_data_type_t* code,
       mach_msg_type_number_t code_count,
       thread_state_flavor_t* flavor,
-      const natural_t* old_state,
+      ConstThreadState old_state,
       mach_msg_type_number_t old_state_count,
       thread_state_t new_state,
       mach_msg_type_number_t* new_state_count,
       const mach_msg_trailer_t* trailer,
       bool* destroy_complex_request) override {
     *destroy_complex_request = true;
     const ConstExceptionCodes exception_codes = {code, code_count};
-    const ConstThreadState old_thread_state = {old_state, &old_state_count};
-    ThreadState new_thread_state = {new_state, new_state_count};
+    const ConstThreadStateAndCount old_thread_state = {old_state,
+                                                       &old_state_count};
+    ThreadStateAndCount new_thread_state = {new_state, new_state_count};
     return MockCatchMachException(behavior,
                                   exception_port,
                                   thread,
                                   task,
                                   exception,
                                   &exception_codes,
                                   flavor,
                                   &old_thread_state,
                                   &new_thread_state,
                                   trailer);
   }
 
   MOCK_METHOD10(MockCatchMachException,
                 kern_return_t(exception_behavior_t behavior,
                               exception_handler_t exception_port,
                               thread_t thread,
                               task_t task,
                               exception_type_t exception,
                               const ConstExceptionCodes* exception_codes,
                               thread_state_flavor_t* flavor,
-                              const ConstThreadState* old_thread_state,
-                              ThreadState* new_thread_state,
+                              const ConstThreadStateAndCount* old_thread_state,
+                              ThreadStateAndCount* new_thread_state,
                               const mach_msg_trailer_t* trailer));
 };
 
 // Matcher for ConstExceptionCodes, testing that it carries 2 codes matching
 // code_0 and code_1.
 MATCHER_P2(AreExceptionCodes, code_0, code_1, "") {
   if (!arg) {
     return false;
   }
 
   if (arg->code_count == 2 && arg->code[0] == code_0 &&
       arg->code[1] == code_1) {
     return true;
   }
 
   *result_listener << "codes (";
   for (size_t index = 0; index < arg->code_count; ++index) {
     *result_listener << arg->code[index];
     if (index < arg->code_count - 1) {
       *result_listener << ", ";
     }
   }
   *result_listener << ")";
 
   return false;
 }
 
-// Matcher for ThreadState and ConstThreadState, testing that *state_count is
-// present and matches the specified value. If 0 is specified for the count,
-// |state| must be nullptr (not present), otherwise |state| must not be nullptr
-// (present).
-MATCHER_P(IsThreadStateCount, state_count, "") {
+// Matcher for ThreadStateAndCount and ConstThreadStateAndCount, testing that
+// *state_count is present and matches the specified value. If 0 is specified
+// for the count, |state| must be nullptr (not present), otherwise |state| must
+// not be nullptr (present).
+MATCHER_P(IsThreadStateAndCount, state_count, "") {
   if (!arg) {
     return false;
   }
   if (!arg->state_count) {
     *result_listener << "state_count nullptr";
     return false;
   }
   if (*(arg->state_count) != state_count) {
     *result_listener << "*state_count " << *(arg->state_count);
     return false;
@@ skipping 45 matching lines @@
 
   EXPECT_CALL(server,
               MockCatchMachException(kExceptionBehavior,
                                      kServerLocalPort,
                                      kExceptionThreadPort,
                                      kExceptionTaskPort,
                                      kExceptionType,
                                      AreExceptionCodes(kTestExceptonCodes[0],
                                                        kTestExceptonCodes[1]),
                                      Pointee(Eq(THREAD_STATE_NONE)),
-                                     IsThreadStateCount(0u),
-                                     IsThreadStateCount(0u),
+                                     IsThreadStateAndCount(0u),
+                                     IsThreadStateAndCount(0u),
                                      Eq(&request.trailer)))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
   EXPECT_TRUE(universal_mach_exc_server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
       &destroy_complex_request));
   EXPECT_TRUE(destroy_complex_request);
@@ skipping 24 matching lines @@
   EXPECT_CALL(
       server,
       MockCatchMachException(
           kExceptionBehavior,
           kServerLocalPort,
           THREAD_NULL,
           TASK_NULL,
           kExceptionType,
           AreExceptionCodes(kTestExceptonCodes[0], kTestExceptonCodes[1]),
           Pointee(Eq(kThreadStateFlavor)),
-          IsThreadStateCount(kThreadStateFlavorCount),
-          IsThreadStateCount(arraysize(reply.new_state)),
+          IsThreadStateAndCount(kThreadStateFlavorCount),
+          IsThreadStateAndCount(arraysize(reply.new_state)),
           Eq(request.Trailer())))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
   EXPECT_TRUE(universal_mach_exc_server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
       &destroy_complex_request));
 
@@ skipping 27 matching lines @@
   EXPECT_CALL(
       server,
       MockCatchMachException(
           kExceptionBehavior,
           kServerLocalPort,
           kExceptionThreadPort,
           kExceptionTaskPort,
           kExceptionType,
           AreExceptionCodes(kTestExceptonCodes[0], kTestExceptonCodes[1]),
           Pointee(Eq(kThreadStateFlavor)),
-          IsThreadStateCount(kThreadStateFlavorCount),
-          IsThreadStateCount(arraysize(reply.new_state)),
+          IsThreadStateAndCount(kThreadStateFlavorCount),
+          IsThreadStateAndCount(arraysize(reply.new_state)),
           Eq(request.Trailer())))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
   EXPECT_TRUE(universal_mach_exc_server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
       &destroy_complex_request));
   EXPECT_TRUE(destroy_complex_request);
@@ skipping 25 matching lines @@
   EXPECT_CALL(
       server,
       MockCatchMachException(kExceptionBehavior,
                              kServerLocalPort,
                              kExceptionThreadPort,
                              kExceptionTaskPort,
                              kExceptionType,
                              AreExceptionCodes(kTestMachExceptionCodes[0],
                                                kTestMachExceptionCodes[1]),
                              Pointee(Eq(THREAD_STATE_NONE)),
-                             IsThreadStateCount(0u),
-                             IsThreadStateCount(0u),
+                             IsThreadStateAndCount(0u),
+                             IsThreadStateAndCount(0u),
                              Eq(&request.trailer)))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
   EXPECT_TRUE(universal_mach_exc_server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
       &destroy_complex_request));
   EXPECT_TRUE(destroy_complex_request);
@@ skipping 25 matching lines @@
   EXPECT_CALL(
       server,
       MockCatchMachException(kExceptionBehavior,
                              kServerLocalPort,
                              THREAD_NULL,
                              TASK_NULL,
                              kExceptionType,
                              AreExceptionCodes(kTestMachExceptionCodes[0],
                                                kTestMachExceptionCodes[1]),
                              Pointee(Eq(kThreadStateFlavor)),
-                             IsThreadStateCount(kThreadStateFlavorCount),
-                             IsThreadStateCount(arraysize(reply.new_state)),
+                             IsThreadStateAndCount(kThreadStateFlavorCount),
+                             IsThreadStateAndCount(arraysize(reply.new_state)),
                              Eq(request.Trailer())))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
   EXPECT_TRUE(universal_mach_exc_server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
       &destroy_complex_request));
 
@@ skipping 28 matching lines @@
   EXPECT_CALL(
       server,
       MockCatchMachException(kExceptionBehavior,
                              kServerLocalPort,
                              kExceptionThreadPort,
                              kExceptionTaskPort,
                              kExceptionType,
                              AreExceptionCodes(kTestMachExceptionCodes[0],
                                                kTestMachExceptionCodes[1]),
                              Pointee(Eq(kThreadStateFlavor)),
-                             IsThreadStateCount(kThreadStateFlavorCount),
-                             IsThreadStateCount(arraysize(reply.new_state)),
+                             IsThreadStateAndCount(kThreadStateFlavorCount),
+                             IsThreadStateAndCount(arraysize(reply.new_state)),
                              Eq(request.Trailer())))
       .WillOnce(Return(KERN_SUCCESS))
       .RetiresOnSaturation();
 
   bool destroy_complex_request = false;
   EXPECT_TRUE(universal_mach_exc_server.MachMessageServerFunction(
       reinterpret_cast<mach_msg_header_t*>(&request),
       reinterpret_cast<mach_msg_header_t*>(&reply),
       &destroy_complex_request));
   EXPECT_TRUE(destroy_complex_request);
@@ skipping 108 matching lines @@
 
   virtual kern_return_t CatchMachException(
       exception_behavior_t behavior,
       exception_handler_t exception_port,
       thread_t thread,
       task_t task,
       exception_type_t exception,
       const mach_exception_data_type_t* code,
       mach_msg_type_number_t code_count,
       thread_state_flavor_t* flavor,
-      const natural_t* old_state,
+      ConstThreadState old_state,
       mach_msg_type_number_t old_state_count,
       thread_state_t new_state,
       mach_msg_type_number_t* new_state_count,
       const mach_msg_trailer_t* trailer,
       bool* destroy_complex_request) override {
     *destroy_complex_request = true;
 
     EXPECT_FALSE(handled_);
     handled_ = true;
 
@@ skipping 358 matching lines @@
     EXPECT_EQ(old_state[i], new_state[i]) << "i " << i;
   }
   for (size_t i = arraysize(old_state); i < arraysize(new_state); ++i) {
     EXPECT_EQ(0u, new_state[i]) << "i " << i;
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad