diff --git a/quic/core/batch_writer/quic_sendmmsg_batch_writer.h b/quic/core/batch_writer/quic_sendmmsg_batch_writer.h
index 26a728e..3b80395 100644
--- a/quic/core/batch_writer/quic_sendmmsg_batch_writer.h
+++ b/quic/core/batch_writer/quic_sendmmsg_batch_writer.h
@@ -25,7 +25,7 @@
   FlushImplResult FlushImpl() override;
 
  protected:
-  typedef QuicMMsgHdr::ControlBufferInitializer CmsgBuilder;
+  using CmsgBuilder = QuicMMsgHdr::ControlBufferInitializer;
   FlushImplResult InternalFlushImpl(size_t cmsg_space,
                                     const CmsgBuilder& cmsg_builder);
 };
diff --git a/quic/core/congestion_control/bandwidth_sampler.h b/quic/core/congestion_control/bandwidth_sampler.h
index f32eabf..2d06560 100644
--- a/quic/core/congestion_control/bandwidth_sampler.h
+++ b/quic/core/congestion_control/bandwidth_sampler.h
@@ -129,11 +129,10 @@
  private:
   // Tracks the maximum number of bytes acked faster than the estimated
   // bandwidth.
-  typedef WindowedFilter<QuicByteCount,
-                         MaxFilter<QuicByteCount>,
-                         QuicRoundTripCount,
-                         QuicRoundTripCount>
-      MaxAckHeightFilter;
+  using MaxAckHeightFilter = WindowedFilter<QuicByteCount,
+                                            MaxFilter<QuicByteCount>,
+                                            QuicRoundTripCount,
+                                            QuicRoundTripCount>;
   MaxAckHeightFilter max_ack_height_filter_;
 
   // The time this aggregation started and the number of bytes acked during it.
diff --git a/quic/core/congestion_control/bbr_sender.h b/quic/core/congestion_control/bbr_sender.h
index 30f2945..586ef1a 100644
--- a/quic/core/congestion_control/bbr_sender.h
+++ b/quic/core/congestion_control/bbr_sender.h
@@ -175,17 +175,15 @@
   // For switching send algorithm mid connection.
   friend class Bbr2Sender;
 
-  typedef WindowedFilter<QuicBandwidth,
-                         MaxFilter<QuicBandwidth>,
-                         QuicRoundTripCount,
-                         QuicRoundTripCount>
-      MaxBandwidthFilter;
+  using MaxBandwidthFilter = WindowedFilter<QuicBandwidth,
+                                            MaxFilter<QuicBandwidth>,
+                                            QuicRoundTripCount,
+                                            QuicRoundTripCount>;
 
-  typedef WindowedFilter<QuicByteCount,
-                         MaxFilter<QuicByteCount>,
-                         QuicRoundTripCount,
-                         QuicRoundTripCount>
-      MaxAckHeightFilter;
+  using MaxAckHeightFilter = WindowedFilter<QuicByteCount,
+                                            MaxFilter<QuicByteCount>,
+                                            QuicRoundTripCount,
+                                            QuicRoundTripCount>;
 
   // Returns whether the connection has achieved full bandwidth required to exit
   // the slow start.
diff --git a/quic/core/congestion_control/send_algorithm_interface.h b/quic/core/congestion_control/send_algorithm_interface.h
index e3fc5e6..533bf4c 100644
--- a/quic/core/congestion_control/send_algorithm_interface.h
+++ b/quic/core/congestion_control/send_algorithm_interface.h
@@ -24,7 +24,7 @@
 
 namespace quic {
 
-typedef uint64_t QuicRoundTripCount;
+using QuicRoundTripCount = uint64_t;
 
 class CachedNetworkParameters;
 class RttStats;
diff --git a/quic/core/crypto/crypto_protocol.h b/quic/core/crypto/crypto_protocol.h
index a1d8028..5372f3f 100644
--- a/quic/core/crypto/crypto_protocol.h
+++ b/quic/core/crypto/crypto_protocol.h
@@ -24,7 +24,7 @@
 
 namespace quic {
 
-typedef std::string ServerConfigID;
+using ServerConfigID = std::string;
 
 // The following tags have been deprecated and should not be reused:
 // "1CON", "BBQ4", "NCON", "RCID", "SREJ", "TBKP", "TB10", "SCLS", "SMHL",
diff --git a/quic/core/crypto/quic_crypto_server_config.h b/quic/core/crypto/quic_crypto_server_config.h
index bd3111b..7fae412 100644
--- a/quic/core/crypto/quic_crypto_server_config.h
+++ b/quic/core/crypto/quic_crypto_server_config.h
@@ -511,8 +511,8 @@
     ~Config() override;
   };
 
-  typedef std::map<ServerConfigID, QuicReferenceCountedPointer<Config>>
-      ConfigMap;
+  using ConfigMap =
+      std::map<ServerConfigID, QuicReferenceCountedPointer<Config>>;
 
   // Get a ref to the config with a given server config id.
   QuicReferenceCountedPointer<Config> GetConfigWithScid(
diff --git a/quic/core/frames/quic_ack_frame.h b/quic/core/frames/quic_ack_frame.h
index 6902340..e69cbbe 100644
--- a/quic/core/frames/quic_ack_frame.h
+++ b/quic/core/frames/quic_ack_frame.h
@@ -29,9 +29,9 @@
   PacketNumberQueue& operator=(const PacketNumberQueue& other);
   PacketNumberQueue& operator=(PacketNumberQueue&& other);
 
-  typedef QuicIntervalSet<QuicPacketNumber>::const_iterator const_iterator;
-  typedef QuicIntervalSet<QuicPacketNumber>::const_reverse_iterator
-      const_reverse_iterator;
+  using const_iterator = QuicIntervalSet<QuicPacketNumber>::const_iterator;
+  using const_reverse_iterator =
+      QuicIntervalSet<QuicPacketNumber>::const_reverse_iterator;
 
   // Adds |packet_number| to the set of packets in the queue.
   void Add(QuicPacketNumber packet_number);
diff --git a/quic/core/frames/quic_frame.h b/quic/core/frames/quic_frame.h
index 6e096e3..505f562 100644
--- a/quic/core/frames/quic_frame.h
+++ b/quic/core/frames/quic_frame.h
@@ -133,7 +133,7 @@
 
 // A inline size of 1 is chosen to optimize the typical use case of
 // 1-stream-frame in QuicTransmissionInfo.retransmittable_frames.
-typedef QuicInlinedVector<QuicFrame, 1> QuicFrames;
+using QuicFrames = QuicInlinedVector<QuicFrame, 1>;
 
 // Deletes all the sub-frames contained in |frames|.
 QUIC_EXPORT_PRIVATE void DeleteFrames(QuicFrames* frames);
diff --git a/quic/core/frames/quic_message_frame.h b/quic/core/frames/quic_message_frame.h
index 7f0179c..68fbf22 100644
--- a/quic/core/frames/quic_message_frame.h
+++ b/quic/core/frames/quic_message_frame.h
@@ -13,7 +13,7 @@
 
 namespace quic {
 
-typedef QuicInlinedVector<QuicMemSlice, 1> QuicMessageData;
+using QuicMessageData = QuicInlinedVector<QuicMemSlice, 1>;
 
 struct QUIC_EXPORT_PRIVATE QuicMessageFrame {
   QuicMessageFrame() = default;
diff --git a/quic/core/quic_buffered_packet_store.cc b/quic/core/quic_buffered_packet_store.cc
index b2780c6..6de1ab0 100644
--- a/quic/core/quic_buffered_packet_store.cc
+++ b/quic/core/quic_buffered_packet_store.cc
@@ -12,9 +12,9 @@
 
 namespace quic {
 
-typedef QuicBufferedPacketStore::BufferedPacket BufferedPacket;
-typedef QuicBufferedPacketStore::BufferedPacketList BufferedPacketList;
-typedef QuicBufferedPacketStore::EnqueuePacketResult EnqueuePacketResult;
+using BufferedPacket = QuicBufferedPacketStore::BufferedPacket;
+using BufferedPacketList = QuicBufferedPacketStore::BufferedPacketList;
+using EnqueuePacketResult = QuicBufferedPacketStore::EnqueuePacketResult;
 
 // Max number of connections this store can keep track.
 static const size_t kDefaultMaxConnectionsInStore = 100;
diff --git a/quic/core/quic_buffered_packet_store.h b/quic/core/quic_buffered_packet_store.h
index 615e91e..7cb179d 100644
--- a/quic/core/quic_buffered_packet_store.h
+++ b/quic/core/quic_buffered_packet_store.h
@@ -77,10 +77,9 @@
     TlsChloExtractor tls_chlo_extractor;
   };
 
-  typedef QuicLinkedHashMap<QuicConnectionId,
-                            BufferedPacketList,
-                            QuicConnectionIdHash>
-      BufferedPacketMap;
+  using BufferedPacketMap = QuicLinkedHashMap<QuicConnectionId,
+                                              BufferedPacketList,
+                                              QuicConnectionIdHash>;
 
   class QUIC_NO_EXPORT VisitorInterface {
    public:
diff --git a/quic/core/quic_buffered_packet_store_test.cc b/quic/core/quic_buffered_packet_store_test.cc
index 85e4e5d..ffb7b5f 100644
--- a/quic/core/quic_buffered_packet_store_test.cc
+++ b/quic/core/quic_buffered_packet_store_test.cc
@@ -15,10 +15,6 @@
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
 
 namespace quic {
-
-typedef QuicBufferedPacketStore::BufferedPacket BufferedPacket;
-typedef QuicBufferedPacketStore::EnqueuePacketResult EnqueuePacketResult;
-
 static const size_t kDefaultMaxConnectionsInStore = 100;
 static const size_t kMaxConnectionsWithoutCHLO =
     kDefaultMaxConnectionsInStore / 2;
@@ -26,9 +22,9 @@
 namespace test {
 namespace {
 
-typedef QuicBufferedPacketStore::BufferedPacket BufferedPacket;
-typedef QuicBufferedPacketStore::BufferedPacketList BufferedPacketList;
-
+using BufferedPacket = QuicBufferedPacketStore::BufferedPacket;
+using BufferedPacketList = QuicBufferedPacketStore::BufferedPacketList;
+using EnqueuePacketResult = QuicBufferedPacketStore::EnqueuePacketResult;
 class QuicBufferedPacketStoreVisitor
     : public QuicBufferedPacketStore::VisitorInterface {
  public:
diff --git a/quic/core/quic_circular_deque_test.cc b/quic/core/quic_circular_deque_test.cc
index 19005f6..f2e14a2 100644
--- a/quic/core/quic_circular_deque_test.cc
+++ b/quic/core/quic_circular_deque_test.cc
@@ -20,7 +20,7 @@
 
 template <typename T, template <typename> class BaseAllocator = std::allocator>
 class CountingAllocator : public BaseAllocator<T> {
-  typedef BaseAllocator<T> BaseType;
+  using BaseType = BaseAllocator<T>;
 
  public:
   using propagate_on_container_copy_assignment = std::true_type;
@@ -582,7 +582,7 @@
 
   {
     // Move construct in Relocate.
-    typedef std::unique_ptr<Foo> MoveConstructible;
+    using MoveConstructible = std::unique_ptr<Foo>;
     ASSERT_FALSE(std::is_trivially_copyable<MoveConstructible>::value);
     ASSERT_TRUE(std::is_move_constructible<MoveConstructible>::value);
     QuicCircularDeque<MoveConstructible, 3,
@@ -603,7 +603,7 @@
 
   {
     // Copy construct in Relocate.
-    typedef Foo NonMoveConstructible;
+    using NonMoveConstructible = Foo;
     ASSERT_FALSE(std::is_trivially_copyable<NonMoveConstructible>::value);
     ASSERT_FALSE(std::is_move_constructible<NonMoveConstructible>::value);
     QuicCircularDeque<NonMoveConstructible, 3,
diff --git a/quic/core/quic_connection.h b/quic/core/quic_connection.h
index 818c093..35d15ff 100644
--- a/quic/core/quic_connection.h
+++ b/quic/core/quic_connection.h
@@ -1217,7 +1217,7 @@
  private:
   friend class test::QuicConnectionPeer;
 
-  typedef std::list<SerializedPacket> QueuedPacketList;
+  using QueuedPacketList = std::list<SerializedPacket>;
 
   // BufferedPacket stores necessary information (encrypted buffer and self/peer
   // addresses) of those packets which are serialized but failed to send because
diff --git a/quic/core/quic_dispatcher.cc b/quic/core/quic_dispatcher.cc
index 11c6753..d048e60 100644
--- a/quic/core/quic_dispatcher.cc
+++ b/quic/core/quic_dispatcher.cc
@@ -27,9 +27,9 @@
 
 namespace quic {
 
-typedef QuicBufferedPacketStore::BufferedPacket BufferedPacket;
-typedef QuicBufferedPacketStore::BufferedPacketList BufferedPacketList;
-typedef QuicBufferedPacketStore::EnqueuePacketResult EnqueuePacketResult;
+using BufferedPacket = QuicBufferedPacketStore::BufferedPacket;
+using BufferedPacketList = QuicBufferedPacketStore::BufferedPacketList;
+using EnqueuePacketResult = QuicBufferedPacketStore::EnqueuePacketResult;
 
 namespace {
 
diff --git a/quic/core/quic_dispatcher.h b/quic/core/quic_dispatcher.h
index 19d7abc..92c7320 100644
--- a/quic/core/quic_dispatcher.h
+++ b/quic/core/quic_dispatcher.h
@@ -41,7 +41,7 @@
       public QuicBufferedPacketStore::VisitorInterface {
  public:
   // Ideally we'd have a linked_hash_set: the  boolean is unused.
-  typedef QuicLinkedHashMap<QuicBlockedWriterInterface*, bool> WriteBlockedList;
+  using WriteBlockedList = QuicLinkedHashMap<QuicBlockedWriterInterface*, bool>;
 
   QuicDispatcher(
       const QuicConfig* config,
diff --git a/quic/core/quic_framer.h b/quic/core/quic_framer.h
index e6936e0..fba99f8 100644
--- a/quic/core/quic_framer.h
+++ b/quic/core/quic_framer.h
@@ -708,7 +708,7 @@
  private:
   friend class test::QuicFramerPeer;
 
-  typedef std::map<QuicPacketNumber, uint8_t> NackRangeMap;
+  using NackRangeMap = std::map<QuicPacketNumber, uint8_t>;
 
   struct QUIC_EXPORT_PRIVATE AckFrameInfo {
     AckFrameInfo();
diff --git a/quic/core/quic_interval_deque_test.cc b/quic/core/quic_interval_deque_test.cc
index f7a8441..2539f1d 100644
--- a/quic/core/quic_interval_deque_test.cc
+++ b/quic/core/quic_interval_deque_test.cc
@@ -32,7 +32,7 @@
       : val(val), interval_start(interval_start), interval_end(interval_end) {}
 };
 
-typedef QuicIntervalDeque<TestIntervalItem> QID;
+using QID = QuicIntervalDeque<TestIntervalItem>;
 
 class QuicIntervalDequeTest : public QuicTest {
  public:
diff --git a/quic/core/quic_interval_set.h b/quic/core/quic_interval_set.h
index 2d44f2b..7ab0647 100644
--- a/quic/core/quic_interval_set.h
+++ b/quic/core/quic_interval_set.h
@@ -67,18 +67,18 @@
 template <typename T>
 class QUIC_NO_EXPORT QuicIntervalSet {
  public:
-  typedef QuicInterval<T> value_type;
+  using value_type = QuicInterval<T>;
 
  private:
   struct QUIC_NO_EXPORT IntervalLess {
     bool operator()(const value_type& a, const value_type& b) const;
   };
   // TODO(wub): Switch to absl::btree_set when it is available in Chromium.
-  typedef std::set<value_type, IntervalLess> Set;
+  using Set = std::set<value_type, IntervalLess>;
 
  public:
-  typedef typename Set::const_iterator const_iterator;
-  typedef typename Set::const_reverse_iterator const_reverse_iterator;
+  using const_iterator = typename Set::const_iterator;
+  using const_reverse_iterator = typename Set::const_reverse_iterator;
 
   // Instantiates an empty QuicIntervalSet.
   QuicIntervalSet() {}
diff --git a/quic/core/quic_linux_socket_utils.h b/quic/core/quic_linux_socket_utils.h
index 4091657..fe186df 100644
--- a/quic/core/quic_linux_socket_utils.h
+++ b/quic/core/quic_linux_socket_utils.h
@@ -161,9 +161,8 @@
 //   QuicSocketUtils::WriteMultiplePackets(fd, &mhdr, &num_packets_sent);
 class QUIC_EXPORT_PRIVATE QuicMMsgHdr {
  public:
-  typedef std::function<
-      void(QuicMMsgHdr* mhdr, int i, const BufferedWrite& buffered_write)>
-      ControlBufferInitializer;
+  using ControlBufferInitializer = std::function<
+      void(QuicMMsgHdr* mhdr, int i, const BufferedWrite& buffered_write)>;
   template <typename IteratorT>
   QuicMMsgHdr(const IteratorT& first,
               const IteratorT& last,
diff --git a/quic/core/quic_stream_sequencer_buffer_test.cc b/quic/core/quic_stream_sequencer_buffer_test.cc
index e6a8914..0ad7244 100644
--- a/quic/core/quic_stream_sequencer_buffer_test.cc
+++ b/quic/core/quic_stream_sequencer_buffer_test.cc
@@ -52,7 +52,7 @@
 
 static const size_t kBlockSizeBytes =
     QuicStreamSequencerBuffer::kBlockSizeBytes;
-typedef QuicStreamSequencerBuffer::BufferBlock BufferBlock;
+using BufferBlock = QuicStreamSequencerBuffer::BufferBlock;
 
 namespace {
 
@@ -864,7 +864,7 @@
 class QuicStreamSequencerBufferRandomIOTest
     : public QuicStreamSequencerBufferTest {
  public:
-  typedef std::pair<QuicStreamOffset, size_t> OffsetSizePair;
+  using OffsetSizePair = std::pair<QuicStreamOffset, size_t>;
 
   void SetUp() override {
     // Test against a larger capacity then above tests. Also make sure the last
diff --git a/quic/core/quic_stream_sequencer_test.cc b/quic/core/quic_stream_sequencer_test.cc
index f53533c..a996ee2 100644
--- a/quic/core/quic_stream_sequencer_test.cc
+++ b/quic/core/quic_stream_sequencer_test.cc
@@ -376,8 +376,8 @@
 
 class QuicSequencerRandomTest : public QuicStreamSequencerTest {
  public:
-  typedef std::pair<int, std::string> Frame;
-  typedef std::vector<Frame> FrameList;
+  using Frame = std::pair<int, std::string>;
+  using FrameList = std::vector<Frame>;
 
   void CreateFrames() {
     int payload_size = ABSL_ARRAYSIZE(kPayload) - 1;
diff --git a/quic/core/quic_tag.h b/quic/core/quic_tag.h
index 8b68e33..606d89d 100644
--- a/quic/core/quic_tag.h
+++ b/quic/core/quic_tag.h
@@ -22,9 +22,9 @@
 // Tags will often be referred to by their ASCII equivalent, e.g. EXMP. This is
 // just a mnemonic for the value 0x504d5845 (little-endian version of the ASCII
 // string E X M P).
-typedef uint32_t QuicTag;
-typedef std::map<QuicTag, std::string> QuicTagValueMap;
-typedef std::vector<QuicTag> QuicTagVector;
+using QuicTag = uint32_t;
+using QuicTagValueMap = std::map<QuicTag, std::string>;
+using QuicTagVector = std::vector<QuicTag>;
 
 // MakeQuicTag returns a value given the four bytes. For example:
 //   MakeQuicTag('C', 'H', 'L', 'O');
diff --git a/quic/core/quic_time_wait_list_manager.h b/quic/core/quic_time_wait_list_manager.h
index 6fd2041..d128691 100644
--- a/quic/core/quic_time_wait_list_manager.h
+++ b/quic/core/quic_time_wait_list_manager.h
@@ -275,10 +275,9 @@
   };
 
   // QuicLinkedHashMap allows lookup by ConnectionId and traversal in add order.
-  typedef QuicLinkedHashMap<QuicConnectionId,
-                            ConnectionIdData,
-                            QuicConnectionIdHash>
-      ConnectionIdMap;
+  using ConnectionIdMap = QuicLinkedHashMap<QuicConnectionId,
+                                            ConnectionIdData,
+                                            QuicConnectionIdHash>;
   ConnectionIdMap connection_id_map_;
 
   // Pending termination packets that need to be sent out to the peer when we
diff --git a/quic/core/quic_write_blocked_list.h b/quic/core/quic_write_blocked_list.h
index a89bf17..930157b 100644
--- a/quic/core/quic_write_blocked_list.h
+++ b/quic/core/quic_write_blocked_list.h
@@ -27,7 +27,7 @@
 // Crypto stream > Headers stream > Data streams by requested priority.
 class QUIC_EXPORT_PRIVATE QuicWriteBlockedList {
  private:
-  typedef spdy::WriteScheduler<QuicStreamId> QuicPriorityWriteScheduler;
+  using QuicPriorityWriteScheduler = spdy::WriteScheduler<QuicStreamId>;
 
  public:
   explicit QuicWriteBlockedList(QuicTransportVersion version);
@@ -118,7 +118,7 @@
     };
 
     // Optimized for the typical case of 2 static streams per session.
-    typedef QuicInlinedVector<StreamIdBlockedPair, 2> StreamsVector;
+    using StreamsVector = QuicInlinedVector<StreamIdBlockedPair, 2>;
 
     StreamsVector::const_iterator begin() const { return streams_.cbegin(); }
 
diff --git a/quic/test_tools/packet_dropping_test_writer.h b/quic/test_tools/packet_dropping_test_writer.h
index 02eebe9..01a07ce 100644
--- a/quic/test_tools/packet_dropping_test_writer.h
+++ b/quic/test_tools/packet_dropping_test_writer.h
@@ -157,7 +157,7 @@
     QuicTime send_time;
   };
 
-  typedef std::list<DelayedWrite> DelayedPacketList;
+  using DelayedPacketList = std::list<DelayedWrite>;
 
   const QuicClock* clock_;
   std::unique_ptr<QuicAlarm> write_unblocked_alarm_;
diff --git a/quic/test_tools/quic_stream_sequencer_buffer_peer.cc b/quic/test_tools/quic_stream_sequencer_buffer_peer.cc
index eaf2c31..8f5553a 100644
--- a/quic/test_tools/quic_stream_sequencer_buffer_peer.cc
+++ b/quic/test_tools/quic_stream_sequencer_buffer_peer.cc
@@ -10,7 +10,7 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
 
-typedef quic::QuicStreamSequencerBuffer::BufferBlock BufferBlock;
+using BufferBlock = quic::QuicStreamSequencerBuffer::BufferBlock;
 
 static const size_t kBlockSizeBytes =
     quic::QuicStreamSequencerBuffer::kBlockSizeBytes;
diff --git a/quic/test_tools/simulator/queue.h b/quic/test_tools/simulator/queue.h
index 6c3c6b0..f9a7560 100644
--- a/quic/test_tools/simulator/queue.h
+++ b/quic/test_tools/simulator/queue.h
@@ -55,7 +55,7 @@
                          QuicTime::Delta aggregation_timeout);
 
  private:
-  typedef uint64_t AggregationBundleNumber;
+  using AggregationBundleNumber = uint64_t;
 
   // In order to implement packet aggregation, each packet is tagged with a
   // bundle number.  The queue keeps a bundle counter, and whenever a bundle is
diff --git a/quic/test_tools/simulator/switch.h b/quic/test_tools/simulator/switch.h
index 3e4cc20..750b24b 100644
--- a/quic/test_tools/simulator/switch.h
+++ b/quic/test_tools/simulator/switch.h
@@ -13,7 +13,7 @@
 namespace quic {
 namespace simulator {
 
-typedef size_t SwitchPortNumber;
+using SwitchPortNumber = size_t;
 
 // Simulates a network switch with simple persistent learning scheme and queues
 // on every output port.
diff --git a/quic/tools/quic_memory_cache_backend.cc b/quic/tools/quic_memory_cache_backend.cc
index f6ecadd..465e0a9 100644
--- a/quic/tools/quic_memory_cache_backend.cc
+++ b/quic/tools/quic_memory_cache_backend.cc
@@ -163,8 +163,8 @@
   return it->second.get();
 }
 
-typedef QuicBackendResponse::ServerPushInfo ServerPushInfo;
-typedef QuicBackendResponse::SpecialResponseType SpecialResponseType;
+using ServerPushInfo = QuicBackendResponse::ServerPushInfo;
+using SpecialResponseType = QuicBackendResponse::SpecialResponseType;
 
 void QuicMemoryCacheBackend::AddSimpleResponse(absl::string_view host,
                                                absl::string_view path,
diff --git a/quic/tools/quic_memory_cache_backend_test.cc b/quic/tools/quic_memory_cache_backend_test.cc
index 1902146..5940baa 100644
--- a/quic/tools/quic_memory_cache_backend_test.cc
+++ b/quic/tools/quic_memory_cache_backend_test.cc
@@ -16,8 +16,8 @@
 namespace test {
 
 namespace {
-typedef QuicBackendResponse Response;
-typedef QuicBackendResponse::ServerPushInfo ServerPushInfo;
+using Response = QuicBackendResponse;
+using ServerPushInfo = QuicBackendResponse::ServerPushInfo;
 }  // namespace
 
 class QuicMemoryCacheBackendTest : public QuicTest {
diff --git a/quic/tools/quic_simple_server_session_test.cc b/quic/tools/quic_simple_server_session_test.cc
index 28e8899..66ee8c4 100644
--- a/quic/tools/quic_simple_server_session_test.cc
+++ b/quic/tools/quic_simple_server_session_test.cc
@@ -51,7 +51,7 @@
 namespace test {
 namespace {
 
-typedef QuicSimpleServerSession::PromisedStreamInfo PromisedStreamInfo;
+using PromisedStreamInfo = QuicSimpleServerSession::PromisedStreamInfo;
 
 const QuicByteCount kHeadersFrameHeaderLength = 2;
 const QuicByteCount kHeadersFramePayloadLength = 9;