Don’t trigger EXC_CORPSE_NOTIFY on OS X 10.11

util/mach/exception_ports_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 63 matching lines @@
 
     EXPECT_EQ(kExceptionMask, crash_handler[0].mask);
     EXPECT_EQ(expect_port, crash_handler[0].port);
     EXPECT_EQ(expect_behavior, crash_handler[0].behavior);
     EXPECT_EQ(expect_flavor, crash_handler[0].flavor);
   } else {
     EXPECT_TRUE(crash_handler.empty());
   }
 
   std::vector<ExceptionPorts::ExceptionHandler> handlers;
-  ASSERT_TRUE(exception_ports.GetExceptionPorts(
-      ExcMaskAll() | EXC_MASK_CRASH, &handlers));
+  ASSERT_TRUE(exception_ports.GetExceptionPorts(ExcMaskValid(), &handlers));
 
   EXPECT_GE(handlers.size(), crash_handler.size());
   bool found = false;
   for (const ExceptionPorts::ExceptionHandler& handler : handlers) {
     if ((handler.mask & kExceptionMask) != 0) {
       base::mac::ScopedMachSendRight port_owner(handler.port);
 
       EXPECT_FALSE(found);
       found = true;
       EXPECT_EQ(expect_port, handler.port);
@@ skipping 97 matching lines @@
       ExcCrashRecoverOriginalException(code[0], nullptr, &signal);
 
       // The child crashed with __builtin_trap(), which shows up as SIGILL.
       EXPECT_EQ(SIGILL, signal);
 
       SetExpectedChildTermination(kTerminationSignal, signal);
     }
 
     EXPECT_EQ(0, AuditPIDFromMachMessageTrailer(trailer));
 
-    return ExcServerSuccessfulReturnValue(behavior, false);
+    ExcServerCopyState(
+        behavior, old_state, old_state_count, new_state, new_state_count);
+    return ExcServerSuccessfulReturnValue(exception, behavior, false);
   }
 
  private:
   class Child {
    public:
     explicit Child(TestExceptionPorts* test_exception_ports)
         : test_exception_ports_(test_exception_ports),
           thread_(),
           init_semaphore_(0),
           crash_semaphore_(0) {}
@@ skipping 369 matching lines @@
   // looking for a KERN_INVALID_ARGUMENT return value. Or, on the off chance
   // that the test is being run as root, just look for KERN_SUCCESS.
   // host_set_exception_ports() is not tested, because if the test were running
   // as root and the call succeeded, it would have global effects.
 
   base::mac::ScopedMachSendRight host(mach_host_self());
   ExceptionPorts explicit_host_ports(ExceptionPorts::kTargetTypeHost, host);
   EXPECT_STREQ("host", explicit_host_ports.TargetTypeName());
 
   std::vector<ExceptionPorts::ExceptionHandler> handlers;
-  bool rv = explicit_host_ports.GetExceptionPorts(
-      ExcMaskAll() | EXC_MASK_CRASH, &handlers);
+  bool rv = explicit_host_ports.GetExceptionPorts(ExcMaskValid(), &handlers);
   if (geteuid() == 0) {
     EXPECT_TRUE(rv);
   } else {
     EXPECT_FALSE(rv);
   }
 
   ExceptionPorts implicit_host_ports(ExceptionPorts::kTargetTypeHost,
                                      HOST_NULL);
   EXPECT_STREQ("host", implicit_host_ports.TargetTypeName());
 
-  rv = implicit_host_ports.GetExceptionPorts(
-      ExcMaskAll() | EXC_MASK_CRASH, &handlers);
+  rv = implicit_host_ports.GetExceptionPorts(ExcMaskValid(), &handlers);
   if (geteuid() == 0) {
     EXPECT_TRUE(rv);
   } else {
     EXPECT_FALSE(rv);
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad