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.
