Use references instead of pointers for CPU context in SimulateCrash

client/simulate_crash_mac.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 41 matching lines @@
 //!     handler. If `false`, this will be suppressed, even when \a behavior
 //!     indicates that the handler receives and returns a thread state.
 //!
 //! \return `true` if the exception was delivered to the handler and the handler
 //!     indicated success. `false` otherwise, with a warning message logged.
 bool DeliverException(thread_t thread,
                       task_t task,
                       exception_type_t exception,
                       const mach_exception_data_t code,
                       mach_msg_type_number_t code_count,
-                      const NativeCPUContext* cpu_context,
+                      const NativeCPUContext& cpu_context,
                       const ExceptionPorts::ExceptionHandler& handler,
                       bool set_state) {
   kern_return_t kr;
 
   bool handler_wants_state = ExceptionBehaviorHasState(handler.behavior);
   if (!handler_wants_state) {
     // Regardless of the passed-in value of |set_state|, if the handler won’t be
     // dealing with any state at all, no state should be set.
     set_state = false;
   }
 
   // old_state is only used if the context already captured doesn’t match (or
   // can’t be converted to) what’s registered for the handler.
   thread_state_data_t old_state;
 
   thread_state_flavor_t flavor = handler.flavor;
   ConstThreadState state;
   mach_msg_type_number_t state_count;
   switch (flavor) {
 #if defined(ARCH_CPU_X86_FAMILY)
     case x86_THREAD_STATE:
-      state = reinterpret_cast<ConstThreadState>(cpu_context);
+      state = reinterpret_cast<ConstThreadState>(&cpu_context);
       state_count = x86_THREAD_STATE_COUNT;
       break;
 #if defined(ARCH_CPU_X86)
     case x86_THREAD_STATE32:
-      state = reinterpret_cast<ConstThreadState>(&cpu_context->uts.ts32);
-      state_count = cpu_context->tsh.count;
+      state = reinterpret_cast<ConstThreadState>(&cpu_context.uts.ts32);
+      state_count = cpu_context.tsh.count;
       break;
 #elif defined(ARCH_CPU_X86_64)
     case x86_THREAD_STATE64:
-      state = reinterpret_cast<ConstThreadState>(&cpu_context->uts.ts64);
-      state_count = cpu_context->tsh.count;
+      state = reinterpret_cast<ConstThreadState>(&cpu_context.uts.ts64);
+      state_count = cpu_context.tsh.count;
       break;
 #endif
 #else
 #error Port to your CPU architecture
 #endif
 
     case THREAD_STATE_NONE:
       // This is only acceptable if the handler doesn’t have one of the “state”
       // behaviors. Otherwise, if the kernel were attempting to send an
       // exception message to this port, it would call thread_getstatus() (known
@@ skipping 63 matching lines @@
   if (kr == KERN_SUCCESS && set_state) {
     kr = thread_set_state(thread, flavor, new_state, new_state_count);
     MACH_LOG_IF(WARNING, kr != KERN_SUCCESS, kr) << "thread_set_state";
   }
 
   return success;
 }
 
 }  // namespace
 
-void SimulateCrash(const NativeCPUContext* cpu_context) {
+void SimulateCrash(const NativeCPUContext& cpu_context) {
 #if defined(ARCH_CPU_X86)
-  DCHECK_EQ(cpu_context->tsh.flavor,
+  DCHECK_EQ(cpu_context.tsh.flavor,
             implicit_cast<thread_state_flavor_t>(x86_THREAD_STATE32));
-  DCHECK_EQ(implicit_cast<mach_msg_type_number_t>(cpu_context->tsh.count),
+  DCHECK_EQ(implicit_cast<mach_msg_type_number_t>(cpu_context.tsh.count),
             x86_THREAD_STATE32_COUNT);
 #elif defined(ARCH_CPU_X86_64)
-  DCHECK_EQ(cpu_context->tsh.flavor,
+  DCHECK_EQ(cpu_context.tsh.flavor,
             implicit_cast<thread_state_flavor_t>(x86_THREAD_STATE64));
-  DCHECK_EQ(implicit_cast<mach_msg_type_number_t>(cpu_context->tsh.count),
+  DCHECK_EQ(implicit_cast<mach_msg_type_number_t>(cpu_context.tsh.count),
             x86_THREAD_STATE64_COUNT);
 #endif
 
   base::mac::ScopedMachSendRight thread(mach_thread_self());
   exception_type_t exception = kMachExceptionSimulated;
   mach_exception_data_type_t codes[] = {0, 0};
   mach_msg_type_number_t code_count = arraysize(codes);
 
   // Look up the handler for EXC_CRASH exceptions in the same way that the
   // kernel would: try a thread handler, then a task handler, and finally a host
@@ skipping 34 matching lines @@
                                    false);
       }
     }
   }
 
   LOG_IF(WARNING, !success)
       << "SimulateCrash did not find an appropriate exception handler";
 }
 
 }  // namespace crashpad