C++11: Use type aliases instead of typedefs

util/stdlib/string_number_conversion.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 22 matching lines @@
 #define CONSTEXPR_STATIC_ASSERT(condition, message) \
   static_assert(condition, message)
 #else
 #define CONSTEXPR_STATIC_ASSERT(condition, message) CHECK(condition) << message
 #endif
 
 namespace {
 
 template <typename TIntType, typename TLongType>
 struct StringToIntegerTraits {
-  typedef TIntType IntType;
-  typedef TLongType LongType;
+  using IntType = TIntType;
+  using LongType = TLongType;
   static void TypeCheck() {
     static_assert(std::numeric_limits<TIntType>::is_integer &&
                       std::numeric_limits<TLongType>::is_integer,
                   "IntType and LongType must be integer");
     static_assert(std::numeric_limits<TIntType>::is_signed ==
                       std::numeric_limits<TLongType>::is_signed,
                   "IntType and LongType signedness must agree");
     CONSTEXPR_STATIC_ASSERT(std::numeric_limits<TIntType>::min() >=
                                     std::numeric_limits<TLongType>::min() &&
                                 std::numeric_limits<TIntType>::min() <
@@ skipping 13 matching lines @@
   static void TypeCheck() {
     static_assert(std::numeric_limits<TIntType>::is_signed,
                   "StringToSignedTraits IntType must be signed");
     return super::TypeCheck();
   }
   static bool IsNegativeOverflow(TLongType value) {
     return value < std::numeric_limits<TIntType>::min();
   }
 
  private:
-  typedef StringToIntegerTraits<TIntType, TLongType> super;
+  using super = StringToIntegerTraits<TIntType, TLongType>;
 };
 
 template <typename TIntType, typename TLongType>
 struct StringToUnsignedIntegerTraits
     : public StringToIntegerTraits<TIntType, TLongType> {
   static void TypeCheck() {
     static_assert(!std::numeric_limits<TIntType>::is_signed,
                   "StringToUnsignedTraits IntType must be unsigned");
     return super::TypeCheck();
   }
   static bool IsNegativeOverflow(TLongType value) { return false; }
 
  private:
-  typedef StringToIntegerTraits<TIntType, TLongType> super;
+  using super = StringToIntegerTraits<TIntType, TLongType>;
 };
 
 struct StringToIntTraits : public StringToSignedIntegerTraits<int, long> {
   static LongType Convert(const char* str, char** end, int base) {
     return strtol(str, end, base);
   }
 };
 
 struct StringToUnsignedIntTraits
     : public StringToUnsignedIntegerTraits<unsigned int, unsigned long> {
   static LongType Convert(const char* str, char** end, int base) {
     if (str[0] == '-') {
       return 0;
     }
     return strtoul(str, end, base);
   }
 };
 
 template <typename Traits>
 bool StringToIntegerInternal(const base::StringPiece& string,
                              typename Traits::IntType* number) {
-  typedef typename Traits::IntType IntType;
-  typedef typename Traits::LongType LongType;
+  using IntType = typename Traits::IntType;
+  using LongType = typename Traits::LongType;
 
   Traits::TypeCheck();
 
   if (string.empty() || isspace(string[0])) {
     return false;
   }
 
   if (string[string.length()] != '\0') {
     // The implementations use the C standard library’s conversion routines,
     // which rely on the strings having a trailing NUL character. std::string
@@ skipping 21 matching lines @@
 
 bool StringToNumber(const base::StringPiece& string, int* number) {
   return StringToIntegerInternal<StringToIntTraits>(string, number);
 }
 
 bool StringToNumber(const base::StringPiece& string, unsigned int* number) {
   return StringToIntegerInternal<StringToUnsignedIntTraits>(string, number);
 }
 
 }  // namespace crashpad