C++11: Use type aliases instead of typedefs

util/mach/exc_server_variants.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 134 matching lines @@
 };
 
 // The MIG-generated __MIG_check__Request__*() functions are not declared as
 // accepting const data, but they could have been because they in fact do not
 // modify the data. These wrapper functions are provided to bridge the const gap
 // between the code in this file, which is const-correct and treats request
 // message data as const, and those generated functions.
 
 kern_return_t MIGCheckRequestExceptionRaise(
     const __Request__exception_raise_t* in_request) {
-  typedef __Request__exception_raise_t Request;
+  using Request = __Request__exception_raise_t;
   return __MIG_check__Request__exception_raise_t(
       const_cast<Request*>(in_request));
 }
 
 kern_return_t MIGCheckRequestExceptionRaiseState(
     const __Request__exception_raise_state_t* in_request,
     const __Request__exception_raise_state_t** in_request_1) {
-  typedef __Request__exception_raise_state_t Request;
+  using Request = __Request__exception_raise_state_t;
   return __MIG_check__Request__exception_raise_state_t(
       const_cast<Request*>(in_request), const_cast<Request**>(in_request_1));
 }
 
 kern_return_t MIGCheckRequestExceptionRaiseStateIdentity(
     const __Request__exception_raise_state_identity_t* in_request,
     const __Request__exception_raise_state_identity_t** in_request_1) {
-  typedef __Request__exception_raise_state_identity_t Request;
+  using Request = __Request__exception_raise_state_identity_t;
   return __MIG_check__Request__exception_raise_state_identity_t(
       const_cast<Request*>(in_request), const_cast<Request**>(in_request_1));
 }
 
 kern_return_t MIGCheckRequestMachExceptionRaise(
     const __Request__mach_exception_raise_t* in_request) {
-  typedef __Request__mach_exception_raise_t Request;
+  using Request = __Request__mach_exception_raise_t;
   return __MIG_check__Request__mach_exception_raise_t(
       const_cast<Request*>(in_request));
 }
 
 kern_return_t MIGCheckRequestMachExceptionRaiseState(
     const __Request__mach_exception_raise_state_t* in_request,
     const __Request__mach_exception_raise_state_t** in_request_1) {
-  typedef __Request__mach_exception_raise_state_t Request;
+  using Request = __Request__mach_exception_raise_state_t;
   return __MIG_check__Request__mach_exception_raise_state_t(
       const_cast<Request*>(in_request), const_cast<Request**>(in_request_1));
 }
 
 kern_return_t MIGCheckRequestMachExceptionRaiseStateIdentity(
     const __Request__mach_exception_raise_state_identity_t* in_request,
     const __Request__mach_exception_raise_state_identity_t** in_request_1) {
-  typedef __Request__mach_exception_raise_state_identity_t Request;
+  using Request = __Request__mach_exception_raise_state_identity_t;
   return __MIG_check__Request__mach_exception_raise_state_identity_t(
       const_cast<Request*>(in_request), const_cast<Request**>(in_request_1));
 }
 
 }  // namespace
 
 namespace crashpad {
 namespace internal {
 
 ExcServer::ExcServer(ExcServer::Interface* interface)
     : MachMessageServer::Interface(),
       interface_(interface) {
 }
 
 bool ExcServer::MachMessageServerFunction(const mach_msg_header_t* in_header,
                                           mach_msg_header_t* out_header,
                                           bool* destroy_complex_request) {
   PrepareReplyFromRequest(in_header, out_header);
 
   switch (in_header->msgh_id) {
     case kMachMessageIDExceptionRaise: {
       // exception_raise(), catch_exception_raise().
-      typedef __Request__exception_raise_t Request;
+      using Request = __Request__exception_raise_t;
       const Request* in_request = reinterpret_cast<const Request*>(in_header);
       kern_return_t kr = MIGCheckRequestExceptionRaise(in_request);
       if (kr != MACH_MSG_SUCCESS) {
         SetReplyError(out_header, kr);
         return true;
       }
 
-      typedef __Reply__exception_raise_t Reply;
+      using Reply = __Reply__exception_raise_t;
       Reply* out_reply = reinterpret_cast<Reply*>(out_header);
       out_reply->RetCode =
           interface_->CatchExceptionRaise(in_header->msgh_local_port,
                                           in_request->thread.name,
                                           in_request->task.name,
                                           in_request->exception,
                                           in_request->code,
                                           in_request->codeCnt,
                                           destroy_complex_request);
       if (out_reply->RetCode != KERN_SUCCESS) {
         return true;
       }
 
       out_header->msgh_size = sizeof(*out_reply);
       return true;
     }
 
     case kMachMessageIDExceptionRaiseState: {
       // exception_raise_state(), catch_exception_raise_state().
-      typedef __Request__exception_raise_state_t Request;
+      using Request = __Request__exception_raise_state_t;
       const Request* in_request = reinterpret_cast<const Request*>(in_header);
 
       // in_request_1 is used for the portion of the request after the codes,
       // which in theory can be variable-length. The check function will set it.
       const Request* in_request_1;
       kern_return_t kr =
           MIGCheckRequestExceptionRaiseState(in_request, &in_request_1);
       if (kr != MACH_MSG_SUCCESS) {
         SetReplyError(out_header, kr);
         return true;
       }
 
-      typedef __Reply__exception_raise_state_t Reply;
+      using Reply = __Reply__exception_raise_state_t;
       Reply* out_reply = reinterpret_cast<Reply*>(out_header);
       out_reply->flavor = in_request_1->flavor;
       out_reply->new_stateCnt = arraysize(out_reply->new_state);
       out_reply->RetCode =
           interface_->CatchExceptionRaiseState(in_header->msgh_local_port,
                                                in_request->exception,
                                                in_request->code,
                                                in_request->codeCnt,
                                                &out_reply->flavor,
                                                in_request_1->old_state,
                                                in_request_1->old_stateCnt,
                                                out_reply->new_state,
                                                &out_reply->new_stateCnt);
       if (out_reply->RetCode != KERN_SUCCESS) {
         return true;
       }
 
       out_header->msgh_size =
           sizeof(*out_reply) - sizeof(out_reply->new_state) +
           sizeof(out_reply->new_state[0]) * out_reply->new_stateCnt;
       return true;
     }
 
     case kMachMessageIDExceptionRaiseStateIdentity: {
       // exception_raise_state_identity(),
       // catch_exception_raise_state_identity().
-      typedef __Request__exception_raise_state_identity_t Request;
+      using Request = __Request__exception_raise_state_identity_t;
       const Request* in_request = reinterpret_cast<const Request*>(in_header);
 
       // in_request_1 is used for the portion of the request after the codes,
       // which in theory can be variable-length. The check function will set it.
       const Request* in_request_1;
       kern_return_t kr =
           MIGCheckRequestExceptionRaiseStateIdentity(in_request, &in_request_1);
       if (kr != MACH_MSG_SUCCESS) {
         SetReplyError(out_header, kr);
         return true;
       }
 
-      typedef __Reply__exception_raise_state_identity_t Reply;
+      using Reply = __Reply__exception_raise_state_identity_t;
       Reply* out_reply = reinterpret_cast<Reply*>(out_header);
       out_reply->flavor = in_request_1->flavor;
       out_reply->new_stateCnt = arraysize(out_reply->new_state);
       out_reply->RetCode = interface_->CatchExceptionRaiseStateIdentity(
           in_header->msgh_local_port,
           in_request->thread.name,
           in_request->task.name,
           in_request->exception,
           in_request->code,
           in_request->codeCnt,
@@ skipping 33 matching lines @@
 
 bool MachExcServer::MachMessageServerFunction(
     const mach_msg_header_t* in_header,
     mach_msg_header_t* out_header,
     bool* destroy_complex_request) {
   PrepareReplyFromRequest(in_header, out_header);
 
   switch (in_header->msgh_id) {
     case kMachMessageIDMachExceptionRaise: {
       // mach_exception_raise(), catch_mach_exception_raise().
-      typedef __Request__mach_exception_raise_t Request;
+      using Request = __Request__mach_exception_raise_t;
       const Request* in_request = reinterpret_cast<const Request*>(in_header);
       kern_return_t kr = MIGCheckRequestMachExceptionRaise(in_request);
       if (kr != MACH_MSG_SUCCESS) {
         SetReplyError(out_header, kr);
         return true;
       }
 
-      typedef __Reply__mach_exception_raise_t Reply;
+      using Reply = __Reply__mach_exception_raise_t;
       Reply* out_reply = reinterpret_cast<Reply*>(out_header);
       out_reply->RetCode =
           interface_->CatchMachExceptionRaise(in_header->msgh_local_port,
                                               in_request->thread.name,
                                               in_request->task.name,
                                               in_request->exception,
                                               in_request->code,
                                               in_request->codeCnt,
                                               destroy_complex_request);
       if (out_reply->RetCode != KERN_SUCCESS) {
         return true;
       }
 
       out_header->msgh_size = sizeof(*out_reply);
       return true;
     }
 
     case kMachMessageIDMachExceptionRaiseState: {
       // mach_exception_raise_state(), catch_mach_exception_raise_state().
-      typedef __Request__mach_exception_raise_state_t Request;
+      using Request = __Request__mach_exception_raise_state_t;
       const Request* in_request = reinterpret_cast<const Request*>(in_header);
 
       // in_request_1 is used for the portion of the request after the codes,
       // which in theory can be variable-length. The check function will set it.
       const Request* in_request_1;
       kern_return_t kr =
           MIGCheckRequestMachExceptionRaiseState(in_request, &in_request_1);
       if (kr != MACH_MSG_SUCCESS) {
         SetReplyError(out_header, kr);
         return true;
       }
 
-      typedef __Reply__mach_exception_raise_state_t Reply;
+      using Reply = __Reply__mach_exception_raise_state_t;
       Reply* out_reply = reinterpret_cast<Reply*>(out_header);
       out_reply->flavor = in_request_1->flavor;
       out_reply->new_stateCnt = arraysize(out_reply->new_state);
       out_reply->RetCode =
           interface_->CatchMachExceptionRaiseState(in_header->msgh_local_port,
                                                    in_request->exception,
                                                    in_request->code,
                                                    in_request->codeCnt,
                                                    &out_reply->flavor,
                                                    in_request_1->old_state,
                                                    in_request_1->old_stateCnt,
                                                    out_reply->new_state,
                                                    &out_reply->new_stateCnt);
       if (out_reply->RetCode != KERN_SUCCESS) {
         return true;
       }
 
       out_header->msgh_size =
           sizeof(*out_reply) - sizeof(out_reply->new_state) +
           sizeof(out_reply->new_state[0]) * out_reply->new_stateCnt;
       return true;
     }
 
     case kMachMessageIDMachExceptionRaiseStateIdentity: {
       // mach_exception_raise_state_identity(),
       // catch_mach_exception_raise_state_identity().
-      typedef __Request__mach_exception_raise_state_identity_t Request;
+      using Request = __Request__mach_exception_raise_state_identity_t;
       const Request* in_request = reinterpret_cast<const Request*>(in_header);
 
       // in_request_1 is used for the portion of the request after the codes,
       // which in theory can be variable-length. The check function will set it.
       const Request* in_request_1;
       kern_return_t kr = MIGCheckRequestMachExceptionRaiseStateIdentity(
           in_request, &in_request_1);
       if (kr != MACH_MSG_SUCCESS) {
         SetReplyError(out_header, kr);
         return true;
       }
 
-      typedef __Reply__mach_exception_raise_state_identity_t Reply;
+      using Reply = __Reply__mach_exception_raise_state_identity_t;
       Reply* out_reply = reinterpret_cast<Reply*>(out_header);
       out_reply->flavor = in_request_1->flavor;
       out_reply->new_stateCnt = arraysize(out_reply->new_state);
       out_reply->RetCode = interface_->CatchMachExceptionRaiseStateIdentity(
           in_header->msgh_local_port,
           in_request->thread.name,
           in_request->task.name,
           in_request->exception,
           in_request->code,
           in_request->codeCnt,
@@ skipping 309 matching lines @@
 kern_return_t ExcServerSuccessfulReturnValue(exception_behavior_t behavior,
                                              bool set_thread_state) {
   if (!set_thread_state && ExceptionBehaviorHasState(behavior)) {
     return MACH_RCV_PORT_DIED;
   }
 
   return KERN_SUCCESS;
 }
 
 }  // namespace crashpad