Add ConstThreadState to mach_extensions.h and use it everywhere

snapshot/mac/cpu_context_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 65 matching lines @@
 // x86_THREAD_STATE32, x86_FLOAT_STATE32, and x86_DEBUG_STATE32 flavors. It also
 // handles the universal x86_THREAD_STATE, x86_FLOAT_STATE, and x86_DEBUG_STATE
 // flavors provided that the associated structure carries 32-bit data of the
 // corresponding state type. |flavor| may be THREAD_STATE_NONE to avoid setting
 // any thread state in |context|. This returns the architecture-specific flavor
 // value for the thread state that was actually set, or THREAD_STATE_NONE if no
 // thread state was set.
 thread_state_flavor_t InitializeCPUContextX86Flavor(
     CPUContextX86* context,
     thread_state_flavor_t flavor,
-    const natural_t* state,
+    ConstThreadState state,
     mach_msg_type_number_t state_count) {
   mach_msg_type_number_t expected_state_count;
   switch (flavor) {
     case x86_THREAD_STATE:
       expected_state_count = x86_THREAD_STATE_COUNT;
       break;
     case x86_FLOAT_STATE:
       expected_state_count = x86_FLOAT_STATE_COUNT;
       break;
     case x86_DEBUG_STATE:
@@ skipping 27 matching lines @@
       const x86_thread_state_t* x86_thread_state =
           reinterpret_cast<const x86_thread_state_t*>(state);
       if (x86_thread_state->tsh.flavor != x86_THREAD_STATE32) {
         LOG(WARNING) << "expected flavor x86_THREAD_STATE32, observed "
                      << x86_thread_state->tsh.flavor;
         return THREAD_STATE_NONE;
       }
       return InitializeCPUContextX86Flavor(
           context,
           x86_thread_state->tsh.flavor,
-          reinterpret_cast<const natural_t*>(&x86_thread_state->uts.ts32),
+          reinterpret_cast<ConstThreadState>(&x86_thread_state->uts.ts32),
           x86_thread_state->tsh.count);
     }
 
     case x86_FLOAT_STATE: {
       const x86_float_state_t* x86_float_state =
           reinterpret_cast<const x86_float_state_t*>(state);
       if (x86_float_state->fsh.flavor != x86_FLOAT_STATE32) {
         LOG(WARNING) << "expected flavor x86_FLOAT_STATE32, observed "
                      << x86_float_state->fsh.flavor;
         return THREAD_STATE_NONE;
       }
       return InitializeCPUContextX86Flavor(
           context,
           x86_float_state->fsh.flavor,
-          reinterpret_cast<const natural_t*>(&x86_float_state->ufs.fs32),
+          reinterpret_cast<ConstThreadState>(&x86_float_state->ufs.fs32),
           x86_float_state->fsh.count);
     }
 
     case x86_DEBUG_STATE: {
       const x86_debug_state_t* x86_debug_state =
           reinterpret_cast<const x86_debug_state_t*>(state);
       if (x86_debug_state->dsh.flavor != x86_DEBUG_STATE32) {
         LOG(WARNING) << "expected flavor x86_DEBUG_STATE32, observed "
                      << x86_debug_state->dsh.flavor;
         return THREAD_STATE_NONE;
       }
       return InitializeCPUContextX86Flavor(
           context,
           x86_debug_state->dsh.flavor,
-          reinterpret_cast<const natural_t*>(&x86_debug_state->uds.ds32),
+          reinterpret_cast<ConstThreadState>(&x86_debug_state->uds.ds32),
           x86_debug_state->dsh.count);
     }
 
     case x86_THREAD_STATE32: {
       const x86_thread_state32_t* x86_thread_state32 =
           reinterpret_cast<const x86_thread_state32_t*>(state);
       InitializeCPUContextX86Thread(context, x86_thread_state32);
       return flavor;
     }
 
@@ skipping 82 matching lines @@
 // x86_THREAD_STATE64, x86_FLOAT_STATE64, and x86_DEBUG_STATE64 flavors. It also
 // handles the universal x86_THREAD_STATE, x86_FLOAT_STATE, and x86_DEBUG_STATE
 // flavors provided that the associated structure carries 64-bit data of the
 // corresponding state type. |flavor| may be THREAD_STATE_NONE to avoid setting
 // any thread state in |context|. This returns the architecture-specific flavor
 // value for the thread state that was actually set, or THREAD_STATE_NONE if no
 // thread state was set.
 thread_state_flavor_t InitializeCPUContextX86_64Flavor(
     CPUContextX86_64* context,
     thread_state_flavor_t flavor,
-    const natural_t* state,
+    ConstThreadState state,
     mach_msg_type_number_t state_count) {
   mach_msg_type_number_t expected_state_count;
   switch (flavor) {
     case x86_THREAD_STATE:
       expected_state_count = x86_THREAD_STATE_COUNT;
       break;
     case x86_FLOAT_STATE:
       expected_state_count = x86_FLOAT_STATE_COUNT;
       break;
     case x86_DEBUG_STATE:
@@ skipping 27 matching lines @@
       const x86_thread_state_t* x86_thread_state =
           reinterpret_cast<const x86_thread_state_t*>(state);
       if (x86_thread_state->tsh.flavor != x86_THREAD_STATE64) {
         LOG(WARNING) << "expected flavor x86_THREAD_STATE64, observed "
                      << x86_thread_state->tsh.flavor;
         return THREAD_STATE_NONE;
       }
       return InitializeCPUContextX86_64Flavor(
           context,
           x86_thread_state->tsh.flavor,
-          reinterpret_cast<const natural_t*>(&x86_thread_state->uts.ts64),
+          reinterpret_cast<ConstThreadState>(&x86_thread_state->uts.ts64),
           x86_thread_state->tsh.count);
     }
 
     case x86_FLOAT_STATE: {
       const x86_float_state_t* x86_float_state =
           reinterpret_cast<const x86_float_state_t*>(state);
       if (x86_float_state->fsh.flavor != x86_FLOAT_STATE64) {
         LOG(WARNING) << "expected flavor x86_FLOAT_STATE64, observed "
                      << x86_float_state->fsh.flavor;
         return THREAD_STATE_NONE;
       }
       return InitializeCPUContextX86_64Flavor(
           context,
           x86_float_state->fsh.flavor,
-          reinterpret_cast<const natural_t*>(&x86_float_state->ufs.fs64),
+          reinterpret_cast<ConstThreadState>(&x86_float_state->ufs.fs64),
           x86_float_state->fsh.count);
     }
 
     case x86_DEBUG_STATE: {
       const x86_debug_state_t* x86_debug_state =
           reinterpret_cast<const x86_debug_state_t*>(state);
       if (x86_debug_state->dsh.flavor != x86_DEBUG_STATE64) {
         LOG(WARNING) << "expected flavor x86_DEBUG_STATE64, observed "
                      << x86_debug_state->dsh.flavor;
         return THREAD_STATE_NONE;
       }
       return InitializeCPUContextX86_64Flavor(
           context,
           x86_debug_state->dsh.flavor,
-          reinterpret_cast<const natural_t*>(&x86_debug_state->uds.ds64),
+          reinterpret_cast<ConstThreadState>(&x86_debug_state->uds.ds64),
           x86_debug_state->dsh.count);
     }
 
     case x86_THREAD_STATE64: {
       const x86_thread_state64_t* x86_thread_state64 =
           reinterpret_cast<const x86_thread_state64_t*>(state);
       InitializeCPUContextX86_64Thread(context, x86_thread_state64);
       return flavor;
     }
 
@@ skipping 24 matching lines @@
     }
   }
 }
 
 }  // namespace
 
 namespace internal {
 
 void InitializeCPUContextX86(CPUContextX86* context,
                              thread_state_flavor_t flavor,
-                             const natural_t* state,
+                             ConstThreadState state,
                              mach_msg_type_number_t state_count,
                              const x86_thread_state32_t* x86_thread_state32,
                              const x86_float_state32_t* x86_float_state32,
                              const x86_debug_state32_t* x86_debug_state32) {
   thread_state_flavor_t set_flavor = THREAD_STATE_NONE;
   if (flavor != THREAD_STATE_NONE) {
     set_flavor =
         InitializeCPUContextX86Flavor(context, flavor, state, state_count);
   }
 
   if (set_flavor != x86_THREAD_STATE32) {
     InitializeCPUContextX86Thread(context, x86_thread_state32);
   }
   if (set_flavor != x86_FLOAT_STATE32) {
     InitializeCPUContextX86Float(context, x86_float_state32);
   }
   if (set_flavor != x86_DEBUG_STATE32) {
     InitializeCPUContextX86Debug(context, x86_debug_state32);
   }
 }
 
 void InitializeCPUContextX86_64(CPUContextX86_64* context,
                                 thread_state_flavor_t flavor,
-                                const natural_t* state,
+                                ConstThreadState state,
                                 mach_msg_type_number_t state_count,
                                 const x86_thread_state64_t* x86_thread_state64,
                                 const x86_float_state64_t* x86_float_state64,
                                 const x86_debug_state64_t* x86_debug_state64) {
   thread_state_flavor_t set_flavor = THREAD_STATE_NONE;
   if (flavor != THREAD_STATE_NONE) {
     set_flavor =
         InitializeCPUContextX86_64Flavor(context, flavor, state, state_count);
   }
 
   if (set_flavor != x86_THREAD_STATE64) {
     InitializeCPUContextX86_64Thread(context, x86_thread_state64);
   }
   if (set_flavor != x86_FLOAT_STATE64) {
     InitializeCPUContextX86_64Float(context, x86_float_state64);
   }
   if (set_flavor != x86_DEBUG_STATE64) {
     InitializeCPUContextX86_64Debug(context, x86_debug_state64);
   }
 }
 
 }  // namespace internal
 
 #endif
 
 }  // namespace crashpad