C++11: Use type aliases instead of typedefs

snapshot/mac/process_types.h

 // 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 13 matching lines @@
 #include "snapshot/mac/process_reader.h"
 
 namespace crashpad {
 namespace process_types {
 namespace internal {
 
 // Some structure definitions differ in 32-bit and 64-bit environments by having
 // additional “reserved” padding fields present only in the 64-bit environment.
 // These Reserved64Only* types allow the process_types system to replicate these
 // structures more precisely.
-typedef char Reserved64Only32[0];
-typedef uint32_t Reserved64Only64;
+using Reserved64Only32 = char[0];
+using Reserved64Only64 = uint32_t;
 
 }  // namespace internal
 }  // namespace process_types
 }  // namespace crashpad
 
 #include "snapshot/mac/process_types/traits.h"
 
 // Creates the traits type crashpad::process_types::internal::TraitsGeneric.
 DECLARE_PROCESS_TYPE_TRAITS_CLASS(Generic, 64)
 
 #undef DECLARE_PROCESS_TYPE_TRAITS_CLASS
 
 // Declare the crashpad::process_types::struct_name structs. These are the
 // user-visible generic structs that callers will interact with. They read data
 // from 32-bit or 64-bit processes by using the specific internal templatized
 // structs below.
 #define PROCESS_TYPE_STRUCT_DECLARE 1
 
 #define PROCESS_TYPE_STRUCT_BEGIN(struct_name)                                 \
   namespace crashpad {                                                         \
   namespace process_types {                                                    \
   struct struct_name {                                                         \
    public:                                                                     \
-    typedef internal::TraitsGeneric::Long Long;                                \
-    typedef internal::TraitsGeneric::ULong ULong;                              \
-    typedef internal::TraitsGeneric::Pointer Pointer;                          \
-    typedef internal::TraitsGeneric::IntPtr IntPtr;                            \
-    typedef internal::TraitsGeneric::UIntPtr UIntPtr;                          \
-    typedef internal::TraitsGeneric::Reserved64Only Reserved64Only;            \
+    using Long = internal::TraitsGeneric::Long;                                \
+    using ULong = internal::TraitsGeneric::ULong;                              \
+    using Pointer = internal::TraitsGeneric::Pointer;                          \
+    using IntPtr = internal::TraitsGeneric::IntPtr;                            \
+    using UIntPtr = internal::TraitsGeneric::UIntPtr;                          \
+    using Reserved64Only = internal::TraitsGeneric::Reserved64Only;            \
                                                                                \
     /* Initializes an object with data read from |process_reader| at           \
      * |address|, properly genericized. */                                     \
     bool Read(ProcessReader* process_reader, mach_vm_address_t address) {      \
       return ReadInto(process_reader, address, this);                          \
     }                                                                          \
                                                                                \
     /* Reads |count| objects from |process_reader| beginning at |address|, and \
      * genericizes the objects. The caller must provide storage for |count|    \
      * objects in |generic|. */                                                \
@@ skipping 54 matching lines @@
 // remote process into the generic form.
 #define PROCESS_TYPE_STRUCT_DECLARE_INTERNAL 1
 
 #define PROCESS_TYPE_STRUCT_BEGIN(struct_name)                                 \
   namespace crashpad {                                                         \
   namespace process_types {                                                    \
   namespace internal {                                                         \
   template <typename Traits>                                                   \
   struct struct_name {                                                         \
    public:                                                                     \
-    typedef typename Traits::Long Long;                                        \
-    typedef typename Traits::ULong ULong;                                      \
-    typedef typename Traits::Pointer Pointer;                                  \
-    typedef typename Traits::IntPtr IntPtr;                                    \
-    typedef typename Traits::UIntPtr UIntPtr;                                  \
-    typedef typename Traits::Reserved64Only Reserved64Only;                    \
+    using Long = typename Traits::Long;                                        \
+    using ULong = typename Traits::ULong;                                      \
+    using Pointer = typename Traits::Pointer;                                  \
+    using IntPtr = typename Traits::IntPtr;                                    \
+    using UIntPtr = typename Traits::UIntPtr;                                  \
+    using Reserved64Only = typename Traits::Reserved64Only;                    \
                                                                                \
     /* Read(), ReadArrayInto(), and Size() are as in the generic user-visible  \
      * struct above. */                                                        \
     bool Read(ProcessReader* process_reader, mach_vm_address_t address) {      \
       return ReadInto(process_reader, address, this);                          \
     }                                                                          \
     static bool ReadArrayInto(ProcessReader* process_reader,                   \
                               mach_vm_address_t address,                       \
                               size_t count,                                    \
                               struct_name<Traits>* specific);                  \
@@ skipping 19 matching lines @@
   }  /* namespace crashpad */
 
 #include "snapshot/mac/process_types/all.proctype"
 
 #undef PROCESS_TYPE_STRUCT_BEGIN
 #undef PROCESS_TYPE_STRUCT_MEMBER
 #undef PROCESS_TYPE_STRUCT_END
 #undef PROCESS_TYPE_STRUCT_DECLARE_INTERNAL
 
 #endif  // CRASHPAD_SNAPSHOT_MAC_PROCESS_TYPES_H_