Clean up UberQuicStreamIdManagerTest by using a Delegate instead of a full Session. Also change the UberQuicStreamIdManager constructor to take a Delegate, Perspective and Version instead of a session.
gfe-relnote: change the UberQuicStreamIdManager constructor to take a Delegate, Perspective and Version instead of a session. Refactor only. Not flag protected.
PiperOrigin-RevId: 270671933
Change-Id: Ie9f8d6051c115f6076179cf8d1fceac1cf6c989b
diff --git a/quic/core/quic_session.cc b/quic/core/quic_session.cc
index 9d0c7bf..cfe7b3f 100644
--- a/quic/core/quic_session.cc
+++ b/quic/core/quic_session.cc
@@ -61,6 +61,8 @@
kDefaultMaxStreamsPerConnection,
config_.GetMaxIncomingBidirectionalStreamsToSend()),
v99_streamid_manager_(
+ perspective(),
+ connection->version(),
this,
num_expected_unidirectional_static_streams,
kDefaultMaxStreamsPerConnection,
diff --git a/quic/core/uber_quic_stream_id_manager.cc b/quic/core/uber_quic_stream_id_manager.cc
index 98c6e8c..f258384 100644
--- a/quic/core/uber_quic_stream_id_manager.cc
+++ b/quic/core/uber_quic_stream_id_manager.cc
@@ -10,24 +10,26 @@
namespace quic {
UberQuicStreamIdManager::UberQuicStreamIdManager(
- QuicSession* session,
+ Perspective perspective,
+ ParsedQuicVersion version,
+ QuicStreamIdManager::DelegateInterface* delegate,
QuicStreamCount num_expected_unidirectiona_static_streams,
QuicStreamCount max_open_outgoing_bidirectional_streams,
QuicStreamCount max_open_outgoing_unidirectional_streams,
QuicStreamCount max_open_incoming_bidirectional_streams,
QuicStreamCount max_open_incoming_unidirectional_streams)
- : bidirectional_stream_id_manager_(session,
+ : bidirectional_stream_id_manager_(delegate,
/*unidirectional=*/false,
- session->perspective(),
- session->transport_version(),
+ perspective,
+ version.transport_version,
0,
max_open_outgoing_bidirectional_streams,
max_open_incoming_bidirectional_streams),
unidirectional_stream_id_manager_(
- session,
+ delegate,
/*unidirectional=*/true,
- session->perspective(),
- session->transport_version(),
+ perspective,
+ version.transport_version,
num_expected_unidirectiona_static_streams,
max_open_outgoing_unidirectional_streams,
max_open_incoming_unidirectional_streams) {}
diff --git a/quic/core/uber_quic_stream_id_manager.h b/quic/core/uber_quic_stream_id_manager.h
index dab571d..a725fdd 100644
--- a/quic/core/uber_quic_stream_id_manager.h
+++ b/quic/core/uber_quic_stream_id_manager.h
@@ -21,8 +21,10 @@
class QUIC_EXPORT_PRIVATE UberQuicStreamIdManager {
public:
UberQuicStreamIdManager(
- QuicSession* session,
- QuicStreamCount num_expected_unidirectiona_static_streams,
+ Perspective perspective,
+ ParsedQuicVersion version,
+ QuicStreamIdManager::DelegateInterface* delegate,
+ QuicStreamCount num_expected_unidirectional_static_streams,
QuicStreamCount max_open_outgoing_bidirectional_streams,
QuicStreamCount max_open_outgoing_unidirectional_streams,
QuicStreamCount max_open_incoming_bidirectional_streams,
diff --git a/quic/core/uber_quic_stream_id_manager_test.cc b/quic/core/uber_quic_stream_id_manager_test.cc
index b4ef1cc..265756f 100644
--- a/quic/core/uber_quic_stream_id_manager_test.cc
+++ b/quic/core/uber_quic_stream_id_manager_test.cc
@@ -6,7 +6,6 @@
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
-#include "net/third_party/quiche/src/quic/test_tools/quic_session_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_stream_id_manager_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
@@ -17,24 +16,28 @@
namespace test {
namespace {
-class UberQuicStreamIdManagerTest : public QuicTestWithParam<Perspective> {
+class MockDelegate : public QuicStreamIdManager::DelegateInterface {
public:
- bool SaveControlFrame(const QuicFrame& frame) {
- frame_ = frame;
- return true;
- }
+ MOCK_METHOD1(OnCanCreateNewOutgoingStream, void(bool unidirectional));
+ MOCK_METHOD2(OnError,
+ void(QuicErrorCode error_code, std::string error_details));
+ MOCK_METHOD2(SendMaxStreams,
+ void(QuicStreamCount stream_count, bool unidirectional));
+ MOCK_METHOD2(SendStreamsBlocked,
+ void(QuicStreamCount stream_count, bool unidirectional));
+};
+class UberQuicStreamIdManagerTest : public QuicTestWithParam<Perspective> {
protected:
UberQuicStreamIdManagerTest()
- : connection_(new MockQuicConnection(
- &helper_,
- &alarm_factory_,
- GetParam(),
- ParsedQuicVersionVector(
- {{PROTOCOL_QUIC_CRYPTO, QUIC_VERSION_99}}))) {
- session_ = std::make_unique<StrictMock<MockQuicSession>>(connection_);
- manager_ = QuicSessionPeer::v99_streamid_manager(session_.get());
- }
+ : manager_(perspective(),
+ version(),
+ &delegate_,
+ /*num_expected_unidirectional_static_streams=*/0,
+ kDefaultMaxStreamsPerConnection,
+ kDefaultMaxStreamsPerConnection,
+ kDefaultMaxStreamsPerConnection,
+ kDefaultMaxStreamsPerConnection) {}
QuicStreamId GetNthClientInitiatedBidirectionalId(int n) {
return QuicUtils::GetFirstBidirectionalStreamId(transport_version(),
@@ -92,16 +95,13 @@
((stream_count - 1) * QuicUtils::StreamIdDelta(transport_version()));
}
- QuicTransportVersion transport_version() {
- return connection_->transport_version();
- }
+ ParsedQuicVersion version() { return {PROTOCOL_TLS1_3, transport_version()}; }
+ QuicTransportVersion transport_version() { return QUIC_VERSION_99; }
- MockQuicConnectionHelper helper_;
- MockAlarmFactory alarm_factory_;
- MockQuicConnection* connection_;
- std::unique_ptr<StrictMock<MockQuicSession>> session_;
- UberQuicStreamIdManager* manager_;
- QuicFrame frame_;
+ Perspective perspective() { return GetParam(); }
+
+ testing::StrictMock<MockDelegate> delegate_;
+ UberQuicStreamIdManager manager_;
};
INSTANTIATE_TEST_SUITE_P(Tests,
@@ -111,16 +111,16 @@
::testing::PrintToStringParamName());
TEST_P(UberQuicStreamIdManagerTest, Initialization) {
- if (GetParam() == Perspective::IS_SERVER) {
+ if (perspective() == Perspective::IS_SERVER) {
EXPECT_EQ(GetNthServerInitiatedBidirectionalId(0),
- manager_->next_outgoing_bidirectional_stream_id());
+ manager_.next_outgoing_bidirectional_stream_id());
EXPECT_EQ(GetNthServerInitiatedUnidirectionalId(0),
- manager_->next_outgoing_unidirectional_stream_id());
+ manager_.next_outgoing_unidirectional_stream_id());
} else {
EXPECT_EQ(GetNthClientInitiatedBidirectionalId(0),
- manager_->next_outgoing_bidirectional_stream_id());
+ manager_.next_outgoing_bidirectional_stream_id());
EXPECT_EQ(GetNthClientInitiatedUnidirectionalId(0),
- manager_->next_outgoing_unidirectional_stream_id());
+ manager_.next_outgoing_unidirectional_stream_id());
}
}
@@ -128,240 +128,240 @@
const size_t kNumMaxOutgoingStream = 123;
// Set the uni- and bi- directional limits to different values to ensure
// that they are managed separately.
- manager_->SetMaxOpenOutgoingBidirectionalStreams(kNumMaxOutgoingStream);
- manager_->SetMaxOpenOutgoingUnidirectionalStreams(kNumMaxOutgoingStream + 1);
+ EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(false));
+ manager_.SetMaxOpenOutgoingBidirectionalStreams(kNumMaxOutgoingStream);
+ EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(true));
+ manager_.SetMaxOpenOutgoingUnidirectionalStreams(kNumMaxOutgoingStream + 1);
EXPECT_EQ(kNumMaxOutgoingStream,
- manager_->max_outgoing_bidirectional_streams());
+ manager_.max_outgoing_bidirectional_streams());
EXPECT_EQ(kNumMaxOutgoingStream + 1,
- manager_->max_outgoing_unidirectional_streams());
+ manager_.max_outgoing_unidirectional_streams());
// Check that, for each directionality, we can open the correct number of
// streams.
int i = kNumMaxOutgoingStream;
while (i) {
- EXPECT_TRUE(manager_->CanOpenNextOutgoingBidirectionalStream());
- manager_->GetNextOutgoingBidirectionalStreamId();
- EXPECT_TRUE(manager_->CanOpenNextOutgoingUnidirectionalStream());
- manager_->GetNextOutgoingUnidirectionalStreamId();
+ EXPECT_TRUE(manager_.CanOpenNextOutgoingBidirectionalStream());
+ manager_.GetNextOutgoingBidirectionalStreamId();
+ EXPECT_TRUE(manager_.CanOpenNextOutgoingUnidirectionalStream());
+ manager_.GetNextOutgoingUnidirectionalStreamId();
i--;
}
// One more unidirectional
- EXPECT_TRUE(manager_->CanOpenNextOutgoingUnidirectionalStream());
- manager_->GetNextOutgoingUnidirectionalStreamId();
+ EXPECT_TRUE(manager_.CanOpenNextOutgoingUnidirectionalStream());
+ manager_.GetNextOutgoingUnidirectionalStreamId();
// Both should be exhausted...
- EXPECT_FALSE(manager_->CanOpenNextOutgoingUnidirectionalStream());
- EXPECT_FALSE(manager_->CanOpenNextOutgoingBidirectionalStream());
+ EXPECT_FALSE(manager_.CanOpenNextOutgoingUnidirectionalStream());
+ EXPECT_FALSE(manager_.CanOpenNextOutgoingBidirectionalStream());
}
TEST_P(UberQuicStreamIdManagerTest, SetMaxOpenIncomingStreams) {
const size_t kNumMaxIncomingStreams = 456;
- manager_->SetMaxOpenIncomingUnidirectionalStreams(kNumMaxIncomingStreams);
+ manager_.SetMaxOpenIncomingUnidirectionalStreams(kNumMaxIncomingStreams);
// Do +1 for bidirectional to ensure that uni- and bi- get properly set.
- manager_->SetMaxOpenIncomingBidirectionalStreams(kNumMaxIncomingStreams + 1);
+ manager_.SetMaxOpenIncomingBidirectionalStreams(kNumMaxIncomingStreams + 1);
EXPECT_EQ(kNumMaxIncomingStreams + 1,
- manager_->GetMaxAllowdIncomingBidirectionalStreams());
+ manager_.GetMaxAllowdIncomingBidirectionalStreams());
EXPECT_EQ(kNumMaxIncomingStreams,
- manager_->GetMaxAllowdIncomingUnidirectionalStreams());
- EXPECT_EQ(manager_->max_incoming_bidirectional_streams(),
- manager_->advertised_max_incoming_bidirectional_streams());
- EXPECT_EQ(manager_->max_incoming_unidirectional_streams(),
- manager_->advertised_max_incoming_unidirectional_streams());
+ manager_.GetMaxAllowdIncomingUnidirectionalStreams());
+ EXPECT_EQ(manager_.max_incoming_bidirectional_streams(),
+ manager_.advertised_max_incoming_bidirectional_streams());
+ EXPECT_EQ(manager_.max_incoming_unidirectional_streams(),
+ manager_.advertised_max_incoming_unidirectional_streams());
// Make sure that we can create kNumMaxIncomingStreams incoming unidirectional
// streams and kNumMaxIncomingStreams+1 incoming bidirectional streams.
size_t i;
for (i = 0; i < kNumMaxIncomingStreams; i++) {
- EXPECT_TRUE(manager_->MaybeIncreaseLargestPeerStreamId(
+ EXPECT_TRUE(manager_.MaybeIncreaseLargestPeerStreamId(
GetNthPeerInitiatedUnidirectionalStreamId(i)));
- EXPECT_TRUE(manager_->MaybeIncreaseLargestPeerStreamId(
+ EXPECT_TRUE(manager_.MaybeIncreaseLargestPeerStreamId(
GetNthPeerInitiatedBidirectionalStreamId(i)));
}
// Should be able to open the next bidirectional stream
- EXPECT_TRUE(manager_->MaybeIncreaseLargestPeerStreamId(
+ EXPECT_TRUE(manager_.MaybeIncreaseLargestPeerStreamId(
GetNthPeerInitiatedBidirectionalStreamId(i)));
// We should have exhausted the counts, the next streams should fail
- EXPECT_FALSE(manager_->MaybeIncreaseLargestPeerStreamId(
+ EXPECT_CALL(delegate_, OnError(QUIC_INVALID_STREAM_ID, _));
+ EXPECT_FALSE(manager_.MaybeIncreaseLargestPeerStreamId(
GetNthPeerInitiatedUnidirectionalStreamId(i)));
- EXPECT_FALSE(manager_->MaybeIncreaseLargestPeerStreamId(
+ EXPECT_CALL(delegate_, OnError(QUIC_INVALID_STREAM_ID, _));
+ EXPECT_FALSE(manager_.MaybeIncreaseLargestPeerStreamId(
GetNthPeerInitiatedBidirectionalStreamId(i + 1)));
}
TEST_P(UberQuicStreamIdManagerTest, GetNextOutgoingStreamId) {
- if (GetParam() == Perspective::IS_SERVER) {
+ if (perspective() == Perspective::IS_SERVER) {
EXPECT_EQ(GetNthServerInitiatedBidirectionalId(0),
- manager_->GetNextOutgoingBidirectionalStreamId());
+ manager_.GetNextOutgoingBidirectionalStreamId());
EXPECT_EQ(GetNthServerInitiatedBidirectionalId(1),
- manager_->GetNextOutgoingBidirectionalStreamId());
+ manager_.GetNextOutgoingBidirectionalStreamId());
EXPECT_EQ(GetNthServerInitiatedUnidirectionalId(0),
- manager_->GetNextOutgoingUnidirectionalStreamId());
+ manager_.GetNextOutgoingUnidirectionalStreamId());
EXPECT_EQ(GetNthServerInitiatedUnidirectionalId(1),
- manager_->GetNextOutgoingUnidirectionalStreamId());
+ manager_.GetNextOutgoingUnidirectionalStreamId());
} else {
EXPECT_EQ(GetNthClientInitiatedBidirectionalId(0),
- manager_->GetNextOutgoingBidirectionalStreamId());
+ manager_.GetNextOutgoingBidirectionalStreamId());
EXPECT_EQ(GetNthClientInitiatedBidirectionalId(1),
- manager_->GetNextOutgoingBidirectionalStreamId());
+ manager_.GetNextOutgoingBidirectionalStreamId());
EXPECT_EQ(GetNthClientInitiatedUnidirectionalId(0),
- manager_->GetNextOutgoingUnidirectionalStreamId());
+ manager_.GetNextOutgoingUnidirectionalStreamId());
EXPECT_EQ(GetNthClientInitiatedUnidirectionalId(1),
- manager_->GetNextOutgoingUnidirectionalStreamId());
+ manager_.GetNextOutgoingUnidirectionalStreamId());
}
}
TEST_P(UberQuicStreamIdManagerTest, AvailableStreams) {
- if (GetParam() == Perspective::IS_SERVER) {
- EXPECT_TRUE(manager_->MaybeIncreaseLargestPeerStreamId(
+ if (perspective() == Perspective::IS_SERVER) {
+ EXPECT_TRUE(manager_.MaybeIncreaseLargestPeerStreamId(
GetNthClientInitiatedBidirectionalId(3)));
EXPECT_TRUE(
- manager_->IsAvailableStream(GetNthClientInitiatedBidirectionalId(1)));
+ manager_.IsAvailableStream(GetNthClientInitiatedBidirectionalId(1)));
EXPECT_TRUE(
- manager_->IsAvailableStream(GetNthClientInitiatedBidirectionalId(2)));
+ manager_.IsAvailableStream(GetNthClientInitiatedBidirectionalId(2)));
- EXPECT_TRUE(manager_->MaybeIncreaseLargestPeerStreamId(
+ EXPECT_TRUE(manager_.MaybeIncreaseLargestPeerStreamId(
GetNthClientInitiatedUnidirectionalId(3)));
EXPECT_TRUE(
- manager_->IsAvailableStream(GetNthClientInitiatedUnidirectionalId(1)));
+ manager_.IsAvailableStream(GetNthClientInitiatedUnidirectionalId(1)));
EXPECT_TRUE(
- manager_->IsAvailableStream(GetNthClientInitiatedUnidirectionalId(2)));
+ manager_.IsAvailableStream(GetNthClientInitiatedUnidirectionalId(2)));
} else {
- EXPECT_TRUE(manager_->MaybeIncreaseLargestPeerStreamId(
+ EXPECT_TRUE(manager_.MaybeIncreaseLargestPeerStreamId(
GetNthServerInitiatedBidirectionalId(3)));
EXPECT_TRUE(
- manager_->IsAvailableStream(GetNthServerInitiatedBidirectionalId(1)));
+ manager_.IsAvailableStream(GetNthServerInitiatedBidirectionalId(1)));
EXPECT_TRUE(
- manager_->IsAvailableStream(GetNthServerInitiatedBidirectionalId(2)));
+ manager_.IsAvailableStream(GetNthServerInitiatedBidirectionalId(2)));
- EXPECT_TRUE(manager_->MaybeIncreaseLargestPeerStreamId(
+ EXPECT_TRUE(manager_.MaybeIncreaseLargestPeerStreamId(
GetNthServerInitiatedUnidirectionalId(3)));
EXPECT_TRUE(
- manager_->IsAvailableStream(GetNthServerInitiatedUnidirectionalId(1)));
+ manager_.IsAvailableStream(GetNthServerInitiatedUnidirectionalId(1)));
EXPECT_TRUE(
- manager_->IsAvailableStream(GetNthServerInitiatedUnidirectionalId(2)));
+ manager_.IsAvailableStream(GetNthServerInitiatedUnidirectionalId(2)));
}
}
TEST_P(UberQuicStreamIdManagerTest, MaybeIncreaseLargestPeerStreamId) {
- EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(0);
- EXPECT_TRUE(manager_->MaybeIncreaseLargestPeerStreamId(StreamCountToId(
- manager_->max_incoming_bidirectional_streams(),
- QuicUtils::InvertPerspective(GetParam()), /* bidirectional=*/true)));
- EXPECT_TRUE(manager_->MaybeIncreaseLargestPeerStreamId(StreamCountToId(
- manager_->max_incoming_bidirectional_streams(),
- QuicUtils::InvertPerspective(GetParam()), /* bidirectional=*/false)));
+ EXPECT_CALL(delegate_, OnError(_, _)).Times(0);
+ EXPECT_TRUE(manager_.MaybeIncreaseLargestPeerStreamId(StreamCountToId(
+ manager_.max_incoming_bidirectional_streams(),
+ QuicUtils::InvertPerspective(perspective()), /* bidirectional=*/true)));
+ EXPECT_TRUE(manager_.MaybeIncreaseLargestPeerStreamId(StreamCountToId(
+ manager_.max_incoming_bidirectional_streams(),
+ QuicUtils::InvertPerspective(perspective()), /* bidirectional=*/false)));
std::string error_details =
- GetParam() == Perspective::IS_SERVER
+ perspective() == Perspective::IS_SERVER
? "Stream id 400 would exceed stream count limit 100"
: "Stream id 401 would exceed stream count limit 100";
- EXPECT_CALL(*connection_,
- CloseConnection(QUIC_INVALID_STREAM_ID, error_details, _));
- EXPECT_FALSE(manager_->MaybeIncreaseLargestPeerStreamId(StreamCountToId(
- manager_->max_incoming_bidirectional_streams() + 1,
- QuicUtils::InvertPerspective(GetParam()), /* bidirectional=*/true)));
- error_details = GetParam() == Perspective::IS_SERVER
+ EXPECT_CALL(delegate_, OnError(QUIC_INVALID_STREAM_ID, error_details));
+ EXPECT_FALSE(manager_.MaybeIncreaseLargestPeerStreamId(StreamCountToId(
+ manager_.max_incoming_bidirectional_streams() + 1,
+ QuicUtils::InvertPerspective(perspective()), /* bidirectional=*/true)));
+ error_details = perspective() == Perspective::IS_SERVER
? "Stream id 402 would exceed stream count limit 100"
: "Stream id 403 would exceed stream count limit 100";
- EXPECT_CALL(*connection_,
- CloseConnection(QUIC_INVALID_STREAM_ID, error_details, _));
- EXPECT_FALSE(manager_->MaybeIncreaseLargestPeerStreamId(StreamCountToId(
- manager_->max_incoming_bidirectional_streams() + 1,
- QuicUtils::InvertPerspective(GetParam()), /* bidirectional=*/false)));
+ EXPECT_CALL(delegate_, OnError(QUIC_INVALID_STREAM_ID, error_details));
+ EXPECT_FALSE(manager_.MaybeIncreaseLargestPeerStreamId(StreamCountToId(
+ manager_.max_incoming_bidirectional_streams() + 1,
+ QuicUtils::InvertPerspective(perspective()), /* bidirectional=*/false)));
}
TEST_P(UberQuicStreamIdManagerTest, OnMaxStreamsFrame) {
QuicStreamCount max_outgoing_bidirectional_stream_count =
- manager_->max_outgoing_bidirectional_streams();
+ manager_.max_outgoing_bidirectional_streams();
QuicStreamCount max_outgoing_unidirectional_stream_count =
- manager_->max_outgoing_unidirectional_streams();
+ manager_.max_outgoing_unidirectional_streams();
// Inject a MAX_STREAMS frame that does not increase the limit and then
// check that there are no changes. First try the bidirectional manager.
QuicMaxStreamsFrame frame(kInvalidControlFrameId,
max_outgoing_bidirectional_stream_count,
/*unidirectional=*/false);
- EXPECT_TRUE(manager_->OnMaxStreamsFrame(frame));
+ EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(frame.unidirectional));
+ EXPECT_TRUE(manager_.OnMaxStreamsFrame(frame));
EXPECT_EQ(max_outgoing_bidirectional_stream_count,
- manager_->max_outgoing_bidirectional_streams());
+ manager_.max_outgoing_bidirectional_streams());
// Now try the unidirectioanl manager
frame.stream_count = max_outgoing_unidirectional_stream_count;
frame.unidirectional = true;
- EXPECT_TRUE(manager_->OnMaxStreamsFrame(frame));
+ EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(frame.unidirectional));
+ EXPECT_TRUE(manager_.OnMaxStreamsFrame(frame));
EXPECT_EQ(max_outgoing_unidirectional_stream_count,
- manager_->max_outgoing_unidirectional_streams());
+ manager_.max_outgoing_unidirectional_streams());
// Now try to increase the bidirectional stream count.
frame.stream_count = max_outgoing_bidirectional_stream_count + 1;
frame.unidirectional = false;
- EXPECT_TRUE(manager_->OnMaxStreamsFrame(frame));
+ EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(frame.unidirectional));
+ EXPECT_TRUE(manager_.OnMaxStreamsFrame(frame));
EXPECT_EQ(max_outgoing_bidirectional_stream_count + 1,
- manager_->max_outgoing_bidirectional_streams());
+ manager_.max_outgoing_bidirectional_streams());
// Make sure that the unidirectional state does not change.
EXPECT_EQ(max_outgoing_unidirectional_stream_count,
- manager_->max_outgoing_unidirectional_streams());
+ manager_.max_outgoing_unidirectional_streams());
// Now check that a MAX_STREAMS for the unidirectional manager increases
// just the unidirectiomal manager's state.
frame.stream_count = max_outgoing_unidirectional_stream_count + 1;
frame.unidirectional = true;
- EXPECT_TRUE(manager_->OnMaxStreamsFrame(frame));
+ EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(frame.unidirectional));
+ EXPECT_TRUE(manager_.OnMaxStreamsFrame(frame));
EXPECT_EQ(max_outgoing_bidirectional_stream_count + 1,
- manager_->max_outgoing_bidirectional_streams());
+ manager_.max_outgoing_bidirectional_streams());
EXPECT_EQ(max_outgoing_unidirectional_stream_count + 1,
- manager_->max_outgoing_unidirectional_streams());
+ manager_.max_outgoing_unidirectional_streams());
}
TEST_P(UberQuicStreamIdManagerTest, OnStreamsBlockedFrame) {
// Allow MAX_STREAMS frame transmission
- manager_->OnConfigNegotiated();
- // Set up to capture calls to SendControlFrame - when a STREAMS_BLOCKED
- // frame is received, it will result in a a new MAX_STREAMS frame being
- // sent (if new streams can be made available).
- EXPECT_CALL(*connection_, SendControlFrame(_))
- .WillRepeatedly(
- Invoke(this, &UberQuicStreamIdManagerTest::SaveControlFrame));
+ manager_.OnConfigNegotiated();
QuicStreamCount stream_count =
- manager_->advertised_max_incoming_bidirectional_streams() - 1;
+ manager_.advertised_max_incoming_bidirectional_streams() - 1;
QuicStreamsBlockedFrame frame(kInvalidControlFrameId, stream_count,
/*unidirectional=*/false);
- session_->OnStreamsBlockedFrame(frame);
- EXPECT_EQ(MAX_STREAMS_FRAME, frame_.type);
- EXPECT_EQ(manager_->max_incoming_bidirectional_streams(),
- frame_.max_streams_frame.stream_count);
+ EXPECT_CALL(delegate_,
+ SendMaxStreams(manager_.max_incoming_bidirectional_streams(),
+ frame.unidirectional));
+ manager_.OnStreamsBlockedFrame(frame);
- stream_count = manager_->advertised_max_incoming_unidirectional_streams() - 1;
+ stream_count = manager_.advertised_max_incoming_unidirectional_streams() - 1;
frame.stream_count = stream_count;
frame.unidirectional = true;
- session_->OnStreamsBlockedFrame(frame);
- EXPECT_EQ(MAX_STREAMS_FRAME, frame_.type);
- EXPECT_EQ(manager_->max_incoming_unidirectional_streams(),
- frame_.max_streams_frame.stream_count);
+ EXPECT_CALL(delegate_,
+ SendMaxStreams(manager_.max_incoming_unidirectional_streams(),
+ frame.unidirectional));
+ manager_.OnStreamsBlockedFrame(frame);
}
TEST_P(UberQuicStreamIdManagerTest, IsIncomingStream) {
- if (GetParam() == Perspective::IS_SERVER) {
+ if (perspective() == Perspective::IS_SERVER) {
EXPECT_TRUE(
- manager_->IsIncomingStream(GetNthClientInitiatedBidirectionalId(0)));
+ manager_.IsIncomingStream(GetNthClientInitiatedBidirectionalId(0)));
EXPECT_TRUE(
- manager_->IsIncomingStream(GetNthClientInitiatedUnidirectionalId(0)));
+ manager_.IsIncomingStream(GetNthClientInitiatedUnidirectionalId(0)));
EXPECT_FALSE(
- manager_->IsIncomingStream(GetNthServerInitiatedBidirectionalId(0)));
+ manager_.IsIncomingStream(GetNthServerInitiatedBidirectionalId(0)));
EXPECT_FALSE(
- manager_->IsIncomingStream(GetNthServerInitiatedUnidirectionalId(0)));
+ manager_.IsIncomingStream(GetNthServerInitiatedUnidirectionalId(0)));
} else {
EXPECT_FALSE(
- manager_->IsIncomingStream(GetNthClientInitiatedBidirectionalId(0)));
+ manager_.IsIncomingStream(GetNthClientInitiatedBidirectionalId(0)));
EXPECT_FALSE(
- manager_->IsIncomingStream(GetNthClientInitiatedUnidirectionalId(0)));
+ manager_.IsIncomingStream(GetNthClientInitiatedUnidirectionalId(0)));
EXPECT_TRUE(
- manager_->IsIncomingStream(GetNthServerInitiatedBidirectionalId(0)));
+ manager_.IsIncomingStream(GetNthServerInitiatedBidirectionalId(0)));
EXPECT_TRUE(
- manager_->IsIncomingStream(GetNthServerInitiatedUnidirectionalId(0)));
+ manager_.IsIncomingStream(GetNthServerInitiatedUnidirectionalId(0)));
}
}
@@ -369,38 +369,41 @@
const size_t kNumMaxOutgoingStream = 123;
// Set the uni- and bi- directional limits to different values to ensure
// that they are managed separately.
- manager_->SetMaxOpenOutgoingBidirectionalStreams(kNumMaxOutgoingStream);
- manager_->SetMaxOpenOutgoingUnidirectionalStreams(kNumMaxOutgoingStream + 1);
+ EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(false));
+ manager_.SetMaxOpenOutgoingBidirectionalStreams(kNumMaxOutgoingStream);
+ EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(true));
+ manager_.SetMaxOpenOutgoingUnidirectionalStreams(kNumMaxOutgoingStream + 1);
EXPECT_EQ(kNumMaxOutgoingStream,
- manager_->max_outgoing_bidirectional_streams());
+ manager_.max_outgoing_bidirectional_streams());
EXPECT_EQ(kNumMaxOutgoingStream + 1,
- manager_->max_outgoing_unidirectional_streams());
+ manager_.max_outgoing_unidirectional_streams());
// Check that, for each directionality, we can open the correct number of
// streams.
int i = kNumMaxOutgoingStream;
while (i) {
- EXPECT_TRUE(manager_->CanOpenNextOutgoingBidirectionalStream());
- manager_->GetNextOutgoingBidirectionalStreamId();
- EXPECT_TRUE(manager_->CanOpenNextOutgoingUnidirectionalStream());
- manager_->GetNextOutgoingUnidirectionalStreamId();
+ EXPECT_TRUE(manager_.CanOpenNextOutgoingBidirectionalStream());
+ manager_.GetNextOutgoingBidirectionalStreamId();
+ EXPECT_TRUE(manager_.CanOpenNextOutgoingUnidirectionalStream());
+ manager_.GetNextOutgoingUnidirectionalStreamId();
i--;
}
// One more unidirectional
- EXPECT_TRUE(manager_->CanOpenNextOutgoingUnidirectionalStream());
- manager_->GetNextOutgoingUnidirectionalStreamId();
+ EXPECT_TRUE(manager_.CanOpenNextOutgoingUnidirectionalStream());
+ manager_.GetNextOutgoingUnidirectionalStreamId();
// Both should be exhausted...
- EXPECT_FALSE(manager_->CanOpenNextOutgoingUnidirectionalStream());
- EXPECT_FALSE(manager_->CanOpenNextOutgoingBidirectionalStream());
+ EXPECT_FALSE(manager_.CanOpenNextOutgoingUnidirectionalStream());
+ EXPECT_FALSE(manager_.CanOpenNextOutgoingBidirectionalStream());
// Now cons a MAX STREAMS frame for unidirectional streams to raise
// the limit.
QuicMaxStreamsFrame frame(1, kNumMaxOutgoingStream + 10,
/*unidirectional=*/true);
- manager_->OnMaxStreamsFrame(frame);
+ EXPECT_CALL(delegate_, OnCanCreateNewOutgoingStream(frame.unidirectional));
+ manager_.OnMaxStreamsFrame(frame);
// We now should be able to get another uni- stream, but not a bi.
- EXPECT_TRUE(manager_->CanOpenNextOutgoingUnidirectionalStream());
- EXPECT_FALSE(manager_->CanOpenNextOutgoingBidirectionalStream());
+ EXPECT_TRUE(manager_.CanOpenNextOutgoingUnidirectionalStream());
+ EXPECT_FALSE(manager_.CanOpenNextOutgoingBidirectionalStream());
}
} // namespace
