Drop Dynamic from CreateIncomingDynamicStream, ShouldCreateIncomingDynamicStream and ShouldCreateOutgoingDynamicStream.
Merge internal change: 214983203
[email protected]
Change-Id: Iacfc81d8ed6e4a8931aab9fcc52ce8d847bd0e06
Reviewed-on: https://chromium-review.googlesource.com/c/1276445
Reviewed-by: Kentaro Hara <[email protected]>
Reviewed-by: Ryan Hamilton <[email protected]>
Commit-Queue: Fan Yang <[email protected]>
Cr-Commit-Position: refs/heads/master@{#599159}diff --git a/net/quic/quic_chromium_client_session.cc b/net/quic/quic_chromium_client_session.cc
index f0eb6249..1dc14e465 100644
--- a/net/quic/quic_chromium_client_session.cc
+++ b/net/quic/quic_chromium_client_session.cc
@@ -1030,7 +1030,7 @@
}
}
-bool QuicChromiumClientSession::ShouldCreateOutgoingDynamicStream() {
+bool QuicChromiumClientSession::ShouldCreateOutgoingStream() {
if (!crypto_stream_->encryption_established()) {
DVLOG(1) << "Encryption not active so no outgoing stream created.";
return false;
@@ -1213,10 +1213,10 @@
hostname);
}
-bool QuicChromiumClientSession::ShouldCreateIncomingDynamicStream(
+bool QuicChromiumClientSession::ShouldCreateIncomingStream(
quic::QuicStreamId id) {
if (!connection()->connected()) {
- LOG(DFATAL) << "ShouldCreateIncomingDynamicStream called when disconnected";
+ LOG(DFATAL) << "ShouldCreateIncomingStream called when disconnected";
return false;
}
if (goaway_received()) {
@@ -1237,9 +1237,9 @@
return true;
}
-QuicChromiumClientStream*
-QuicChromiumClientSession::CreateIncomingDynamicStream(quic::QuicStreamId id) {
- if (!ShouldCreateIncomingDynamicStream(id)) {
+QuicChromiumClientStream* QuicChromiumClientSession::CreateIncomingStream(
+ quic::QuicStreamId id) {
+ if (!ShouldCreateIncomingStream(id)) {
return nullptr;
}
net::NetworkTrafficAnnotationTag traffic_annotation =
diff --git a/net/quic/quic_chromium_client_session.h b/net/quic/quic_chromium_client_session.h
index dfcc477..d6591b0 100644
--- a/net/quic/quic_chromium_client_session.h
+++ b/net/quic/quic_chromium_client_session.h
@@ -644,10 +644,10 @@
protected:
// quic::QuicSession methods:
- bool ShouldCreateIncomingDynamicStream(quic::QuicStreamId id) override;
- bool ShouldCreateOutgoingDynamicStream() override;
+ bool ShouldCreateIncomingStream(quic::QuicStreamId id) override;
+ bool ShouldCreateOutgoingStream() override;
- QuicChromiumClientStream* CreateIncomingDynamicStream(
+ QuicChromiumClientStream* CreateIncomingStream(
quic::QuicStreamId id) override;
private:
diff --git a/net/quic/quic_chromium_client_session_peer.cc b/net/quic/quic_chromium_client_session_peer.cc
index d6e4fb81..b37a2f4 100644
--- a/net/quic/quic_chromium_client_session_peer.cc
+++ b/net/quic/quic_chromium_client_session_peer.cc
@@ -32,10 +32,9 @@
}
// static
-QuicChromiumClientStream*
-QuicChromiumClientSessionPeer::CreateOutgoingDynamicStream(
+QuicChromiumClientStream* QuicChromiumClientSessionPeer::CreateOutgoingStream(
QuicChromiumClientSession* session) {
- return session->ShouldCreateOutgoingDynamicStream()
+ return session->ShouldCreateOutgoingStream()
? session->CreateOutgoingReliableStreamImpl(
TRAFFIC_ANNOTATION_FOR_TESTS)
: nullptr;
diff --git a/net/quic/quic_chromium_client_session_peer.h b/net/quic/quic_chromium_client_session_peer.h
index 8bdf717..23cdd51 100644
--- a/net/quic/quic_chromium_client_session_peer.h
+++ b/net/quic/quic_chromium_client_session_peer.h
@@ -29,7 +29,7 @@
static uint64_t GetPushedAndUnclaimedBytesCount(
QuicChromiumClientSession* session);
- static QuicChromiumClientStream* CreateOutgoingDynamicStream(
+ static QuicChromiumClientStream* CreateOutgoingStream(
QuicChromiumClientSession* session);
private:
diff --git a/net/quic/quic_chromium_client_session_test.cc b/net/quic/quic_chromium_client_session_test.cc
index 4c46ee0..030ab19 100644
--- a/net/quic/quic_chromium_client_session_test.cc
+++ b/net/quic/quic_chromium_client_session_test.cc
@@ -510,7 +510,7 @@
// can not proceed immediately.
const size_t kMaxOpenStreams = session_->max_open_outgoing_streams();
for (size_t i = 0; i < kMaxOpenStreams; i++) {
- QuicChromiumClientSessionPeer::CreateOutgoingDynamicStream(session_.get());
+ QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get());
}
EXPECT_EQ(kMaxOpenStreams, session_->GetNumOpenOutgoingStreams());
@@ -552,7 +552,7 @@
// can not proceed immediately.
const size_t kMaxOpenStreams = session_->max_open_outgoing_streams();
for (size_t i = 0; i < kMaxOpenStreams; i++) {
- QuicChromiumClientSessionPeer::CreateOutgoingDynamicStream(session_.get());
+ QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get());
}
EXPECT_EQ(kMaxOpenStreams, session_->GetNumOpenOutgoingStreams());
@@ -605,7 +605,7 @@
// can not proceed immediately.
const size_t kMaxOpenStreams = session_->max_open_outgoing_streams();
for (size_t i = 0; i < kMaxOpenStreams; i++) {
- QuicChromiumClientSessionPeer::CreateOutgoingDynamicStream(session_.get());
+ QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get());
}
EXPECT_EQ(kMaxOpenStreams, session_->GetNumOpenOutgoingStreams());
@@ -711,7 +711,7 @@
// can not proceed immediately.
const size_t kMaxOpenStreams = session_->max_open_outgoing_streams();
for (size_t i = 0; i < kMaxOpenStreams; i++) {
- QuicChromiumClientSessionPeer::CreateOutgoingDynamicStream(session_.get());
+ QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get());
}
EXPECT_EQ(kMaxOpenStreams, session_->GetNumOpenOutgoingStreams());
@@ -754,13 +754,12 @@
std::vector<QuicChromiumClientStream*> streams;
for (size_t i = 0; i < kMaxOpenStreams; i++) {
QuicChromiumClientStream* stream =
- QuicChromiumClientSessionPeer::CreateOutgoingDynamicStream(
- session_.get());
+ QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get());
EXPECT_TRUE(stream);
streams.push_back(stream);
}
- EXPECT_FALSE(QuicChromiumClientSessionPeer::CreateOutgoingDynamicStream(
- session_.get()));
+ EXPECT_FALSE(
+ QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get()));
EXPECT_EQ(kMaxOpenStreams, session_->GetNumOpenOutgoingStreams());
@@ -768,14 +767,14 @@
quic::QuicStreamId stream_id = streams[0]->id();
session_->CloseStream(stream_id);
- EXPECT_FALSE(QuicChromiumClientSessionPeer::CreateOutgoingDynamicStream(
- session_.get()));
+ EXPECT_FALSE(
+ QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get()));
quic::QuicRstStreamFrame rst1(quic::kInvalidControlFrameId, stream_id,
quic::QUIC_STREAM_NO_ERROR, 0);
session_->OnRstStream(rst1);
EXPECT_EQ(kMaxOpenStreams - 1, session_->GetNumOpenOutgoingStreams());
- EXPECT_TRUE(QuicChromiumClientSessionPeer::CreateOutgoingDynamicStream(
- session_.get()));
+ EXPECT_TRUE(
+ QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get()));
}
TEST_P(QuicChromiumClientSessionTest, PushStreamTimedOutNoResponse) {
@@ -801,8 +800,7 @@
session_->OnProofVerifyDetailsAvailable(details);
QuicChromiumClientStream* stream =
- QuicChromiumClientSessionPeer::CreateOutgoingDynamicStream(
- session_.get());
+ QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get());
EXPECT_TRUE(stream);
spdy::SpdyHeaderBlock promise_headers;
@@ -852,8 +850,7 @@
session_->OnProofVerifyDetailsAvailable(details);
QuicChromiumClientStream* stream =
- QuicChromiumClientSessionPeer::CreateOutgoingDynamicStream(
- session_.get());
+ QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get());
EXPECT_TRUE(stream);
spdy::SpdyHeaderBlock promise_headers;
@@ -908,8 +905,7 @@
session_->OnProofVerifyDetailsAvailable(details);
QuicChromiumClientStream* stream =
- QuicChromiumClientSessionPeer::CreateOutgoingDynamicStream(
- session_.get());
+ QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get());
EXPECT_TRUE(stream);
spdy::SpdyHeaderBlock promise_headers;
@@ -963,8 +959,7 @@
session_->OnProofVerifyDetailsAvailable(details);
QuicChromiumClientStream* stream =
- QuicChromiumClientSessionPeer::CreateOutgoingDynamicStream(
- session_.get());
+ QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get());
EXPECT_TRUE(stream);
spdy::SpdyHeaderBlock promise_headers;
@@ -1014,8 +1009,7 @@
session_->OnProofVerifyDetailsAvailable(details);
QuicChromiumClientStream* stream =
- QuicChromiumClientSessionPeer::CreateOutgoingDynamicStream(
- session_.get());
+ QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get());
EXPECT_TRUE(stream);
spdy::SpdyHeaderBlock promise_headers;
@@ -1068,8 +1062,7 @@
std::vector<QuicChromiumClientStream*> streams;
for (size_t i = 0; i < kMaxOpenStreams; i++) {
QuicChromiumClientStream* stream =
- QuicChromiumClientSessionPeer::CreateOutgoingDynamicStream(
- session_.get());
+ QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get());
EXPECT_TRUE(stream);
streams.push_back(stream);
}
@@ -1108,7 +1101,7 @@
session_->connection()->OnGoAwayFrame(
quic::QuicGoAwayFrame(quic::kInvalidControlFrameId,
quic::QUIC_PEER_GOING_AWAY, 1u, "Going away."));
- EXPECT_EQ(nullptr, QuicChromiumClientSessionPeer::CreateOutgoingDynamicStream(
+ EXPECT_EQ(nullptr, QuicChromiumClientSessionPeer::CreateOutgoingStream(
session_.get()));
}
@@ -1303,8 +1296,7 @@
// Write data to session.
QuicChromiumClientStream* stream =
- QuicChromiumClientSessionPeer::CreateOutgoingDynamicStream(
- session_.get());
+ QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get());
struct iovec iov[1];
iov[0].iov_base = data;
iov[0].iov_len = 4;
@@ -1519,8 +1511,8 @@
// Open a stream since the connection only sends PINGs to keep a
// retransmittable packet on the wire if there's an open stream.
- EXPECT_TRUE(QuicChromiumClientSessionPeer::CreateOutgoingDynamicStream(
- session_.get()));
+ EXPECT_TRUE(
+ QuicChromiumClientSessionPeer::CreateOutgoingStream(session_.get()));
quic::QuicAlarm* alarm =
quic::test::QuicConnectionPeer::GetRetransmittableOnWireAlarm(
diff --git a/net/quic/quic_chromium_client_stream_test.cc b/net/quic/quic_chromium_client_stream_test.cc
index 99924ba..869042c 100644
--- a/net/quic/quic_chromium_client_stream_test.cc
+++ b/net/quic/quic_chromium_client_stream_test.cc
@@ -60,7 +60,7 @@
void(quic::QuicErrorCode error,
const std::string& error_details,
quic::ConnectionCloseSource source));
- MOCK_METHOD1(CreateIncomingDynamicStream,
+ MOCK_METHOD1(CreateIncomingStream,
quic::QuicSpdyStream*(quic::QuicStreamId id));
MOCK_METHOD0(CreateOutgoingBidirectionalStream, QuicChromiumClientStream*());
MOCK_METHOD0(CreateOutgoingUnidirectionalStream, QuicChromiumClientStream*());
@@ -129,8 +129,8 @@
bool IsAuthorized(const std::string& hostname) override { return true; }
protected:
- MOCK_METHOD1(ShouldCreateIncomingDynamicStream, bool(quic::QuicStreamId id));
- MOCK_METHOD0(ShouldCreateOutgoingDynamicStream, bool());
+ MOCK_METHOD1(ShouldCreateIncomingStream, bool(quic::QuicStreamId id));
+ MOCK_METHOD0(ShouldCreateOutgoingStream, bool());
private:
std::unique_ptr<quic::QuicCryptoStream> crypto_stream_;
diff --git a/net/third_party/quic/core/http/quic_server_session_base.cc b/net/third_party/quic/core/http/quic_server_session_base.cc
index 1326676..fd73f2c7 100644
--- a/net/third_party/quic/core/http/quic_server_session_base.cc
+++ b/net/third_party/quic/core/http/quic_server_session_base.cc
@@ -192,9 +192,9 @@
connection()->sent_packet_manager().GetLargestSentPacket();
}
-bool QuicServerSessionBase::ShouldCreateIncomingDynamicStream(QuicStreamId id) {
+bool QuicServerSessionBase::ShouldCreateIncomingStream(QuicStreamId id) {
if (!connection()->connected()) {
- QUIC_BUG << "ShouldCreateIncomingDynamicStream called when disconnected";
+ QUIC_BUG << "ShouldCreateIncomingStream called when disconnected";
return false;
}
@@ -208,9 +208,9 @@
return true;
}
-bool QuicServerSessionBase::ShouldCreateOutgoingDynamicStream() {
+bool QuicServerSessionBase::ShouldCreateOutgoingStream() {
if (!connection()->connected()) {
- QUIC_BUG << "ShouldCreateOutgoingDynamicStream called when disconnected";
+ QUIC_BUG << "ShouldCreateOutgoingStream called when disconnected";
return false;
}
if (!crypto_stream_->encryption_established()) {
diff --git a/net/third_party/quic/core/http/quic_server_session_base.h b/net/third_party/quic/core/http/quic_server_session_base.h
index 1ff4691..67f39b0 100644
--- a/net/third_party/quic/core/http/quic_server_session_base.h
+++ b/net/third_party/quic/core/http/quic_server_session_base.h
@@ -79,12 +79,12 @@
// Return false when connection is closed or forward secure encryption hasn't
// established yet or number of server initiated streams already reaches the
// upper limit.
- bool ShouldCreateOutgoingDynamicStream() override;
+ bool ShouldCreateOutgoingStream() override;
// If we should create an incoming stream, returns true. Otherwise
// does error handling, including communicating the error to the client and
// possibly closing the connection, and returns false.
- bool ShouldCreateIncomingDynamicStream(QuicStreamId id) override;
+ bool ShouldCreateIncomingStream(QuicStreamId id) override;
virtual QuicCryptoServerStreamBase* CreateQuicCryptoServerStream(
const QuicCryptoServerConfig* crypto_config,
diff --git a/net/third_party/quic/core/http/quic_server_session_base_test.cc b/net/third_party/quic/core/http/quic_server_session_base_test.cc
index 01d134c..f6816a46 100644
--- a/net/third_party/quic/core/http/quic_server_session_base_test.cc
+++ b/net/third_party/quic/core/http/quic_server_session_base_test.cc
@@ -63,8 +63,8 @@
~TestServerSession() override { delete connection(); };
protected:
- QuicSpdyStream* CreateIncomingDynamicStream(QuicStreamId id) override {
- if (!ShouldCreateIncomingDynamicStream(id)) {
+ QuicSpdyStream* CreateIncomingStream(QuicStreamId id) override {
+ if (!ShouldCreateIncomingStream(id)) {
return nullptr;
}
QuicSpdyStream* stream = new QuicSimpleServerStream(
@@ -79,7 +79,7 @@
}
QuicSpdyStream* CreateOutgoingUnidirectionalStream() override {
- if (!ShouldCreateOutgoingDynamicStream()) {
+ if (!ShouldCreateOutgoingStream()) {
return nullptr;
}
@@ -355,7 +355,7 @@
QuicConnectionPeer::TearDownLocalConnectionState(connection_);
EXPECT_QUIC_BUG(QuicServerSessionBasePeer::GetOrCreateDynamicStream(
session_.get(), GetNthClientInitiatedId(0)),
- "ShouldCreateIncomingDynamicStream called when disconnected");
+ "ShouldCreateIncomingStream called when disconnected");
}
class MockQuicCryptoServerStream : public QuicCryptoServerStream {
diff --git a/net/third_party/quic/core/http/quic_spdy_client_session.cc b/net/third_party/quic/core/http/quic_spdy_client_session.cc
index 24ff19b6..b756662 100644
--- a/net/third_party/quic/core/http/quic_spdy_client_session.cc
+++ b/net/third_party/quic/core/http/quic_spdy_client_session.cc
@@ -41,7 +41,7 @@
void QuicSpdyClientSession::OnProofVerifyDetailsAvailable(
const ProofVerifyDetails& /*verify_details*/) {}
-bool QuicSpdyClientSession::ShouldCreateOutgoingDynamicStream() {
+bool QuicSpdyClientSession::ShouldCreateOutgoingStream() {
if (!crypto_stream_->encryption_established()) {
QUIC_DLOG(INFO) << "Encryption not active so no outgoing stream created.";
return false;
@@ -70,7 +70,7 @@
QuicSpdyClientStream*
QuicSpdyClientSession::CreateOutgoingBidirectionalStream() {
- if (!ShouldCreateOutgoingDynamicStream()) {
+ if (!ShouldCreateOutgoingStream()) {
return nullptr;
}
std::unique_ptr<QuicSpdyClientStream> stream = CreateClientStream();
@@ -113,9 +113,9 @@
return crypto_stream_->num_scup_messages_received();
}
-bool QuicSpdyClientSession::ShouldCreateIncomingDynamicStream(QuicStreamId id) {
+bool QuicSpdyClientSession::ShouldCreateIncomingStream(QuicStreamId id) {
if (!connection()->connected()) {
- QUIC_BUG << "ShouldCreateIncomingDynamicStream called when disconnected";
+ QUIC_BUG << "ShouldCreateIncomingStream called when disconnected";
return false;
}
if (goaway_received() && respect_goaway_) {
@@ -133,9 +133,8 @@
return true;
}
-QuicSpdyStream* QuicSpdyClientSession::CreateIncomingDynamicStream(
- QuicStreamId id) {
- if (!ShouldCreateIncomingDynamicStream(id)) {
+QuicSpdyStream* QuicSpdyClientSession::CreateIncomingStream(QuicStreamId id) {
+ if (!ShouldCreateIncomingStream(id)) {
return nullptr;
}
QuicSpdyStream* stream =
diff --git a/net/third_party/quic/core/http/quic_spdy_client_session.h b/net/third_party/quic/core/http/quic_spdy_client_session.h
index 9e1bc11..a3ca1669 100644
--- a/net/third_party/quic/core/http/quic_spdy_client_session.h
+++ b/net/third_party/quic/core/http/quic_spdy_client_session.h
@@ -65,12 +65,12 @@
protected:
// QuicSession methods:
- QuicSpdyStream* CreateIncomingDynamicStream(QuicStreamId id) override;
+ QuicSpdyStream* CreateIncomingStream(QuicStreamId id) override;
// If an outgoing stream can be created, return true.
- bool ShouldCreateOutgoingDynamicStream() override;
+ bool ShouldCreateOutgoingStream() override;
// If an incoming stream can be created, return true.
- bool ShouldCreateIncomingDynamicStream(QuicStreamId id) override;
+ bool ShouldCreateIncomingStream(QuicStreamId id) override;
// Create the crypto stream. Called by Initialize().
virtual std::unique_ptr<QuicCryptoClientStreamBase> CreateQuicCryptoStream();
diff --git a/net/third_party/quic/core/http/quic_spdy_client_session_test.cc b/net/third_party/quic/core/http/quic_spdy_client_session_test.cc
index a9058c2..dcb4567 100644
--- a/net/third_party/quic/core/http/quic_spdy_client_session_test.cc
+++ b/net/third_party/quic/core/http/quic_spdy_client_session_test.cc
@@ -58,8 +58,7 @@
this, BIDIRECTIONAL);
}
- MockQuicSpdyClientStream* CreateIncomingDynamicStream(
- QuicStreamId id) override {
+ MockQuicSpdyClientStream* CreateIncomingStream(QuicStreamId id) override {
MockQuicSpdyClientStream* stream =
new MockQuicSpdyClientStream(id, this, READ_UNIDIRECTIONAL);
ActivateStream(QuicWrapUnique(stream));
diff --git a/net/third_party/quic/core/http/quic_spdy_session.h b/net/third_party/quic/core/http/quic_spdy_session.h
index 937a765..1bea32e9 100644
--- a/net/third_party/quic/core/http/quic_spdy_session.h
+++ b/net/third_party/quic/core/http/quic_spdy_session.h
@@ -135,21 +135,20 @@
}
protected:
- // Override CreateIncomingDynamicStream(),
- // CreateOutgoingBidirectionalStream() and
+ // Override CreateIncomingStream(), CreateOutgoingBidirectionalStream() and
// CreateOutgoingUnidirectionalStream() with QuicSpdyStream return type to
// make sure that all data streams are QuicSpdyStreams.
- QuicSpdyStream* CreateIncomingDynamicStream(QuicStreamId id) override = 0;
+ QuicSpdyStream* CreateIncomingStream(QuicStreamId id) override = 0;
QuicSpdyStream* CreateOutgoingBidirectionalStream() override = 0;
QuicSpdyStream* CreateOutgoingUnidirectionalStream() override = 0;
QuicSpdyStream* GetSpdyDataStream(const QuicStreamId stream_id);
// If an incoming stream can be created, return true.
- virtual bool ShouldCreateIncomingDynamicStream(QuicStreamId id) = 0;
+ virtual bool ShouldCreateIncomingStream(QuicStreamId id) = 0;
// If an outgoing stream can be created, return true.
- virtual bool ShouldCreateOutgoingDynamicStream() = 0;
+ virtual bool ShouldCreateOutgoingStream() = 0;
// This was formerly QuicHeadersStream::WriteHeaders. Needs to be
// separate from QuicSpdySession::WriteHeaders because tests call
diff --git a/net/third_party/quic/core/http/quic_spdy_session_test.cc b/net/third_party/quic/core/http/quic_spdy_session_test.cc
index c1f9400c..206b47397 100644
--- a/net/third_party/quic/core/http/quic_spdy_session_test.cc
+++ b/net/third_party/quic/core/http/quic_spdy_session_test.cc
@@ -168,7 +168,7 @@
return stream;
}
- TestStream* CreateIncomingDynamicStream(QuicStreamId id) override {
+ TestStream* CreateIncomingStream(QuicStreamId id) override {
// Enforce the limit on the number of open streams.
if (GetNumOpenIncomingStreams() + 1 > max_open_incoming_streams()) {
connection()->CloseConnection(
@@ -182,11 +182,9 @@
}
}
- bool ShouldCreateIncomingDynamicStream(QuicStreamId /*id*/) override {
- return true;
- }
+ bool ShouldCreateIncomingStream(QuicStreamId /*id*/) override { return true; }
- bool ShouldCreateOutgoingDynamicStream() override { return true; }
+ bool ShouldCreateOutgoingStream() override { return true; }
bool IsClosedStream(QuicStreamId id) {
return QuicSession::IsClosedStream(id);
@@ -1605,7 +1603,7 @@
TEST_P(QuicSpdySessionTestServer, OnPriorityFrame) {
QuicStreamId stream_id = GetNthClientInitiatedId(0);
- TestStream* stream = session_.CreateIncomingDynamicStream(stream_id);
+ TestStream* stream = session_.CreateIncomingStream(stream_id);
session_.OnPriorityFrame(stream_id, kV3HighestPriority);
EXPECT_EQ(kV3HighestPriority, stream->priority());
}
diff --git a/net/third_party/quic/core/quic_dispatcher_test.cc b/net/third_party/quic/core/quic_dispatcher_test.cc
index ee06318..8c5ab72 100644
--- a/net/third_party/quic/core/quic_dispatcher_test.cc
+++ b/net/third_party/quic/core/quic_dispatcher_test.cc
@@ -75,7 +75,7 @@
void(QuicErrorCode error,
const QuicString& error_details,
ConnectionCloseSource source));
- MOCK_METHOD1(CreateIncomingDynamicStream, QuicSpdyStream*(QuicStreamId id));
+ MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(QuicStreamId id));
MOCK_METHOD0(CreateOutgoingBidirectionalStream, QuicSpdyStream*());
MOCK_METHOD0(CreateOutgoingUnidirectionalStream, QuicSpdyStream*());
diff --git a/net/third_party/quic/core/quic_session.cc b/net/third_party/quic/core/quic_session.cc
index 69587ef3..e4d7450 100644
--- a/net/third_party/quic/core/quic_session.cc
+++ b/net/third_party/quic/core/quic_session.cc
@@ -931,7 +931,7 @@
return nullptr;
}
- return CreateIncomingDynamicStream(stream_id);
+ return CreateIncomingStream(stream_id);
}
void QuicSession::set_max_open_incoming_streams(
diff --git a/net/third_party/quic/core/quic_session.h b/net/third_party/quic/core/quic_session.h
index b4d757d..da9bd76 100644
--- a/net/third_party/quic/core/quic_session.h
+++ b/net/third_party/quic/core/quic_session.h
@@ -356,7 +356,7 @@
// Creates a new stream to handle a peer-initiated stream.
// Caller does not own the returned stream.
// Returns nullptr and does error handling if the stream can not be created.
- virtual QuicStream* CreateIncomingDynamicStream(QuicStreamId id) = 0;
+ virtual QuicStream* CreateIncomingStream(QuicStreamId id) = 0;
// Create a new stream to handle a locally-initiated bidirectional stream.
// Caller does not own the returned stream.
diff --git a/net/third_party/quic/core/quic_session_test.cc b/net/third_party/quic/core/quic_session_test.cc
index d3b255c..d0d61f7 100644
--- a/net/third_party/quic/core/quic_session_test.cc
+++ b/net/third_party/quic/core/quic_session_test.cc
@@ -158,7 +158,7 @@
return stream;
}
- TestStream* CreateIncomingDynamicStream(QuicStreamId id) override {
+ TestStream* CreateIncomingStream(QuicStreamId id) override {
// Enforce the limit on the number of open streams.
if (GetNumOpenIncomingStreams() + 1 > max_open_incoming_streams()) {
connection()->CloseConnection(
diff --git a/net/third_party/quic/quartc/quartc_session.cc b/net/third_party/quic/quartc/quartc_session.cc
index 93de609..c08e0c9 100644
--- a/net/third_party/quic/quartc/quartc_session.cc
+++ b/net/third_party/quic/quartc/quartc_session.cc
@@ -309,7 +309,7 @@
// TODO(zhihuang): Handle the proof verification.
}
-QuicStream* QuartcSession::CreateIncomingDynamicStream(QuicStreamId id) {
+QuicStream* QuartcSession::CreateIncomingStream(QuicStreamId id) {
return ActivateDataStream(CreateDataStream(id, QuicStream::kDefaultPriority));
}
diff --git a/net/third_party/quic/quartc/quartc_session.h b/net/third_party/quic/quartc/quartc_session.h
index d0dd8af..742d9da 100644
--- a/net/third_party/quic/quartc/quartc_session.h
+++ b/net/third_party/quic/quartc/quartc_session.h
@@ -137,7 +137,7 @@
protected:
// QuicSession override.
- QuicStream* CreateIncomingDynamicStream(QuicStreamId id) override;
+ QuicStream* CreateIncomingStream(QuicStreamId id) override;
std::unique_ptr<QuartcStream> CreateDataStream(QuicStreamId id,
spdy::SpdyPriority priority);
diff --git a/net/third_party/quic/quartc/quartc_stream_test.cc b/net/third_party/quic/quartc/quartc_stream_test.cc
index cc8858a..f2ff1c4 100644
--- a/net/third_party/quic/quartc/quartc_stream_test.cc
+++ b/net/third_party/quic/quartc/quartc_stream_test.cc
@@ -58,7 +58,7 @@
return QuicConsumedData(write_length, state != StreamSendingState::NO_FIN);
}
- QuartcStream* CreateIncomingDynamicStream(QuicStreamId id) override {
+ QuartcStream* CreateIncomingStream(QuicStreamId id) override {
return nullptr;
}
diff --git a/net/third_party/quic/test_tools/quic_test_server.cc b/net/third_party/quic/test_tools/quic_test_server.cc
index edcef09..6bbfe0b 100644
--- a/net/third_party/quic/test_tools/quic_test_server.cc
+++ b/net/third_party/quic/test_tools/quic_test_server.cc
@@ -37,8 +37,8 @@
stream_factory_(stream_factory),
crypto_stream_factory_(crypto_stream_factory) {}
- QuicSpdyStream* CreateIncomingDynamicStream(QuicStreamId id) override {
- if (!ShouldCreateIncomingDynamicStream(id)) {
+ QuicSpdyStream* CreateIncomingStream(QuicStreamId id) override {
+ if (!ShouldCreateIncomingStream(id)) {
return nullptr;
}
if (stream_factory_) {
@@ -47,7 +47,7 @@
ActivateStream(QuicWrapUnique(stream));
return stream;
}
- return QuicSimpleServerSession::CreateIncomingDynamicStream(id);
+ return QuicSimpleServerSession::CreateIncomingStream(id);
}
QuicCryptoServerStreamBase* CreateQuicCryptoServerStream(
diff --git a/net/third_party/quic/test_tools/quic_test_utils.h b/net/third_party/quic/test_tools/quic_test_utils.h
index 78273700..30a2d6c6 100644
--- a/net/third_party/quic/test_tools/quic_test_utils.h
+++ b/net/third_party/quic/test_tools/quic_test_utils.h
@@ -557,11 +557,11 @@
void(QuicErrorCode error,
const QuicString& error_details,
ConnectionCloseSource source));
- MOCK_METHOD1(CreateIncomingDynamicStream, QuicStream*(QuicStreamId id));
+ MOCK_METHOD1(CreateIncomingStream, QuicStream*(QuicStreamId id));
MOCK_METHOD0(CreateOutgoingBidirectionalStream, QuicStream*());
MOCK_METHOD0(CreateOutgoingUnidirectionalStream, QuicStream*());
- MOCK_METHOD1(ShouldCreateIncomingDynamicStream2, bool(QuicStreamId id));
- MOCK_METHOD0(ShouldCreateOutgoingDynamicStream2, bool());
+ MOCK_METHOD1(ShouldCreateIncomingStream2, bool(QuicStreamId id));
+ MOCK_METHOD0(ShouldCreateOutgoingStream2, bool());
MOCK_METHOD5(WritevData,
QuicConsumedData(QuicStream* stream,
QuicStreamId id,
@@ -635,11 +635,11 @@
void(QuicErrorCode error,
const QuicString& error_details,
ConnectionCloseSource source));
- MOCK_METHOD1(CreateIncomingDynamicStream, QuicSpdyStream*(QuicStreamId id));
+ MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(QuicStreamId id));
MOCK_METHOD0(CreateOutgoingBidirectionalStream, QuicSpdyStream*());
MOCK_METHOD0(CreateOutgoingUnidirectionalStream, QuicSpdyStream*());
- MOCK_METHOD1(ShouldCreateIncomingDynamicStream, bool(QuicStreamId id));
- MOCK_METHOD0(ShouldCreateOutgoingDynamicStream, bool());
+ MOCK_METHOD1(ShouldCreateIncomingStream, bool(QuicStreamId id));
+ MOCK_METHOD0(ShouldCreateOutgoingStream, bool());
MOCK_METHOD5(WritevData,
QuicConsumedData(QuicStream* stream,
QuicStreamId id,
@@ -718,7 +718,7 @@
delete;
~TestQuicSpdyServerSession() override;
- MOCK_METHOD1(CreateIncomingDynamicStream, QuicSpdyStream*(QuicStreamId id));
+ MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(QuicStreamId id));
MOCK_METHOD0(CreateOutgoingBidirectionalStream, QuicSpdyStream*());
MOCK_METHOD0(CreateOutgoingUnidirectionalStream, QuicSpdyStream*());
QuicCryptoServerStreamBase* CreateQuicCryptoServerStream(
@@ -781,11 +781,11 @@
void(const ProofVerifyDetails& verify_details));
// TestQuicSpdyClientSession
- MOCK_METHOD1(CreateIncomingDynamicStream, QuicSpdyStream*(QuicStreamId id));
+ MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(QuicStreamId id));
MOCK_METHOD0(CreateOutgoingBidirectionalStream, QuicSpdyStream*());
MOCK_METHOD0(CreateOutgoingUnidirectionalStream, QuicSpdyStream*());
- MOCK_METHOD1(ShouldCreateIncomingDynamicStream, bool(QuicStreamId id));
- MOCK_METHOD0(ShouldCreateOutgoingDynamicStream, bool());
+ MOCK_METHOD1(ShouldCreateIncomingStream, bool(QuicStreamId id));
+ MOCK_METHOD0(ShouldCreateOutgoingStream, bool());
// Override to not send max header list size.
void OnCryptoHandshakeEvent(CryptoHandshakeEvent event) override;
diff --git a/net/third_party/quic/tools/quic_simple_server_session.cc b/net/third_party/quic/tools/quic_simple_server_session.cc
index 64d081f..2288691 100644
--- a/net/third_party/quic/tools/quic_simple_server_session.cc
+++ b/net/third_party/quic/tools/quic_simple_server_session.cc
@@ -86,9 +86,8 @@
HandlePromisedPushRequests();
}
-QuicSpdyStream* QuicSimpleServerSession::CreateIncomingDynamicStream(
- QuicStreamId id) {
- if (!ShouldCreateIncomingDynamicStream(id)) {
+QuicSpdyStream* QuicSimpleServerSession::CreateIncomingStream(QuicStreamId id) {
+ if (!ShouldCreateIncomingStream(id)) {
return nullptr;
}
@@ -106,7 +105,7 @@
QuicSimpleServerStream*
QuicSimpleServerSession::CreateOutgoingUnidirectionalStream() {
- if (!ShouldCreateOutgoingDynamicStream()) {
+ if (!ShouldCreateOutgoingStream()) {
return nullptr;
}
@@ -187,7 +186,7 @@
}
void QuicSimpleServerSession::HandlePromisedPushRequests() {
- while (!promised_streams_.empty() && ShouldCreateOutgoingDynamicStream()) {
+ while (!promised_streams_.empty() && ShouldCreateOutgoingStream()) {
PromisedStreamInfo& promised_info = promised_streams_.front();
DCHECK_EQ(next_outgoing_stream_id(), promised_info.stream_id);
diff --git a/net/third_party/quic/tools/quic_simple_server_session.h b/net/third_party/quic/tools/quic_simple_server_session.h
index bc105b9..6e5160a 100644
--- a/net/third_party/quic/tools/quic_simple_server_session.h
+++ b/net/third_party/quic/tools/quic_simple_server_session.h
@@ -85,7 +85,7 @@
protected:
// QuicSession methods:
- QuicSpdyStream* CreateIncomingDynamicStream(QuicStreamId id) override;
+ QuicSpdyStream* CreateIncomingStream(QuicStreamId id) override;
QuicSimpleServerStream* CreateOutgoingBidirectionalStream() override;
QuicSimpleServerStream* CreateOutgoingUnidirectionalStream() override;
// Closing an outgoing stream can reduce open outgoing stream count, try
diff --git a/net/third_party/quic/tools/quic_simple_server_session_test.cc b/net/third_party/quic/tools/quic_simple_server_session_test.cc
index 4f555619..e24d917 100644
--- a/net/third_party/quic/tools/quic_simple_server_session_test.cc
+++ b/net/third_party/quic/tools/quic_simple_server_session_test.cc
@@ -58,9 +58,9 @@
s->RegisterStaticStream(kCryptoStreamId, crypto_stream);
}
- static QuicSpdyStream* CreateIncomingDynamicStream(QuicSimpleServerSession* s,
- QuicStreamId id) {
- return s->CreateIncomingDynamicStream(id);
+ static QuicSpdyStream* CreateIncomingStream(QuicSimpleServerSession* s,
+ QuicStreamId id) {
+ return s->CreateIncomingStream(id);
}
static QuicSimpleServerStream* CreateOutgoingUnidirectionalStream(
@@ -326,7 +326,7 @@
EXPECT_TRUE(connection_->connected());
}
-TEST_P(QuicSimpleServerSessionTest, CreateIncomingDynamicStreamDisconnected) {
+TEST_P(QuicSimpleServerSessionTest, CreateIncomingStreamDisconnected) {
// EXPECT_QUIC_BUG tests are expensive so only run one instance of them.
if (GetParam() != AllSupportedVersions()[0]) {
return;
@@ -335,9 +335,9 @@
// Tests that incoming stream creation fails when connection is not connected.
size_t initial_num_open_stream = session_->GetNumOpenIncomingStreams();
QuicConnectionPeer::TearDownLocalConnectionState(connection_);
- EXPECT_QUIC_BUG(QuicSimpleServerSessionPeer::CreateIncomingDynamicStream(
+ EXPECT_QUIC_BUG(QuicSimpleServerSessionPeer::CreateIncomingStream(
session_.get(), GetNthClientInitiatedId(0)),
- "ShouldCreateIncomingDynamicStream called when disconnected");
+ "ShouldCreateIncomingStream called when disconnected");
EXPECT_EQ(initial_num_open_stream, session_->GetNumOpenIncomingStreams());
}
@@ -347,14 +347,13 @@
EXPECT_CALL(*connection_,
CloseConnection(QUIC_INVALID_STREAM_ID,
"Client created even numbered stream", _));
- QuicSimpleServerSessionPeer::CreateIncomingDynamicStream(session_.get(), 2);
+ QuicSimpleServerSessionPeer::CreateIncomingStream(session_.get(), 2);
EXPECT_EQ(initial_num_open_stream, session_->GetNumOpenIncomingStreams());
}
-TEST_P(QuicSimpleServerSessionTest, CreateIncomingDynamicStream) {
- QuicSpdyStream* stream =
- QuicSimpleServerSessionPeer::CreateIncomingDynamicStream(
- session_.get(), GetNthClientInitiatedId(0));
+TEST_P(QuicSimpleServerSessionTest, CreateIncomingStream) {
+ QuicSpdyStream* stream = QuicSimpleServerSessionPeer::CreateIncomingStream(
+ session_.get(), GetNthClientInitiatedId(0));
EXPECT_NE(nullptr, stream);
EXPECT_EQ(GetNthClientInitiatedId(0), stream->id());
}
@@ -371,7 +370,7 @@
EXPECT_QUIC_BUG(
QuicSimpleServerSessionPeer::CreateOutgoingUnidirectionalStream(
session_.get()),
- "ShouldCreateOutgoingDynamicStream called when disconnected");
+ "ShouldCreateOutgoingStream called when disconnected");
EXPECT_EQ(initial_num_open_stream, session_->GetNumOpenOutgoingStreams());
}
diff --git a/net/third_party/quic/tools/quic_simple_server_stream_test.cc b/net/third_party/quic/tools/quic_simple_server_stream_test.cc
index 026b8a1..23324ca0 100644
--- a/net/third_party/quic/tools/quic_simple_server_stream_test.cc
+++ b/net/third_party/quic/tools/quic_simple_server_stream_test.cc
@@ -115,7 +115,7 @@
void(QuicErrorCode error,
const QuicString& error_details,
ConnectionCloseSource source));
- MOCK_METHOD1(CreateIncomingDynamicStream, QuicSpdyStream*(QuicStreamId id));
+ MOCK_METHOD1(CreateIncomingStream, QuicSpdyStream*(QuicStreamId id));
MOCK_METHOD5(WritevData,
QuicConsumedData(QuicStream* stream,
QuicStreamId id,
diff --git a/third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_transport_impl.cc b/third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_transport_impl.cc
index fe216c2..e1895c44 100644
--- a/third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_transport_impl.cc
+++ b/third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_transport_impl.cc
@@ -237,7 +237,7 @@
return nullptr;
}
-P2PQuicStreamImpl* P2PQuicTransportImpl::CreateIncomingDynamicStream(
+P2PQuicStreamImpl* P2PQuicTransportImpl::CreateIncomingStream(
quic::QuicStreamId id) {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
P2PQuicStreamImpl* stream = CreateStreamInternal(id);
diff --git a/third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_transport_impl.h b/third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_transport_impl.h
index 609f223c..60c85ef 100644
--- a/third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_transport_impl.h
+++ b/third_party/blink/renderer/modules/peerconnection/adapters/p2p_quic_transport_impl.h
@@ -104,7 +104,7 @@
// Creates a new stream initiated from the remote side. The caller does not
// own the stream, so the stream is activated and ownership is moved to the
// quic::QuicSession.
- P2PQuicStreamImpl* CreateIncomingDynamicStream(
+ P2PQuicStreamImpl* CreateIncomingStream(
quic::QuicStreamId id) override;
// Creates a new outgoing stream. The caller does not own the
