| // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "net/quic/quic_packet_creator.h" |
| |
| #include <stdint.h> |
| |
| #include "base/macros.h" |
| #include "base/stl_util.h" |
| #include "net/quic/crypto/null_encrypter.h" |
| #include "net/quic/crypto/quic_decrypter.h" |
| #include "net/quic/crypto/quic_encrypter.h" |
| #include "net/quic/quic_flags.h" |
| #include "net/quic/quic_simple_buffer_allocator.h" |
| #include "net/quic/quic_utils.h" |
| #include "net/quic/test_tools/mock_random.h" |
| #include "net/quic/test_tools/quic_framer_peer.h" |
| #include "net/quic/test_tools/quic_packet_creator_peer.h" |
| #include "net/quic/test_tools/quic_test_utils.h" |
| #include "net/test/gtest_util.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| |
| using base::StringPiece; |
| using std::ostream; |
| using std::string; |
| using std::vector; |
| using testing::DoAll; |
| using testing::InSequence; |
| using testing::Return; |
| using testing::SaveArg; |
| using testing::StrictMock; |
| using testing::_; |
| |
| namespace net { |
| namespace test { |
| namespace { |
| |
| // Run tests with combinations of {QuicVersion, ToggleVersionSerialization}. |
| struct TestParams { |
| TestParams(QuicVersion version, |
| bool version_serialization, |
| QuicConnectionIdLength length) |
| : version(version), |
| connection_id_length(length), |
| version_serialization(version_serialization) {} |
| |
| friend ostream& operator<<(ostream& os, const TestParams& p) { |
| os << "{ client_version: " << QuicVersionToString(p.version) |
| << " connection id length: " << p.connection_id_length |
| << " include version: " << p.version_serialization << " }"; |
| return os; |
| } |
| |
| QuicVersion version; |
| QuicConnectionIdLength connection_id_length; |
| bool version_serialization; |
| }; |
| |
| // Constructs various test permutations. |
| vector<TestParams> GetTestParams() { |
| vector<TestParams> params; |
| QuicConnectionIdLength max = PACKET_8BYTE_CONNECTION_ID; |
| QuicVersionVector all_supported_versions = QuicSupportedVersions(); |
| for (size_t i = 0; i < all_supported_versions.size(); ++i) { |
| params.push_back(TestParams(all_supported_versions[i], true, max)); |
| params.push_back(TestParams(all_supported_versions[i], false, max)); |
| } |
| params.push_back( |
| TestParams(all_supported_versions[0], true, PACKET_0BYTE_CONNECTION_ID)); |
| params.push_back( |
| TestParams(all_supported_versions[0], true, PACKET_1BYTE_CONNECTION_ID)); |
| params.push_back( |
| TestParams(all_supported_versions[0], true, PACKET_4BYTE_CONNECTION_ID)); |
| params.push_back(TestParams(all_supported_versions[0], true, max)); |
| return params; |
| } |
| |
| class MockDelegate : public QuicPacketCreator::DelegateInterface { |
| public: |
| MockDelegate() {} |
| ~MockDelegate() override {} |
| |
| MOCK_METHOD1(OnSerializedPacket, void(SerializedPacket* packet)); |
| MOCK_METHOD0(OnResetFecGroup, void()); |
| MOCK_METHOD2(CloseConnection, void(QuicErrorCode, bool)); |
| |
| private: |
| DISALLOW_COPY_AND_ASSIGN(MockDelegate); |
| }; |
| |
| class QuicPacketCreatorTest : public ::testing::TestWithParam<TestParams> { |
| public: |
| void ClearSerializedPacket(SerializedPacket* serialized_packet) { |
| if (serialized_packet == nullptr) { |
| return; |
| } |
| |
| delete serialized_packet->retransmittable_frames; |
| delete serialized_packet->packet; |
| } |
| |
| void SaveSerializedPacket(SerializedPacket* serialized_packet) { |
| if (serialized_packet == nullptr) { |
| return; |
| } |
| |
| serialized_packet_ = *serialized_packet; |
| serialized_packet_.packet = serialized_packet->packet->Clone(); |
| delete serialized_packet->packet; |
| } |
| |
| protected: |
| QuicPacketCreatorTest() |
| : server_framer_(SupportedVersions(GetParam().version), |
| QuicTime::Zero(), |
| Perspective::IS_SERVER), |
| client_framer_(SupportedVersions(GetParam().version), |
| QuicTime::Zero(), |
| Perspective::IS_CLIENT), |
| connection_id_(2), |
| data_("foo"), |
| creator_(connection_id_, |
| &client_framer_, |
| &mock_random_, |
| &buffer_allocator_, |
| &delegate_), |
| serialized_packet_(creator_.NoPacket()) { |
| creator_.set_connection_id_length(GetParam().connection_id_length); |
| |
| creator_.SetEncrypter(ENCRYPTION_INITIAL, new NullEncrypter()); |
| creator_.SetEncrypter(ENCRYPTION_FORWARD_SECURE, new NullEncrypter()); |
| client_framer_.set_visitor(&framer_visitor_); |
| client_framer_.set_received_entropy_calculator(&entropy_calculator_); |
| server_framer_.set_visitor(&framer_visitor_); |
| // TODO(ianswett): Fix this test so it uses a non-null encrypter. |
| FLAGS_quic_never_write_unencrypted_data = false; |
| } |
| |
| ~QuicPacketCreatorTest() override {} |
| |
| SerializedPacket SerializeAllFrames(const QuicFrames& frames) { |
| SerializedPacket packet = |
| creator_.SerializeAllFrames(frames, buffer_, kMaxPacketSize); |
| EXPECT_EQ(QuicPacketCreatorPeer::GetEncryptionLevel(&creator_), |
| packet.encryption_level); |
| return packet; |
| } |
| |
| void ProcessPacket(QuicEncryptedPacket* encrypted) { |
| server_framer_.ProcessPacket(*encrypted); |
| } |
| |
| void CheckStreamFrame(const QuicFrame& frame, |
| QuicStreamId stream_id, |
| const string& data, |
| QuicStreamOffset offset, |
| bool fin) { |
| EXPECT_EQ(STREAM_FRAME, frame.type); |
| ASSERT_TRUE(frame.stream_frame); |
| EXPECT_EQ(stream_id, frame.stream_frame->stream_id); |
| EXPECT_EQ(data, StringPiece(frame.stream_frame->frame_buffer, |
| frame.stream_frame->frame_length)); |
| EXPECT_EQ(offset, frame.stream_frame->offset); |
| EXPECT_EQ(fin, frame.stream_frame->fin); |
| } |
| |
| // Returns the number of bytes consumed by the header of packet, including |
| // the version. |
| size_t GetPacketHeaderOverhead(InFecGroup is_in_fec_group) { |
| return GetPacketHeaderSize( |
| creator_.connection_id_length(), kIncludeVersion, !kIncludePathId, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_), |
| is_in_fec_group); |
| } |
| |
| // Returns the number of bytes of overhead that will be added to a packet |
| // of maximum length. |
| size_t GetEncryptionOverhead() { |
| return creator_.max_packet_length() - |
| client_framer_.GetMaxPlaintextSize(creator_.max_packet_length()); |
| } |
| |
| // Returns the number of bytes consumed by the non-data fields of a stream |
| // frame, assuming it is the last frame in the packet |
| size_t GetStreamFrameOverhead(InFecGroup is_in_fec_group) { |
| return QuicFramer::GetMinStreamFrameSize(kClientDataStreamId1, kOffset, |
| true, is_in_fec_group); |
| } |
| |
| QuicIOVector MakeIOVector(StringPiece s) { |
| return ::net::MakeIOVector(s, &iov_); |
| } |
| |
| static const QuicStreamOffset kOffset = 1u; |
| |
| char buffer_[kMaxPacketSize]; |
| QuicFrames frames_; |
| QuicFramer server_framer_; |
| QuicFramer client_framer_; |
| StrictMock<MockFramerVisitor> framer_visitor_; |
| StrictMock<MockDelegate> delegate_; |
| QuicConnectionId connection_id_; |
| string data_; |
| struct iovec iov_; |
| MockRandom mock_random_; |
| SimpleBufferAllocator buffer_allocator_; |
| QuicPacketCreator creator_; |
| MockEntropyCalculator entropy_calculator_; |
| SerializedPacket serialized_packet_; |
| }; |
| |
| // Run all packet creator tests with all supported versions of QUIC, and with |
| // and without version in the packet header, as well as doing a run for each |
| // length of truncated connection id. |
| INSTANTIATE_TEST_CASE_P(QuicPacketCreatorTests, |
| QuicPacketCreatorTest, |
| ::testing::ValuesIn(GetTestParams())); |
| |
| TEST_P(QuicPacketCreatorTest, SerializeFrames) { |
| for (int i = ENCRYPTION_NONE; i < NUM_ENCRYPTION_LEVELS; ++i) { |
| EncryptionLevel level = static_cast<EncryptionLevel>(i); |
| creator_.set_encryption_level(level); |
| frames_.push_back(QuicFrame(new QuicAckFrame(MakeAckFrame(0u)))); |
| frames_.push_back( |
| QuicFrame(new QuicStreamFrame(0u, false, 0u, StringPiece()))); |
| frames_.push_back( |
| QuicFrame(new QuicStreamFrame(0u, true, 0u, StringPiece()))); |
| SerializedPacket serialized = SerializeAllFrames(frames_); |
| EXPECT_EQ(level, serialized.encryption_level); |
| delete frames_[0].ack_frame; |
| delete frames_[1].stream_frame; |
| delete frames_[2].stream_frame; |
| frames_.clear(); |
| |
| { |
| InSequence s; |
| EXPECT_CALL(framer_visitor_, OnPacket()); |
| EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_)); |
| EXPECT_CALL(framer_visitor_, OnPacketHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnAckFrame(_)); |
| EXPECT_CALL(framer_visitor_, OnStreamFrame(_)); |
| EXPECT_CALL(framer_visitor_, OnStreamFrame(_)); |
| EXPECT_CALL(framer_visitor_, OnPacketComplete()); |
| } |
| ProcessPacket(serialized.packet); |
| delete serialized.packet; |
| } |
| } |
| |
| TEST_P(QuicPacketCreatorTest, SerializeWithFEC) { |
| // Send FEC packet every 6 packets. |
| creator_.set_max_packets_per_fec_group(6); |
| // Should return false since we do not have enough packets in the FEC group to |
| // trigger an FEC packet. |
| ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false)); |
| // Turn on FEC protection. |
| QuicFrame frame; |
| QuicIOVector io_vector(MakeIOVector("test")); |
| ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame, |
| MUST_FEC_PROTECT)); |
| EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_)); |
| // Serialize the packet. |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); |
| creator_.Flush(); |
| |
| { |
| InSequence s; |
| EXPECT_CALL(framer_visitor_, OnPacket()); |
| EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_)); |
| EXPECT_CALL(framer_visitor_, OnPacketHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnFecProtectedPayload(_)); |
| EXPECT_CALL(framer_visitor_, OnStreamFrame(_)); |
| EXPECT_CALL(framer_visitor_, OnPacketComplete()); |
| } |
| ProcessPacket(serialized_packet_.packet); |
| ClearSerializedPacket(&serialized_packet_); |
| |
| // Should return false since we do not have enough packets in the FEC group to |
| // trigger an FEC packet. |
| ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false)); |
| // Should return true since there are packets in the FEC group. |
| ASSERT_TRUE(creator_.ShouldSendFec(/*force_close=*/true)); |
| |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); |
| creator_.MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/true, |
| /*is_fec_timeout=*/false); |
| ASSERT_EQ(2u, serialized_packet_.packet_number); |
| { |
| InSequence s; |
| EXPECT_CALL(framer_visitor_, OnPacket()); |
| EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_)); |
| EXPECT_CALL(framer_visitor_, OnPacketHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnFecData(_)); |
| EXPECT_CALL(framer_visitor_, OnPacketComplete()); |
| } |
| ProcessPacket(serialized_packet_.packet); |
| ClearSerializedPacket(&serialized_packet_); |
| } |
| |
| TEST_P(QuicPacketCreatorTest, SerializeChangingSequenceNumberLength) { |
| frames_.push_back(QuicFrame(new QuicAckFrame(MakeAckFrame(0u)))); |
| creator_.AddSavedFrame(frames_[0]); |
| QuicPacketCreatorPeer::SetNextPacketNumberLength(&creator_, |
| PACKET_4BYTE_PACKET_NUMBER); |
| |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .WillRepeatedly( |
| Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); |
| creator_.Flush(); |
| // The packet number length will not change mid-packet. |
| EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER, |
| serialized_packet_.packet_number_length); |
| |
| { |
| InSequence s; |
| EXPECT_CALL(framer_visitor_, OnPacket()); |
| EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_)); |
| EXPECT_CALL(framer_visitor_, OnPacketHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnAckFrame(_)); |
| EXPECT_CALL(framer_visitor_, OnPacketComplete()); |
| } |
| ProcessPacket(serialized_packet_.packet); |
| ClearSerializedPacket(&serialized_packet_); |
| |
| creator_.AddSavedFrame(frames_[0]); |
| creator_.Flush(); |
| // Now the actual packet number length should have changed. |
| EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER, |
| serialized_packet_.packet_number_length); |
| delete frames_[0].ack_frame; |
| |
| { |
| InSequence s; |
| EXPECT_CALL(framer_visitor_, OnPacket()); |
| EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_)); |
| EXPECT_CALL(framer_visitor_, OnPacketHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnAckFrame(_)); |
| EXPECT_CALL(framer_visitor_, OnPacketComplete()); |
| } |
| ProcessPacket(serialized_packet_.packet); |
| ClearSerializedPacket(&serialized_packet_); |
| } |
| |
| TEST_P(QuicPacketCreatorTest, ChangeSequenceNumberLengthMidPacket) { |
| // Changing the packet number length with queued frames in the creator |
| // should hold the change until after any currently queued frames are |
| // serialized. |
| |
| // Packet 1. |
| // Queue a frame in the creator. |
| EXPECT_FALSE(creator_.HasPendingFrames()); |
| QuicFrame ack_frame = QuicFrame(new QuicAckFrame(MakeAckFrame(0u))); |
| creator_.AddSavedFrame(ack_frame); |
| |
| // Now change packet number length. |
| QuicPacketCreatorPeer::SetNextPacketNumberLength(&creator_, |
| PACKET_4BYTE_PACKET_NUMBER); |
| |
| // Add a STOP_WAITING frame since it contains a packet number, |
| // whose length should be 1. |
| QuicStopWaitingFrame stop_waiting_frame; |
| EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&stop_waiting_frame))); |
| EXPECT_TRUE(creator_.HasPendingFrames()); |
| |
| // Ensure the packet is successfully created. |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .WillRepeatedly( |
| Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); |
| creator_.Flush(); |
| ASSERT_TRUE(serialized_packet_.packet); |
| EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER, |
| serialized_packet_.packet_number_length); |
| |
| // Verify that header in transmitted packet has 1 byte sequence length. |
| QuicPacketHeader header; |
| { |
| InSequence s; |
| EXPECT_CALL(framer_visitor_, OnPacket()); |
| EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_)); |
| EXPECT_CALL(framer_visitor_, OnPacketHeader(_)) |
| .WillOnce(DoAll(SaveArg<0>(&header), Return(true))); |
| EXPECT_CALL(framer_visitor_, OnAckFrame(_)); |
| EXPECT_CALL(framer_visitor_, OnStopWaitingFrame(_)); |
| EXPECT_CALL(framer_visitor_, OnPacketComplete()); |
| } |
| ProcessPacket(serialized_packet_.packet); |
| EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER, |
| header.public_header.packet_number_length); |
| ClearSerializedPacket(&serialized_packet_); |
| |
| // Packet 2. |
| EXPECT_FALSE(creator_.HasPendingFrames()); |
| // Generate Packet 2 with one frame -- packet number length should now |
| // change to 4 bytes. |
| EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&stop_waiting_frame))); |
| EXPECT_TRUE(creator_.HasPendingFrames()); |
| |
| // Ensure the packet is successfully created. |
| creator_.Flush(); |
| ASSERT_TRUE(serialized_packet_.packet); |
| EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER, |
| serialized_packet_.packet_number_length); |
| |
| // Verify that header in transmitted packet has 4 byte sequence length. |
| { |
| InSequence s; |
| EXPECT_CALL(framer_visitor_, OnPacket()); |
| EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_)); |
| EXPECT_CALL(framer_visitor_, OnPacketHeader(_)) |
| .WillOnce(DoAll(SaveArg<0>(&header), Return(true))); |
| EXPECT_CALL(framer_visitor_, OnStopWaitingFrame(_)); |
| EXPECT_CALL(framer_visitor_, OnPacketComplete()); |
| } |
| ProcessPacket(serialized_packet_.packet); |
| EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER, |
| header.public_header.packet_number_length); |
| |
| ClearSerializedPacket(&serialized_packet_); |
| delete ack_frame.ack_frame; |
| } |
| |
| TEST_P(QuicPacketCreatorTest, SerializeWithFECChangingSequenceNumberLength) { |
| // Test goal is to test the following sequence (P1 => generate Packet 1): |
| // P1 <change seq num length> P2 FEC, |
| // and we expect that packet number length should not change until the end |
| // of the open FEC group. |
| |
| // Send FEC packet every 6 packets. |
| creator_.set_max_packets_per_fec_group(6); |
| // Should return false since we do not have enough packets in the FEC group to |
| // trigger an FEC packet. |
| ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false)); |
| |
| // Generate Packet 1. |
| QuicFrame frame; |
| QuicIOVector io_vector(MakeIOVector("test")); |
| ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame, |
| MUST_FEC_PROTECT)); |
| // Change the packet number length mid-FEC group and it should not change. |
| QuicPacketCreatorPeer::SetNextPacketNumberLength(&creator_, |
| PACKET_4BYTE_PACKET_NUMBER); |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .WillRepeatedly( |
| Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); |
| creator_.Flush(); |
| EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER, |
| serialized_packet_.packet_number_length); |
| |
| { |
| InSequence s; |
| EXPECT_CALL(framer_visitor_, OnPacket()); |
| EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_)); |
| EXPECT_CALL(framer_visitor_, OnPacketHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnFecProtectedPayload(_)); |
| EXPECT_CALL(framer_visitor_, OnStreamFrame(_)); |
| EXPECT_CALL(framer_visitor_, OnPacketComplete()); |
| } |
| ProcessPacket(serialized_packet_.packet); |
| ClearSerializedPacket(&serialized_packet_); |
| |
| // Generate Packet 2. |
| ASSERT_TRUE(creator_.ConsumeData(2u, io_vector, 0u, 0u, false, false, &frame, |
| MUST_FEC_PROTECT)); |
| creator_.Flush(); |
| EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER, |
| serialized_packet_.packet_number_length); |
| |
| { |
| InSequence s; |
| EXPECT_CALL(framer_visitor_, OnPacket()); |
| EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_)); |
| EXPECT_CALL(framer_visitor_, OnPacketHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnFecProtectedPayload(_)); |
| EXPECT_CALL(framer_visitor_, OnStreamFrame(_)); |
| EXPECT_CALL(framer_visitor_, OnPacketComplete()); |
| } |
| ProcessPacket(serialized_packet_.packet); |
| ClearSerializedPacket(&serialized_packet_); |
| |
| // Should return false since we do not have enough packets in the FEC group to |
| // trigger an FEC packet. |
| ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false)); |
| // Should return true since there are packets in the FEC group. |
| ASSERT_TRUE(creator_.ShouldSendFec(/*force_close=*/true)); |
| |
| // Force generation of FEC packet. |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); |
| // Turn off FEC protection. |
| creator_.MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/true, |
| /*is_fec_timeout=*/false); |
| EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER, |
| serialized_packet_.packet_number_length); |
| ASSERT_EQ(3u, serialized_packet_.packet_number); |
| |
| { |
| InSequence s; |
| EXPECT_CALL(framer_visitor_, OnPacket()); |
| EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_)); |
| EXPECT_CALL(framer_visitor_, OnPacketHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnFecData(_)); |
| EXPECT_CALL(framer_visitor_, OnPacketComplete()); |
| } |
| ProcessPacket(serialized_packet_.packet); |
| ClearSerializedPacket(&serialized_packet_); |
| |
| // Ensure the next FEC group starts using the new packet number length. |
| ASSERT_TRUE(creator_.ConsumeData(3u, io_vector, 0u, 0u, false, false, &frame, |
| MUST_FEC_PROTECT)); |
| EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_)); |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); |
| creator_.Flush(); |
| EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER, |
| serialized_packet_.packet_number_length); |
| ClearSerializedPacket(&serialized_packet_); |
| } |
| |
| TEST_P(QuicPacketCreatorTest, ReserializeFramesWithSequenceNumberLength) { |
| // If the original packet number length, the current packet number |
| // length, and the configured send packet number length are different, the |
| // retransmit must sent with the original length and the others do not change. |
| QuicPacketCreatorPeer::SetNextPacketNumberLength(&creator_, |
| PACKET_4BYTE_PACKET_NUMBER); |
| QuicPacketCreatorPeer::SetPacketNumberLength(&creator_, |
| PACKET_2BYTE_PACKET_NUMBER); |
| QuicStreamFrame* stream_frame = |
| new QuicStreamFrame(kCryptoStreamId, /*fin=*/false, 0u, StringPiece()); |
| RetransmittableFrames frames; |
| frames.AddFrame(QuicFrame(stream_frame)); |
| char buffer[kMaxPacketSize]; |
| SerializedPacket serialized = creator_.ReserializeAllFrames( |
| frames, ENCRYPTION_NONE, PACKET_1BYTE_PACKET_NUMBER, buffer, |
| kMaxPacketSize); |
| EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)); |
| EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER, |
| QuicPacketCreatorPeer::GetPacketNumberLength(&creator_)); |
| EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER, serialized.packet_number_length); |
| |
| { |
| InSequence s; |
| EXPECT_CALL(framer_visitor_, OnPacket()); |
| EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_)); |
| EXPECT_CALL(framer_visitor_, OnPacketHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnStreamFrame(_)); |
| EXPECT_CALL(framer_visitor_, OnPacketComplete()); |
| } |
| ProcessPacket(serialized.packet); |
| delete serialized.packet; |
| } |
| |
| TEST_P(QuicPacketCreatorTest, ReserializeCryptoFrameWithForwardSecurity) { |
| QuicStreamFrame* stream_frame = |
| new QuicStreamFrame(kCryptoStreamId, /*fin=*/false, 0u, StringPiece()); |
| RetransmittableFrames frames; |
| frames.AddFrame(QuicFrame(stream_frame)); |
| creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE); |
| char buffer[kMaxPacketSize]; |
| SerializedPacket serialized = creator_.ReserializeAllFrames( |
| frames, ENCRYPTION_NONE, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_), buffer, |
| kMaxPacketSize); |
| EXPECT_EQ(ENCRYPTION_NONE, serialized.encryption_level); |
| delete serialized.packet; |
| } |
| |
| TEST_P(QuicPacketCreatorTest, ReserializeFrameWithForwardSecurity) { |
| QuicStreamFrame* stream_frame = |
| new QuicStreamFrame(0u, /*fin=*/false, 0u, StringPiece()); |
| RetransmittableFrames frames; |
| frames.AddFrame(QuicFrame(stream_frame)); |
| creator_.set_encryption_level(ENCRYPTION_FORWARD_SECURE); |
| char buffer[kMaxPacketSize]; |
| SerializedPacket serialized = creator_.ReserializeAllFrames( |
| frames, ENCRYPTION_NONE, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_), buffer, |
| kMaxPacketSize); |
| EXPECT_EQ(ENCRYPTION_FORWARD_SECURE, serialized.encryption_level); |
| delete serialized.packet; |
| } |
| |
| TEST_P(QuicPacketCreatorTest, ReserializeFramesWithPadding) { |
| QuicFrame frame; |
| QuicIOVector io_vector(MakeIOVector("fake handshake message data")); |
| QuicPacketCreatorPeer::CreateStreamFrame(&creator_, kCryptoStreamId, |
| io_vector, 0u, 0u, false, &frame); |
| RetransmittableFrames frames; |
| frames.AddFrame(frame); |
| frames.set_needs_padding(true); |
| char buffer[kMaxPacketSize]; |
| SerializedPacket serialized = creator_.ReserializeAllFrames( |
| frames, ENCRYPTION_NONE, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_), buffer, |
| kMaxPacketSize); |
| EXPECT_EQ(kDefaultMaxPacketSize, serialized.packet->length()); |
| delete serialized.packet; |
| } |
| |
| TEST_P(QuicPacketCreatorTest, ReserializeFramesWithFullPacketAndPadding) { |
| const size_t overhead = GetPacketHeaderOverhead(NOT_IN_FEC_GROUP) + |
| GetEncryptionOverhead() + |
| GetStreamFrameOverhead(NOT_IN_FEC_GROUP); |
| size_t capacity = kDefaultMaxPacketSize - overhead; |
| for (int delta = -5; delta <= 0; ++delta) { |
| string data(capacity + delta, 'A'); |
| size_t bytes_free = 0 - delta; |
| |
| QuicFrame frame; |
| QuicIOVector io_vector(MakeIOVector(data)); |
| UniqueStreamBuffer stream_buffer; |
| QuicPacketCreatorPeer::CreateStreamFrame( |
| &creator_, kCryptoStreamId, io_vector, 0, kOffset, false, &frame); |
| RetransmittableFrames frames; |
| frames.AddFrame(frame); |
| frames.set_needs_padding(true); |
| char buffer[kMaxPacketSize]; |
| SerializedPacket serialized = creator_.ReserializeAllFrames( |
| frames, ENCRYPTION_NONE, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_), buffer, |
| kMaxPacketSize); |
| |
| // If there is not enough space in the packet to fit a padding frame |
| // (1 byte) and to expand the stream frame (another 2 bytes) the packet |
| // will not be padded. |
| if (bytes_free < 3) { |
| EXPECT_EQ(kDefaultMaxPacketSize - bytes_free, |
| serialized.packet->length()); |
| } else { |
| EXPECT_EQ(kDefaultMaxPacketSize, serialized.packet->length()); |
| } |
| |
| delete serialized.packet; |
| frames_.clear(); |
| } |
| } |
| |
| TEST_P(QuicPacketCreatorTest, SerializeConnectionClose) { |
| QuicConnectionCloseFrame frame; |
| frame.error_code = QUIC_NO_ERROR; |
| frame.error_details = "error"; |
| |
| QuicFrames frames; |
| frames.push_back(QuicFrame(&frame)); |
| SerializedPacket serialized = SerializeAllFrames(frames); |
| EXPECT_EQ(ENCRYPTION_NONE, serialized.encryption_level); |
| ASSERT_EQ(1u, serialized.packet_number); |
| ASSERT_EQ(1u, creator_.packet_number()); |
| |
| InSequence s; |
| EXPECT_CALL(framer_visitor_, OnPacket()); |
| EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_)); |
| EXPECT_CALL(framer_visitor_, OnPacketHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnConnectionCloseFrame(_)); |
| EXPECT_CALL(framer_visitor_, OnPacketComplete()); |
| |
| ProcessPacket(serialized.packet); |
| delete serialized.packet; |
| } |
| |
| TEST_P(QuicPacketCreatorTest, SwitchFecOnOffWithGroupInProgress) { |
| // Send FEC packet every 6 packets. |
| creator_.set_max_packets_per_fec_group(6); |
| // Turn on FEC protection. |
| QuicFrame frame; |
| QuicIOVector io_vector(MakeIOVector("test")); |
| ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame, |
| MUST_FEC_PROTECT)); |
| EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_)); |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .WillOnce(Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket)); |
| creator_.Flush(); |
| // We do not have enough packets in the FEC group to trigger an FEC packet. |
| EXPECT_FALSE(creator_.ShouldSendFec(/*force_close=*/false)); |
| // Should return true since there are packets in the FEC group. |
| EXPECT_TRUE(creator_.ShouldSendFec(/*force_close=*/true)); |
| |
| // Switching FEC off should not change creator state, since there is an |
| // FEC packet under construction. |
| EXPECT_DFATAL(QuicPacketCreatorPeer::StopFecProtectingPackets(&creator_), |
| "Cannot stop FEC protection with open FEC group."); |
| EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_)); |
| // Confirm that FEC packet is still under construction. |
| EXPECT_TRUE(creator_.ShouldSendFec(/*force_close=*/true)); |
| |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .WillOnce(Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket)); |
| // Turn off FEC protection. |
| creator_.MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/true, |
| /*is_fec_timeout=*/false); |
| EXPECT_FALSE(QuicPacketCreatorPeer::IsFecProtected(&creator_)); |
| } |
| |
| TEST_P(QuicPacketCreatorTest, SwitchFecOnWithStreamFrameQueued) { |
| // Add a stream frame to the creator. |
| QuicFrame frame; |
| QuicIOVector io_vector(MakeIOVector("test")); |
| ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame, |
| MAY_FEC_PROTECT)); |
| EXPECT_FALSE(QuicPacketCreatorPeer::IsFecProtected(&creator_)); |
| ASSERT_TRUE(frame.stream_frame); |
| size_t consumed = frame.stream_frame->frame_length; |
| EXPECT_EQ(4u, consumed); |
| EXPECT_TRUE(creator_.HasPendingFrames()); |
| |
| // Enable FEC protection, and send FEC packet every 6 packets. |
| creator_.set_max_packets_per_fec_group(6); |
| EXPECT_TRUE(QuicPacketCreatorPeer::IsFecEnabled(&creator_)); |
| EXPECT_DFATAL(QuicPacketCreatorPeer::StartFecProtectingPackets(&creator_), |
| "Cannot start FEC protection with pending frames."); |
| EXPECT_FALSE(QuicPacketCreatorPeer::IsFecProtected(&creator_)); |
| |
| // Start FEC protection after current open packet is flushed. |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .WillOnce(Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket)); |
| ASSERT_TRUE(creator_.ConsumeData(2u, io_vector, 0u, 0u, false, false, &frame, |
| MUST_FEC_PROTECT)); |
| ASSERT_TRUE(frame.stream_frame); |
| consumed = frame.stream_frame->frame_length; |
| EXPECT_EQ(4u, consumed); |
| EXPECT_TRUE(creator_.HasPendingFrames()); |
| EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_)); |
| } |
| |
| TEST_P(QuicPacketCreatorTest, ConsumeData) { |
| QuicFrame frame; |
| QuicIOVector io_vector(MakeIOVector("test")); |
| ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame, |
| MAY_FEC_PROTECT)); |
| ASSERT_TRUE(frame.stream_frame); |
| size_t consumed = frame.stream_frame->frame_length; |
| EXPECT_EQ(4u, consumed); |
| CheckStreamFrame(frame, 1u, "test", 0u, false); |
| EXPECT_TRUE(creator_.HasPendingFrames()); |
| } |
| |
| TEST_P(QuicPacketCreatorTest, ConsumeDataFin) { |
| QuicFrame frame; |
| QuicIOVector io_vector(MakeIOVector("test")); |
| ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 10u, true, false, &frame, |
| MAY_FEC_PROTECT)); |
| ASSERT_TRUE(frame.stream_frame); |
| size_t consumed = frame.stream_frame->frame_length; |
| EXPECT_EQ(4u, consumed); |
| CheckStreamFrame(frame, 1u, "test", 10u, true); |
| EXPECT_TRUE(creator_.HasPendingFrames()); |
| } |
| |
| TEST_P(QuicPacketCreatorTest, ConsumeDataFinOnly) { |
| QuicFrame frame; |
| QuicIOVector io_vector(nullptr, 0, 0); |
| ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, true, false, &frame, |
| MAY_FEC_PROTECT)); |
| ASSERT_TRUE(frame.stream_frame); |
| size_t consumed = frame.stream_frame->frame_length; |
| EXPECT_EQ(0u, consumed); |
| CheckStreamFrame(frame, 1u, string(), 0u, true); |
| EXPECT_TRUE(creator_.HasPendingFrames()); |
| } |
| |
| TEST_P(QuicPacketCreatorTest, ConsumeDataWithFecProtect) { |
| creator_.set_max_packets_per_fec_group(6); |
| QuicFrame frame; |
| QuicIOVector io_vector(MakeIOVector("test")); |
| EXPECT_FALSE(QuicPacketCreatorPeer::IsFecProtected(&creator_)); |
| ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame, |
| MUST_FEC_PROTECT)); |
| ASSERT_TRUE(frame.stream_frame); |
| size_t consumed = frame.stream_frame->frame_length; |
| EXPECT_EQ(4u, consumed); |
| CheckStreamFrame(frame, 1u, "test", 0u, false); |
| EXPECT_TRUE(creator_.HasPendingFrames()); |
| EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_)); |
| } |
| |
| TEST_P(QuicPacketCreatorTest, CreateAllFreeBytesForStreamFrames) { |
| const size_t overhead = |
| GetPacketHeaderOverhead(NOT_IN_FEC_GROUP) + GetEncryptionOverhead(); |
| for (size_t i = overhead; i < overhead + 100; ++i) { |
| creator_.SetMaxPacketLength(i); |
| const bool should_have_room = |
| i > overhead + GetStreamFrameOverhead(NOT_IN_FEC_GROUP); |
| ASSERT_EQ(should_have_room, |
| creator_.HasRoomForStreamFrame(kClientDataStreamId1, kOffset)); |
| if (should_have_room) { |
| QuicFrame frame; |
| QuicIOVector io_vector(MakeIOVector("testdata")); |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .WillRepeatedly( |
| Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket)); |
| ASSERT_TRUE(creator_.ConsumeData(kClientDataStreamId1, io_vector, 0u, |
| kOffset, false, false, &frame, |
| MAY_FEC_PROTECT)); |
| ASSERT_TRUE(frame.stream_frame); |
| size_t bytes_consumed = frame.stream_frame->frame_length; |
| EXPECT_LT(0u, bytes_consumed); |
| creator_.Flush(); |
| } |
| } |
| } |
| |
| TEST_P(QuicPacketCreatorTest, StreamFrameConsumption) { |
| // Compute the total overhead for a single frame in packet. |
| const size_t overhead = GetPacketHeaderOverhead(NOT_IN_FEC_GROUP) + |
| GetEncryptionOverhead() + |
| GetStreamFrameOverhead(NOT_IN_FEC_GROUP); |
| size_t capacity = kDefaultMaxPacketSize - overhead; |
| // Now, test various sizes around this size. |
| for (int delta = -5; delta <= 5; ++delta) { |
| string data(capacity + delta, 'A'); |
| size_t bytes_free = delta > 0 ? 0 : 0 - delta; |
| QuicFrame frame; |
| QuicIOVector io_vector(MakeIOVector(data)); |
| ASSERT_TRUE(creator_.ConsumeData(kClientDataStreamId1, io_vector, 0u, |
| kOffset, false, false, &frame, |
| MAY_FEC_PROTECT)); |
| ASSERT_TRUE(frame.stream_frame); |
| |
| // BytesFree() returns bytes available for the next frame, which will |
| // be two bytes smaller since the stream frame would need to be grown. |
| EXPECT_EQ(2u, creator_.ExpansionOnNewFrame()); |
| size_t expected_bytes_free = bytes_free < 3 ? 0 : bytes_free - 2; |
| EXPECT_EQ(expected_bytes_free, creator_.BytesFree()) << "delta: " << delta; |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); |
| creator_.Flush(); |
| ASSERT_TRUE(serialized_packet_.packet); |
| ClearSerializedPacket(&serialized_packet_); |
| } |
| } |
| |
| TEST_P(QuicPacketCreatorTest, StreamFrameConsumptionWithFec) { |
| // Send FEC packet every 6 packets. |
| creator_.set_max_packets_per_fec_group(6); |
| // Turn on FEC protection. |
| QuicFrame frame; |
| QuicIOVector io_vector(MakeIOVector("test")); |
| ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame, |
| MUST_FEC_PROTECT)); |
| EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_)); |
| |
| // Serialize the packet. |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .WillOnce(Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket)); |
| creator_.Flush(); |
| // Compute the total overhead for a single frame in packet. |
| const size_t overhead = GetPacketHeaderOverhead(IN_FEC_GROUP) + |
| GetEncryptionOverhead() + |
| GetStreamFrameOverhead(IN_FEC_GROUP); |
| size_t capacity = kDefaultMaxPacketSize - overhead; |
| // Now, test various sizes around this size. |
| for (int delta = -5; delta <= 5; ++delta) { |
| string data(capacity + delta, 'A'); |
| size_t bytes_free = delta > 0 ? 0 : 0 - delta; |
| QuicFrame frame; |
| QuicIOVector io_vector(MakeIOVector(data)); |
| ASSERT_TRUE(creator_.ConsumeData(kClientDataStreamId1, io_vector, 0u, |
| kOffset, false, false, &frame, |
| MUST_FEC_PROTECT)); |
| ASSERT_TRUE(frame.stream_frame); |
| // BytesFree() returns bytes available for the next frame. Since stream |
| // frame does not grow for FEC protected packets, this should be the same |
| // as bytes_free (bound by 0). |
| EXPECT_EQ(0u, creator_.ExpansionOnNewFrame()); |
| size_t expected_bytes_free = bytes_free > 0 ? bytes_free : 0; |
| EXPECT_EQ(expected_bytes_free, creator_.BytesFree()) << "delta: " << delta; |
| { |
| InSequence s; |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); |
| // Every 6th packet will generate an extra FEC packet. |
| if (delta == -1 || delta == 5) { |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .WillOnce( |
| Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket)); |
| } |
| } |
| creator_.Flush(); |
| ASSERT_TRUE(serialized_packet_.packet); |
| ClearSerializedPacket(&serialized_packet_); |
| } |
| } |
| |
| TEST_P(QuicPacketCreatorTest, CryptoStreamFramePacketPadding) { |
| // Compute the total overhead for a single frame in packet. |
| const size_t overhead = GetPacketHeaderOverhead(NOT_IN_FEC_GROUP) + |
| GetEncryptionOverhead() + |
| GetStreamFrameOverhead(NOT_IN_FEC_GROUP); |
| ASSERT_GT(kMaxPacketSize, overhead); |
| size_t capacity = kDefaultMaxPacketSize - overhead; |
| // Now, test various sizes around this size. |
| for (int delta = -5; delta <= 5; ++delta) { |
| string data(capacity + delta, 'A'); |
| size_t bytes_free = delta > 0 ? 0 : 0 - delta; |
| |
| QuicFrame frame; |
| QuicIOVector io_vector(MakeIOVector(data)); |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .WillRepeatedly( |
| Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); |
| ASSERT_TRUE(creator_.ConsumeData(kCryptoStreamId, io_vector, 0u, kOffset, |
| false, true, &frame, MAY_FEC_PROTECT)); |
| ASSERT_TRUE(frame.stream_frame); |
| size_t bytes_consumed = frame.stream_frame->frame_length; |
| EXPECT_LT(0u, bytes_consumed); |
| creator_.Flush(); |
| ASSERT_TRUE(serialized_packet_.packet); |
| // If there is not enough space in the packet to fit a padding frame |
| // (1 byte) and to expand the stream frame (another 2 bytes) the packet |
| // will not be padded. |
| if (bytes_free < 3) { |
| EXPECT_EQ(kDefaultMaxPacketSize - bytes_free, |
| serialized_packet_.packet->length()); |
| } else { |
| EXPECT_EQ(kDefaultMaxPacketSize, serialized_packet_.packet->length()); |
| } |
| ClearSerializedPacket(&serialized_packet_); |
| } |
| } |
| |
| TEST_P(QuicPacketCreatorTest, NonCryptoStreamFramePacketNonPadding) { |
| // Compute the total overhead for a single frame in packet. |
| const size_t overhead = GetPacketHeaderOverhead(NOT_IN_FEC_GROUP) + |
| GetEncryptionOverhead() + |
| GetStreamFrameOverhead(NOT_IN_FEC_GROUP); |
| ASSERT_GT(kDefaultMaxPacketSize, overhead); |
| size_t capacity = kDefaultMaxPacketSize - overhead; |
| // Now, test various sizes around this size. |
| for (int delta = -5; delta <= 5; ++delta) { |
| string data(capacity + delta, 'A'); |
| size_t bytes_free = delta > 0 ? 0 : 0 - delta; |
| |
| QuicFrame frame; |
| QuicIOVector io_vector(MakeIOVector(data)); |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); |
| ASSERT_TRUE(creator_.ConsumeData(kClientDataStreamId1, io_vector, 0u, |
| kOffset, false, false, &frame, |
| MAY_FEC_PROTECT)); |
| ASSERT_TRUE(frame.stream_frame); |
| size_t bytes_consumed = frame.stream_frame->frame_length; |
| EXPECT_LT(0u, bytes_consumed); |
| creator_.Flush(); |
| ASSERT_TRUE(serialized_packet_.packet); |
| if (bytes_free > 0) { |
| EXPECT_EQ(kDefaultMaxPacketSize - bytes_free, |
| serialized_packet_.packet->length()); |
| } else { |
| EXPECT_EQ(kDefaultMaxPacketSize, serialized_packet_.packet->length()); |
| } |
| ClearSerializedPacket(&serialized_packet_); |
| } |
| } |
| |
| TEST_P(QuicPacketCreatorTest, SerializeVersionNegotiationPacket) { |
| QuicFramerPeer::SetPerspective(&client_framer_, Perspective::IS_SERVER); |
| QuicVersionVector versions; |
| versions.push_back(test::QuicVersionMax()); |
| scoped_ptr<QuicEncryptedPacket> encrypted( |
| creator_.SerializeVersionNegotiationPacket(versions)); |
| |
| { |
| InSequence s; |
| EXPECT_CALL(framer_visitor_, OnPacket()); |
| EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnVersionNegotiationPacket(_)); |
| } |
| QuicFramerPeer::SetPerspective(&client_framer_, Perspective::IS_CLIENT); |
| client_framer_.ProcessPacket(*encrypted); |
| } |
| |
| TEST_P(QuicPacketCreatorTest, UpdatePacketSequenceNumberLengthLeastAwaiting) { |
| EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)); |
| |
| size_t max_packets_per_fec_group = 10; |
| creator_.set_max_packets_per_fec_group(max_packets_per_fec_group); |
| QuicPacketCreatorPeer::SetPacketNumber(&creator_, |
| 64 - max_packets_per_fec_group); |
| creator_.UpdatePacketNumberLength(2, 10000 / kDefaultMaxPacketSize); |
| EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)); |
| |
| QuicPacketCreatorPeer::SetPacketNumber(&creator_, |
| 64 * 256 - max_packets_per_fec_group); |
| creator_.UpdatePacketNumberLength(2, 10000 / kDefaultMaxPacketSize); |
| EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)); |
| |
| QuicPacketCreatorPeer::SetPacketNumber( |
| &creator_, 64 * 256 * 256 - max_packets_per_fec_group); |
| creator_.UpdatePacketNumberLength(2, 10000 / kDefaultMaxPacketSize); |
| EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)); |
| |
| QuicPacketCreatorPeer::SetPacketNumber( |
| &creator_, |
| UINT64_C(64) * 256 * 256 * 256 * 256 - max_packets_per_fec_group); |
| creator_.UpdatePacketNumberLength(2, 10000 / kDefaultMaxPacketSize); |
| EXPECT_EQ(PACKET_6BYTE_PACKET_NUMBER, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)); |
| } |
| |
| TEST_P(QuicPacketCreatorTest, UpdatePacketSequenceNumberLengthBandwidth) { |
| EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)); |
| |
| creator_.UpdatePacketNumberLength(1, 10000 / kDefaultMaxPacketSize); |
| EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)); |
| |
| creator_.UpdatePacketNumberLength(1, 10000 * 256 / kDefaultMaxPacketSize); |
| EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)); |
| |
| creator_.UpdatePacketNumberLength(1, |
| 10000 * 256 * 256 / kDefaultMaxPacketSize); |
| EXPECT_EQ(PACKET_4BYTE_PACKET_NUMBER, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)); |
| |
| creator_.UpdatePacketNumberLength( |
| 1, UINT64_C(1000) * 256 * 256 * 256 * 256 / kDefaultMaxPacketSize); |
| EXPECT_EQ(PACKET_6BYTE_PACKET_NUMBER, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)); |
| } |
| |
| TEST_P(QuicPacketCreatorTest, SerializeFrame) { |
| if (!GetParam().version_serialization) { |
| creator_.StopSendingVersion(); |
| } |
| frames_.push_back( |
| QuicFrame(new QuicStreamFrame(0u, false, 0u, StringPiece()))); |
| SerializedPacket serialized = SerializeAllFrames(frames_); |
| delete frames_[0].stream_frame; |
| |
| QuicPacketHeader header; |
| { |
| InSequence s; |
| EXPECT_CALL(framer_visitor_, OnPacket()); |
| EXPECT_CALL(framer_visitor_, OnUnauthenticatedPublicHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_)); |
| EXPECT_CALL(framer_visitor_, OnDecryptedPacket(_)); |
| EXPECT_CALL(framer_visitor_, OnPacketHeader(_)) |
| .WillOnce(DoAll(SaveArg<0>(&header), Return(true))); |
| EXPECT_CALL(framer_visitor_, OnStreamFrame(_)); |
| EXPECT_CALL(framer_visitor_, OnPacketComplete()); |
| } |
| ProcessPacket(serialized.packet); |
| EXPECT_EQ(GetParam().version_serialization, |
| header.public_header.version_flag); |
| delete serialized.packet; |
| } |
| |
| TEST_P(QuicPacketCreatorTest, ConsumeDataLargerThanOneStreamFrame) { |
| if (!GetParam().version_serialization) { |
| creator_.StopSendingVersion(); |
| } |
| // A string larger than fits into a frame. |
| size_t payload_length; |
| creator_.SetMaxPacketLength(GetPacketLengthForOneStream( |
| client_framer_.version(), |
| QuicPacketCreatorPeer::SendVersionInPacket(&creator_), |
| creator_.connection_id_length(), PACKET_1BYTE_PACKET_NUMBER, |
| NOT_IN_FEC_GROUP, &payload_length)); |
| QuicFrame frame; |
| const string too_long_payload(payload_length * 2, 'a'); |
| QuicIOVector io_vector(MakeIOVector(too_long_payload)); |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); |
| ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, true, false, &frame, |
| MAY_FEC_PROTECT)); |
| ASSERT_TRUE(frame.stream_frame); |
| size_t consumed = frame.stream_frame->frame_length; |
| EXPECT_EQ(payload_length, consumed); |
| const string payload(payload_length, 'a'); |
| CheckStreamFrame(frame, 1u, payload, 0u, false); |
| creator_.Flush(); |
| ClearSerializedPacket(&serialized_packet_); |
| } |
| |
| TEST_P(QuicPacketCreatorTest, AddFrameAndFlush) { |
| if (!GetParam().version_serialization) { |
| creator_.StopSendingVersion(); |
| } |
| const size_t max_plaintext_size = |
| client_framer_.GetMaxPlaintextSize(creator_.max_packet_length()); |
| EXPECT_FALSE(creator_.HasPendingFrames()); |
| EXPECT_EQ(max_plaintext_size - |
| GetPacketHeaderSize( |
| creator_.connection_id_length(), |
| QuicPacketCreatorPeer::SendVersionInPacket(&creator_), |
| /*include_path_id=*/false, PACKET_1BYTE_PACKET_NUMBER, |
| NOT_IN_FEC_GROUP), |
| creator_.BytesFree()); |
| |
| // Add a variety of frame types and then a padding frame. |
| QuicAckFrame ack_frame(MakeAckFrame(0u)); |
| EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&ack_frame))); |
| EXPECT_TRUE(creator_.HasPendingFrames()); |
| |
| QuicFrame frame; |
| QuicIOVector io_vector(MakeIOVector("test")); |
| ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame, |
| MAY_FEC_PROTECT)); |
| ASSERT_TRUE(frame.stream_frame); |
| size_t consumed = frame.stream_frame->frame_length; |
| EXPECT_EQ(4u, consumed); |
| EXPECT_TRUE(creator_.HasPendingFrames()); |
| |
| QuicPaddingFrame padding_frame; |
| EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(padding_frame))); |
| EXPECT_TRUE(creator_.HasPendingFrames()); |
| EXPECT_EQ(0u, creator_.BytesFree()); |
| |
| // Packet is full. Creator will flush. |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); |
| EXPECT_FALSE(creator_.AddSavedFrame(QuicFrame(&ack_frame))); |
| |
| // Ensure the packet is successfully created. |
| ASSERT_TRUE(serialized_packet_.packet); |
| ASSERT_TRUE(serialized_packet_.retransmittable_frames); |
| RetransmittableFrames* retransmittable = |
| serialized_packet_.retransmittable_frames; |
| ASSERT_EQ(1u, retransmittable->frames().size()); |
| EXPECT_EQ(STREAM_FRAME, retransmittable->frames()[0].type); |
| ASSERT_TRUE(retransmittable->frames()[0].stream_frame); |
| ClearSerializedPacket(&serialized_packet_); |
| |
| EXPECT_FALSE(creator_.HasPendingFrames()); |
| EXPECT_EQ(max_plaintext_size - |
| GetPacketHeaderSize( |
| creator_.connection_id_length(), |
| QuicPacketCreatorPeer::SendVersionInPacket(&creator_), |
| /*include_path_id=*/false, PACKET_1BYTE_PACKET_NUMBER, |
| NOT_IN_FEC_GROUP), |
| creator_.BytesFree()); |
| } |
| |
| TEST_P(QuicPacketCreatorTest, SerializeTruncatedAckFrameWithLargePacketSize) { |
| if (!GetParam().version_serialization) { |
| creator_.StopSendingVersion(); |
| } |
| creator_.SetMaxPacketLength(kMaxPacketSize); |
| |
| // Serialized length of ack frame with 2000 nack ranges should be limited by |
| // the number of nack ranges that can be fit in an ack frame. |
| QuicAckFrame ack_frame = MakeAckFrameWithNackRanges(2000u, 0u); |
| size_t frame_len = client_framer_.GetSerializedFrameLength( |
| QuicFrame(&ack_frame), creator_.BytesFree(), true, true, NOT_IN_FEC_GROUP, |
| PACKET_1BYTE_PACKET_NUMBER); |
| EXPECT_GT(creator_.BytesFree(), frame_len); |
| EXPECT_GT(creator_.max_packet_length(), creator_.PacketSize()); |
| |
| // Add ack frame to creator. |
| EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&ack_frame))); |
| EXPECT_TRUE(creator_.HasPendingFrames()); |
| EXPECT_GT(creator_.max_packet_length(), creator_.PacketSize()); |
| EXPECT_LT(0u, creator_.BytesFree()); |
| |
| // Make sure that an additional stream frame can be added to the packet. |
| QuicFrame frame; |
| QuicIOVector io_vector(MakeIOVector("test")); |
| ASSERT_TRUE(creator_.ConsumeData(2u, io_vector, 0u, 0u, false, false, &frame, |
| MAY_FEC_PROTECT)); |
| ASSERT_TRUE(frame.stream_frame); |
| size_t consumed = frame.stream_frame->frame_length; |
| EXPECT_EQ(4u, consumed); |
| EXPECT_TRUE(creator_.HasPendingFrames()); |
| |
| // Ensure the packet is successfully created, and the packet size estimate |
| // matches the serialized packet length. |
| EXPECT_CALL(entropy_calculator_, EntropyHash(_)).WillOnce(testing::Return(0)); |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); |
| size_t est_packet_size = creator_.PacketSize(); |
| creator_.Flush(); |
| ASSERT_TRUE(serialized_packet_.packet); |
| EXPECT_EQ(est_packet_size, client_framer_.GetMaxPlaintextSize( |
| serialized_packet_.packet->length())); |
| ClearSerializedPacket(&serialized_packet_); |
| } |
| |
| TEST_P(QuicPacketCreatorTest, SerializeTruncatedAckFrameWithSmallPacketSize) { |
| if (!GetParam().version_serialization) { |
| creator_.StopSendingVersion(); |
| } |
| creator_.SetMaxPacketLength(500u); |
| |
| const size_t max_plaintext_size = |
| client_framer_.GetMaxPlaintextSize(creator_.max_packet_length()); |
| EXPECT_EQ(max_plaintext_size - creator_.PacketSize(), creator_.BytesFree()); |
| |
| // Serialized length of ack frame with 2000 nack ranges should be limited by |
| // the packet size. |
| QuicAckFrame ack_frame = MakeAckFrameWithNackRanges(2000u, 0u); |
| size_t frame_len = client_framer_.GetSerializedFrameLength( |
| QuicFrame(&ack_frame), creator_.BytesFree(), true, true, NOT_IN_FEC_GROUP, |
| PACKET_1BYTE_PACKET_NUMBER); |
| EXPECT_EQ(creator_.BytesFree(), frame_len); |
| |
| // Add ack frame to creator. |
| EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&ack_frame))); |
| EXPECT_TRUE(creator_.HasPendingFrames()); |
| EXPECT_EQ(client_framer_.GetMaxPlaintextSize(creator_.max_packet_length()), |
| creator_.PacketSize()); |
| EXPECT_EQ(0u, creator_.BytesFree()); |
| |
| // Ensure the packet is successfully created, and the packet size estimate |
| // may not match the serialized packet length. |
| EXPECT_CALL(entropy_calculator_, EntropyHash(_)).WillOnce(Return(0)); |
| size_t est_packet_size = creator_.PacketSize(); |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); |
| creator_.Flush(); |
| ASSERT_TRUE(serialized_packet_.packet); |
| EXPECT_GE(est_packet_size, client_framer_.GetMaxPlaintextSize( |
| serialized_packet_.packet->length())); |
| ClearSerializedPacket(&serialized_packet_); |
| } |
| |
| TEST_P(QuicPacketCreatorTest, EntropyFlag) { |
| frames_.push_back( |
| QuicFrame(new QuicStreamFrame(0u, false, 0u, StringPiece()))); |
| |
| for (int i = 0; i < 2; ++i) { |
| for (int j = 0; j < 64; ++j) { |
| SerializedPacket serialized = SerializeAllFrames(frames_); |
| // Verify both BoolSource and hash algorithm. |
| bool expected_rand_bool = |
| (mock_random_.RandUint64() & (UINT64_C(1) << j)) != 0; |
| bool observed_rand_bool = |
| (serialized.entropy_hash & (1 << ((j + 1) % 8))) != 0; |
| uint8_t rest_of_hash = serialized.entropy_hash & ~(1 << ((j + 1) % 8)); |
| EXPECT_EQ(expected_rand_bool, observed_rand_bool); |
| EXPECT_EQ(0, rest_of_hash); |
| delete serialized.packet; |
| } |
| // After 64 calls, BoolSource will refresh the bucket - make sure it does. |
| mock_random_.ChangeValue(); |
| } |
| |
| delete frames_[0].stream_frame; |
| } |
| |
| TEST_P(QuicPacketCreatorTest, ResetFecGroup) { |
| // Send FEC packet every 6 packets. |
| creator_.set_max_packets_per_fec_group(6); |
| // Add a stream frame and turn on FEC protection. |
| QuicFrame frame; |
| QuicIOVector io_vector(MakeIOVector("test")); |
| ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame, |
| MUST_FEC_PROTECT)); |
| // Serialize the packet. |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .WillOnce(Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket)); |
| creator_.Flush(); |
| |
| EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_)); |
| EXPECT_TRUE(creator_.IsFecGroupOpen()); |
| // We do not have enough packets in the FEC group to trigger an FEC packet. |
| EXPECT_FALSE(creator_.ShouldSendFec(/*force_close=*/false)); |
| // Should return true since there are packets in the FEC group. |
| EXPECT_TRUE(creator_.ShouldSendFec(/*force_close=*/true)); |
| |
| // FEC group will be reset if FEC police is alarm trigger but FEC alarm does |
| // not fire. |
| EXPECT_CALL(delegate_, OnResetFecGroup()).Times(1); |
| creator_.set_fec_send_policy(FEC_ALARM_TRIGGER); |
| creator_.MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/true, |
| /*is_fec_timeout=*/false); |
| EXPECT_FALSE(QuicPacketCreatorPeer::IsFecProtected(&creator_)); |
| EXPECT_FALSE(creator_.IsFecGroupOpen()); |
| // We do not have enough packets in the FEC group to trigger an FEC packet. |
| EXPECT_FALSE(creator_.ShouldSendFec(/*force_close=*/false)); |
| // Confirm that there is no FEC packet under construction. |
| EXPECT_FALSE(creator_.ShouldSendFec(/*force_close=*/true)); |
| |
| char buffer[kMaxPacketSize]; |
| EXPECT_DFATAL( |
| QuicPacketCreatorPeer::SerializeFec(&creator_, buffer, kMaxPacketSize), |
| "SerializeFEC called but no group or zero packets in group."); |
| |
| // Create and send a new FEC protected packet. |
| ASSERT_TRUE(creator_.ConsumeData(2u, io_vector, 0u, 0u, false, false, &frame, |
| MUST_FEC_PROTECT)); |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .WillOnce(Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket)); |
| creator_.Flush(); |
| |
| EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_)); |
| EXPECT_TRUE(creator_.IsFecGroupOpen()); |
| // We do not have enough packets in the FEC group to trigger an FEC packet. |
| EXPECT_FALSE(creator_.ShouldSendFec(/*force_close=*/false)); |
| // Should return true since there are packets in the FEC group. |
| EXPECT_TRUE(creator_.ShouldSendFec(/*force_close=*/true)); |
| |
| // Should return false since we do not have enough packets in the FEC group to |
| // trigger an FEC packet. |
| ASSERT_FALSE(creator_.ShouldSendFec(/*force_close=*/false)); |
| // Should return true since there are packets in the FEC group. |
| ASSERT_TRUE(creator_.ShouldSendFec(/*force_close=*/true)); |
| |
| // Change FEC policy, send FEC packet and close FEC group. |
| creator_.set_fec_send_policy(FEC_ANY_TRIGGER); |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); |
| creator_.MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/true, |
| /*is_fec_timeout=*/false); |
| ASSERT_EQ(3u, serialized_packet_.packet_number); |
| ClearSerializedPacket(&serialized_packet_); |
| } |
| |
| TEST_P(QuicPacketCreatorTest, ResetFecGroupWithQueuedFrames) { |
| // Send FEC packet every 6 packets. |
| creator_.set_max_packets_per_fec_group(6); |
| // Add a stream frame to the creator and turn on FEC protection. |
| QuicFrame frame; |
| QuicIOVector io_vector(MakeIOVector("test")); |
| ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame, |
| MUST_FEC_PROTECT)); |
| ASSERT_TRUE(frame.stream_frame); |
| size_t consumed = frame.stream_frame->frame_length; |
| EXPECT_EQ(4u, consumed); |
| EXPECT_TRUE(creator_.HasPendingFrames()); |
| EXPECT_DFATAL(QuicPacketCreatorPeer::ResetFecGroup(&creator_), |
| "Cannot reset FEC group with pending frames."); |
| |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .WillOnce(Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket)); |
| creator_.Flush(); |
| EXPECT_FALSE(creator_.HasPendingFrames()); |
| |
| // FEC group will be reset if FEC police is alarm trigger but FEC alarm does |
| // not fire. |
| EXPECT_CALL(delegate_, OnResetFecGroup()).Times(1); |
| creator_.set_fec_send_policy(FEC_ALARM_TRIGGER); |
| creator_.MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/true, |
| /*is_fec_timeout=*/false); |
| EXPECT_FALSE(creator_.IsFecGroupOpen()); |
| } |
| |
| TEST_P(QuicPacketCreatorTest, SetCurrentPath) { |
| // Current path is the default path. |
| EXPECT_EQ(kDefaultPathId, QuicPacketCreatorPeer::GetCurrentPath(&creator_)); |
| EXPECT_EQ(0u, creator_.packet_number()); |
| EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)); |
| // Add a stream frame to the creator. |
| QuicFrame frame; |
| QuicIOVector io_vector(MakeIOVector("test")); |
| ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame, |
| MAY_FEC_PROTECT)); |
| ASSERT_TRUE(frame.stream_frame); |
| size_t consumed = frame.stream_frame->frame_length; |
| EXPECT_EQ(4u, consumed); |
| EXPECT_TRUE(creator_.HasPendingFrames()); |
| EXPECT_EQ(0u, creator_.packet_number()); |
| |
| // Change current path. |
| QuicPathId kPathId1 = 1; |
| EXPECT_DFATAL(creator_.SetCurrentPath(kPathId1, 1, 0), |
| "Unable to change paths when a packet is under construction"); |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .Times(1) |
| .WillRepeatedly( |
| Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket)); |
| creator_.Flush(); |
| EXPECT_FALSE(creator_.HasPendingFrames()); |
| creator_.SetCurrentPath(kPathId1, 1, 0); |
| EXPECT_EQ(kPathId1, QuicPacketCreatorPeer::GetCurrentPath(&creator_)); |
| EXPECT_FALSE(creator_.HasPendingFrames()); |
| EXPECT_EQ(0u, creator_.packet_number()); |
| EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)); |
| |
| // Change current path back. |
| creator_.SetCurrentPath(kDefaultPathId, 2, 1); |
| EXPECT_EQ(kDefaultPathId, QuicPacketCreatorPeer::GetCurrentPath(&creator_)); |
| EXPECT_EQ(1u, creator_.packet_number()); |
| EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)); |
| // Add a stream frame to the creator. |
| ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame, |
| MAY_FEC_PROTECT)); |
| ASSERT_TRUE(frame.stream_frame); |
| consumed = frame.stream_frame->frame_length; |
| EXPECT_EQ(4u, consumed); |
| EXPECT_TRUE(creator_.HasPendingFrames()); |
| |
| // Does not change current path. |
| creator_.SetCurrentPath(kDefaultPathId, 2, 0); |
| EXPECT_EQ(kDefaultPathId, QuicPacketCreatorPeer::GetCurrentPath(&creator_)); |
| EXPECT_TRUE(creator_.HasPendingFrames()); |
| EXPECT_EQ(1u, creator_.packet_number()); |
| EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)); |
| } |
| |
| TEST_P(QuicPacketCreatorTest, SetCurrentPathWithFec) { |
| // Send FEC packet every 6 packets. |
| creator_.set_max_packets_per_fec_group(6); |
| // Current path is the default path. |
| EXPECT_EQ(kDefaultPathId, QuicPacketCreatorPeer::GetCurrentPath(&creator_)); |
| EXPECT_EQ(0u, creator_.packet_number()); |
| EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)); |
| EXPECT_FALSE(QuicPacketCreatorPeer::IsFecProtected(&creator_)); |
| // Add a stream frame to the creator. |
| QuicFrame frame; |
| QuicIOVector io_vector(MakeIOVector("test")); |
| ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame, |
| MUST_FEC_PROTECT)); |
| ASSERT_TRUE(frame.stream_frame); |
| size_t consumed = frame.stream_frame->frame_length; |
| EXPECT_EQ(4u, consumed); |
| EXPECT_TRUE(creator_.HasPendingFrames()); |
| EXPECT_EQ(0u, creator_.packet_number()); |
| EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)); |
| EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_)); |
| |
| // Change current path. |
| QuicPathId kPathId1 = 1; |
| EXPECT_DFATAL(creator_.SetCurrentPath(kPathId1, 1, 0), |
| "Unable to change paths when a packet is under construction"); |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .Times(2) |
| .WillRepeatedly( |
| Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket)); |
| creator_.Flush(); |
| EXPECT_FALSE(creator_.HasPendingFrames()); |
| creator_.SetCurrentPath(kPathId1, 1, 0); |
| EXPECT_EQ(kPathId1, QuicPacketCreatorPeer::GetCurrentPath(&creator_)); |
| EXPECT_FALSE(creator_.HasPendingFrames()); |
| EXPECT_EQ(0u, creator_.packet_number()); |
| EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)); |
| EXPECT_FALSE(QuicPacketCreatorPeer::IsFecProtected(&creator_)); |
| |
| // Change current path back. |
| creator_.SetCurrentPath(kDefaultPathId, 3, 2); |
| EXPECT_EQ(kDefaultPathId, QuicPacketCreatorPeer::GetCurrentPath(&creator_)); |
| // FEC packet consumes a packet number. |
| EXPECT_EQ(2u, creator_.packet_number()); |
| EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)); |
| // Add a stream frame to the creator. |
| ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame, |
| MUST_FEC_PROTECT)); |
| ASSERT_TRUE(frame.stream_frame); |
| consumed = frame.stream_frame->frame_length; |
| EXPECT_EQ(4u, consumed); |
| EXPECT_TRUE(creator_.HasPendingFrames()); |
| |
| // Does not change current path. |
| creator_.SetCurrentPath(kDefaultPathId, 3, 0); |
| EXPECT_EQ(kDefaultPathId, QuicPacketCreatorPeer::GetCurrentPath(&creator_)); |
| EXPECT_TRUE(creator_.HasPendingFrames()); |
| // FEC packet consumes a packet number. |
| EXPECT_EQ(2u, creator_.packet_number()); |
| EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)); |
| EXPECT_TRUE(QuicPacketCreatorPeer::IsFecProtected(&creator_)); |
| } |
| |
| TEST_P(QuicPacketCreatorTest, |
| SetCurrentPathWithFecAndUpdatePacketSequenceNumberLength) { |
| // Send FEC packet every 10 packets. |
| size_t max_packets_per_fec_group = 10; |
| creator_.set_max_packets_per_fec_group(max_packets_per_fec_group); |
| // Current path is the default path. |
| EXPECT_EQ(kDefaultPathId, QuicPacketCreatorPeer::GetCurrentPath(&creator_)); |
| EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)); |
| QuicPacketCreatorPeer::SetPacketNumber( |
| &creator_, 64 * 256 - max_packets_per_fec_group - 2); |
| // Add a stream frame to the creator and send the packet. |
| QuicFrame frame; |
| QuicIOVector io_vector(MakeIOVector("test")); |
| ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame, |
| MUST_FEC_PROTECT)); |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .Times(2) |
| .WillRepeatedly( |
| Invoke(this, &QuicPacketCreatorTest::ClearSerializedPacket)); |
| creator_.Flush(); |
| EXPECT_EQ(64 * 256 - max_packets_per_fec_group - 1, creator_.packet_number()); |
| creator_.UpdatePacketNumberLength(2, 10000 / kDefaultMaxPacketSize); |
| EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)); |
| |
| // Change current path. |
| QuicPathId kPathId1 = 1; |
| creator_.SetCurrentPath(kPathId1, 1, 0); |
| EXPECT_EQ(0u, creator_.packet_number()); |
| EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)); |
| |
| // Change current path back. |
| creator_.SetCurrentPath(kDefaultPathId, 2, 10000 / kDefaultMaxPacketSize); |
| // FEC packet consumes a packet number. |
| EXPECT_EQ(64 * 256 - max_packets_per_fec_group, creator_.packet_number()); |
| EXPECT_EQ(PACKET_2BYTE_PACKET_NUMBER, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)); |
| } |
| |
| TEST_P(QuicPacketCreatorTest, SerializePacketOnDifferentPath) { |
| // Current path is the default path. |
| EXPECT_EQ(kDefaultPathId, QuicPacketCreatorPeer::GetCurrentPath(&creator_)); |
| EXPECT_EQ(0u, creator_.packet_number()); |
| // Add a stream frame to the creator and flush the packet. |
| QuicFrame frame; |
| QuicIOVector io_vector(MakeIOVector("test")); |
| ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame, |
| MAY_FEC_PROTECT)); |
| ASSERT_TRUE(frame.stream_frame); |
| size_t consumed = frame.stream_frame->frame_length; |
| EXPECT_EQ(4u, consumed); |
| EXPECT_TRUE(creator_.HasPendingFrames()); |
| EXPECT_EQ(0u, creator_.packet_number()); |
| EXPECT_CALL(delegate_, OnSerializedPacket(_)) |
| .WillRepeatedly( |
| Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket)); |
| creator_.Flush(); |
| EXPECT_FALSE(creator_.HasPendingFrames()); |
| EXPECT_EQ(1u, creator_.packet_number()); |
| // Verify serialized data packet's path id. |
| EXPECT_EQ(kDefaultPathId, serialized_packet_.path_id); |
| ClearSerializedPacket(&serialized_packet_); |
| |
| // Change to path 1. |
| QuicPathId kPathId1 = 1; |
| creator_.SetCurrentPath(kPathId1, 1, 0); |
| EXPECT_EQ(kPathId1, QuicPacketCreatorPeer::GetCurrentPath(&creator_)); |
| EXPECT_FALSE(creator_.HasPendingFrames()); |
| EXPECT_EQ(0u, creator_.packet_number()); |
| EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER, |
| QuicPacketCreatorPeer::NextPacketNumberLength(&creator_)); |
| |
| // Add a stream frame to the creator and flush the packet. |
| ASSERT_TRUE(creator_.ConsumeData(1u, io_vector, 0u, 0u, false, false, &frame, |
| MAY_FEC_PROTECT)); |
| ASSERT_TRUE(frame.stream_frame); |
| consumed = frame.stream_frame->frame_length; |
| EXPECT_EQ(4u, consumed); |
| EXPECT_TRUE(creator_.HasPendingFrames()); |
| creator_.Flush(); |
| // Verify serialized data packet's path id. |
| EXPECT_EQ(kPathId1, serialized_packet_.path_id); |
| ClearSerializedPacket(&serialized_packet_); |
| } |
| |
| TEST_P(QuicPacketCreatorTest, AddUnencryptedStreamDataClosesConnection) { |
| FLAGS_quic_never_write_unencrypted_data = true; |
| EXPECT_CALL(delegate_, CloseConnection(_, _)); |
| QuicStreamFrame stream_frame(kHeadersStreamId, /*fin=*/false, 0u, |
| StringPiece()); |
| EXPECT_DFATAL(creator_.AddSavedFrame(QuicFrame(&stream_frame)), |
| "Cannot send stream data without encryption."); |
| } |
| |
| } // namespace |
| } // namespace test |
| } // namespace net |
