Roll Chrome into Mojo.

net/quic/quic_packet_generator_test.cc

 // 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_generator.h"
 
 #include <string>
 
 #include "net/quic/crypto/crypto_protocol.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_utils.h"
 #include "net/quic/test_tools/quic_packet_creator_peer.h"
 #include "net/quic/test_tools/quic_packet_generator_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/simple_quic_framer.h"
+#include "net/test/gtest_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::StringPiece;
 using std::string;
 using testing::InSequence;
 using testing::Return;
 using testing::SaveArg;
 using testing::StrictMock;
 using testing::_;
@@ skipping 393 matching lines @@
       kHeadersStreamId, MakeIOVector("foo"), 2, true, MAY_FEC_PROTECT, nullptr);
   EXPECT_EQ(3u, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
   EXPECT_FALSE(generator_.HasQueuedFrames());
 
   PacketContents contents;
   contents.num_stream_frames = 1;
   CheckPacketContains(contents, packet_);
 }
 
+TEST_F(QuicPacketGeneratorTest, ConsumeData_EmptyData) {
+  ValueRestore<bool> old_flag(&FLAGS_quic_empty_data_no_fin_early_return, true);
+  EXPECT_DFATAL(generator_.ConsumeData(kHeadersStreamId, MakeIOVector(""), 0,
+                                       false, MAY_FEC_PROTECT, nullptr),
+                "Attempt to consume empty data without FIN.");
+}
+
 TEST_F(QuicPacketGeneratorTest,
        ConsumeDataMultipleTimes_WritableAndShouldNotFlush) {
   delegate_.SetCanWriteAnything();
   generator_.StartBatchOperations();
 
   generator_.ConsumeData(kHeadersStreamId, MakeIOVector("foo"), 2, true,
                          MAY_FEC_PROTECT, nullptr);
   QuicConsumedData consumed = generator_.ConsumeData(
       3, MakeIOVector("quux"), 7, false, MAY_FEC_PROTECT, nullptr);
   EXPECT_EQ(4u, consumed.bytes_consumed);
@@ skipping 129 matching lines @@
   EXPECT_EQ(3u, consumed.bytes_consumed);
   EXPECT_TRUE(consumed.fin_consumed);
   EXPECT_FALSE(generator_.HasQueuedFrames());
 
   PacketContents contents;
   contents.num_stream_frames = 1;
   CheckPacketContains(contents, packet_);
   CheckPacketContains(contents, packet2_);
 }
 
+TEST_F(QuicPacketGeneratorTest, FecTimeoutOnRttChange) {
+  EXPECT_EQ(QuicTime::Delta::Zero(), generator_.fec_timeout());
+  generator_.OnRttChange(QuicTime::Delta::FromMilliseconds(300));
+  EXPECT_EQ(QuicTime::Delta::FromMilliseconds(150), generator_.fec_timeout());
+}
+
 TEST_F(QuicPacketGeneratorTest, FecGroupSizeOnCongestionWindowChange) {
   delegate_.SetCanWriteAnything();
   creator_->set_max_packets_per_fec_group(50);
   EXPECT_EQ(50u, creator_->max_packets_per_fec_group());
   EXPECT_FALSE(creator_->IsFecGroupOpen());
 
   // On reduced cwnd.
   generator_.OnCongestionWindowChange(7);
   EXPECT_EQ(3u, creator_->max_packets_per_fec_group());
 
@@ skipping 405 matching lines @@
   generator_.SetConnectionIdLength(7);
   EXPECT_EQ(PACKET_8BYTE_CONNECTION_ID, creator_->connection_id_length());
   generator_.SetConnectionIdLength(8);
   EXPECT_EQ(PACKET_8BYTE_CONNECTION_ID, creator_->connection_id_length());
   generator_.SetConnectionIdLength(9);
   EXPECT_EQ(PACKET_8BYTE_CONNECTION_ID, creator_->connection_id_length());
 }
 
 }  // namespace test
 }  // namespace net