diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index 7a0bd9a..7bee398 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -1998,13 +1998,13 @@
   // count.
   size_t client_max_open_outgoing_bidirectional_streams =
       version_.HasIetfQuicFrames()
-          ? QuicSessionPeer::v99_streamid_manager(client_session)
+          ? QuicSessionPeer::ietf_streamid_manager(client_session)
                 ->max_outgoing_bidirectional_streams()
           : QuicSessionPeer::GetStreamIdManager(client_session)
                 ->max_open_outgoing_streams();
   size_t client_max_open_outgoing_unidirectional_streams =
       version_.HasIetfQuicFrames()
-          ? QuicSessionPeer::v99_streamid_manager(client_session)
+          ? QuicSessionPeer::ietf_streamid_manager(client_session)
                     ->max_outgoing_unidirectional_streams() -
                 kHttp3StaticUnidirectionalStreamCount
           : QuicSessionPeer::GetStreamIdManager(client_session)
@@ -2018,13 +2018,13 @@
   if (server_session != nullptr) {
     size_t server_max_open_outgoing_bidirectional_streams =
         version_.HasIetfQuicFrames()
-            ? QuicSessionPeer::v99_streamid_manager(server_session)
+            ? QuicSessionPeer::ietf_streamid_manager(server_session)
                   ->max_outgoing_bidirectional_streams()
             : QuicSessionPeer::GetStreamIdManager(server_session)
                   ->max_open_outgoing_streams();
     size_t server_max_open_outgoing_unidirectional_streams =
         version_.HasIetfQuicFrames()
-            ? QuicSessionPeer::v99_streamid_manager(server_session)
+            ? QuicSessionPeer::ietf_streamid_manager(server_session)
                       ->max_outgoing_unidirectional_streams() -
                   kHttp3StaticUnidirectionalStreamCount
             : QuicSessionPeer::GetStreamIdManager(server_session)
@@ -4602,7 +4602,7 @@
   QuicSpdySession* client_session = GetClientSession();
   ASSERT_TRUE(client_session);
   QuicStreamIdManager* stream_id_manager =
-      QuicSessionPeer::v99_bidirectional_stream_id_manager(client_session);
+      QuicSessionPeer::ietf_bidirectional_stream_id_manager(client_session);
   ASSERT_TRUE(stream_id_manager);
   QuicStreamCount max_number_of_streams =
       stream_id_manager->outgoing_max_streams();
diff --git a/quic/core/http/quic_spdy_client_session_test.cc b/quic/core/http/quic_spdy_client_session_test.cc
index c3fc0e0..4917a42 100644
--- a/quic/core/http/quic_spdy_client_session_test.cc
+++ b/quic/core/http/quic_spdy_client_session_test.cc
@@ -294,7 +294,7 @@
   EXPECT_FALSE(session_->CreateOutgoingBidirectionalStream());
 
   // Close the stream, but without having received a FIN or a RST_STREAM
-  // or MAX_STREAMS (V99) and check that a new one can not be created.
+  // or MAX_STREAMS (IETF QUIC) and check that a new one can not be created.
   session_->ResetStream(stream->id(), QUIC_STREAM_CANCELLED);
   EXPECT_EQ(1u, QuicSessionPeer::GetNumOpenDynamicStreams(session_.get()));
 
@@ -317,7 +317,7 @@
   // Check that a new one can be created.
   EXPECT_EQ(0u, QuicSessionPeer::GetNumOpenDynamicStreams(session_.get()));
   if (VersionHasIetfQuicFrames(GetParam().transport_version)) {
-    // In V99 the stream limit increases only if we get a MAX_STREAMS
+    // In IETF QUIC the stream limit increases only if we get a MAX_STREAMS
     // frame; pretend we got one.
 
     QuicMaxStreamsFrame frame(0, 2,
@@ -330,7 +330,7 @@
     // Ensure that we have 2 total streams, 1 open and 1 closed.
     QuicStreamCount expected_stream_count = 2;
     EXPECT_EQ(expected_stream_count,
-              QuicSessionPeer::v99_bidirectional_stream_id_manager(&*session_)
+              QuicSessionPeer::ietf_bidirectional_stream_id_manager(&*session_)
                   ->outgoing_stream_count());
   }
 }
@@ -347,7 +347,7 @@
   ASSERT_NE(nullptr, stream);
 
   if (VersionHasIetfQuicFrames(GetParam().transport_version)) {
-    // For v99, trying to open a stream and failing due to lack
+    // For IETF QUIC, trying to open a stream and failing due to lack
     // of stream ids will result in a STREAMS_BLOCKED. Make
     // sure we get one. Also clear out the frame because if it's
     // left sitting, the later SendRstStream will not actually
@@ -399,7 +399,7 @@
     // Ensure that we have 2 open streams.
     QuicStreamCount expected_stream_count = 2;
     EXPECT_EQ(expected_stream_count,
-              QuicSessionPeer::v99_bidirectional_stream_id_manager(&*session_)
+              QuicSessionPeer::ietf_bidirectional_stream_id_manager(&*session_)
                   ->outgoing_stream_count());
   }
 }
@@ -1022,7 +1022,7 @@
   EXPECT_EQ(kInitialSessionFlowControlWindowForTest,
             session_->flow_controller()->send_window_offset());
   if (session_->version().UsesHttp3()) {
-    auto* id_manager = QuicSessionPeer::v99_streamid_manager(session_.get());
+    auto* id_manager = QuicSessionPeer::ietf_streamid_manager(session_.get());
     EXPECT_EQ(kDefaultMaxStreamsPerConnection,
               id_manager->max_outgoing_bidirectional_streams());
     EXPECT_EQ(
@@ -1055,7 +1055,7 @@
   EXPECT_EQ(kInitialSessionFlowControlWindowForTest + 1,
             session_->flow_controller()->send_window_offset());
   if (session_->version().UsesHttp3()) {
-    auto* id_manager = QuicSessionPeer::v99_streamid_manager(session_.get());
+    auto* id_manager = QuicSessionPeer::ietf_streamid_manager(session_.get());
     auto* control_stream =
         QuicSpdySessionPeer::GetSendControlStream(session_.get());
     EXPECT_EQ(kDefaultMaxStreamsPerConnection + 1,
diff --git a/quic/core/http/quic_spdy_session_test.cc b/quic/core/http/quic_spdy_session_test.cc
index 6f7d85f..46a5456 100644
--- a/quic/core/http/quic_spdy_session_test.cc
+++ b/quic/core/http/quic_spdy_session_test.cc
@@ -405,7 +405,7 @@
       EXPECT_CALL(*connection_, SendControlFrame(_))
           .WillOnce(Invoke(&ClearControlFrame));
     } else {
-      // V99 has two frames, RST_STREAM and STOP_SENDING
+      // IETF QUIC has two frames, RST_STREAM and STOP_SENDING
       EXPECT_CALL(*connection_, SendControlFrame(_))
           .Times(2)
           .WillRepeatedly(Invoke(&ClearControlFrame));
@@ -601,27 +601,29 @@
     // is not the number of open streams, we allocate the max and the max+2.
     // Get the max allowed stream ID, this should succeed.
     QuicStreamId stream_id = StreamCountToId(
-        QuicSessionPeer::v99_streamid_manager(&session_)
+        QuicSessionPeer::ietf_streamid_manager(&session_)
             ->max_incoming_bidirectional_streams(),
         Perspective::IS_CLIENT,  // Client initates stream, allocs stream id.
         /*bidirectional=*/true);
     EXPECT_NE(nullptr, session_.GetOrCreateStream(stream_id));
-    stream_id = StreamCountToId(QuicSessionPeer::v99_streamid_manager(&session_)
-                                    ->max_incoming_unidirectional_streams(),
-                                Perspective::IS_CLIENT,
-                                /*bidirectional=*/false);
+    stream_id =
+        StreamCountToId(QuicSessionPeer::ietf_streamid_manager(&session_)
+                            ->max_incoming_unidirectional_streams(),
+                        Perspective::IS_CLIENT,
+                        /*bidirectional=*/false);
     EXPECT_NE(nullptr, session_.GetOrCreateStream(stream_id));
     EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(2);
     // Get the (max allowed stream ID)++. These should all fail.
-    stream_id = StreamCountToId(QuicSessionPeer::v99_streamid_manager(&session_)
-                                        ->max_incoming_bidirectional_streams() +
-                                    1,
-                                Perspective::IS_CLIENT,
-                                /*bidirectional=*/true);
+    stream_id =
+        StreamCountToId(QuicSessionPeer::ietf_streamid_manager(&session_)
+                                ->max_incoming_bidirectional_streams() +
+                            1,
+                        Perspective::IS_CLIENT,
+                        /*bidirectional=*/true);
     EXPECT_EQ(nullptr, session_.GetOrCreateStream(stream_id));
 
     stream_id =
-        StreamCountToId(QuicSessionPeer::v99_streamid_manager(&session_)
+        StreamCountToId(QuicSessionPeer::ietf_streamid_manager(&session_)
                                 ->max_incoming_unidirectional_streams() +
                             1,
                         Perspective::IS_CLIENT,
@@ -1669,7 +1671,7 @@
   // However, the stream ID manager does not assume stream 4 is for headers.
   // The ID manager would assume that stream#5 is streamid 24.
   // In order to make this all work out properly, kFinalStreamId will
-  // be set to GetNth...(kMaxStreams-1)... but only for V99
+  // be set to GetNth...(kMaxStreams-1)... but only for IETF QUIC
   const QuicStreamId kFirstStreamId = GetNthClientInitiatedBidirectionalId(0);
   const QuicStreamId kFinalStreamId =
       GetNthClientInitiatedBidirectionalId(kMaxStreams);
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index b17883c..178ddf3 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -65,14 +65,14 @@
                          connection->transport_version(),
                          kDefaultMaxStreamsPerConnection,
                          config_.GetMaxBidirectionalStreamsToSend()),
-      v99_streamid_manager_(perspective(),
-                            connection->version(),
-                            this,
-                            0,
-                            num_expected_unidirectional_static_streams,
-                            config_.GetMaxBidirectionalStreamsToSend(),
-                            config_.GetMaxUnidirectionalStreamsToSend() +
-                                num_expected_unidirectional_static_streams),
+      ietf_streamid_manager_(perspective(),
+                             connection->version(),
+                             this,
+                             0,
+                             num_expected_unidirectional_static_streams,
+                             config_.GetMaxBidirectionalStreamsToSend(),
+                             config_.GetMaxUnidirectionalStreamsToSend() +
+                                 num_expected_unidirectional_static_streams),
       num_draining_streams_(0),
       num_outgoing_draining_streams_(0),
       num_static_streams_(0),
@@ -841,7 +841,7 @@
 
 void QuicSession::SendGoAway(QuicErrorCode error_code,
                              const std::string& reason) {
-  // GOAWAY frame is not supported in v99.
+  // GOAWAY frame is not supported in IETF QUIC.
   DCHECK(!VersionHasIetfQuicFrames(transport_version()));
   if (transport_goaway_sent_) {
     return;
@@ -942,7 +942,7 @@
   if (IsIncomingStream(stream_id)) {
     // Stream Id manager is only interested in peer initiated stream IDs.
     if (VersionHasIetfQuicFrames(transport_version())) {
-      v99_streamid_manager_.OnStreamClosed(stream_id);
+      ietf_streamid_manager_.OnStreamClosed(stream_id);
     }
     return;
   }
@@ -956,7 +956,7 @@
   DCHECK(VersionHasIetfQuicFrames(transport_version()));
   pending_stream_map_.erase(stream_id);
   if (connection_->connected()) {
-    v99_streamid_manager_.OnStreamClosed(stream_id);
+    ietf_streamid_manager_.OnStreamClosed(stream_id);
   }
 }
 
@@ -991,7 +991,7 @@
   }
   if (IsIncomingStream(stream_id)) {
     if (VersionHasIetfQuicFrames(transport_version())) {
-      v99_streamid_manager_.OnStreamClosed(stream_id);
+      ietf_streamid_manager_.OnStreamClosed(stream_id);
     }
   } else if (!VersionHasIetfQuicFrames(transport_version())) {
     OnCanCreateNewOutgoingStream(false);
@@ -1038,14 +1038,14 @@
     }
     if (was_zero_rtt_rejected_ &&
         max_streams <
-            v99_streamid_manager_.outgoing_bidirectional_stream_count()) {
+            ietf_streamid_manager_.outgoing_bidirectional_stream_count()) {
       connection_->CloseConnection(
           QUIC_ZERO_RTT_UNRETRANSMITTABLE,
           quiche::QuicheStrCat(
               "Server rejected 0-RTT, aborting because new bidirectional "
               "initial stream limit ",
               max_streams, " is less than current open streams: ",
-              v99_streamid_manager_.outgoing_bidirectional_stream_count()),
+              ietf_streamid_manager_.outgoing_bidirectional_stream_count()),
           ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
       return;
     }
@@ -1054,7 +1054,7 @@
                   << max_streams;
     if (perspective_ == Perspective::IS_CLIENT &&
         max_streams <
-            v99_streamid_manager_.max_outgoing_bidirectional_streams()) {
+            ietf_streamid_manager_.max_outgoing_bidirectional_streams()) {
       connection_->CloseConnection(
           was_zero_rtt_rejected_ ? QUIC_ZERO_RTT_REJECTION_LIMIT_REDUCED
                                  : QUIC_ZERO_RTT_RESUMPTION_LIMIT_REDUCED,
@@ -1064,11 +1064,11 @@
                   : "",
               "new bidirectional limit ", max_streams,
               " decreases the current limit: ",
-              v99_streamid_manager_.max_outgoing_bidirectional_streams()),
+              ietf_streamid_manager_.max_outgoing_bidirectional_streams()),
           ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
       return;
     }
-    if (v99_streamid_manager_.MaybeAllowNewOutgoingBidirectionalStreams(
+    if (ietf_streamid_manager_.MaybeAllowNewOutgoingBidirectionalStreams(
             max_streams)) {
       OnCanCreateNewOutgoingStream(/*unidirectional = */ false);
     }
@@ -1080,20 +1080,20 @@
 
     if (was_zero_rtt_rejected_ &&
         max_streams <
-            v99_streamid_manager_.outgoing_unidirectional_stream_count()) {
+            ietf_streamid_manager_.outgoing_unidirectional_stream_count()) {
       connection_->CloseConnection(
           QUIC_ZERO_RTT_UNRETRANSMITTABLE,
           quiche::QuicheStrCat(
               "Server rejected 0-RTT, aborting because new unidirectional "
               "initial stream limit ",
               max_streams, " is less than current open streams: ",
-              v99_streamid_manager_.outgoing_unidirectional_stream_count()),
+              ietf_streamid_manager_.outgoing_unidirectional_stream_count()),
           ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
       return;
     }
 
     if (max_streams <
-        v99_streamid_manager_.max_outgoing_unidirectional_streams()) {
+        ietf_streamid_manager_.max_outgoing_unidirectional_streams()) {
       connection_->CloseConnection(
           was_zero_rtt_rejected_ ? QUIC_ZERO_RTT_REJECTION_LIMIT_REDUCED
                                  : QUIC_ZERO_RTT_RESUMPTION_LIMIT_REDUCED,
@@ -1103,14 +1103,14 @@
                   : "",
               "new unidirectional limit ", max_streams,
               " decreases the current limit: ",
-              v99_streamid_manager_.max_outgoing_unidirectional_streams()),
+              ietf_streamid_manager_.max_outgoing_unidirectional_streams()),
           ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
       return;
     }
     QUIC_DVLOG(1) << ENDPOINT
                   << "Setting Unidirectional outgoing_max_streams_ to "
                   << max_streams;
-    if (v99_streamid_manager_.MaybeAllowNewOutgoingUnidirectionalStreams(
+    if (ietf_streamid_manager_.MaybeAllowNewOutgoingUnidirectionalStreams(
             max_streams)) {
       OnCanCreateNewOutgoingStream(/*unidirectional = */ true);
     }
@@ -1179,9 +1179,9 @@
   }
 
   if (VersionHasIetfQuicFrames(transport_version())) {
-    v99_streamid_manager_.SetMaxOpenIncomingBidirectionalStreams(
+    ietf_streamid_manager_.SetMaxOpenIncomingBidirectionalStreams(
         config_.GetMaxBidirectionalStreamsToSend());
-    v99_streamid_manager_.SetMaxOpenIncomingUnidirectionalStreams(
+    ietf_streamid_manager_.SetMaxOpenIncomingUnidirectionalStreams(
         config_.GetMaxUnidirectionalStreamsToSend());
   } else {
     // A small number of additional incoming streams beyond the limit should be
@@ -1693,14 +1693,14 @@
 
 QuicStreamId QuicSession::GetNextOutgoingBidirectionalStreamId() {
   if (VersionHasIetfQuicFrames(transport_version())) {
-    return v99_streamid_manager_.GetNextOutgoingBidirectionalStreamId();
+    return ietf_streamid_manager_.GetNextOutgoingBidirectionalStreamId();
   }
   return stream_id_manager_.GetNextOutgoingStreamId();
 }
 
 QuicStreamId QuicSession::GetNextOutgoingUnidirectionalStreamId() {
   if (VersionHasIetfQuicFrames(transport_version())) {
-    return v99_streamid_manager_.GetNextOutgoingUnidirectionalStreamId();
+    return ietf_streamid_manager_.GetNextOutgoingUnidirectionalStreamId();
   }
   return stream_id_manager_.GetNextOutgoingStreamId();
 }
@@ -1715,11 +1715,11 @@
       return false;
     }
   } else {
-    if (!v99_streamid_manager_.CanOpenNextOutgoingBidirectionalStream()) {
+    if (!ietf_streamid_manager_.CanOpenNextOutgoingBidirectionalStream()) {
       if (is_configured_) {
         // Send STREAM_BLOCKED after config negotiated.
         control_frame_manager_.WriteOrBufferStreamsBlocked(
-            v99_streamid_manager_.max_outgoing_bidirectional_streams(),
+            ietf_streamid_manager_.max_outgoing_bidirectional_streams(),
             /*unidirectional=*/false);
       }
       return false;
@@ -1739,13 +1739,13 @@
   if (!VersionHasIetfQuicFrames(transport_version())) {
     return stream_id_manager_.CanOpenNextOutgoingStream();
   }
-  if (v99_streamid_manager_.CanOpenNextOutgoingUnidirectionalStream()) {
+  if (ietf_streamid_manager_.CanOpenNextOutgoingUnidirectionalStream()) {
     return true;
   }
   if (is_configured_) {
     // Send STREAM_BLOCKED after config negotiated.
     control_frame_manager_.WriteOrBufferStreamsBlocked(
-        v99_streamid_manager_.max_outgoing_unidirectional_streams(),
+        ietf_streamid_manager_.max_outgoing_unidirectional_streams(),
         /*unidirectional=*/true);
   }
   return false;
@@ -1754,7 +1754,7 @@
 QuicStreamCount QuicSession::GetAdvertisedMaxIncomingBidirectionalStreams()
     const {
   DCHECK(VersionHasIetfQuicFrames(transport_version()));
-  return v99_streamid_manager_.advertised_max_incoming_bidirectional_streams();
+  return ietf_streamid_manager_.advertised_max_incoming_bidirectional_streams();
 }
 
 QuicStream* QuicSession::GetOrCreateStream(const QuicStreamId stream_id) {
@@ -1800,7 +1800,7 @@
   DCHECK(QuicContainsKey(stream_map_, stream_id));
   QUIC_DVLOG(1) << ENDPOINT << "Stream " << stream_id << " is draining";
   if (VersionHasIetfQuicFrames(transport_version())) {
-    v99_streamid_manager_.OnStreamClosed(stream_id);
+    ietf_streamid_manager_.OnStreamClosed(stream_id);
   } else {
     stream_id_manager_.OnStreamClosed(
         /*is_incoming=*/IsIncomingStream(stream_id));
@@ -1816,7 +1816,7 @@
     const QuicStreamId stream_id) {
   if (VersionHasIetfQuicFrames(transport_version())) {
     std::string error_details;
-    if (v99_streamid_manager_.MaybeIncreaseLargestPeerStreamId(
+    if (ietf_streamid_manager_.MaybeIncreaseLargestPeerStreamId(
             stream_id, &error_details)) {
       return true;
     }
@@ -1871,7 +1871,7 @@
     bool unidirectional) const {
   // This method is only used in IETF QUIC.
   DCHECK(VersionHasIetfQuicFrames(transport_version()));
-  return v99_streamid_manager_.GetLargestPeerCreatedStreamId(unidirectional);
+  return ietf_streamid_manager_.GetLargestPeerCreatedStreamId(unidirectional);
 }
 
 void QuicSession::DeleteConnection() {
@@ -1901,7 +1901,7 @@
   }
 
   if (VersionHasIetfQuicFrames(transport_version())) {
-    return !v99_streamid_manager_.IsAvailableStream(id);
+    return !ietf_streamid_manager_.IsAvailableStream(id);
   }
 
   return !stream_id_manager_.IsAvailableStream(id);
@@ -1983,14 +1983,14 @@
 
 size_t QuicSession::MaxAvailableBidirectionalStreams() const {
   if (VersionHasIetfQuicFrames(transport_version())) {
-    return v99_streamid_manager_.GetMaxAllowdIncomingBidirectionalStreams();
+    return ietf_streamid_manager_.GetMaxAllowdIncomingBidirectionalStreams();
   }
   return stream_id_manager_.MaxAvailableStreams();
 }
 
 size_t QuicSession::MaxAvailableUnidirectionalStreams() const {
   if (VersionHasIetfQuicFrames(transport_version())) {
-    return v99_streamid_manager_.GetMaxAllowdIncomingUnidirectionalStreams();
+    return ietf_streamid_manager_.GetMaxAllowdIncomingUnidirectionalStreams();
   }
   return stream_id_manager_.MaxAvailableStreams();
 }
@@ -2340,14 +2340,14 @@
 
 QuicStreamId QuicSession::next_outgoing_bidirectional_stream_id() const {
   if (VersionHasIetfQuicFrames(transport_version())) {
-    return v99_streamid_manager_.next_outgoing_bidirectional_stream_id();
+    return ietf_streamid_manager_.next_outgoing_bidirectional_stream_id();
   }
   return stream_id_manager_.next_outgoing_stream_id();
 }
 
 QuicStreamId QuicSession::next_outgoing_unidirectional_stream_id() const {
   if (VersionHasIetfQuicFrames(transport_version())) {
-    return v99_streamid_manager_.next_outgoing_unidirectional_stream_id();
+    return ietf_streamid_manager_.next_outgoing_unidirectional_stream_id();
   }
   return stream_id_manager_.next_outgoing_stream_id();
 }
@@ -2355,9 +2355,9 @@
 bool QuicSession::OnMaxStreamsFrame(const QuicMaxStreamsFrame& frame) {
   const bool allow_new_streams =
       frame.unidirectional
-          ? v99_streamid_manager_.MaybeAllowNewOutgoingUnidirectionalStreams(
+          ? ietf_streamid_manager_.MaybeAllowNewOutgoingUnidirectionalStreams(
                 frame.stream_count)
-          : v99_streamid_manager_.MaybeAllowNewOutgoingBidirectionalStreams(
+          : ietf_streamid_manager_.MaybeAllowNewOutgoingBidirectionalStreams(
                 frame.stream_count);
   if (allow_new_streams) {
     OnCanCreateNewOutgoingStream(frame.unidirectional);
@@ -2368,7 +2368,7 @@
 
 bool QuicSession::OnStreamsBlockedFrame(const QuicStreamsBlockedFrame& frame) {
   std::string error_details;
-  if (v99_streamid_manager_.OnStreamsBlockedFrame(frame, &error_details)) {
+  if (ietf_streamid_manager_.OnStreamsBlockedFrame(frame, &error_details)) {
     return true;
   }
   connection_->CloseConnection(
@@ -2379,14 +2379,14 @@
 
 size_t QuicSession::max_open_incoming_bidirectional_streams() const {
   if (VersionHasIetfQuicFrames(transport_version())) {
-    return v99_streamid_manager_.GetMaxAllowdIncomingBidirectionalStreams();
+    return ietf_streamid_manager_.GetMaxAllowdIncomingBidirectionalStreams();
   }
   return stream_id_manager_.max_open_incoming_streams();
 }
 
 size_t QuicSession::max_open_incoming_unidirectional_streams() const {
   if (VersionHasIetfQuicFrames(transport_version())) {
-    return v99_streamid_manager_.GetMaxAllowdIncomingUnidirectionalStreams();
+    return ietf_streamid_manager_.GetMaxAllowdIncomingUnidirectionalStreams();
   }
   return stream_id_manager_.max_open_incoming_streams();
 }
diff --git a/quic/core/quic_session.h b/quic/core/quic_session.h
index cb2c44c..e5a0f5c 100644
--- a/quic/core/quic_session.h
+++ b/quic/core/quic_session.h
@@ -757,7 +757,7 @@
   LegacyQuicStreamIdManager stream_id_manager_;
 
   // Manages stream IDs for version99/IETF QUIC
-  UberQuicStreamIdManager v99_streamid_manager_;
+  UberQuicStreamIdManager ietf_streamid_manager_;
 
   // A counter for streams which have sent and received FIN but waiting for
   // application to consume data.
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index e39f505..4c611d1 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -2731,7 +2731,7 @@
     return;
   }
   QuicStreamId bidirectional_stream_id = StreamCountToId(
-      QuicSessionPeer::v99_streamid_manager(&session_)
+      QuicSessionPeer::ietf_streamid_manager(&session_)
               ->advertised_max_incoming_bidirectional_streams() -
           1,
       Perspective::IS_CLIENT,
@@ -2743,7 +2743,7 @@
   session_.OnStreamFrame(bidirectional_stream_frame);
 
   QuicStreamId unidirectional_stream_id = StreamCountToId(
-      QuicSessionPeer::v99_streamid_manager(&session_)
+      QuicSessionPeer::ietf_streamid_manager(&session_)
               ->advertised_max_incoming_unidirectional_streams() -
           1,
       Perspective::IS_CLIENT,
@@ -2761,7 +2761,7 @@
     return;
   }
   QuicStreamId bidirectional_stream_id =
-      StreamCountToId(QuicSessionPeer::v99_streamid_manager(&session_)
+      StreamCountToId(QuicSessionPeer::ietf_streamid_manager(&session_)
                           ->advertised_max_incoming_bidirectional_streams(),
                       Perspective::IS_CLIENT, /*bidirectional=*/true);
   QuicStreamFrame bidirectional_stream_frame(bidirectional_stream_id, false, 0,
@@ -2770,7 +2770,7 @@
   session_.OnStreamFrame(bidirectional_stream_frame);
 
   QuicStreamId unidirectional_stream_id =
-      StreamCountToId(QuicSessionPeer::v99_streamid_manager(&session_)
+      StreamCountToId(QuicSessionPeer::ietf_streamid_manager(&session_)
                           ->advertised_max_incoming_unidirectional_streams(),
                       Perspective::IS_CLIENT, /*bidirectional=*/false);
   QuicStreamFrame unidirectional_stream_frame(unidirectional_stream_id, false,
@@ -2787,7 +2787,7 @@
   }
 
   QuicStreamId bidirectional_stream_id = StreamCountToId(
-      QuicSessionPeer::v99_streamid_manager(&session_)
+      QuicSessionPeer::ietf_streamid_manager(&session_)
               ->advertised_max_incoming_bidirectional_streams() +
           1,
       Perspective::IS_CLIENT, /*bidirectional=*/true);
@@ -2800,7 +2800,7 @@
   session_.OnStreamFrame(bidirectional_stream_frame);
 
   QuicStreamId unidirectional_stream_id = StreamCountToId(
-      QuicSessionPeer::v99_streamid_manager(&session_)
+      QuicSessionPeer::ietf_streamid_manager(&session_)
               ->advertised_max_incoming_unidirectional_streams() +
           1,
       Perspective::IS_CLIENT, /*bidirectional=*/false);
diff --git a/quic/core/tls_client_handshaker_test.cc b/quic/core/tls_client_handshaker_test.cc
index 132e636..bfd937f 100644
--- a/quic/core/tls_client_handshaker_test.cc
+++ b/quic/core/tls_client_handshaker_test.cc
@@ -634,7 +634,7 @@
   CreateConnection();
 
   stream()->CryptoConnect();
-  auto* id_manager = QuicSessionPeer::v99_streamid_manager(session_.get());
+  auto* id_manager = QuicSessionPeer::ietf_streamid_manager(session_.get());
   EXPECT_EQ(kDefaultMaxStreamsPerConnection,
             id_manager->max_outgoing_bidirectional_streams());
   QuicConfig config;
diff --git a/quic/test_tools/quic_session_peer.cc b/quic/test_tools/quic_session_peer.cc
index 05d74d7..a57840e 100644
--- a/quic/test_tools/quic_session_peer.cc
+++ b/quic/test_tools/quic_session_peer.cc
@@ -28,7 +28,7 @@
 void QuicSessionPeer::SetNextOutgoingBidirectionalStreamId(QuicSession* session,
                                                            QuicStreamId id) {
   if (VersionHasIetfQuicFrames(session->transport_version())) {
-    session->v99_streamid_manager_.bidirectional_stream_id_manager_
+    session->ietf_streamid_manager_.bidirectional_stream_id_manager_
         .next_outgoing_stream_id_ = id;
     return;
   }
@@ -40,9 +40,9 @@
                                                 uint32_t max_streams) {
   if (VersionHasIetfQuicFrames(session->transport_version())) {
     QUIC_BUG << "SetmaxOpenIncomingStreams deprecated for IETF QUIC";
-    session->v99_streamid_manager_.SetMaxOpenIncomingUnidirectionalStreams(
+    session->ietf_streamid_manager_.SetMaxOpenIncomingUnidirectionalStreams(
         max_streams);
-    session->v99_streamid_manager_.SetMaxOpenIncomingBidirectionalStreams(
+    session->ietf_streamid_manager_.SetMaxOpenIncomingBidirectionalStreams(
         max_streams);
     return;
   }
@@ -56,7 +56,7 @@
   DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
       << "SetmaxOpenIncomingBidirectionalStreams not supported for Google "
          "QUIC";
-  session->v99_streamid_manager_.SetMaxOpenIncomingBidirectionalStreams(
+  session->ietf_streamid_manager_.SetMaxOpenIncomingBidirectionalStreams(
       max_streams);
 }
 // static
@@ -66,7 +66,7 @@
   DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
       << "SetmaxOpenIncomingUnidirectionalStreams not supported for Google "
          "QUIC";
-  session->v99_streamid_manager_.SetMaxOpenIncomingUnidirectionalStreams(
+  session->ietf_streamid_manager_.SetMaxOpenIncomingUnidirectionalStreams(
       max_streams);
 }
 
@@ -87,7 +87,7 @@
   DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
       << "SetmaxOpenOutgoingBidirectionalStreams not supported for Google "
          "QUIC";
-  session->v99_streamid_manager_.MaybeAllowNewOutgoingBidirectionalStreams(
+  session->ietf_streamid_manager_.MaybeAllowNewOutgoingBidirectionalStreams(
       max_streams);
 }
 // static
@@ -97,7 +97,7 @@
   DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
       << "SetmaxOpenOutgoingUnidirectionalStreams not supported for Google "
          "QUIC";
-  session->v99_streamid_manager_.MaybeAllowNewOutgoingUnidirectionalStreams(
+  session->ietf_streamid_manager_.MaybeAllowNewOutgoingUnidirectionalStreams(
       max_streams);
 }
 
@@ -157,12 +157,12 @@
   if (VersionHasIetfQuicFrames(session->transport_version())) {
     if (id % QuicUtils::StreamIdDelta(session->transport_version()) < 2) {
       return QuicContainsKey(
-          session->v99_streamid_manager_.bidirectional_stream_id_manager_
+          session->ietf_streamid_manager_.bidirectional_stream_id_manager_
               .available_streams_,
           id);
     }
     return QuicContainsKey(
-        session->v99_streamid_manager_.unidirectional_stream_id_manager_
+        session->ietf_streamid_manager_.unidirectional_stream_id_manager_
             .available_streams_,
         id);
   }
@@ -192,21 +192,21 @@
 }
 
 // static
-UberQuicStreamIdManager* QuicSessionPeer::v99_streamid_manager(
+UberQuicStreamIdManager* QuicSessionPeer::ietf_streamid_manager(
     QuicSession* session) {
-  return &session->v99_streamid_manager_;
+  return &session->ietf_streamid_manager_;
 }
 
 // static
-QuicStreamIdManager* QuicSessionPeer::v99_bidirectional_stream_id_manager(
+QuicStreamIdManager* QuicSessionPeer::ietf_bidirectional_stream_id_manager(
     QuicSession* session) {
-  return &session->v99_streamid_manager_.bidirectional_stream_id_manager_;
+  return &session->ietf_streamid_manager_.bidirectional_stream_id_manager_;
 }
 
 // static
-QuicStreamIdManager* QuicSessionPeer::v99_unidirectional_stream_id_manager(
+QuicStreamIdManager* QuicSessionPeer::ietf_unidirectional_stream_id_manager(
     QuicSession* session) {
-  return &session->v99_streamid_manager_.unidirectional_stream_id_manager_;
+  return &session->ietf_streamid_manager_.unidirectional_stream_id_manager_;
 }
 
 // static
diff --git a/quic/test_tools/quic_session_peer.h b/quic/test_tools/quic_session_peer.h
index ffd6c6f..9a6fdef 100644
--- a/quic/test_tools/quic_session_peer.h
+++ b/quic/test_tools/quic_session_peer.h
@@ -71,10 +71,10 @@
   static bool IsStreamWriteBlocked(QuicSession* session, QuicStreamId id);
   static QuicAlarm* GetCleanUpClosedStreamsAlarm(QuicSession* session);
   static LegacyQuicStreamIdManager* GetStreamIdManager(QuicSession* session);
-  static UberQuicStreamIdManager* v99_streamid_manager(QuicSession* session);
-  static QuicStreamIdManager* v99_bidirectional_stream_id_manager(
+  static UberQuicStreamIdManager* ietf_streamid_manager(QuicSession* session);
+  static QuicStreamIdManager* ietf_bidirectional_stream_id_manager(
       QuicSession* session);
-  static QuicStreamIdManager* v99_unidirectional_stream_id_manager(
+  static QuicStreamIdManager* ietf_unidirectional_stream_id_manager(
       QuicSession* session);
   static PendingStream* GetPendingStream(QuicSession* session,
                                          QuicStreamId stream_id);