diff --git a/quic/core/http/quic_headers_stream.cc b/quic/core/http/quic_headers_stream.cc
index 9c99ab7..394d42a 100644
--- a/quic/core/http/quic_headers_stream.cc
+++ b/quic/core/http/quic_headers_stream.cc
@@ -27,8 +27,7 @@
 QuicHeadersStream::CompressedHeaderInfo::~CompressedHeaderInfo() {}
 
 QuicHeadersStream::QuicHeadersStream(QuicSpdySession* session)
-    : QuicStream(QuicUtils::GetHeadersStreamId(
-                     session->connection()->transport_version()),
+    : QuicStream(QuicUtils::GetHeadersStreamId(session->transport_version()),
                  session,
                  /*is_static=*/true,
                  BIDIRECTIONAL),
diff --git a/quic/core/http/quic_headers_stream_test.cc b/quic/core/http/quic_headers_stream_test.cc
index 2035d47..cfc5381 100644
--- a/quic/core/http/quic_headers_stream_test.cc
+++ b/quic/core/http/quic_headers_stream_test.cc
@@ -202,7 +202,7 @@
     deframer_ = std::unique_ptr<http2::Http2DecoderAdapter>(
         new http2::Http2DecoderAdapter());
     deframer_->set_visitor(&visitor_);
-    EXPECT_EQ(transport_version(), session_.connection()->transport_version());
+    EXPECT_EQ(transport_version(), session_.transport_version());
     EXPECT_TRUE(headers_stream_ != nullptr);
     connection_->AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
     client_id_1_ = GetNthClientInitiatedBidirectionalStreamId(
diff --git a/quic/core/http/quic_server_session_base.cc b/quic/core/http/quic_server_session_base.cc
index 29bce86..5805fc9 100644
--- a/quic/core/http/quic_server_session_base.cc
+++ b/quic/core/http/quic_server_session_base.cc
@@ -201,8 +201,7 @@
     return false;
   }
 
-  if (QuicUtils::IsServerInitiatedStreamId(connection()->transport_version(),
-                                           id)) {
+  if (QuicUtils::IsServerInitiatedStreamId(transport_version(), id)) {
     QUIC_DLOG(INFO) << "Invalid incoming even stream_id:" << id;
     connection()->CloseConnection(
         QUIC_INVALID_STREAM_ID, "Client created even numbered stream",
@@ -224,7 +223,7 @@
   }
 
   if (!GetQuicReloadableFlag(quic_use_common_stream_check) &&
-      !VersionHasIetfQuicFrames(connection()->transport_version())) {
+      !VersionHasIetfQuicFrames(transport_version())) {
     if (GetNumOpenOutgoingStreams() >=
         stream_id_manager().max_open_outgoing_streams()) {
       QUIC_VLOG(1) << "No more streams should be created. "
@@ -248,7 +247,7 @@
   }
 
   if (!GetQuicReloadableFlag(quic_use_common_stream_check) &&
-      !VersionHasIetfQuicFrames(connection()->transport_version())) {
+      !VersionHasIetfQuicFrames(transport_version())) {
     if (GetNumOpenOutgoingStreams() >=
         stream_id_manager().max_open_outgoing_streams()) {
       QUIC_VLOG(1) << "No more streams should be created. "
diff --git a/quic/core/http/quic_spdy_client_session.cc b/quic/core/http/quic_spdy_client_session.cc
index 50ed00d..ef9f2e2 100644
--- a/quic/core/http/quic_spdy_client_session.cc
+++ b/quic/core/http/quic_spdy_client_session.cc
@@ -53,7 +53,7 @@
     return false;
   }
   if (!GetQuicReloadableFlag(quic_use_common_stream_check) &&
-      !VersionHasIetfQuicFrames(connection()->transport_version())) {
+      !VersionHasIetfQuicFrames(transport_version())) {
     if (GetNumOpenOutgoingStreams() >=
         stream_id_manager().max_open_outgoing_streams()) {
       QUIC_DLOG(INFO) << "Failed to create a new outgoing stream. "
@@ -136,9 +136,8 @@
                     << "Already received goaway.";
     return false;
   }
-  if (QuicUtils::IsClientInitiatedStreamId(connection()->transport_version(),
-                                           id) ||
-      (VersionHasIetfQuicFrames(connection()->transport_version()) &&
+  if (QuicUtils::IsClientInitiatedStreamId(transport_version(), id) ||
+      (VersionHasIetfQuicFrames(transport_version()) &&
        QuicUtils::IsBidirectionalStreamId(id))) {
     QUIC_LOG(WARNING) << "Received invalid push stream id " << id;
     connection()->CloseConnection(
diff --git a/quic/core/http/quic_spdy_client_session_base.cc b/quic/core/http/quic_spdy_client_session_base.cc
index a2a9aae..37e5dd5 100644
--- a/quic/core/http/quic_spdy_client_session_base.cc
+++ b/quic/core/http/quic_spdy_client_session_base.cc
@@ -43,7 +43,7 @@
     CryptoHandshakeEvent event) {
   QuicSpdySession::OnCryptoHandshakeEvent(event);
   if (event == HANDSHAKE_CONFIRMED && max_allowed_push_id() > 0 &&
-      VersionHasIetfQuicFrames(connection()->transport_version())) {
+      VersionHasIetfQuicFrames(transport_version())) {
     SendMaxPushId(max_allowed_push_id());
   }
 }
@@ -75,9 +75,9 @@
     return;
   }
   if (promised_stream_id !=
-          QuicUtils::GetInvalidStreamId(connection()->transport_version()) &&
+          QuicUtils::GetInvalidStreamId(transport_version()) &&
       largest_promised_stream_id_ !=
-          QuicUtils::GetInvalidStreamId(connection()->transport_version()) &&
+          QuicUtils::GetInvalidStreamId(transport_version()) &&
       promised_stream_id <= largest_promised_stream_id_) {
     connection()->CloseConnection(
         QUIC_INVALID_STREAM_ID,
@@ -93,7 +93,7 @@
     return;
   }
 
-  if (VersionHasIetfQuicFrames(connection()->transport_version()) &&
+  if (VersionHasIetfQuicFrames(transport_version()) &&
       promised_stream_id > max_allowed_push_id()) {
     connection()->CloseConnection(
         QUIC_INVALID_STREAM_ID,
@@ -199,7 +199,7 @@
   // ToDo: Consider implementing logic to send a new MAX_PUSH_ID frame to allow
   // another stream to be promised.
   promised_by_id_.erase(promised->id());
-  if (!VersionUsesQpack(connection()->transport_version())) {
+  if (!VersionUsesQpack(transport_version())) {
     headers_stream()->MaybeReleaseSequencerBuffer();
   }
 }
@@ -219,7 +219,7 @@
 void QuicSpdyClientSessionBase::CloseStreamInner(QuicStreamId stream_id,
                                                  bool locally_reset) {
   QuicSpdySession::CloseStreamInner(stream_id, locally_reset);
-  if (!VersionUsesQpack(connection()->transport_version())) {
+  if (!VersionUsesQpack(transport_version())) {
     headers_stream()->MaybeReleaseSequencerBuffer();
   }
 }
diff --git a/quic/core/http/quic_spdy_server_stream_base_test.cc b/quic/core/http/quic_spdy_server_stream_base_test.cc
index 15638ca..1888e03 100644
--- a/quic/core/http/quic_spdy_server_stream_base_test.cc
+++ b/quic/core/http/quic_spdy_server_stream_base_test.cc
@@ -31,10 +31,10 @@
       : session_(new MockQuicConnection(&helper_,
                                         &alarm_factory_,
                                         Perspective::IS_SERVER)) {
-    stream_ = new TestQuicSpdyServerStream(
-        GetNthClientInitiatedBidirectionalStreamId(
-            session_.connection()->transport_version(), 0),
-        &session_, BIDIRECTIONAL);
+    stream_ =
+        new TestQuicSpdyServerStream(GetNthClientInitiatedBidirectionalStreamId(
+                                         session_.transport_version(), 0),
+                                     &session_, BIDIRECTIONAL);
     session_.ActivateStream(QuicWrapUnique(stream_));
     helper_.AdvanceTime(QuicTime::Delta::FromSeconds(1));
   }
@@ -59,7 +59,7 @@
 
   EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
 
-  if (!VersionHasIetfQuicFrames(session_.connection()->transport_version())) {
+  if (!VersionHasIetfQuicFrames(session_.transport_version())) {
     EXPECT_CALL(session_, SendRstStream(_, QUIC_RST_ACKNOWLEDGEMENT, _))
         .Times(1);
   } else {
@@ -76,7 +76,7 @@
   QuicRstStreamFrame rst_frame(kInvalidControlFrameId, stream_->id(),
                                QUIC_STREAM_CANCELLED, 1234);
   stream_->OnStreamReset(rst_frame);
-  if (VersionHasIetfQuicFrames(session_.connection()->transport_version())) {
+  if (VersionHasIetfQuicFrames(session_.transport_version())) {
     // Create and inject a STOP SENDING frame to complete the close
     // of the stream. This is only needed for version 99/IETF QUIC.
     QuicStopSendingFrame stop_sending(
diff --git a/quic/core/http/quic_spdy_session.cc b/quic/core/http/quic_spdy_session.cc
index 719b3dc..e626f2a 100644
--- a/quic/core/http/quic_spdy_session.cc
+++ b/quic/core/http/quic_spdy_session.cc
@@ -186,7 +186,7 @@
       return;
     }
 
-    if (VersionUsesQpack(session_->connection()->transport_version())) {
+    if (VersionUsesQpack(session_->transport_version())) {
       CloseConnection("HEADERS frame not allowed on headers stream.",
                       QUIC_INVALID_HEADERS_STREAM_DATA);
       return;
@@ -239,7 +239,7 @@
                   int weight,
                   bool exclusive) override {
     DCHECK(!VersionUsesQpack(session_->transport_version()));
-    if (session_->connection()->transport_version() <= QUIC_VERSION_39) {
+    if (session_->transport_version() <= QUIC_VERSION_39) {
       CloseConnection("SPDY PRIORITY frame received.",
                       QUIC_INVALID_HEADERS_STREAM_DATA);
       return;
@@ -368,17 +368,17 @@
 void QuicSpdySession::Initialize() {
   QuicSession::Initialize();
 
-  if (!VersionUsesQpack(connection()->transport_version())) {
+  if (!VersionUsesQpack(transport_version())) {
     if (perspective() == Perspective::IS_SERVER) {
       set_largest_peer_created_stream_id(
-          QuicUtils::GetHeadersStreamId(connection()->transport_version()));
+          QuicUtils::GetHeadersStreamId(transport_version()));
     } else {
       QuicStreamId headers_stream_id = GetNextOutgoingBidirectionalStreamId();
-      DCHECK_EQ(headers_stream_id, QuicUtils::GetHeadersStreamId(
-                                       connection()->transport_version()));
+      DCHECK_EQ(headers_stream_id,
+                QuicUtils::GetHeadersStreamId(transport_version()));
     }
     auto headers_stream = QuicMakeUnique<QuicHeadersStream>((this));
-    DCHECK_EQ(QuicUtils::GetHeadersStreamId(connection()->transport_version()),
+    DCHECK_EQ(QuicUtils::GetHeadersStreamId(transport_version()),
               headers_stream->id());
 
     headers_stream_ = headers_stream.get();
@@ -403,14 +403,14 @@
 }
 
 void QuicSpdySession::OnDecoderStreamError(QuicStringPiece /*error_message*/) {
-  DCHECK(VersionUsesQpack(connection()->transport_version()));
+  DCHECK(VersionUsesQpack(transport_version()));
 
   // TODO(112770235): Signal connection error on decoder stream errors.
   QUIC_NOTREACHED();
 }
 
 void QuicSpdySession::OnEncoderStreamError(QuicStringPiece /*error_message*/) {
-  DCHECK(VersionUsesQpack(connection()->transport_version()));
+  DCHECK(VersionUsesQpack(transport_version()));
 
   // TODO(112770235): Signal connection error on encoder stream errors.
   QUIC_NOTREACHED();
@@ -491,7 +491,7 @@
     bool fin,
     const spdy::SpdyStreamPrecedence& precedence,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
-  DCHECK(!VersionUsesQpack(connection()->transport_version()));
+  DCHECK(!VersionUsesQpack(transport_version()));
 
   return WriteHeadersOnHeadersStreamImpl(
       id, std::move(headers), fin,
@@ -504,8 +504,8 @@
                                       QuicStreamId parent_stream_id,
                                       int weight,
                                       bool exclusive) {
-  DCHECK(!VersionUsesQpack(connection()->transport_version()));
-  if (connection()->transport_version() <= QUIC_VERSION_39) {
+  DCHECK(!VersionUsesQpack(transport_version()));
+  if (transport_version() <= QUIC_VERSION_39) {
     return 0;
   }
   SpdyPriorityIR priority_frame(id, parent_stream_id, weight, exclusive);
@@ -516,7 +516,7 @@
 }
 
 void QuicSpdySession::WriteH3Priority(const PriorityFrame& priority) {
-  DCHECK(VersionHasStreamType(connection()->transport_version()));
+  DCHECK(VersionHasStreamType(transport_version()));
   DCHECK(perspective() == Perspective::IS_CLIENT)
       << "Server must not send priority";
 
@@ -533,14 +533,14 @@
     return;
   }
 
-  if (VersionHasIetfQuicFrames(connection()->transport_version()) &&
+  if (VersionHasIetfQuicFrames(transport_version()) &&
       promised_stream_id > max_allowed_push_id()) {
     QUIC_BUG
         << "Server shouldn't send push id higher than client's MAX_PUSH_ID.";
     return;
   }
 
-  if (!VersionHasStreamType(connection()->transport_version())) {
+  if (!VersionHasStreamType(transport_version())) {
     SpdyPushPromiseIR push_promise(original_stream_id, promised_stream_id,
                                    std::move(headers));
     // PUSH_PROMISE must not be the last frame sent out, at least followed by
@@ -564,7 +564,7 @@
 }
 
 void QuicSpdySession::SendMaxHeaderListSize(size_t value) {
-  if (VersionHasStreamType(connection()->transport_version())) {
+  if (VersionHasStreamType(transport_version())) {
     QuicConnection::ScopedPacketFlusher flusher(connection());
     send_control_stream_->MaybeSendSettingsFrame();
     // TODO(renjietang): Remove this once stream id manager can take dynamically
@@ -587,13 +587,13 @@
 }
 
 QpackEncoder* QuicSpdySession::qpack_encoder() {
-  DCHECK(VersionUsesQpack(connection()->transport_version()));
+  DCHECK(VersionUsesQpack(transport_version()));
 
   return qpack_encoder_.get();
 }
 
 QpackDecoder* QuicSpdySession::qpack_decoder() {
-  DCHECK(VersionUsesQpack(connection()->transport_version()));
+  DCHECK(VersionUsesQpack(transport_version()));
 
   return qpack_decoder_.get();
 }
@@ -645,7 +645,7 @@
   // QuicSpdySession supports PendingStreams, therefore this method should
   // eventually just return true.  However, pending streams can only be used if
   // unidirectional stream type is supported.
-  return VersionHasStreamType(connection()->transport_version());
+  return VersionHasStreamType(transport_version());
 }
 
 size_t QuicSpdySession::WriteHeadersOnHeadersStreamImpl(
@@ -656,7 +656,7 @@
     int weight,
     bool exclusive,
     QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
-  DCHECK(!VersionUsesQpack(connection()->transport_version()));
+  DCHECK(!VersionUsesQpack(transport_version()));
 
   SpdyHeadersIR headers_frame(id, std::move(headers));
   headers_frame.set_fin(fin);
@@ -686,7 +686,7 @@
 }
 
 void QuicSpdySession::OnSetting(uint64_t id, uint64_t value) {
-  if (VersionHasStreamType(connection()->transport_version())) {
+  if (VersionHasStreamType(transport_version())) {
     // SETTINGS frame received on the control stream.
     switch (id) {
       case SETTINGS_QPACK_MAX_TABLE_CAPACITY:
@@ -798,9 +798,8 @@
       return;
     }
   }
-  DCHECK_EQ(QuicUtils::GetInvalidStreamId(connection()->transport_version()),
-            stream_id_);
-  DCHECK_EQ(QuicUtils::GetInvalidStreamId(connection()->transport_version()),
+  DCHECK_EQ(QuicUtils::GetInvalidStreamId(transport_version()), stream_id_);
+  DCHECK_EQ(QuicUtils::GetInvalidStreamId(transport_version()),
             promised_stream_id_);
   stream_id_ = stream_id;
   fin_ = fin;
@@ -808,9 +807,8 @@
 
 void QuicSpdySession::OnPushPromise(SpdyStreamId stream_id,
                                     SpdyStreamId promised_stream_id) {
-  DCHECK_EQ(QuicUtils::GetInvalidStreamId(connection()->transport_version()),
-            stream_id_);
-  DCHECK_EQ(QuicUtils::GetInvalidStreamId(connection()->transport_version()),
+  DCHECK_EQ(QuicUtils::GetInvalidStreamId(transport_version()), stream_id_);
+  DCHECK_EQ(QuicUtils::GetInvalidStreamId(transport_version()),
             promised_stream_id_);
   stream_id_ = stream_id;
   promised_stream_id_ = promised_stream_id;
@@ -832,21 +830,20 @@
   QUIC_DVLOG(1) << "Received header list for stream " << stream_id_ << ": "
                 << header_list.DebugString();
   // This code path is only executed for push promise in IETF QUIC.
-  if (VersionUsesQpack(connection()->transport_version())) {
+  if (VersionUsesQpack(transport_version())) {
     DCHECK(promised_stream_id_ !=
-           QuicUtils::GetInvalidStreamId(connection()->transport_version()));
+           QuicUtils::GetInvalidStreamId(transport_version()));
   }
   if (promised_stream_id_ ==
-      QuicUtils::GetInvalidStreamId(connection()->transport_version())) {
+      QuicUtils::GetInvalidStreamId(transport_version())) {
     OnStreamHeaderList(stream_id_, fin_, frame_len_, header_list);
   } else {
     OnPromiseHeaderList(stream_id_, promised_stream_id_, frame_len_,
                         header_list);
   }
   // Reset state for the next frame.
-  promised_stream_id_ =
-      QuicUtils::GetInvalidStreamId(connection()->transport_version());
-  stream_id_ = QuicUtils::GetInvalidStreamId(connection()->transport_version());
+  promised_stream_id_ = QuicUtils::GetInvalidStreamId(transport_version());
+  stream_id_ = QuicUtils::GetInvalidStreamId(transport_version());
   fin_ = false;
   frame_len_ = 0;
 }
@@ -894,7 +891,7 @@
 }
 
 bool QuicSpdySession::ProcessPendingStream(PendingStream* pending) {
-  DCHECK(VersionHasStreamType(connection()->transport_version()));
+  DCHECK(VersionHasStreamType(transport_version()));
   DCHECK(connection()->connected());
   struct iovec iov;
   if (!pending->sequencer()->GetReadableRegion(&iov)) {
@@ -968,7 +965,7 @@
 }
 
 void QuicSpdySession::MaybeInitializeHttp3UnidirectionalStreams() {
-  DCHECK(VersionHasStreamType(connection()->transport_version()));
+  DCHECK(VersionHasStreamType(transport_version()));
   if (!send_control_stream_ && CanOpenNextOutgoingUnidirectionalStream()) {
     auto send_control = QuicMakeUnique<QuicSendControlStream>(
         GetNextOutgoingUnidirectionalStreamId(), this,
@@ -999,15 +996,14 @@
 }
 
 void QuicSpdySession::OnCanCreateNewOutgoingStream(bool unidirectional) {
-  if (unidirectional &&
-      VersionHasStreamType(connection()->transport_version())) {
+  if (unidirectional && VersionHasStreamType(transport_version())) {
     MaybeInitializeHttp3UnidirectionalStreams();
   }
 }
 
 void QuicSpdySession::set_max_allowed_push_id(
     QuicStreamId max_allowed_push_id) {
-  if (VersionHasIetfQuicFrames(connection()->transport_version()) &&
+  if (VersionHasIetfQuicFrames(transport_version()) &&
       perspective() == Perspective::IS_SERVER &&
       max_allowed_push_id > max_allowed_push_id_) {
     OnCanCreateNewOutgoingStream(true);
@@ -1015,14 +1011,14 @@
 
   max_allowed_push_id_ = max_allowed_push_id;
 
-  if (VersionHasIetfQuicFrames(connection()->transport_version()) &&
+  if (VersionHasIetfQuicFrames(transport_version()) &&
       perspective() == Perspective::IS_CLIENT && IsHandshakeConfirmed()) {
     SendMaxPushId(max_allowed_push_id);
   }
 }
 
 void QuicSpdySession::SendMaxPushId(QuicStreamId max_allowed_push_id) {
-  DCHECK(VersionHasStreamType(connection()->transport_version()));
+  DCHECK(VersionHasStreamType(transport_version()));
   send_control_stream_->SendMaxPushIdFrame(max_allowed_push_id);
 }
 
diff --git a/quic/core/http/quic_spdy_stream.cc b/quic/core/http/quic_spdy_stream.cc
index 28bcdcf..d77cfef 100644
--- a/quic/core/http/quic_spdy_stream.cc
+++ b/quic/core/http/quic_spdy_stream.cc
@@ -199,8 +199,7 @@
       is_decoder_processing_input_(false),
       ack_listener_(nullptr) {
   DCHECK_EQ(session()->connection(), spdy_session->connection());
-  DCHECK_EQ(transport_version(),
-            spdy_session->connection()->transport_version());
+  DCHECK_EQ(transport_version(), spdy_session->transport_version());
   DCHECK(!QuicUtils::IsCryptoStreamId(transport_version(), id));
   DCHECK_EQ(0u, sequencer()->NumBytesConsumed());
   // If headers are sent on the headers stream, then do not receive any
@@ -234,8 +233,7 @@
       is_decoder_processing_input_(false),
       ack_listener_(nullptr) {
   DCHECK_EQ(session()->connection(), spdy_session->connection());
-  DCHECK_EQ(transport_version(),
-            spdy_session->connection()->transport_version());
+  DCHECK_EQ(transport_version(), spdy_session->transport_version());
   DCHECK(!QuicUtils::IsCryptoStreamId(transport_version(), id()));
   // If headers are sent on the headers stream, then do not receive any
   // callbacks from the sequencer until headers are complete.
@@ -983,8 +981,7 @@
 
 void QuicSpdyStream::ProcessDecodedHeaders(const QuicHeaderList& headers) {
   if (spdy_session_->promised_stream_id() ==
-      QuicUtils::GetInvalidStreamId(
-          session()->connection()->transport_version())) {
+      QuicUtils::GetInvalidStreamId(session()->transport_version())) {
     const QuicByteCount frame_length = headers_decompressed_
                                            ? trailers_payload_length_
                                            : headers_payload_length_;
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index e09cbf4..572ba5c 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -1527,11 +1527,11 @@
       SupportedVersions(GetParam()));
   std::unique_ptr<TestMockUpdateStreamSession> session(
       new StrictMock<TestMockUpdateStreamSession>(connection));
-  auto stream = new StrictMock<TestStream>(
-      GetNthClientInitiatedBidirectionalStreamId(
-          session->connection()->transport_version(), 0),
-      session.get(),
-      /*should_process_data=*/true);
+  auto stream =
+      new StrictMock<TestStream>(GetNthClientInitiatedBidirectionalStreamId(
+                                     session->transport_version(), 0),
+                                 session.get(),
+                                 /*should_process_data=*/true);
   session->ActivateStream(QuicWrapUnique(stream));
 
   // QuicSpdyStream::SetPriority() should eventually call UpdateStreamPriority()
diff --git a/quic/core/legacy_quic_stream_id_manager.cc b/quic/core/legacy_quic_stream_id_manager.cc
index a7ec123..157e375 100644
--- a/quic/core/legacy_quic_stream_id_manager.cc
+++ b/quic/core/legacy_quic_stream_id_manager.cc
@@ -19,19 +19,17 @@
     : session_(session),
       max_open_outgoing_streams_(max_open_outgoing_streams),
       max_open_incoming_streams_(max_open_incoming_streams),
-      next_outgoing_stream_id_(QuicUtils::GetFirstBidirectionalStreamId(
-          session->connection()->transport_version(),
-          session->perspective())),
+      next_outgoing_stream_id_(
+          QuicUtils::GetFirstBidirectionalStreamId(session->transport_version(),
+                                                   session->perspective())),
       largest_peer_created_stream_id_(
           session->perspective() == Perspective::IS_SERVER
-              ? (QuicVersionUsesCryptoFrames(
-                     session->connection()->transport_version())
+              ? (QuicVersionUsesCryptoFrames(session->transport_version())
                      ? QuicUtils::GetInvalidStreamId(
-                           session->connection()->transport_version())
+                           session->transport_version())
                      : QuicUtils::GetCryptoStreamId(
-                           session->connection()->transport_version()))
-              : QuicUtils::GetInvalidStreamId(
-                    session->connection()->transport_version())) {}
+                           session->transport_version()))
+              : QuicUtils::GetInvalidStreamId(session->transport_version())) {}
 
 LegacyQuicStreamIdManager::~LegacyQuicStreamIdManager() {
   QUIC_LOG_IF(WARNING,
@@ -71,8 +69,7 @@
   available_streams_.erase(stream_id);
 
   if (largest_peer_created_stream_id_ !=
-          QuicUtils::GetInvalidStreamId(
-              session_->connection()->transport_version()) &&
+          QuicUtils::GetInvalidStreamId(session_->transport_version()) &&
       stream_id <= largest_peer_created_stream_id_) {
     return true;
   }
@@ -83,8 +80,7 @@
   size_t additional_available_streams =
       (stream_id - largest_peer_created_stream_id_) / 2 - 1;
   if (largest_peer_created_stream_id_ ==
-      QuicUtils::GetInvalidStreamId(
-          session_->connection()->transport_version())) {
+      QuicUtils::GetInvalidStreamId(session_->transport_version())) {
     additional_available_streams = (stream_id + 1) / 2 - 1;
   }
   size_t new_num_available_streams =
@@ -105,10 +101,9 @@
   }
   QuicStreamId first_available_stream = largest_peer_created_stream_id_ + 2;
   if (largest_peer_created_stream_id_ ==
-      QuicUtils::GetInvalidStreamId(
-          session_->connection()->transport_version())) {
+      QuicUtils::GetInvalidStreamId(session_->transport_version())) {
     first_available_stream = QuicUtils::GetFirstBidirectionalStreamId(
-        session_->connection()->transport_version(),
+        session_->transport_version(),
         QuicUtils::InvertPerspective(session_->perspective()));
   }
   for (QuicStreamId id = first_available_stream; id < stream_id; id += 2) {
@@ -133,8 +128,7 @@
   }
   // For peer created streams, we also need to consider available streams.
   return largest_peer_created_stream_id_ ==
-             QuicUtils::GetInvalidStreamId(
-                 session_->connection()->transport_version()) ||
+             QuicUtils::GetInvalidStreamId(session_->transport_version()) ||
          id > largest_peer_created_stream_id_ ||
          QuicContainsKey(available_streams_, id);
 }
diff --git a/quic/core/quic_crypto_client_handshaker.cc b/quic/core/quic_crypto_client_handshaker.cc
index ac15301..a8a479e 100644
--- a/quic/core/quic_crypto_client_handshaker.cc
+++ b/quic/core/quic_crypto_client_handshaker.cc
@@ -154,7 +154,7 @@
       crypto_config_->LookupOrCreate(server_id_);
   QuicErrorCode error = crypto_config_->ProcessServerConfigUpdate(
       server_config_update, session()->connection()->clock()->WallNow(),
-      session()->connection()->transport_version(), chlo_hash_, cached,
+      session()->transport_version(), chlo_hash_, cached,
       crypto_negotiated_params_, &error_details);
 
   if (error != QUIC_NO_ERROR) {
@@ -373,7 +373,7 @@
   std::string error_details;
   QuicErrorCode error = crypto_config_->ProcessRejection(
       *in, session()->connection()->clock()->WallNow(),
-      session()->connection()->transport_version(), chlo_hash_, cached,
+      session()->transport_version(), chlo_hash_, cached,
       crypto_negotiated_params_, &error_details);
 
   if (error != QUIC_NO_ERROR) {
@@ -409,7 +409,7 @@
 
   QuicAsyncStatus status = verifier->VerifyProof(
       server_id_.host(), server_id_.port(), cached->server_config(),
-      session()->connection()->transport_version(), chlo_hash_, cached->certs(),
+      session()->transport_version(), chlo_hash_, cached->certs(),
       cached->cert_sct(), cached->signature(), verify_context_.get(),
       &verify_error_details_, &verify_details_,
       std::unique_ptr<ProofVerifierCallback>(proof_verify_callback));
diff --git a/quic/core/quic_crypto_client_stream_test.cc b/quic/core/quic_crypto_client_stream_test.cc
index 12fc9a2..e9d0267 100644
--- a/quic/core/quic_crypto_client_stream_test.cc
+++ b/quic/core/quic_crypto_client_stream_test.cc
@@ -280,8 +280,8 @@
   // Note: relies on the callback being invoked synchronously
   bool ok = false;
   crypto_config.BuildServerConfigUpdateMessage(
-      session_->connection()->transport_version(), stream()->chlo_hash(),
-      tokens, QuicSocketAddress(QuicIpAddress::Loopback6(), 1234),
+      session_->transport_version(), stream()->chlo_hash(), tokens,
+      QuicSocketAddress(QuicIpAddress::Loopback6(), 1234),
       QuicIpAddress::Loopback6(), connection_->clock(),
       QuicRandom::GetInstance(), &cache, stream()->crypto_negotiated_params(),
       &network_params,
diff --git a/quic/core/quic_crypto_server_handshaker.cc b/quic/core/quic_crypto_server_handshaker.cc
index ab381d7..49e7209 100644
--- a/quic/core/quic_crypto_server_handshaker.cc
+++ b/quic/core/quic_crypto_server_handshaker.cc
@@ -258,7 +258,7 @@
   send_server_config_update_cb_ = cb.get();
 
   crypto_config_->BuildServerConfigUpdateMessage(
-      session()->connection()->transport_version(), chlo_hash_,
+      session()->transport_version(), chlo_hash_,
       previous_source_address_tokens_, session()->connection()->self_address(),
       GetClientAddress().host(), session()->connection()->clock(),
       session()->connection()->random_generator(), compressed_certs_cache_,
diff --git a/quic/core/quic_crypto_server_handshaker.h b/quic/core/quic_crypto_server_handshaker.h
index 4b7b3ba..b24e9e9 100644
--- a/quic/core/quic_crypto_server_handshaker.h
+++ b/quic/core/quic_crypto_server_handshaker.h
@@ -155,7 +155,7 @@
 
   // Returns the QuicTransportVersion of the connection.
   QuicTransportVersion transport_version() const {
-    return session_->connection()->transport_version();
+    return session_->transport_version();
   }
 
   QuicCryptoServerStream* stream_;
diff --git a/quic/core/quic_crypto_stream.cc b/quic/core/quic_crypto_stream.cc
index e5b13f1..e1ee5bf 100644
--- a/quic/core/quic_crypto_stream.cc
+++ b/quic/core/quic_crypto_stream.cc
@@ -24,18 +24,15 @@
                                                         " ")
 
 QuicCryptoStream::QuicCryptoStream(QuicSession* session)
-    : QuicStream(QuicVersionUsesCryptoFrames(
-                     session->connection()->transport_version())
-                     ? QuicUtils::GetInvalidStreamId(
-                           session->connection()->transport_version())
-                     : QuicUtils::GetCryptoStreamId(
-                           session->connection()->transport_version()),
-                 session,
-                 /*is_static=*/true,
-                 QuicVersionUsesCryptoFrames(
-                     session->connection()->transport_version())
-                     ? CRYPTO
-                     : BIDIRECTIONAL),
+    : QuicStream(
+          QuicVersionUsesCryptoFrames(session->transport_version())
+              ? QuicUtils::GetInvalidStreamId(session->transport_version())
+              : QuicUtils::GetCryptoStreamId(session->transport_version()),
+          session,
+          /*is_static=*/true,
+          QuicVersionUsesCryptoFrames(session->transport_version())
+              ? CRYPTO
+              : BIDIRECTIONAL),
       substreams_{{this, ENCRYPTION_INITIAL},
                   {this, ENCRYPTION_HANDSHAKE},
                   {this, ENCRYPTION_ZERO_RTT},
@@ -73,8 +70,7 @@
 }
 
 void QuicCryptoStream::OnCryptoFrame(const QuicCryptoFrame& frame) {
-  QUIC_BUG_IF(!QuicVersionUsesCryptoFrames(
-      session()->connection()->transport_version()))
+  QUIC_BUG_IF(!QuicVersionUsesCryptoFrames(session()->transport_version()))
       << "Versions less than 47 shouldn't receive CRYPTO frames";
   EncryptionLevel level = session()->connection()->last_decrypted_level();
   substreams_[level].sequencer.OnCryptoFrame(frame);
@@ -86,8 +82,7 @@
 }
 
 void QuicCryptoStream::OnStreamFrame(const QuicStreamFrame& frame) {
-  if (QuicVersionUsesCryptoFrames(
-          session()->connection()->transport_version())) {
+  if (QuicVersionUsesCryptoFrames(session()->transport_version())) {
     QUIC_PEER_BUG
         << "Crypto data received in stream frame instead of crypto frame";
     CloseConnectionWithDetails(QUIC_INVALID_STREAM_DATA,
@@ -98,8 +93,7 @@
 
 void QuicCryptoStream::OnDataAvailable() {
   EncryptionLevel level = session()->connection()->last_decrypted_level();
-  if (!QuicVersionUsesCryptoFrames(
-          session()->connection()->transport_version())) {
+  if (!QuicVersionUsesCryptoFrames(session()->transport_version())) {
     // Versions less than 47 only support QUIC crypto, which ignores the
     // EncryptionLevel passed into CryptoMessageParser::ProcessInput (and
     // OnDataAvailableInSequencer).
@@ -147,8 +141,7 @@
 
 void QuicCryptoStream::WriteCryptoData(EncryptionLevel level,
                                        QuicStringPiece data) {
-  if (!QuicVersionUsesCryptoFrames(
-          session()->connection()->transport_version())) {
+  if (!QuicVersionUsesCryptoFrames(session()->transport_version())) {
     // The QUIC crypto handshake takes care of setting the appropriate
     // encryption level before writing data. Since that is the only handshake
     // supported in versions less than 47, |level| can be ignored here.
@@ -206,8 +199,7 @@
 }
 
 void QuicCryptoStream::NeuterUnencryptedStreamData() {
-  if (!QuicVersionUsesCryptoFrames(
-          session()->connection()->transport_version())) {
+  if (!QuicVersionUsesCryptoFrames(session()->transport_version())) {
     for (const auto& interval : bytes_consumed_[ENCRYPTION_INITIAL]) {
       QuicByteCount newly_acked_length = 0;
       send_buffer().OnStreamDataAcked(
@@ -229,8 +221,7 @@
 }
 
 void QuicCryptoStream::OnStreamDataConsumed(size_t bytes_consumed) {
-  if (QuicVersionUsesCryptoFrames(
-          session()->connection()->transport_version())) {
+  if (QuicVersionUsesCryptoFrames(session()->transport_version())) {
     QUIC_BUG << "Stream data consumed when CRYPTO frames should be in use";
   }
   if (bytes_consumed > 0) {
@@ -241,8 +232,7 @@
 }
 
 bool QuicCryptoStream::HasPendingCryptoRetransmission() const {
-  if (!QuicVersionUsesCryptoFrames(
-          session()->connection()->transport_version())) {
+  if (!QuicVersionUsesCryptoFrames(session()->transport_version())) {
     return false;
   }
   for (EncryptionLevel level :
@@ -255,8 +245,7 @@
 }
 
 void QuicCryptoStream::WritePendingCryptoRetransmission() {
-  QUIC_BUG_IF(!QuicVersionUsesCryptoFrames(
-      session()->connection()->transport_version()))
+  QUIC_BUG_IF(!QuicVersionUsesCryptoFrames(session()->transport_version()))
       << "Versions less than 47 don't write CRYPTO frames";
   EncryptionLevel current_encryption_level =
       session()->connection()->encryption_level();
@@ -364,8 +353,7 @@
 }
 
 uint64_t QuicCryptoStream::crypto_bytes_read() const {
-  if (!QuicVersionUsesCryptoFrames(
-          session()->connection()->transport_version())) {
+  if (!QuicVersionUsesCryptoFrames(session()->transport_version())) {
     return stream_bytes_read();
   }
   return substreams_[ENCRYPTION_INITIAL].sequencer.NumBytesConsumed() +
@@ -381,24 +369,21 @@
                                         QuicStreamOffset offset,
                                         QuicByteCount data_length,
                                         QuicDataWriter* writer) {
-  QUIC_BUG_IF(!QuicVersionUsesCryptoFrames(
-      session()->connection()->transport_version()))
+  QUIC_BUG_IF(!QuicVersionUsesCryptoFrames(session()->transport_version()))
       << "Versions less than 47 don't write CRYPTO frames (2)";
   return substreams_[level].send_buffer.WriteStreamData(offset, data_length,
                                                         writer);
 }
 
 void QuicCryptoStream::OnCryptoFrameLost(QuicCryptoFrame* crypto_frame) {
-  QUIC_BUG_IF(!QuicVersionUsesCryptoFrames(
-      session()->connection()->transport_version()))
+  QUIC_BUG_IF(!QuicVersionUsesCryptoFrames(session()->transport_version()))
       << "Versions less than 47 don't lose CRYPTO frames";
   substreams_[crypto_frame->level].send_buffer.OnStreamDataLost(
       crypto_frame->offset, crypto_frame->data_length);
 }
 
 void QuicCryptoStream::RetransmitData(QuicCryptoFrame* crypto_frame) {
-  QUIC_BUG_IF(!QuicVersionUsesCryptoFrames(
-      session()->connection()->transport_version()))
+  QUIC_BUG_IF(!QuicVersionUsesCryptoFrames(session()->transport_version()))
       << "Versions less than 47 don't retransmit CRYPTO frames";
   QuicIntervalSet<QuicStreamOffset> retransmission(
       crypto_frame->offset, crypto_frame->offset + crypto_frame->data_length);
@@ -423,8 +408,7 @@
 }
 
 void QuicCryptoStream::WriteBufferedCryptoFrames() {
-  QUIC_BUG_IF(!QuicVersionUsesCryptoFrames(
-      session()->connection()->transport_version()))
+  QUIC_BUG_IF(!QuicVersionUsesCryptoFrames(session()->transport_version()))
       << "Versions less than 47 don't use CRYPTO frames";
   EncryptionLevel current_encryption_level =
       session()->connection()->encryption_level();
@@ -450,8 +434,7 @@
 }
 
 bool QuicCryptoStream::HasBufferedCryptoFrames() const {
-  QUIC_BUG_IF(!QuicVersionUsesCryptoFrames(
-      session()->connection()->transport_version()))
+  QUIC_BUG_IF(!QuicVersionUsesCryptoFrames(session()->transport_version()))
       << "Versions less than 47 don't use CRYPTO frames";
   for (EncryptionLevel level :
        {ENCRYPTION_INITIAL, ENCRYPTION_ZERO_RTT, ENCRYPTION_FORWARD_SECURE}) {
@@ -467,8 +450,7 @@
 bool QuicCryptoStream::IsFrameOutstanding(EncryptionLevel level,
                                           size_t offset,
                                           size_t length) const {
-  if (!QuicVersionUsesCryptoFrames(
-          session()->connection()->transport_version())) {
+  if (!QuicVersionUsesCryptoFrames(session()->transport_version())) {
     // This only happens if a client was originally configured for a version
     // greater than 45, but received a version negotiation packet and is
     // attempting to retransmit for a version less than 47. Outside of tests,
@@ -481,8 +463,7 @@
 }
 
 bool QuicCryptoStream::IsWaitingForAcks() const {
-  if (!QuicVersionUsesCryptoFrames(
-          session()->connection()->transport_version())) {
+  if (!QuicVersionUsesCryptoFrames(session()->transport_version())) {
     return QuicStream::IsWaitingForAcks();
   }
   for (EncryptionLevel level :
diff --git a/quic/core/quic_flow_controller.cc b/quic/core/quic_flow_controller.cc
index dbc5100..40f18a3 100644
--- a/quic/core/quic_flow_controller.cc
+++ b/quic/core/quic_flow_controller.cc
@@ -54,9 +54,9 @@
       last_blocked_send_window_offset_(0),
       prev_window_update_time_(QuicTime::Zero()) {
   DCHECK_LE(receive_window_size_, receive_window_size_limit_);
-  DCHECK_EQ(is_connection_flow_controller_,
-            QuicUtils::GetInvalidStreamId(
-                session_->connection()->transport_version()) == id_);
+  DCHECK_EQ(
+      is_connection_flow_controller_,
+      QuicUtils::GetInvalidStreamId(session_->transport_version()) == id_);
 
   QUIC_DVLOG(1) << ENDPOINT << "Created flow controller for " << LogLabel()
                 << ", setting initial receive window offset to: "
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 464c4f5..eb8ee80 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -110,11 +110,11 @@
   connection_->SetDataProducer(this);
   connection_->SetFromConfig(config_);
 
-  if (QuicVersionUsesCryptoFrames(connection_->transport_version())) {
+  if (QuicVersionUsesCryptoFrames(transport_version())) {
     return;
   }
 
-  DCHECK_EQ(QuicUtils::GetCryptoStreamId(connection_->transport_version()),
+  DCHECK_EQ(QuicUtils::GetCryptoStreamId(transport_version()),
             GetMutableCryptoStream()->id());
 }
 
@@ -141,7 +141,7 @@
 }
 
 void QuicSession::PendingStreamOnStreamFrame(const QuicStreamFrame& frame) {
-  DCHECK(VersionHasStreamType(connection()->transport_version()));
+  DCHECK(VersionHasStreamType(transport_version()));
   QuicStreamId stream_id = frame.stream_id;
 
   PendingStream* pending = GetOrCreatePendingStream(stream_id);
@@ -173,8 +173,7 @@
 void QuicSession::OnStreamFrame(const QuicStreamFrame& frame) {
   // TODO(rch) deal with the error case of stream id 0.
   QuicStreamId stream_id = frame.stream_id;
-  if (stream_id ==
-      QuicUtils::GetInvalidStreamId(connection()->transport_version())) {
+  if (stream_id == QuicUtils::GetInvalidStreamId(transport_version())) {
     connection()->CloseConnection(
         QUIC_INVALID_STREAM_ID, "Received data for an invalid stream",
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
@@ -220,12 +219,11 @@
   // could not call OnStopSending... This is just a check that is good when
   // both a new protocol and a new implementation of that protocol are both
   // being developed.
-  DCHECK(VersionHasIetfQuicFrames(connection_->transport_version()));
+  DCHECK(VersionHasIetfQuicFrames(transport_version()));
 
   QuicStreamId stream_id = frame.stream_id;
   // If Stream ID is invalid then close the connection.
-  if (stream_id ==
-      QuicUtils::GetInvalidStreamId(connection()->transport_version())) {
+  if (stream_id == QuicUtils::GetInvalidStreamId(transport_version())) {
     QUIC_DVLOG(1) << ENDPOINT
                   << "Received STOP_SENDING with invalid stream_id: "
                   << stream_id << " Closing connection";
@@ -239,8 +237,7 @@
   // TODO(fkastenholz): IETF Quic does not have static streams and does not
   // make exceptions for them with respect to processing things like
   // STOP_SENDING.
-  if (QuicUtils::IsCryptoStreamId(connection_->transport_version(),
-                                  stream_id)) {
+  if (QuicUtils::IsCryptoStreamId(transport_version(), stream_id)) {
     QUIC_DVLOG(1) << ENDPOINT
                   << "Received STOP_SENDING for a static stream, id: "
                   << stream_id << " Closing connection";
@@ -312,7 +309,7 @@
 }
 
 void QuicSession::PendingStreamOnRstStream(const QuicRstStreamFrame& frame) {
-  DCHECK(VersionHasStreamType(connection()->transport_version()));
+  DCHECK(VersionHasStreamType(transport_version()));
   QuicStreamId stream_id = frame.stream_id;
 
   PendingStream* pending = GetOrCreatePendingStream(stream_id);
@@ -329,8 +326,7 @@
 
 void QuicSession::OnRstStream(const QuicRstStreamFrame& frame) {
   QuicStreamId stream_id = frame.stream_id;
-  if (stream_id ==
-      QuicUtils::GetInvalidStreamId(connection()->transport_version())) {
+  if (stream_id == QuicUtils::GetInvalidStreamId(transport_version())) {
     connection()->CloseConnection(
         QUIC_INVALID_STREAM_ID, "Received data for an invalid stream",
         ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
@@ -471,8 +467,7 @@
   // Stream may be closed by the time we receive a WINDOW_UPDATE, so we can't
   // assume that it still exists.
   QuicStreamId stream_id = frame.stream_id;
-  if (stream_id ==
-      QuicUtils::GetInvalidStreamId(connection_->transport_version())) {
+  if (stream_id == QuicUtils::GetInvalidStreamId(transport_version())) {
     // This is a window update that applies to the connection, rather than an
     // individual stream.
     QUIC_DVLOG(1) << ENDPOINT
@@ -483,7 +478,7 @@
     return;
   }
 
-  if (VersionHasIetfQuicFrames(connection_->transport_version()) &&
+  if (VersionHasIetfQuicFrames(transport_version()) &&
       QuicUtils::GetStreamType(stream_id, perspective(),
                                IsIncomingStream(stream_id)) ==
           READ_UNIDIRECTIONAL) {
@@ -574,13 +569,13 @@
                           ? write_blocked_streams_.NumBlockedSpecialStreams()
                           : write_blocked_streams_.NumBlockedStreams();
   if (num_writes == 0 && !control_frame_manager_.WillingToWrite() &&
-      (!QuicVersionUsesCryptoFrames(connection_->transport_version()) ||
+      (!QuicVersionUsesCryptoFrames(transport_version()) ||
        !GetCryptoStream()->HasBufferedCryptoFrames())) {
     return;
   }
 
   QuicConnection::ScopedPacketFlusher flusher(connection_);
-  if (QuicVersionUsesCryptoFrames(connection_->transport_version())) {
+  if (QuicVersionUsesCryptoFrames(transport_version())) {
     QuicCryptoStream* crypto_stream = GetMutableCryptoStream();
     if (crypto_stream->HasBufferedCryptoFrames()) {
       crypto_stream->WriteBufferedCryptoFrames();
@@ -640,7 +635,7 @@
   // 3) If the crypto or headers streams are blocked, or
   // 4) connection is not flow control blocked and there are write blocked
   // streams.
-  if (QuicVersionUsesCryptoFrames(connection_->transport_version()) &&
+  if (QuicVersionUsesCryptoFrames(transport_version()) &&
       HasPendingHandshake()) {
     return true;
   }
@@ -652,15 +647,14 @@
 }
 
 bool QuicSession::HasPendingHandshake() const {
-  if (QuicVersionUsesCryptoFrames(connection_->transport_version())) {
+  if (QuicVersionUsesCryptoFrames(transport_version())) {
     return GetCryptoStream()->HasPendingCryptoRetransmission() ||
            GetCryptoStream()->HasBufferedCryptoFrames();
   }
-  return QuicContainsKey(
-             streams_with_pending_retransmission_,
-             QuicUtils::GetCryptoStreamId(connection_->transport_version())) ||
+  return QuicContainsKey(streams_with_pending_retransmission_,
+                         QuicUtils::GetCryptoStreamId(transport_version())) ||
          write_blocked_streams_.IsStreamBlocked(
-             QuicUtils::GetCryptoStreamId(connection_->transport_version()));
+             QuicUtils::GetCryptoStreamId(transport_version()));
 }
 
 uint64_t QuicSession::GetNumOpenDynamicStreams() const {
@@ -685,7 +679,7 @@
   // it might end up resulting in unencrypted stream data being sent.
   // While this is impossible to avoid given sufficient corruption, this
   // seems like a reasonable mitigation.
-  if (QuicUtils::IsCryptoStreamId(connection_->transport_version(), id) &&
+  if (QuicUtils::IsCryptoStreamId(transport_version(), id) &&
       stream != GetMutableCryptoStream()) {
     QUIC_BUG << "Stream id mismatch";
     connection_->CloseConnection(
@@ -695,7 +689,7 @@
     return QuicConsumedData(0, false);
   }
   if (!IsEncryptionEstablished() &&
-      !QuicUtils::IsCryptoStreamId(connection_->transport_version(), id)) {
+      !QuicUtils::IsCryptoStreamId(transport_version(), id)) {
     // Do not let streams write without encryption. The calling stream will end
     // up write blocked until OnCanWrite is next called.
     return QuicConsumedData(0, false);
@@ -727,14 +721,14 @@
   if (connection()->connected()) {
     // Only send if still connected.
     if (close_write_side_only) {
-      DCHECK(VersionHasIetfQuicFrames(connection_->transport_version()));
+      DCHECK(VersionHasIetfQuicFrames(transport_version()));
       // Send a RST_STREAM frame.
       control_frame_manager_.WriteOrBufferRstStream(id, error, bytes_written);
     } else {
       // Send a RST_STREAM frame plus, if version 99, an IETF
       // QUIC STOP_SENDING frame. Both sre sent to emulate
       // the two-way close that Google QUIC's RST_STREAM does.
-      if (VersionHasIetfQuicFrames(connection_->transport_version())) {
+      if (VersionHasIetfQuicFrames(transport_version())) {
         QuicConnection::ScopedPacketFlusher flusher(connection());
         control_frame_manager_.WriteOrBufferRstStream(id, error, bytes_written);
         control_frame_manager_.WriteOrBufferStopSending(error, id);
@@ -753,7 +747,7 @@
     CloseStreamInner(id, true);
     return;
   }
-  DCHECK(VersionHasIetfQuicFrames(connection_->transport_version()));
+  DCHECK(VersionHasIetfQuicFrames(transport_version()));
 
   StreamMap::iterator it = stream_map_.find(id);
   if (it != stream_map_.end()) {
@@ -777,7 +771,7 @@
 void QuicSession::SendGoAway(QuicErrorCode error_code,
                              const std::string& reason) {
   // GOAWAY frame is not supported in v99.
-  DCHECK(!VersionHasIetfQuicFrames(connection_->transport_version()));
+  DCHECK(!VersionHasIetfQuicFrames(transport_version()));
   if (goaway_sent_) {
     return;
   }
@@ -886,7 +880,7 @@
       --num_draining_incoming_streams_;
     }
     draining_streams_.erase(stream_id);
-  } else if (VersionHasIetfQuicFrames(connection_->transport_version())) {
+  } else if (VersionHasIetfQuicFrames(transport_version())) {
     // Stream was not draining, but we did have a fin or rst, so we can now
     // free the stream ID if version 99.
     if (had_fin_or_rst) {
@@ -897,7 +891,7 @@
   stream->OnClose();
 
   if (!stream_was_draining && !IsIncomingStream(stream_id) && had_fin_or_rst &&
-      !VersionHasIetfQuicFrames(connection_->transport_version())) {
+      !VersionHasIetfQuicFrames(transport_version())) {
     // Streams that first became draining already called OnCanCreate...
     // This covers the case where the stream went directly to being closed.
     OnCanCreateNewOutgoingStream(type != BIDIRECTIONAL);
@@ -908,7 +902,7 @@
   QUIC_DVLOG(1) << ENDPOINT << "Closing stream " << stream_id;
 
   pending_stream_map_.erase(stream_id);
-  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     v99_streamid_manager_.OnStreamClosed(stream_id);
   }
 }
@@ -940,10 +934,10 @@
   locally_closed_streams_highest_offset_.erase(it);
   if (IsIncomingStream(stream_id)) {
     --num_locally_closed_incoming_streams_highest_offset_;
-    if (VersionHasIetfQuicFrames(connection_->transport_version())) {
+    if (VersionHasIetfQuicFrames(transport_version())) {
       v99_streamid_manager_.OnStreamClosed(stream_id);
     }
-  } else if (!VersionHasIetfQuicFrames(connection_->transport_version())) {
+  } else if (!VersionHasIetfQuicFrames(transport_version())) {
     OnCanCreateNewOutgoingStream(false);
   }
 }
@@ -1009,26 +1003,23 @@
       }
       if (GetQuicReloadableFlag(quic_use_http2_priority_write_scheduler) &&
           ContainsQuicTag(config_.ReceivedConnectionOptions(), kH2PR) &&
-          !VersionHasIetfQuicFrames(connection_->transport_version())) {
+          !VersionHasIetfQuicFrames(transport_version())) {
         // Enable HTTP2 (tree-style) priority write scheduler.
         use_http2_priority_write_scheduler_ =
             write_blocked_streams_.SwitchWriteScheduler(
-                spdy::WriteSchedulerType::HTTP2,
-                connection_->transport_version());
+                spdy::WriteSchedulerType::HTTP2, transport_version());
       } else if (GetQuicReloadableFlag(quic_enable_fifo_write_scheduler) &&
                  ContainsQuicTag(config_.ReceivedConnectionOptions(), kFIFO)) {
         // Enable FIFO write scheduler.
         if (write_blocked_streams_.SwitchWriteScheduler(
-                spdy::WriteSchedulerType::FIFO,
-                connection_->transport_version())) {
+                spdy::WriteSchedulerType::FIFO, transport_version())) {
           QUIC_RELOADABLE_FLAG_COUNT(quic_enable_fifo_write_scheduler);
         }
       } else if (GetQuicReloadableFlag(quic_enable_lifo_write_scheduler) &&
                  ContainsQuicTag(config_.ReceivedConnectionOptions(), kLIFO)) {
         // Enable LIFO write scheduler.
         if (write_blocked_streams_.SwitchWriteScheduler(
-                spdy::WriteSchedulerType::LIFO,
-                connection_->transport_version())) {
+                spdy::WriteSchedulerType::LIFO, transport_version())) {
           QUIC_RELOADABLE_FLAG_COUNT(quic_enable_lifo_write_scheduler);
         }
       }
@@ -1037,7 +1028,7 @@
     config_.SetStatelessResetTokenToSend(GetStatelessResetToken());
   }
 
-  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     v99_streamid_manager_.SetMaxOpenIncomingBidirectionalStreams(
         config_.GetMaxIncomingBidirectionalStreamsToSend());
     v99_streamid_manager_.SetMaxOpenIncomingUnidirectionalStreams(
@@ -1090,7 +1081,7 @@
   for (auto const& kv : stream_map_) {
     kv.second->flow_controller()->UpdateReceiveWindowSize(stream_window);
   }
-  if (!QuicVersionUsesCryptoFrames(connection_->transport_version())) {
+  if (!QuicVersionUsesCryptoFrames(transport_version())) {
     GetMutableCryptoStream()->flow_controller()->UpdateReceiveWindowSize(
         stream_window);
   }
@@ -1134,7 +1125,7 @@
   for (auto const& kv : stream_map_) {
     kv.second->UpdateSendWindowOffset(new_window);
   }
-  if (!QuicVersionUsesCryptoFrames(connection_->transport_version())) {
+  if (!QuicVersionUsesCryptoFrames(transport_version())) {
     GetMutableCryptoStream()->UpdateSendWindowOffset(new_window);
   }
 }
@@ -1218,21 +1209,21 @@
 }
 
 QuicStreamId QuicSession::GetNextOutgoingBidirectionalStreamId() {
-  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     return v99_streamid_manager_.GetNextOutgoingBidirectionalStreamId();
   }
   return stream_id_manager_.GetNextOutgoingStreamId();
 }
 
 QuicStreamId QuicSession::GetNextOutgoingUnidirectionalStreamId() {
-  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     return v99_streamid_manager_.GetNextOutgoingUnidirectionalStreamId();
   }
   return stream_id_manager_.GetNextOutgoingStreamId();
 }
 
 bool QuicSession::CanOpenNextOutgoingBidirectionalStream() {
-  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     return v99_streamid_manager_.CanOpenNextOutgoingBidirectionalStream();
   }
   return stream_id_manager_.CanOpenNextOutgoingStream(
@@ -1240,7 +1231,7 @@
 }
 
 bool QuicSession::CanOpenNextOutgoingUnidirectionalStream() {
-  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     return v99_streamid_manager_.CanOpenNextOutgoingUnidirectionalStream();
   }
   return stream_id_manager_.CanOpenNextOutgoingStream(
@@ -1249,8 +1240,7 @@
 
 QuicStream* QuicSession::GetOrCreateStream(const QuicStreamId stream_id) {
   DCHECK(!QuicContainsKey(pending_stream_map_, stream_id));
-  if (QuicUtils::IsCryptoStreamId(connection_->transport_version(),
-                                  stream_id)) {
+  if (QuicUtils::IsCryptoStreamId(transport_version(), stream_id)) {
     return GetMutableCryptoStream();
   }
 
@@ -1277,7 +1267,7 @@
     return nullptr;
   }
 
-  if (!VersionHasIetfQuicFrames(connection_->transport_version())) {
+  if (!VersionHasIetfQuicFrames(transport_version())) {
     // TODO(fayang): Let LegacyQuicStreamIdManager count open streams and make
     // CanOpenIncomingStream interface consistent with that of v99.
     if (!stream_id_manager_.CanOpenIncomingStream(
@@ -1298,13 +1288,13 @@
     if (IsIncomingStream(stream_id)) {
       ++num_draining_incoming_streams_;
     }
-    if (VersionHasIetfQuicFrames(connection_->transport_version())) {
+    if (VersionHasIetfQuicFrames(transport_version())) {
       v99_streamid_manager_.OnStreamClosed(stream_id);
     }
   }
   if (!IsIncomingStream(stream_id)) {
     // Inform application that a stream is available.
-    if (VersionHasIetfQuicFrames(connection_->transport_version())) {
+    if (VersionHasIetfQuicFrames(transport_version())) {
       OnCanCreateNewOutgoingStream(
           !QuicUtils::IsBidirectionalStreamId(stream_id));
     } else {
@@ -1320,7 +1310,7 @@
 
 bool QuicSession::MaybeIncreaseLargestPeerStreamId(
     const QuicStreamId stream_id) {
-  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     return v99_streamid_manager_.MaybeIncreaseLargestPeerStreamId(stream_id);
   }
   return stream_id_manager_.MaybeIncreaseLargestPeerStreamId(stream_id);
@@ -1377,7 +1367,7 @@
     return nullptr;
   }
 
-  if (!VersionHasIetfQuicFrames(connection_->transport_version())) {
+  if (!VersionHasIetfQuicFrames(transport_version())) {
     // TODO(fayang): Let LegacyQuicStreamIdManager count open streams and make
     // CanOpenIncomingStream interface cosistent with that of v99.
     if (!stream_id_manager_.CanOpenIncomingStream(
@@ -1393,7 +1383,7 @@
 
 void QuicSession::set_largest_peer_created_stream_id(
     QuicStreamId largest_peer_created_stream_id) {
-  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     v99_streamid_manager_.SetLargestPeerCreatedStreamId(
         largest_peer_created_stream_id);
     return;
@@ -1403,14 +1393,13 @@
 }
 
 bool QuicSession::IsClosedStream(QuicStreamId id) {
-  DCHECK_NE(QuicUtils::GetInvalidStreamId(connection_->transport_version()),
-            id);
+  DCHECK_NE(QuicUtils::GetInvalidStreamId(transport_version()), id);
   if (IsOpenStream(id)) {
     // Stream is active
     return false;
   }
 
-  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     return !v99_streamid_manager_.IsAvailableStream(id);
   }
 
@@ -1418,11 +1407,10 @@
 }
 
 bool QuicSession::IsOpenStream(QuicStreamId id) {
-  DCHECK_NE(QuicUtils::GetInvalidStreamId(connection_->transport_version()),
-            id);
+  DCHECK_NE(QuicUtils::GetInvalidStreamId(transport_version()), id);
   if (QuicContainsKey(stream_map_, id) ||
       QuicContainsKey(pending_stream_map_, id) ||
-      QuicUtils::IsCryptoStreamId(connection_->transport_version(), id)) {
+      QuicUtils::IsCryptoStreamId(transport_version(), id)) {
     // Stream is active
     return true;
   }
@@ -1517,7 +1505,7 @@
       return true;
     }
   }
-  if (!QuicVersionUsesCryptoFrames(connection_->transport_version()) &&
+  if (!QuicVersionUsesCryptoFrames(transport_version()) &&
       GetMutableCryptoStream()->flow_controller()->IsBlocked()) {
     return true;
   }
@@ -1525,21 +1513,21 @@
 }
 
 size_t QuicSession::MaxAvailableBidirectionalStreams() const {
-  if (VersionHasIetfQuicFrames(connection()->transport_version())) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     return v99_streamid_manager_.GetMaxAllowdIncomingBidirectionalStreams();
   }
   return stream_id_manager_.MaxAvailableStreams();
 }
 
 size_t QuicSession::MaxAvailableUnidirectionalStreams() const {
-  if (VersionHasIetfQuicFrames(connection()->transport_version())) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     return v99_streamid_manager_.GetMaxAllowdIncomingUnidirectionalStreams();
   }
   return stream_id_manager_.MaxAvailableStreams();
 }
 
 bool QuicSession::IsIncomingStream(QuicStreamId id) const {
-  if (VersionHasIetfQuicFrames(connection()->transport_version())) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     return v99_streamid_manager_.IsIncomingStream(id);
   }
   return stream_id_manager_.IsIncomingStream(id);
@@ -1603,7 +1591,7 @@
     return zombie_stream->second.get();
   }
 
-  if (QuicUtils::IsCryptoStreamId(connection_->transport_version(), id)) {
+  if (QuicUtils::IsCryptoStreamId(transport_version(), id)) {
     return const_cast<QuicCryptoStream*>(GetCryptoStream());
   }
 
@@ -1754,7 +1742,7 @@
     // This causes the connection to be closed because of failed to serialize
     // packet.
     QUIC_BUG << "Stream " << id << " does not exist when trying to write data."
-             << " version:" << connection_->transport_version();
+             << " version:" << transport_version();
     return STREAM_MISSING;
   }
   if (stream->WriteStreamData(offset, data_length, writer)) {
@@ -1778,8 +1766,7 @@
 bool QuicSession::RetransmitLostData() {
   QuicConnection::ScopedPacketFlusher retransmission_flusher(connection_);
   // Retransmit crypto data first.
-  bool uses_crypto_frames =
-      QuicVersionUsesCryptoFrames(connection_->transport_version());
+  bool uses_crypto_frames = QuicVersionUsesCryptoFrames(transport_version());
   QuicCryptoStream* crypto_stream = GetMutableCryptoStream();
   if (uses_crypto_frames && crypto_stream->HasPendingCryptoRetransmission()) {
     SetTransmissionType(HANDSHAKE_RETRANSMISSION);
@@ -1787,13 +1774,12 @@
   }
   // Retransmit crypto data in stream 1 frames (version < 47).
   if (!uses_crypto_frames &&
-      QuicContainsKey(
-          streams_with_pending_retransmission_,
-          QuicUtils::GetCryptoStreamId(connection_->transport_version()))) {
+      QuicContainsKey(streams_with_pending_retransmission_,
+                      QuicUtils::GetCryptoStreamId(transport_version()))) {
     SetTransmissionType(HANDSHAKE_RETRANSMISSION);
     // Retransmit crypto data first.
-    QuicStream* crypto_stream = GetStream(
-        QuicUtils::GetCryptoStreamId(connection_->transport_version()));
+    QuicStream* crypto_stream =
+        GetStream(QuicUtils::GetCryptoStreamId(transport_version()));
     crypto_stream->OnCanWrite();
     DCHECK(CheckStreamWriteBlocked(crypto_stream));
     if (crypto_stream->HasPendingRetransmission()) {
@@ -1801,7 +1787,7 @@
       return false;
     } else {
       streams_with_pending_retransmission_.erase(
-          QuicUtils::GetCryptoStreamId(connection_->transport_version()));
+          QuicUtils::GetCryptoStreamId(transport_version()));
     }
   }
   if (control_frame_manager_.HasPendingRetransmission()) {
@@ -1846,9 +1832,9 @@
     QuicCryptoStream* crypto_stream = GetMutableCryptoStream();
     crypto_stream->NeuterUnencryptedStreamData();
     if (!crypto_stream->HasPendingRetransmission() &&
-        !QuicVersionUsesCryptoFrames(connection_->transport_version())) {
+        !QuicVersionUsesCryptoFrames(transport_version())) {
       streams_with_pending_retransmission_.erase(
-          QuicUtils::GetCryptoStreamId(connection_->transport_version()));
+          QuicUtils::GetCryptoStreamId(transport_version()));
     }
   }
   connection_->NeuterUnencryptedPackets();
@@ -1903,14 +1889,14 @@
 void QuicSession::OnCanCreateNewOutgoingStream(bool /*unidirectional*/) {}
 
 QuicStreamId QuicSession::next_outgoing_bidirectional_stream_id() const {
-  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     return v99_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(connection_->transport_version())) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     return v99_streamid_manager_.next_outgoing_unidirectional_stream_id();
   }
   return stream_id_manager_.next_outgoing_stream_id();
@@ -1925,14 +1911,14 @@
 }
 
 size_t QuicSession::max_open_incoming_bidirectional_streams() const {
-  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     return v99_streamid_manager_.GetMaxAllowdIncomingBidirectionalStreams();
   }
   return stream_id_manager_.max_open_incoming_streams();
 }
 
 size_t QuicSession::max_open_incoming_unidirectional_streams() const {
-  if (VersionHasIetfQuicFrames(connection_->transport_version())) {
+  if (VersionHasIetfQuicFrames(transport_version())) {
     return v99_streamid_manager_.GetMaxAllowdIncomingUnidirectionalStreams();
   }
   return stream_id_manager_.max_open_incoming_streams();
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index 7480eee..eafb0bd 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -69,8 +69,8 @@
         kInitialStreamFlowControlWindowForTest);
     session()->config()->SetInitialSessionFlowControlWindowToSend(
         kInitialSessionFlowControlWindowForTest);
-    session()->config()->ToHandshakeMessage(
-        &msg, session()->connection()->transport_version());
+    session()->config()->ToHandshakeMessage(&msg,
+                                            session()->transport_version());
     const QuicErrorCode error =
         session()->config()->ProcessPeerHello(msg, CLIENT, &error_details);
     EXPECT_EQ(QUIC_NO_ERROR, error);
@@ -362,7 +362,7 @@
   }
 
   void CloseStream(QuicStreamId id) {
-    if (VersionHasIetfQuicFrames(session_.connection()->transport_version()) &&
+    if (VersionHasIetfQuicFrames(session_.transport_version()) &&
         QuicUtils::GetStreamType(id, session_.perspective(),
                                  session_.IsIncomingStream(id)) ==
             READ_UNIDIRECTIONAL) {
@@ -371,8 +371,7 @@
       EXPECT_CALL(*connection_, OnStreamReset(_, _)).Times(0);
     } else {
       // Verify reset IS sent for BIDIRECTIONAL streams.
-      if (VersionHasIetfQuicFrames(
-              session_.connection()->transport_version())) {
+      if (VersionHasIetfQuicFrames(session_.transport_version())) {
         // Once for the RST_STREAM, Once for the STOP_SENDING
         EXPECT_CALL(*connection_, SendControlFrame(_))
             .Times(2)
diff --git a/quic/core/quic_stream.cc b/quic/core/quic_stream.cc
index eb8b96b..c08688b 100644
--- a/quic/core/quic_stream.cc
+++ b/quic/core/quic_stream.cc
@@ -270,8 +270,7 @@
       buffered_data_threshold_(GetQuicFlag(FLAGS_quic_buffered_data_threshold)),
       is_static_(is_static),
       deadline_(QuicTime::Zero()),
-      type_(VersionHasIetfQuicFrames(
-                session->connection()->transport_version()) &&
+      type_(VersionHasIetfQuicFrames(session->transport_version()) &&
                     type != CRYPTO
                 ? QuicUtils::GetStreamType(id_,
                                            perspective_,
@@ -701,7 +700,7 @@
 }
 
 QuicTransportVersion QuicStream::transport_version() const {
-  return session_->connection()->transport_version();
+  return session_->transport_version();
 }
 
 HandshakeProtocol QuicStream::handshake_protocol() const {
diff --git a/quic/core/quic_stream_id_manager.cc b/quic/core/quic_stream_id_manager.cc
index f856ab0..c400d77 100644
--- a/quic/core/quic_stream_id_manager.cc
+++ b/quic/core/quic_stream_id_manager.cc
@@ -328,7 +328,7 @@
 }
 
 QuicTransportVersion QuicStreamIdManager::transport_version() const {
-  return session_->connection()->transport_version();
+  return session_->transport_version();
 }
 
 size_t QuicStreamIdManager::available_incoming_streams() {
diff --git a/quic/core/quic_stream_id_manager_test.cc b/quic/core/quic_stream_id_manager_test.cc
index 19e4d59..d8e1b78 100644
--- a/quic/core/quic_stream_id_manager_test.cc
+++ b/quic/core/quic_stream_id_manager_test.cc
@@ -62,8 +62,7 @@
   TestQuicStream* CreateIncomingStream(QuicStreamId id) override {
     TestQuicStream* stream = new TestQuicStream(
         id, this,
-        DetermineStreamType(id, connection()->transport_version(),
-                            perspective(),
+        DetermineStreamType(id, transport_version(), perspective(),
                             /*is_incoming=*/true, BIDIRECTIONAL));
     ActivateStream(QuicWrapUnique(stream));
     return stream;
diff --git a/quic/qbone/qbone_client_session.cc b/quic/qbone/qbone_client_session.cc
index c2972ea..5c199e2 100644
--- a/quic/qbone/qbone_client_session.cc
+++ b/quic/qbone/qbone_client_session.cc
@@ -39,8 +39,7 @@
       ->CryptoConnect();
   // Register the reserved control stream.
   QuicStreamId next_id = GetNextOutgoingBidirectionalStreamId();
-  DCHECK_EQ(next_id, QboneConstants::GetControlStreamId(
-                         connection()->transport_version()));
+  DCHECK_EQ(next_id, QboneConstants::GetControlStreamId(transport_version()));
   auto control_stream =
       QuicMakeUnique<QboneClientControlStream>(this, handler_);
   control_stream_ = control_stream.get();
diff --git a/quic/qbone/qbone_control_stream.cc b/quic/qbone/qbone_control_stream.cc
index 6272f3f..02b1cb8 100644
--- a/quic/qbone/qbone_control_stream.cc
+++ b/quic/qbone/qbone_control_stream.cc
@@ -15,11 +15,11 @@
 }  // namespace
 
 QboneControlStreamBase::QboneControlStreamBase(QuicSession* session)
-    : QuicStream(QboneConstants::GetControlStreamId(
-                     session->connection()->transport_version()),
-                 session,
-                 /*is_static=*/true,
-                 BIDIRECTIONAL),
+    : QuicStream(
+          QboneConstants::GetControlStreamId(session->transport_version()),
+          session,
+          /*is_static=*/true,
+          BIDIRECTIONAL),
       pending_message_size_(0) {}
 
 void QboneControlStreamBase::OnDataAvailable() {
diff --git a/quic/quartc/quartc_session.h b/quic/quartc/quartc_session.h
index 638333e..e9001d6 100644
--- a/quic/quartc/quartc_session.h
+++ b/quic/quartc/quartc_session.h
@@ -70,7 +70,7 @@
 
   // Return true if transport support message frame.
   bool CanSendMessage() const {
-    return VersionSupportsMessageFrames(connection()->transport_version());
+    return VersionSupportsMessageFrames(transport_version());
   }
 
   void OnCryptoHandshakeEvent(CryptoHandshakeEvent event) override;
diff --git a/quic/test_tools/crypto_test_utils.cc b/quic/test_tools/crypto_test_utils.cc
index 27e47b2..e2a8b8b 100644
--- a/quic/test_tools/crypto_test_utils.cc
+++ b/quic/test_tools/crypto_test_utils.cc
@@ -303,12 +303,10 @@
                                   Perspective /*perspective*/) {
   const QuicData& data = message.GetSerialized();
   QuicSession* session = QuicStreamPeer::session(stream);
-  if (!QuicVersionUsesCryptoFrames(
-          session->connection()->transport_version())) {
-    QuicStreamFrame frame(QuicUtils::GetCryptoStreamId(
-                              session->connection()->transport_version()),
-                          false, stream->crypto_bytes_read(),
-                          data.AsStringPiece());
+  if (!QuicVersionUsesCryptoFrames(session->transport_version())) {
+    QuicStreamFrame frame(
+        QuicUtils::GetCryptoStreamId(session->transport_version()), false,
+        stream->crypto_bytes_read(), data.AsStringPiece());
     stream->OnStreamFrame(frame);
   } else {
     EncryptionLevel level = session->connection()->last_decrypted_level();
diff --git a/quic/test_tools/quic_session_peer.cc b/quic/test_tools/quic_session_peer.cc
index ab4e5af..db803af 100644
--- a/quic/test_tools/quic_session_peer.cc
+++ b/quic/test_tools/quic_session_peer.cc
@@ -27,7 +27,7 @@
 // static
 void QuicSessionPeer::SetNextOutgoingBidirectionalStreamId(QuicSession* session,
                                                            QuicStreamId id) {
-  if (VersionHasIetfQuicFrames(session->connection()->transport_version())) {
+  if (VersionHasIetfQuicFrames(session->transport_version())) {
     session->v99_streamid_manager_.bidirectional_stream_id_manager_
         .next_outgoing_stream_id_ = id;
     return;
@@ -38,7 +38,7 @@
 // static
 void QuicSessionPeer::SetMaxOpenIncomingStreams(QuicSession* session,
                                                 uint32_t max_streams) {
-  if (VersionHasIetfQuicFrames(session->connection()->transport_version())) {
+  if (VersionHasIetfQuicFrames(session->transport_version())) {
     QUIC_BUG << "SetmaxOpenIncomingStreams deprecated for IETF QUIC";
     session->v99_streamid_manager_.SetMaxOpenIncomingUnidirectionalStreams(
         max_streams);
@@ -53,7 +53,7 @@
 void QuicSessionPeer::SetMaxOpenIncomingBidirectionalStreams(
     QuicSession* session,
     uint32_t max_streams) {
-  DCHECK(VersionHasIetfQuicFrames(session->connection()->transport_version()))
+  DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
       << "SetmaxOpenIncomingBidirectionalStreams not supported for Google "
          "QUIC";
   session->v99_streamid_manager_.SetMaxOpenIncomingBidirectionalStreams(
@@ -63,7 +63,7 @@
 void QuicSessionPeer::SetMaxOpenIncomingUnidirectionalStreams(
     QuicSession* session,
     uint32_t max_streams) {
-  DCHECK(VersionHasIetfQuicFrames(session->connection()->transport_version()))
+  DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
       << "SetmaxOpenIncomingUnidirectionalStreams not supported for Google "
          "QUIC";
   session->v99_streamid_manager_.SetMaxOpenIncomingUnidirectionalStreams(
@@ -73,7 +73,7 @@
 // static
 void QuicSessionPeer::SetMaxOpenOutgoingStreams(QuicSession* session,
                                                 uint32_t max_streams) {
-  if (VersionHasIetfQuicFrames(session->connection()->transport_version())) {
+  if (VersionHasIetfQuicFrames(session->transport_version())) {
     QUIC_BUG << "SetmaxOpenOutgoingStreams deprecated for IETF QUIC";
     session->v99_streamid_manager_.SetMaxOpenOutgoingUnidirectionalStreams(
         max_streams);
@@ -88,7 +88,7 @@
 void QuicSessionPeer::SetMaxOpenOutgoingBidirectionalStreams(
     QuicSession* session,
     uint32_t max_streams) {
-  DCHECK(VersionHasIetfQuicFrames(session->connection()->transport_version()))
+  DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
       << "SetmaxOpenOutgoingBidirectionalStreams not supported for Google "
          "QUIC";
   session->v99_streamid_manager_.SetMaxOpenOutgoingBidirectionalStreams(
@@ -98,7 +98,7 @@
 void QuicSessionPeer::SetMaxOpenOutgoingUnidirectionalStreams(
     QuicSession* session,
     uint32_t max_streams) {
-  DCHECK(VersionHasIetfQuicFrames(session->connection()->transport_version()))
+  DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
       << "SetmaxOpenOutgoingUnidirectionalStreams not supported for Google "
          "QUIC";
   session->v99_streamid_manager_.SetMaxOpenOutgoingUnidirectionalStreams(
@@ -176,10 +176,8 @@
 
 // static
 bool QuicSessionPeer::IsStreamAvailable(QuicSession* session, QuicStreamId id) {
-  if (VersionHasIetfQuicFrames(session->connection()->transport_version())) {
-    if (id % QuicUtils::StreamIdDelta(
-                 session->connection()->transport_version()) <
-        2) {
+  if (VersionHasIetfQuicFrames(session->transport_version())) {
+    if (id % QuicUtils::StreamIdDelta(session->transport_version()) < 2) {
       return QuicContainsKey(
           session->v99_streamid_manager_.bidirectional_stream_id_manager_
               .available_streams_,
diff --git a/quic/test_tools/quic_spdy_session_peer.cc b/quic/test_tools/quic_spdy_session_peer.cc
index 85237c4..4af55f5 100644
--- a/quic/test_tools/quic_spdy_session_peer.cc
+++ b/quic/test_tools/quic_spdy_session_peer.cc
@@ -14,16 +14,16 @@
 // static
 QuicHeadersStream* QuicSpdySessionPeer::GetHeadersStream(
     QuicSpdySession* session) {
-  DCHECK(!VersionUsesQpack(session->connection()->transport_version()));
+  DCHECK(!VersionUsesQpack(session->transport_version()));
   return session->headers_stream();
 }
 
 void QuicSpdySessionPeer::SetHeadersStream(QuicSpdySession* session,
                                            QuicHeadersStream* headers_stream) {
-  DCHECK(!VersionUsesQpack(session->connection()->transport_version()));
+  DCHECK(!VersionUsesQpack(session->transport_version()));
   for (auto& it : session->stream_map()) {
-    if (it.first == QuicUtils::GetHeadersStreamId(
-                        session->connection()->transport_version())) {
+    if (it.first ==
+        QuicUtils::GetHeadersStreamId(session->transport_version())) {
       it.second.reset(headers_stream);
       session->headers_stream_ = static_cast<QuicHeadersStream*>(it.second.get());
       break;
diff --git a/quic/test_tools/quic_test_client.cc b/quic/test_tools/quic_test_client.cc
index 402a231..9d4cb03 100644
--- a/quic/test_tools/quic_test_client.cc
+++ b/quic/test_tools/quic_test_client.cc
@@ -377,7 +377,7 @@
   ssize_t ret = SendMessage(headers, "", /*fin=*/true, /*flush=*/false);
 
   QuicStreamId stream_id = GetNthClientInitiatedBidirectionalStreamId(
-      session->connection()->transport_version(), 0);
+      session->transport_version(), 0);
   session->SendRstStream(stream_id, QUIC_STREAM_CANCELLED, 0);
   return ret;
 }
diff --git a/quic/tools/quic_simple_server_session.cc b/quic/tools/quic_simple_server_session.cc
index d06cd4b..8298122 100644
--- a/quic/tools/quic_simple_server_session.cc
+++ b/quic/tools/quic_simple_server_session.cc
@@ -75,8 +75,8 @@
     spdy::SpdyHeaderBlock headers = SynthesizePushRequestHeaders(
         request_url, resource, original_request_headers);
     highest_promised_stream_id_ +=
-        QuicUtils::StreamIdDelta(connection()->transport_version());
-    if (VersionHasIetfQuicFrames(connection()->transport_version()) &&
+        QuicUtils::StreamIdDelta(transport_version());
+    if (VersionHasIetfQuicFrames(transport_version()) &&
         highest_promised_stream_id_ > max_allowed_push_id()) {
       return;
     }
@@ -138,7 +138,7 @@
   // connection shouldn't be closed.
   // Otherwise behave in the same way as base class.
   if (highest_promised_stream_id_ ==
-          QuicUtils::GetInvalidStreamId(connection()->transport_version()) ||
+          QuicUtils::GetInvalidStreamId(transport_version()) ||
       stream_id > highest_promised_stream_id_) {
     QuicSession::HandleFrameOnNonexistentOutgoingStream(stream_id);
   }
@@ -154,12 +154,12 @@
     // Since PromisedStreamInfo are queued in sequence, the corresponding
     // index for it in promised_streams_ can be calculated.
     QuicStreamId next_stream_id = next_outgoing_unidirectional_stream_id();
-    if (VersionHasIetfQuicFrames(connection()->transport_version())) {
+    if (VersionHasIetfQuicFrames(transport_version())) {
       DCHECK(!QuicUtils::IsBidirectionalStreamId(frame.stream_id));
     }
     DCHECK_GE(frame.stream_id, next_stream_id);
     size_t index = (frame.stream_id - next_stream_id) /
-                   QuicUtils::StreamIdDelta(connection()->transport_version());
+                   QuicUtils::StreamIdDelta(transport_version());
     DCHECK_LE(index, promised_streams_.size());
     promised_streams_[index].is_cancelled = true;
     control_frame_manager().WriteOrBufferRstStream(frame.stream_id,
diff --git a/quic/tools/quic_simple_server_stream.cc b/quic/tools/quic_simple_server_stream.cc
index 26ea62a..5badfe1 100644
--- a/quic/tools/quic_simple_server_stream.cc
+++ b/quic/tools/quic_simple_server_stream.cc
@@ -107,8 +107,8 @@
 
 void QuicSimpleServerStream::PushResponse(
     SpdyHeaderBlock push_request_headers) {
-  if (QuicUtils::IsClientInitiatedStreamId(
-          session()->connection()->transport_version(), id())) {
+  if (QuicUtils::IsClientInitiatedStreamId(session()->transport_version(),
+                                           id())) {
     QUIC_BUG << "Client initiated stream shouldn't be used as promised stream.";
     return;
   }
@@ -220,8 +220,8 @@
     return;
   }
 
-  if (QuicUtils::IsServerInitiatedStreamId(
-          session()->connection()->transport_version(), id())) {
+  if (QuicUtils::IsServerInitiatedStreamId(session()->transport_version(),
+                                           id())) {
     // A server initiated stream is only used for a server push response,
     // and only 200 and 30X response codes are supported for server push.
     // This behavior mirrors the HTTP/2 implementation.