Don’t trigger EXC_CORPSE_NOTIFY on OS X 10.11

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 <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/mac/mac_util.h"
 #include "util/mach/exception_behaviors.h"
 #include "util/mach/exception_types.h"
 #include "util/mach/mach_message.h"
 
 namespace crashpad {
 namespace test {
 namespace {
 
 using testing::DefaultValue;
 using testing::Eq;
@@ skipping 993 matching lines @@
     }
 
     EXPECT_EQ(implicit_cast<mach_msg_trailer_type_t>(MACH_MSG_TRAILER_FORMAT_0),
               trailer->msgh_trailer_type);
     EXPECT_EQ(REQUESTED_TRAILER_SIZE(kMachMessageOptions),
               trailer->msgh_trailer_size);
 
     ExcServerCopyState(
         behavior, old_state, old_state_count, new_state, new_state_count);
 
-    return ExcServerSuccessfulReturnValue(behavior, false);
+    return ExcServerSuccessfulReturnValue(exception, behavior, false);
   }
 
  private:
   // MachMultiprocess:
 
   void MachMultiprocessParent() override {
     UniversalMachExcServer universal_mach_exc_server(this);
 
     kern_return_t kr =
         MachMessageServer::Run(&universal_mach_exc_server,
@@ skipping 130 matching lines @@
 
     TestExcServerVariants test_exc_server_variants(
         MACH_EXCEPTION_CODES | EXCEPTION_STATE_IDENTITY,
         test.flavor,
         test.count);
     test_exc_server_variants.Run();
   }
 }
 
 TEST(ExcServerVariants, ExcServerSuccessfulReturnValue) {
+  const kern_return_t prefer_not_set_thread_state =
+      MacOSXMinorVersion() < 11 ? MACH_RCV_PORT_DIED : KERN_SUCCESS;
+
   struct TestData {
+    exception_type_t exception;
     exception_behavior_t behavior;
     bool set_thread_state;
     kern_return_t kr;
   };
   const TestData kTestData[] = {
-      {EXCEPTION_DEFAULT, false, KERN_SUCCESS},
-      {EXCEPTION_STATE, false, MACH_RCV_PORT_DIED},
-      {EXCEPTION_STATE_IDENTITY, false, MACH_RCV_PORT_DIED},
-      {kMachExceptionCodes | EXCEPTION_DEFAULT, false, KERN_SUCCESS},
-      {kMachExceptionCodes | EXCEPTION_STATE, false, MACH_RCV_PORT_DIED},
-      {kMachExceptionCodes | EXCEPTION_STATE_IDENTITY,
+      {EXC_CRASH, EXCEPTION_DEFAULT, false, KERN_SUCCESS},
+      {EXC_CRASH, EXCEPTION_STATE, false, prefer_not_set_thread_state},
+      {EXC_CRASH, EXCEPTION_STATE_IDENTITY, false, prefer_not_set_thread_state},
+      {EXC_CRASH, kMachExceptionCodes | EXCEPTION_DEFAULT, false, KERN_SUCCESS},
+      {EXC_CRASH,
+       kMachExceptionCodes | EXCEPTION_STATE,
+       false,
+       prefer_not_set_thread_state},
+      {EXC_CRASH,
+       kMachExceptionCodes | EXCEPTION_STATE_IDENTITY,
+       false,
+       prefer_not_set_thread_state},
+      {EXC_CRASH, EXCEPTION_DEFAULT, true, KERN_SUCCESS},
+      {EXC_CRASH, EXCEPTION_STATE, true, KERN_SUCCESS},
+      {EXC_CRASH, EXCEPTION_STATE_IDENTITY, true, KERN_SUCCESS},
+      {EXC_CRASH, kMachExceptionCodes | EXCEPTION_DEFAULT, true, KERN_SUCCESS},
+      {EXC_CRASH, kMachExceptionCodes | EXCEPTION_STATE, true, KERN_SUCCESS},
+      {EXC_CRASH,
+       kMachExceptionCodes | EXCEPTION_STATE_IDENTITY,
+       true,
+       KERN_SUCCESS},
+

[Robert Sesek, 2015/09/04 17:29:49]

Extra blank line?

+      {EXC_BAD_ACCESS, EXCEPTION_DEFAULT, false, KERN_SUCCESS},
+      {EXC_BAD_INSTRUCTION, EXCEPTION_STATE, false, MACH_RCV_PORT_DIED},
+      {EXC_ARITHMETIC, EXCEPTION_STATE_IDENTITY, false, MACH_RCV_PORT_DIED},
+      {EXC_EMULATION,
+       kMachExceptionCodes | EXCEPTION_DEFAULT,
+       false,
+       KERN_SUCCESS},
+      {EXC_SOFTWARE,
+       kMachExceptionCodes | EXCEPTION_STATE,
        false,
        MACH_RCV_PORT_DIED},
-      {EXCEPTION_DEFAULT, true, KERN_SUCCESS},
-      {EXCEPTION_STATE, true, KERN_SUCCESS},
-      {EXCEPTION_STATE_IDENTITY, true, KERN_SUCCESS},
-      {kMachExceptionCodes | EXCEPTION_DEFAULT, true, KERN_SUCCESS},
-      {kMachExceptionCodes | EXCEPTION_STATE, true, KERN_SUCCESS},
-      {kMachExceptionCodes | EXCEPTION_STATE_IDENTITY, true, KERN_SUCCESS},
+      {EXC_BREAKPOINT,
+       kMachExceptionCodes | EXCEPTION_STATE_IDENTITY,
+       false,
+       MACH_RCV_PORT_DIED},
+      {EXC_SYSCALL, EXCEPTION_DEFAULT, true, KERN_SUCCESS},
+      {EXC_MACH_SYSCALL, EXCEPTION_STATE, true, KERN_SUCCESS},
+      {EXC_RPC_ALERT, EXCEPTION_STATE_IDENTITY, true, KERN_SUCCESS},
+      {EXC_RESOURCE,
+       kMachExceptionCodes | EXCEPTION_DEFAULT,
+       true,
+       KERN_SUCCESS},
+      {EXC_GUARD, kMachExceptionCodes | EXCEPTION_STATE, true, KERN_SUCCESS},
+      {EXC_CORPSE_NOTIFY,
+       kMachExceptionCodes | EXCEPTION_STATE_IDENTITY,
+       true,
+       KERN_SUCCESS},
   };
 
   for (size_t index = 0; index < arraysize(kTestData); ++index) {
     const TestData& test_data = kTestData[index];
     SCOPED_TRACE(
         base::StringPrintf("index %zu, behavior %d, set_thread_state %s",
                            index,
                            test_data.behavior,
                            test_data.set_thread_state ? "true" : "false"));
 
     EXPECT_EQ(test_data.kr,
-              ExcServerSuccessfulReturnValue(test_data.behavior,
+              ExcServerSuccessfulReturnValue(test_data.exception,
+                                             test_data.behavior,
                                              test_data.set_thread_state));
   }
 }
 
 TEST(ExcServerVariants, ExcServerCopyState) {
   const natural_t old_state[] = {1, 2, 3, 4, 5};
   natural_t new_state[10] = {};
 
   const mach_msg_type_number_t old_state_count = arraysize(old_state);
   mach_msg_type_number_t new_state_count = arraysize(new_state);
@@ skipping 61 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