Use QuicSession::transport_version() instead of QuicConnection::transport_version() to make code cleaner. gfe-relnote: code cleanup, not protected. PiperOrigin-RevId: 267628510 Change-Id: I2b28c42ec2345870905e7e5d7e88721be86ad6e4
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.