C++11: Use type aliases instead of typedefs

minidump/minidump_thread_writer_test.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 463 matching lines @@
                                                   kMemoryValue2,
                                                   true));
     ASSERT_NO_FATAL_FAILURE(
         ExpectMinidumpContextX86(kSeed2, observed_context, false));
     ASSERT_NO_FATAL_FAILURE(ExpectMinidumpMemoryDescriptor(
         observed_stack, &memory_list->MemoryRanges[2]));
   }
 }
 
 struct InitializeFromSnapshotX86Traits {
-  typedef MinidumpContextX86 MinidumpContextType;
+  using MinidumpContextType = MinidumpContextX86;
   static void InitializeCPUContext(CPUContext* context, uint32_t seed) {
     return InitializeCPUContextX86(context, seed);
   }
   static void ExpectMinidumpContext(
       uint32_t expect_seed, const MinidumpContextX86* observed, bool snapshot) {
     return ExpectMinidumpContextX86(expect_seed, observed, snapshot);
   }
 };
 
 struct InitializeFromSnapshotAMD64Traits {
-  typedef MinidumpContextAMD64 MinidumpContextType;
+  using MinidumpContextType = MinidumpContextAMD64;
   static void InitializeCPUContext(CPUContext* context, uint32_t seed) {
     return InitializeCPUContextX86_64(context, seed);
   }
   static void ExpectMinidumpContext(uint32_t expect_seed,
                                     const MinidumpContextAMD64* observed,
                                     bool snapshot) {
     return ExpectMinidumpContextAMD64(expect_seed, observed, snapshot);
   }
 };
 
 struct InitializeFromSnapshotNoContextTraits {
-  typedef MinidumpContextX86 MinidumpContextType;
+  using MinidumpContextType = MinidumpContextX86;
   static void InitializeCPUContext(CPUContext* context, uint32_t seed) {
     context->architecture = kCPUArchitectureUnknown;
   }
   static void ExpectMinidumpContext(uint32_t expect_seed,
                                     const MinidumpContextX86* observed,
                                     bool snapshot) {
     FAIL();
   }
 };
 
 template <typename Traits>
 void RunInitializeFromSnapshotTest(bool thread_id_collision) {
-  typedef typename Traits::MinidumpContextType MinidumpContextType;
+  using MinidumpContextType = typename Traits::MinidumpContextType;
   MINIDUMP_THREAD expect_threads[3] = {};
   uint64_t thread_ids[arraysize(expect_threads)] = {};
   uint8_t memory_values[arraysize(expect_threads)] = {};
   uint32_t context_seeds[arraysize(expect_threads)] = {};
 
   expect_threads[0].ThreadId = 1;
   expect_threads[0].SuspendCount = 2;
   expect_threads[0].Priority = 3;
   expect_threads[0].Teb = 0x0123456789abcdef;
   expect_threads[0].Stack.StartOfMemoryRange = 0x1000;
@@ skipping 144 matching lines @@
 
 TEST(MinidumpThreadWriterDeathTest, InitializeFromSnapshot_NoContext) {
   ASSERT_DEATH(
       RunInitializeFromSnapshotTest<InitializeFromSnapshotNoContextTraits>(
           false), "context_");
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad