1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "net/quic/quic_packet_generator.h"
6
7#include <string>
8
9#include "net/quic/crypto/crypto_protocol.h"
10#include "net/quic/crypto/null_encrypter.h"
11#include "net/quic/crypto/quic_decrypter.h"
12#include "net/quic/crypto/quic_encrypter.h"
13#include "net/quic/quic_utils.h"
14#include "net/quic/test_tools/quic_packet_creator_peer.h"
15#include "net/quic/test_tools/quic_packet_generator_peer.h"
16#include "net/quic/test_tools/quic_test_utils.h"
17#include "net/quic/test_tools/simple_quic_framer.h"
18#include "testing/gmock/include/gmock/gmock.h"
19#include "testing/gtest/include/gtest/gtest.h"
20
21using base::StringPiece;
22using std::string;
23using testing::InSequence;
24using testing::Return;
25using testing::SaveArg;
26using testing::StrictMock;
27using testing::_;
28
29namespace net {
30namespace test {
31namespace {
32
33class MockDelegate : public QuicPacketGenerator::DelegateInterface {
34 public:
35  MockDelegate() {}
36  virtual ~MockDelegate() OVERRIDE {}
37
38  MOCK_METHOD3(ShouldGeneratePacket,
39               bool(TransmissionType transmission_type,
40                    HasRetransmittableData retransmittable,
41                    IsHandshake handshake));
42  MOCK_METHOD0(CreateAckFrame, QuicAckFrame*());
43  MOCK_METHOD0(CreateFeedbackFrame, QuicCongestionFeedbackFrame*());
44  MOCK_METHOD0(CreateStopWaitingFrame, QuicStopWaitingFrame*());
45  MOCK_METHOD1(OnSerializedPacket, void(const SerializedPacket& packet));
46  MOCK_METHOD2(CloseConnection, void(QuicErrorCode, bool));
47
48  void SetCanWriteAnything() {
49    EXPECT_CALL(*this, ShouldGeneratePacket(NOT_RETRANSMISSION, _, _))
50        .WillRepeatedly(Return(true));
51    EXPECT_CALL(*this, ShouldGeneratePacket(NOT_RETRANSMISSION,
52                                            NO_RETRANSMITTABLE_DATA, _))
53        .WillRepeatedly(Return(true));
54  }
55
56  void SetCanNotWrite() {
57    EXPECT_CALL(*this, ShouldGeneratePacket(NOT_RETRANSMISSION, _, _))
58        .WillRepeatedly(Return(false));
59    EXPECT_CALL(*this, ShouldGeneratePacket(NOT_RETRANSMISSION,
60                                            NO_RETRANSMITTABLE_DATA, _))
61        .WillRepeatedly(Return(false));
62  }
63
64  // Use this when only ack and feedback frames should be allowed to be written.
65  void SetCanWriteOnlyNonRetransmittable() {
66    EXPECT_CALL(*this, ShouldGeneratePacket(NOT_RETRANSMISSION, _, _))
67        .WillRepeatedly(Return(false));
68    EXPECT_CALL(*this, ShouldGeneratePacket(NOT_RETRANSMISSION,
69                                            NO_RETRANSMITTABLE_DATA, _))
70        .WillRepeatedly(Return(true));
71  }
72
73 private:
74  DISALLOW_COPY_AND_ASSIGN(MockDelegate);
75};
76
77// Simple struct for describing the contents of a packet.
78// Useful in conjunction with a SimpleQuicFrame for validating
79// that a packet contains the expected frames.
80struct PacketContents {
81  PacketContents()
82      : num_ack_frames(0),
83        num_connection_close_frames(0),
84        num_feedback_frames(0),
85        num_goaway_frames(0),
86        num_rst_stream_frames(0),
87        num_stop_waiting_frames(0),
88        num_stream_frames(0),
89        fec_group(0) {
90  }
91
92  size_t num_ack_frames;
93  size_t num_connection_close_frames;
94  size_t num_feedback_frames;
95  size_t num_goaway_frames;
96  size_t num_rst_stream_frames;
97  size_t num_stop_waiting_frames;
98  size_t num_stream_frames;
99
100  QuicFecGroupNumber fec_group;
101};
102
103}  // namespace
104
105class QuicPacketGeneratorTest : public ::testing::Test {
106 protected:
107  QuicPacketGeneratorTest()
108      : framer_(QuicSupportedVersions(), QuicTime::Zero(), false),
109        generator_(42, &framer_, &random_, &delegate_),
110        creator_(QuicPacketGeneratorPeer::GetPacketCreator(&generator_)),
111        packet_(0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL),
112        packet2_(0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL),
113        packet3_(0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL),
114        packet4_(0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL),
115        packet5_(0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL),
116        packet6_(0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL),
117        packet7_(0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL) {
118  }
119
120  virtual ~QuicPacketGeneratorTest() OVERRIDE {
121    delete packet_.packet;
122    delete packet_.retransmittable_frames;
123    delete packet2_.packet;
124    delete packet2_.retransmittable_frames;
125    delete packet3_.packet;
126    delete packet3_.retransmittable_frames;
127    delete packet4_.packet;
128    delete packet4_.retransmittable_frames;
129    delete packet5_.packet;
130    delete packet5_.retransmittable_frames;
131    delete packet6_.packet;
132    delete packet6_.retransmittable_frames;
133    delete packet7_.packet;
134    delete packet7_.retransmittable_frames;
135  }
136
137  QuicAckFrame* CreateAckFrame() {
138    // TODO(rch): Initialize this so it can be verified later.
139    return new QuicAckFrame(MakeAckFrame(0));
140  }
141
142  QuicCongestionFeedbackFrame* CreateFeedbackFrame() {
143    QuicCongestionFeedbackFrame* frame = new QuicCongestionFeedbackFrame;
144    frame->type = kTCP;
145    frame->tcp.receive_window = 0x4030;
146    return frame;
147  }
148
149  QuicStopWaitingFrame* CreateStopWaitingFrame() {
150    QuicStopWaitingFrame* frame = new QuicStopWaitingFrame();
151    frame->entropy_hash = 0;
152    frame->least_unacked = 0;
153    return frame;
154  }
155
156  QuicRstStreamFrame* CreateRstStreamFrame() {
157    return new QuicRstStreamFrame(1, QUIC_STREAM_NO_ERROR, 0);
158  }
159
160  QuicGoAwayFrame* CreateGoAwayFrame() {
161    return new QuicGoAwayFrame(QUIC_NO_ERROR, 1, string());
162  }
163
164  void CheckPacketContains(const PacketContents& contents,
165                           const SerializedPacket& packet) {
166    size_t num_retransmittable_frames = contents.num_connection_close_frames +
167        contents.num_goaway_frames + contents.num_rst_stream_frames +
168        contents.num_stream_frames;
169    size_t num_frames = contents.num_feedback_frames + contents.num_ack_frames +
170        contents.num_stop_waiting_frames + num_retransmittable_frames;
171
172    if (num_retransmittable_frames == 0) {
173      ASSERT_TRUE(packet.retransmittable_frames == NULL);
174    } else {
175      ASSERT_TRUE(packet.retransmittable_frames != NULL);
176      EXPECT_EQ(num_retransmittable_frames,
177                packet.retransmittable_frames->frames().size());
178    }
179
180    ASSERT_TRUE(packet.packet != NULL);
181    ASSERT_TRUE(simple_framer_.ProcessPacket(*packet.packet));
182    EXPECT_EQ(num_frames, simple_framer_.num_frames());
183    EXPECT_EQ(contents.num_ack_frames, simple_framer_.ack_frames().size());
184    EXPECT_EQ(contents.num_connection_close_frames,
185              simple_framer_.connection_close_frames().size());
186    EXPECT_EQ(contents.num_feedback_frames,
187              simple_framer_.feedback_frames().size());
188    EXPECT_EQ(contents.num_goaway_frames,
189              simple_framer_.goaway_frames().size());
190    EXPECT_EQ(contents.num_rst_stream_frames,
191              simple_framer_.rst_stream_frames().size());
192    EXPECT_EQ(contents.num_stream_frames,
193              simple_framer_.stream_frames().size());
194    EXPECT_EQ(contents.num_stop_waiting_frames,
195              simple_framer_.stop_waiting_frames().size());
196    EXPECT_EQ(contents.fec_group, simple_framer_.header().fec_group);
197  }
198
199  void CheckPacketHasSingleStreamFrame(const SerializedPacket& packet) {
200    ASSERT_TRUE(packet.retransmittable_frames != NULL);
201    EXPECT_EQ(1u, packet.retransmittable_frames->frames().size());
202    ASSERT_TRUE(packet.packet != NULL);
203    ASSERT_TRUE(simple_framer_.ProcessPacket(*packet.packet));
204    EXPECT_EQ(1u, simple_framer_.num_frames());
205    EXPECT_EQ(1u, simple_framer_.stream_frames().size());
206  }
207
208  void CheckPacketIsFec(const SerializedPacket& packet,
209                        QuicPacketSequenceNumber fec_group) {
210    ASSERT_TRUE(packet.retransmittable_frames == NULL);
211    ASSERT_TRUE(packet.packet != NULL);
212    ASSERT_TRUE(simple_framer_.ProcessPacket(*packet.packet));
213    EXPECT_TRUE(simple_framer_.header().fec_flag);
214    EXPECT_EQ(fec_group, simple_framer_.fec_data().fec_group);
215  }
216
217  IOVector CreateData(size_t len) {
218    data_array_.reset(new char[len]);
219    memset(data_array_.get(), '?', len);
220    IOVector data;
221    data.Append(data_array_.get(), len);
222    return data;
223  }
224
225  QuicFramer framer_;
226  MockRandom random_;
227  StrictMock<MockDelegate> delegate_;
228  QuicPacketGenerator generator_;
229  QuicPacketCreator* creator_;
230  SimpleQuicFramer simple_framer_;
231  SerializedPacket packet_;
232  SerializedPacket packet2_;
233  SerializedPacket packet3_;
234  SerializedPacket packet4_;
235  SerializedPacket packet5_;
236  SerializedPacket packet6_;
237  SerializedPacket packet7_;
238
239 private:
240  scoped_ptr<char[]> data_array_;
241};
242
243class MockDebugDelegate : public QuicPacketGenerator::DebugDelegate {
244 public:
245  MOCK_METHOD1(OnFrameAddedToPacket,
246               void(const QuicFrame&));
247};
248
249TEST_F(QuicPacketGeneratorTest, ShouldSendAck_NotWritable) {
250  delegate_.SetCanNotWrite();
251
252  generator_.SetShouldSendAck(false, false);
253  EXPECT_TRUE(generator_.HasQueuedFrames());
254}
255
256TEST_F(QuicPacketGeneratorTest, ShouldSendAck_WritableAndShouldNotFlush) {
257  StrictMock<MockDebugDelegate> debug_delegate;
258
259  generator_.set_debug_delegate(&debug_delegate);
260  delegate_.SetCanWriteOnlyNonRetransmittable();
261  generator_.StartBatchOperations();
262
263  EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame()));
264  EXPECT_CALL(debug_delegate, OnFrameAddedToPacket(_)).Times(1);
265
266  generator_.SetShouldSendAck(false, false);
267  EXPECT_TRUE(generator_.HasQueuedFrames());
268}
269
270TEST_F(QuicPacketGeneratorTest, ShouldSendAck_WritableAndShouldFlush) {
271  delegate_.SetCanWriteOnlyNonRetransmittable();
272
273  EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame()));
274  EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(SaveArg<0>(&packet_));
275
276  generator_.SetShouldSendAck(false, false);
277  EXPECT_FALSE(generator_.HasQueuedFrames());
278
279  PacketContents contents;
280  contents.num_ack_frames = 1;
281  CheckPacketContains(contents, packet_);
282}
283
284TEST_F(QuicPacketGeneratorTest,
285       ShouldSendAckWithFeedback_WritableAndShouldNotFlush) {
286  delegate_.SetCanWriteOnlyNonRetransmittable();
287  generator_.StartBatchOperations();
288
289  EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame()));
290  EXPECT_CALL(delegate_, CreateFeedbackFrame()).WillOnce(
291      Return(CreateFeedbackFrame()));
292
293  generator_.SetShouldSendAck(true, false);
294  EXPECT_TRUE(generator_.HasQueuedFrames());
295}
296
297TEST_F(QuicPacketGeneratorTest,
298       ShouldSendAckWithFeedback_WritableAndShouldFlush) {
299  delegate_.SetCanWriteOnlyNonRetransmittable();
300
301  EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame()));
302  EXPECT_CALL(delegate_, CreateFeedbackFrame()).WillOnce(
303      Return(CreateFeedbackFrame()));
304  EXPECT_CALL(delegate_, CreateStopWaitingFrame()).WillOnce(
305      Return(CreateStopWaitingFrame()));
306
307  EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(SaveArg<0>(&packet_));
308
309  generator_.SetShouldSendAck(true, true);
310  EXPECT_FALSE(generator_.HasQueuedFrames());
311
312  PacketContents contents;
313  contents.num_ack_frames = 1;
314  contents.num_feedback_frames = 1;
315  contents.num_stop_waiting_frames = 1;
316  CheckPacketContains(contents, packet_);
317}
318
319TEST_F(QuicPacketGeneratorTest, AddControlFrame_NotWritable) {
320  delegate_.SetCanNotWrite();
321
322  generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
323  EXPECT_TRUE(generator_.HasQueuedFrames());
324}
325
326TEST_F(QuicPacketGeneratorTest, AddControlFrame_OnlyAckWritable) {
327  delegate_.SetCanWriteOnlyNonRetransmittable();
328
329  generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
330  EXPECT_TRUE(generator_.HasQueuedFrames());
331}
332
333TEST_F(QuicPacketGeneratorTest, AddControlFrame_WritableAndShouldNotFlush) {
334  delegate_.SetCanWriteAnything();
335  generator_.StartBatchOperations();
336
337  generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
338  EXPECT_TRUE(generator_.HasQueuedFrames());
339}
340
341TEST_F(QuicPacketGeneratorTest, AddControlFrame_NotWritableBatchThenFlush) {
342  delegate_.SetCanNotWrite();
343  generator_.StartBatchOperations();
344
345  generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
346  EXPECT_TRUE(generator_.HasQueuedFrames());
347  generator_.FinishBatchOperations();
348  EXPECT_TRUE(generator_.HasQueuedFrames());
349
350  EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(SaveArg<0>(&packet_));
351  generator_.FlushAllQueuedFrames();
352  EXPECT_FALSE(generator_.HasQueuedFrames());
353
354  PacketContents contents;
355  contents.num_rst_stream_frames = 1;
356  CheckPacketContains(contents, packet_);
357}
358
359TEST_F(QuicPacketGeneratorTest, AddControlFrame_WritableAndShouldFlush) {
360  delegate_.SetCanWriteAnything();
361
362  EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(SaveArg<0>(&packet_));
363
364  generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
365  EXPECT_FALSE(generator_.HasQueuedFrames());
366
367  PacketContents contents;
368  contents.num_rst_stream_frames = 1;
369  CheckPacketContains(contents, packet_);
370}
371
372TEST_F(QuicPacketGeneratorTest, ConsumeData_NotWritable) {
373  delegate_.SetCanNotWrite();
374
375  QuicConsumedData consumed = generator_.ConsumeData(
376      kHeadersStreamId, MakeIOVector("foo"), 2, true, MAY_FEC_PROTECT, NULL);
377  EXPECT_EQ(0u, consumed.bytes_consumed);
378  EXPECT_FALSE(consumed.fin_consumed);
379  EXPECT_FALSE(generator_.HasQueuedFrames());
380}
381
382TEST_F(QuicPacketGeneratorTest, ConsumeData_WritableAndShouldNotFlush) {
383  delegate_.SetCanWriteAnything();
384  generator_.StartBatchOperations();
385
386  QuicConsumedData consumed = generator_.ConsumeData(
387      kHeadersStreamId, MakeIOVector("foo"), 2, true, MAY_FEC_PROTECT, NULL);
388  EXPECT_EQ(3u, consumed.bytes_consumed);
389  EXPECT_TRUE(consumed.fin_consumed);
390  EXPECT_TRUE(generator_.HasQueuedFrames());
391}
392
393TEST_F(QuicPacketGeneratorTest, ConsumeData_WritableAndShouldFlush) {
394  delegate_.SetCanWriteAnything();
395
396  EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(SaveArg<0>(&packet_));
397  QuicConsumedData consumed = generator_.ConsumeData(
398      kHeadersStreamId, MakeIOVector("foo"), 2, true, MAY_FEC_PROTECT, NULL);
399  EXPECT_EQ(3u, consumed.bytes_consumed);
400  EXPECT_TRUE(consumed.fin_consumed);
401  EXPECT_FALSE(generator_.HasQueuedFrames());
402
403  PacketContents contents;
404  contents.num_stream_frames = 1;
405  CheckPacketContains(contents, packet_);
406}
407
408TEST_F(QuicPacketGeneratorTest,
409       ConsumeDataMultipleTimes_WritableAndShouldNotFlush) {
410  delegate_.SetCanWriteAnything();
411  generator_.StartBatchOperations();
412
413  generator_.ConsumeData(kHeadersStreamId, MakeIOVector("foo"), 2, true,
414                         MAY_FEC_PROTECT, NULL);
415  QuicConsumedData consumed = generator_.ConsumeData(
416      3, MakeIOVector("quux"), 7, false, MAY_FEC_PROTECT, NULL);
417  EXPECT_EQ(4u, consumed.bytes_consumed);
418  EXPECT_FALSE(consumed.fin_consumed);
419  EXPECT_TRUE(generator_.HasQueuedFrames());
420}
421
422TEST_F(QuicPacketGeneratorTest, ConsumeData_BatchOperations) {
423  delegate_.SetCanWriteAnything();
424  generator_.StartBatchOperations();
425
426  generator_.ConsumeData(kHeadersStreamId, MakeIOVector("foo"), 2, true,
427                         MAY_FEC_PROTECT, NULL);
428  QuicConsumedData consumed = generator_.ConsumeData(
429      3, MakeIOVector("quux"), 7, false, MAY_FEC_PROTECT, NULL);
430  EXPECT_EQ(4u, consumed.bytes_consumed);
431  EXPECT_FALSE(consumed.fin_consumed);
432  EXPECT_TRUE(generator_.HasQueuedFrames());
433
434  // Now both frames will be flushed out.
435  EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(SaveArg<0>(&packet_));
436  generator_.FinishBatchOperations();
437  EXPECT_FALSE(generator_.HasQueuedFrames());
438
439  PacketContents contents;
440  contents.num_stream_frames = 2;
441  CheckPacketContains(contents, packet_);
442}
443
444TEST_F(QuicPacketGeneratorTest, ConsumeDataFEC) {
445  delegate_.SetCanWriteAnything();
446
447  // Send FEC every two packets.
448  creator_->set_max_packets_per_fec_group(2);
449
450  {
451    InSequence dummy;
452    EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
453        SaveArg<0>(&packet_));
454    EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
455        SaveArg<0>(&packet2_));
456    EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
457        SaveArg<0>(&packet3_));
458    EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
459        SaveArg<0>(&packet4_));
460    EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
461        SaveArg<0>(&packet5_));
462  }
463
464  // Send enough data to create 3 packets: two full and one partial. Send
465  // with MUST_FEC_PROTECT flag.
466  size_t data_len = 2 * kDefaultMaxPacketSize + 100;
467  QuicConsumedData consumed =
468      generator_.ConsumeData(3, CreateData(data_len), 0, true,
469                             MUST_FEC_PROTECT, NULL);
470  EXPECT_EQ(data_len, consumed.bytes_consumed);
471  EXPECT_TRUE(consumed.fin_consumed);
472  EXPECT_FALSE(generator_.HasQueuedFrames());
473
474  CheckPacketHasSingleStreamFrame(packet_);
475  CheckPacketHasSingleStreamFrame(packet2_);
476  CheckPacketIsFec(packet3_, 1);
477
478  CheckPacketHasSingleStreamFrame(packet4_);
479  CheckPacketIsFec(packet5_, 4);
480}
481
482TEST_F(QuicPacketGeneratorTest, ConsumeDataSendsFecAtEnd) {
483  delegate_.SetCanWriteAnything();
484
485  // Enable FEC.
486  creator_->set_max_packets_per_fec_group(6);
487  {
488    InSequence dummy;
489    EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
490        SaveArg<0>(&packet_));
491    EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
492        SaveArg<0>(&packet2_));
493    EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
494        SaveArg<0>(&packet3_));
495  }
496
497  // Send enough data to create 2 packets: one full and one partial. Send
498  // with MUST_FEC_PROTECT flag.
499  size_t data_len = 1 * kDefaultMaxPacketSize + 100;
500  QuicConsumedData consumed =
501      generator_.ConsumeData(3, CreateData(data_len), 0, true,
502                             MUST_FEC_PROTECT, NULL);
503  EXPECT_EQ(data_len, consumed.bytes_consumed);
504  EXPECT_TRUE(consumed.fin_consumed);
505  EXPECT_FALSE(generator_.HasQueuedFrames());
506
507  CheckPacketHasSingleStreamFrame(packet_);
508  CheckPacketHasSingleStreamFrame(packet2_);
509  CheckPacketIsFec(packet3_, 1);
510}
511
512TEST_F(QuicPacketGeneratorTest, ConsumeData_FramesPreviouslyQueued) {
513  // Set the packet size be enough for two stream frames with 0 stream offset,
514  // but not enough for a stream frame of 0 offset and one with non-zero offset.
515  size_t length =
516      NullEncrypter().GetCiphertextSize(0) +
517      GetPacketHeaderSize(creator_->connection_id_length(),
518                          true,
519                          creator_->next_sequence_number_length(),
520                          NOT_IN_FEC_GROUP) +
521      // Add an extra 3 bytes for the payload and 1 byte so BytesFree is larger
522      // than the GetMinStreamFrameSize.
523      QuicFramer::GetMinStreamFrameSize(1, 0, false, NOT_IN_FEC_GROUP) + 3 +
524      QuicFramer::GetMinStreamFrameSize(1, 0, true, NOT_IN_FEC_GROUP) + 1;
525  creator_->set_max_packet_length(length);
526  delegate_.SetCanWriteAnything();
527  {
528     InSequence dummy;
529     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
530         SaveArg<0>(&packet_));
531     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
532         SaveArg<0>(&packet2_));
533  }
534  generator_.StartBatchOperations();
535  // Queue enough data to prevent a stream frame with a non-zero offset from
536  // fitting.
537  QuicConsumedData consumed = generator_.ConsumeData(
538      kHeadersStreamId, MakeIOVector("foo"), 0, false, MAY_FEC_PROTECT, NULL);
539  EXPECT_EQ(3u, consumed.bytes_consumed);
540  EXPECT_FALSE(consumed.fin_consumed);
541  EXPECT_TRUE(generator_.HasQueuedFrames());
542
543  // This frame will not fit with the existing frame, causing the queued frame
544  // to be serialized, and it will not fit with another frame like it, so it is
545  // serialized by itself.
546  consumed = generator_.ConsumeData(kHeadersStreamId, MakeIOVector("bar"), 3,
547                                    true, MAY_FEC_PROTECT, NULL);
548  EXPECT_EQ(3u, consumed.bytes_consumed);
549  EXPECT_TRUE(consumed.fin_consumed);
550  EXPECT_FALSE(generator_.HasQueuedFrames());
551
552  PacketContents contents;
553  contents.num_stream_frames = 1;
554  CheckPacketContains(contents, packet_);
555  CheckPacketContains(contents, packet2_);
556}
557
558TEST_F(QuicPacketGeneratorTest, FecGroupSizeOnCongestionWindowChange) {
559  delegate_.SetCanWriteAnything();
560  creator_->set_max_packets_per_fec_group(50);
561  EXPECT_EQ(50u, creator_->max_packets_per_fec_group());
562  EXPECT_FALSE(creator_->IsFecGroupOpen());
563
564  // On reduced cwnd.
565  generator_.OnCongestionWindowChange(7 * kDefaultTCPMSS);
566  EXPECT_EQ(3u, creator_->max_packets_per_fec_group());
567
568  // On increased cwnd.
569  generator_.OnCongestionWindowChange(100 * kDefaultTCPMSS);
570  EXPECT_EQ(50u, creator_->max_packets_per_fec_group());
571
572  // On collapsed cwnd.
573  generator_.OnCongestionWindowChange(1 * kDefaultTCPMSS);
574  EXPECT_EQ(2u, creator_->max_packets_per_fec_group());
575}
576
577TEST_F(QuicPacketGeneratorTest, FecGroupSizeChangeWithOpenGroup) {
578  delegate_.SetCanWriteAnything();
579  // TODO(jri): This starting of batch mode should not be required when
580  // FEC sending is separated from batching operations.
581  generator_.StartBatchOperations();
582  creator_->set_max_packets_per_fec_group(50);
583  EXPECT_EQ(50u, creator_->max_packets_per_fec_group());
584  EXPECT_FALSE(creator_->IsFecGroupOpen());
585
586  // Send enough data to create 4 packets with MUST_FEC_PROTECT flag.
587  // 3 packets are sent, one is queued in the creator.
588  {
589    InSequence dummy;
590    EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
591        SaveArg<0>(&packet_));
592    EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
593        SaveArg<0>(&packet2_));
594    EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
595        SaveArg<0>(&packet3_));
596  }
597  size_t data_len = 3 * kDefaultMaxPacketSize + 1;
598  QuicConsumedData consumed = generator_.ConsumeData(
599      7, CreateData(data_len), 0, true, MUST_FEC_PROTECT, NULL);
600  EXPECT_EQ(data_len, consumed.bytes_consumed);
601  EXPECT_TRUE(creator_->IsFecGroupOpen());
602
603  // Change FEC groupsize.
604  generator_.OnCongestionWindowChange(2 * kDefaultTCPMSS);
605  EXPECT_EQ(2u, creator_->max_packets_per_fec_group());
606
607  // Send enough data to trigger one unprotected data packet,
608  // causing the FEC packet to also be sent.
609  {
610    InSequence dummy;
611    EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
612        SaveArg<0>(&packet4_));
613    EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
614        SaveArg<0>(&packet5_));
615  }
616  consumed = generator_.ConsumeData(7, CreateData(kDefaultMaxPacketSize), 0,
617                                    true, MAY_FEC_PROTECT, NULL);
618  EXPECT_EQ(kDefaultMaxPacketSize, consumed.bytes_consumed);
619  // Verify that one FEC packet was sent.
620  CheckPacketIsFec(packet5_, /*fec_group=*/1u);
621  EXPECT_FALSE(creator_->IsFecGroupOpen());
622  EXPECT_FALSE(creator_->IsFecProtected());
623}
624
625TEST_F(QuicPacketGeneratorTest, SwitchFecOnOff) {
626  delegate_.SetCanWriteAnything();
627  creator_->set_max_packets_per_fec_group(2);
628  EXPECT_FALSE(creator_->IsFecProtected());
629
630  // Send one unprotected data packet.
631  EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
632        SaveArg<0>(&packet_));
633  QuicConsumedData consumed =
634      generator_.ConsumeData(5, CreateData(1u), 0, true, MAY_FEC_PROTECT,
635                             NULL);
636  EXPECT_EQ(1u, consumed.bytes_consumed);
637  EXPECT_FALSE(generator_.HasQueuedFrames());
638  EXPECT_FALSE(creator_->IsFecProtected());
639  // Verify that one data packet was sent.
640  PacketContents contents;
641  contents.num_stream_frames = 1;
642  CheckPacketContains(contents, packet_);
643
644  {
645    InSequence dummy;
646    EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
647        SaveArg<0>(&packet2_));
648    EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
649        SaveArg<0>(&packet3_));
650    EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
651        SaveArg<0>(&packet4_));
652    EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
653        SaveArg<0>(&packet5_));
654    EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
655        SaveArg<0>(&packet6_));
656  }
657  // Send enough data to create 3 packets with MUST_FEC_PROTECT flag.
658  size_t data_len = 2 * kDefaultMaxPacketSize + 100;
659  consumed = generator_.ConsumeData(7, CreateData(data_len), 0, true,
660                                    MUST_FEC_PROTECT, NULL);
661  EXPECT_EQ(data_len, consumed.bytes_consumed);
662  EXPECT_FALSE(generator_.HasQueuedFrames());
663
664  // Verify that two FEC packets were sent.
665  CheckPacketHasSingleStreamFrame(packet2_);
666  CheckPacketHasSingleStreamFrame(packet3_);
667  CheckPacketIsFec(packet4_, /*fec_group=*/2u);
668  CheckPacketHasSingleStreamFrame(packet5_);
669  CheckPacketIsFec(packet6_, /*fec_group=*/5u);  // Sent at the end of stream.
670
671  // Send one unprotected data packet.
672  EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
673        SaveArg<0>(&packet7_));
674  consumed = generator_.ConsumeData(7, CreateData(1u), 0, true,
675                                    MAY_FEC_PROTECT, NULL);
676  EXPECT_EQ(1u, consumed.bytes_consumed);
677  EXPECT_FALSE(generator_.HasQueuedFrames());
678  EXPECT_FALSE(creator_->IsFecProtected());
679  // Verify that one unprotected data packet was sent.
680  CheckPacketContains(contents, packet7_);
681}
682
683TEST_F(QuicPacketGeneratorTest, SwitchFecOnWithPendingFrameInCreator) {
684  delegate_.SetCanWriteAnything();
685  // Enable FEC.
686  creator_->set_max_packets_per_fec_group(2);
687
688  generator_.StartBatchOperations();
689  // Queue enough data to prevent a stream frame with a non-zero offset from
690  // fitting.
691  QuicConsumedData consumed = generator_.ConsumeData(
692      7, CreateData(1u), 0, true, MAY_FEC_PROTECT, NULL);
693  EXPECT_EQ(1u, consumed.bytes_consumed);
694  EXPECT_TRUE(creator_->HasPendingFrames());
695
696  // Queue protected data for sending. Should cause queued frames to be flushed.
697  EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
698      SaveArg<0>(&packet_));
699  EXPECT_FALSE(creator_->IsFecProtected());
700  consumed = generator_.ConsumeData(7, CreateData(1u), 0, true,
701                                    MUST_FEC_PROTECT, NULL);
702  EXPECT_EQ(1u, consumed.bytes_consumed);
703  PacketContents contents;
704  contents.num_stream_frames = 1;
705  // Transmitted packet was not FEC protected.
706  CheckPacketContains(contents, packet_);
707  EXPECT_TRUE(creator_->IsFecProtected());
708  EXPECT_TRUE(creator_->HasPendingFrames());
709}
710
711TEST_F(QuicPacketGeneratorTest, SwitchFecOnWithPendingFramesInGenerator) {
712  // Enable FEC.
713  creator_->set_max_packets_per_fec_group(2);
714
715  // Queue control frames in generator.
716  delegate_.SetCanNotWrite();
717  generator_.SetShouldSendAck(true, true);
718  delegate_.SetCanWriteAnything();
719  generator_.StartBatchOperations();
720
721  // Set up frames to write into the creator when control frames are written.
722  EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame()));
723  EXPECT_CALL(delegate_, CreateFeedbackFrame()).WillOnce(
724      Return(CreateFeedbackFrame()));
725  EXPECT_CALL(delegate_, CreateStopWaitingFrame()).WillOnce(
726      Return(CreateStopWaitingFrame()));
727
728  // Generator should have queued control frames, and creator should be empty.
729  EXPECT_TRUE(generator_.HasQueuedFrames());
730  EXPECT_FALSE(creator_->HasPendingFrames());
731  EXPECT_FALSE(creator_->IsFecProtected());
732
733  // Queue protected data for sending. Should cause queued frames to be flushed.
734  EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
735      SaveArg<0>(&packet_));
736  QuicConsumedData consumed = generator_.ConsumeData(7, CreateData(1u), 0, true,
737                                                     MUST_FEC_PROTECT, NULL);
738  EXPECT_EQ(1u, consumed.bytes_consumed);
739  PacketContents contents;
740  contents.num_ack_frames = 1;
741  contents.num_feedback_frames = 1;
742  contents.num_stop_waiting_frames = 1;
743  CheckPacketContains(contents, packet_);
744
745  // FEC protection should be on in creator.
746  EXPECT_TRUE(creator_->IsFecProtected());
747}
748
749TEST_F(QuicPacketGeneratorTest, SwitchFecOnOffWithSubsequentFramesProtected) {
750  delegate_.SetCanWriteAnything();
751
752  // Enable FEC.
753  creator_->set_max_packets_per_fec_group(2);
754  EXPECT_FALSE(creator_->IsFecProtected());
755
756  // Queue stream frame to be protected in creator.
757  generator_.StartBatchOperations();
758  QuicConsumedData consumed = generator_.ConsumeData(5, CreateData(1u), 0, true,
759                                                     MUST_FEC_PROTECT, NULL);
760  EXPECT_EQ(1u, consumed.bytes_consumed);
761  // Creator has a pending protected frame.
762  EXPECT_TRUE(creator_->HasPendingFrames());
763  EXPECT_TRUE(creator_->IsFecProtected());
764
765  // Add enough unprotected data to exceed size of current packet, so that
766  // current packet is sent. Both frames will be sent out in a single packet.
767  EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(SaveArg<0>(&packet_));
768  size_t data_len = kDefaultMaxPacketSize;
769  consumed = generator_.ConsumeData(5, CreateData(data_len), 0, true,
770                                    MAY_FEC_PROTECT, NULL);
771  EXPECT_EQ(data_len, consumed.bytes_consumed);
772  PacketContents contents;
773  contents.num_stream_frames = 2u;
774  contents.fec_group = 1u;
775  CheckPacketContains(contents, packet_);
776  // FEC protection should still be on in creator.
777  EXPECT_TRUE(creator_->IsFecProtected());
778}
779
780TEST_F(QuicPacketGeneratorTest, SwitchFecOnOffWithSubsequentPacketsProtected) {
781  delegate_.SetCanWriteAnything();
782
783  // Enable FEC.
784  creator_->set_max_packets_per_fec_group(2);
785  EXPECT_FALSE(creator_->IsFecProtected());
786
787  generator_.StartBatchOperations();
788  // Send first packet, FEC protected.
789  EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(SaveArg<0>(&packet_));
790  // Write enough data to cause a packet to be emitted.
791  size_t data_len = kDefaultMaxPacketSize;
792  QuicConsumedData consumed = generator_.ConsumeData(
793      5, CreateData(data_len), 0, true, MUST_FEC_PROTECT, NULL);
794  EXPECT_EQ(data_len, consumed.bytes_consumed);
795  PacketContents contents;
796  contents.num_stream_frames = 1u;
797  contents.fec_group = 1u;
798  CheckPacketContains(contents, packet_);
799
800  // FEC should still be on in creator.
801  EXPECT_TRUE(creator_->IsFecProtected());
802
803  // Send enough unprotected data to cause second packet to be sent, which gets
804  // protected because it happens to fall within an open FEC group. Data packet
805  // will be followed by FEC packet.
806  {
807    InSequence dummy;
808    EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
809        SaveArg<0>(&packet2_));
810    EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
811        SaveArg<0>(&packet3_));
812  }
813  consumed = generator_.ConsumeData(5, CreateData(data_len), 0, true,
814                                    MAY_FEC_PROTECT, NULL);
815  EXPECT_EQ(data_len, consumed.bytes_consumed);
816  contents.num_stream_frames = 2u;
817  CheckPacketContains(contents, packet2_);
818  CheckPacketIsFec(packet3_, /*fec_group=*/1u);
819
820  // FEC protection should be off in creator.
821  EXPECT_FALSE(creator_->IsFecProtected());
822}
823
824TEST_F(QuicPacketGeneratorTest, SwitchFecOnOffThenOnWithCreatorProtectionOn) {
825  delegate_.SetCanWriteAnything();
826  generator_.StartBatchOperations();
827
828  // Enable FEC.
829  creator_->set_max_packets_per_fec_group(2);
830  EXPECT_FALSE(creator_->IsFecProtected());
831
832  // Queue one byte of FEC protected data.
833  QuicConsumedData consumed = generator_.ConsumeData(5, CreateData(1u), 0, true,
834                                                     MUST_FEC_PROTECT, NULL);
835  EXPECT_TRUE(creator_->HasPendingFrames());
836
837  // Add more unprotected data causing first packet to be sent, FEC protected.
838  EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
839      SaveArg<0>(&packet_));
840  size_t data_len = kDefaultMaxPacketSize;
841  consumed = generator_.ConsumeData(5, CreateData(data_len), 0, true,
842                                    MAY_FEC_PROTECT, NULL);
843  EXPECT_EQ(data_len, consumed.bytes_consumed);
844  PacketContents contents;
845  contents.num_stream_frames = 2u;
846  contents.fec_group = 1u;
847  CheckPacketContains(contents, packet_);
848
849  // FEC group is still open in creator.
850  EXPECT_TRUE(creator_->IsFecProtected());
851
852  // Add data that should be protected, large enough to cause second packet to
853  // be sent. Data packet should be followed by FEC packet.
854  {
855    InSequence dummy;
856    EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
857        SaveArg<0>(&packet2_));
858    EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
859        SaveArg<0>(&packet3_));
860  }
861  consumed = generator_.ConsumeData(5, CreateData(data_len), 0, true,
862                                    MUST_FEC_PROTECT, NULL);
863  EXPECT_EQ(data_len, consumed.bytes_consumed);
864  CheckPacketContains(contents, packet2_);
865  CheckPacketIsFec(packet3_, /*fec_group=*/1u);
866
867  // FEC protection should remain on in creator.
868  EXPECT_TRUE(creator_->IsFecProtected());
869}
870
871TEST_F(QuicPacketGeneratorTest, NotWritableThenBatchOperations) {
872  delegate_.SetCanNotWrite();
873
874  generator_.SetShouldSendAck(true, false);
875  generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
876  EXPECT_TRUE(generator_.HasQueuedFrames());
877
878  delegate_.SetCanWriteAnything();
879
880  generator_.StartBatchOperations();
881
882  // When the first write operation is invoked, the ack and feedback
883  // frames will be returned.
884  EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame()));
885  EXPECT_CALL(delegate_, CreateFeedbackFrame()).WillOnce(
886      Return(CreateFeedbackFrame()));
887
888  // Send some data and a control frame
889  generator_.ConsumeData(3, MakeIOVector("quux"), 7, false,
890                         MAY_FEC_PROTECT, NULL);
891  generator_.AddControlFrame(QuicFrame(CreateGoAwayFrame()));
892
893  // All five frames will be flushed out in a single packet.
894  EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(SaveArg<0>(&packet_));
895  generator_.FinishBatchOperations();
896  EXPECT_FALSE(generator_.HasQueuedFrames());
897
898  PacketContents contents;
899  contents.num_ack_frames = 1;
900  contents.num_goaway_frames = 1;
901  contents.num_feedback_frames = 1;
902  contents.num_rst_stream_frames = 1;
903  contents.num_stream_frames = 1;
904  CheckPacketContains(contents, packet_);
905}
906
907TEST_F(QuicPacketGeneratorTest, NotWritableThenBatchOperations2) {
908  delegate_.SetCanNotWrite();
909
910  generator_.SetShouldSendAck(true, false);
911  generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
912  EXPECT_TRUE(generator_.HasQueuedFrames());
913
914  delegate_.SetCanWriteAnything();
915
916  generator_.StartBatchOperations();
917
918  // When the first write operation is invoked, the ack and feedback
919  // frames will be returned.
920  EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame()));
921  EXPECT_CALL(delegate_, CreateFeedbackFrame()).WillOnce(
922      Return(CreateFeedbackFrame()));
923
924  {
925    InSequence dummy;
926    // All five frames will be flushed out in a single packet
927    EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
928        SaveArg<0>(&packet_));
929    EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
930        SaveArg<0>(&packet2_));
931  }
932
933  // Send enough data to exceed one packet
934  size_t data_len = kDefaultMaxPacketSize + 100;
935  QuicConsumedData consumed =
936      generator_.ConsumeData(3, CreateData(data_len), 0, true,
937                             MAY_FEC_PROTECT, NULL);
938  EXPECT_EQ(data_len, consumed.bytes_consumed);
939  EXPECT_TRUE(consumed.fin_consumed);
940  generator_.AddControlFrame(QuicFrame(CreateGoAwayFrame()));
941
942  generator_.FinishBatchOperations();
943  EXPECT_FALSE(generator_.HasQueuedFrames());
944
945  // The first packet should have the queued data and part of the stream data.
946  PacketContents contents;
947  contents.num_ack_frames = 1;
948  contents.num_feedback_frames = 1;
949  contents.num_rst_stream_frames = 1;
950  contents.num_stream_frames = 1;
951  CheckPacketContains(contents, packet_);
952
953  // The second should have the remainder of the stream data.
954  PacketContents contents2;
955  contents2.num_goaway_frames = 1;
956  contents2.num_stream_frames = 1;
957  CheckPacketContains(contents2, packet2_);
958}
959
960}  // namespace test
961}  // namespace net
962