Remove QuicPacketGenerator::OnSerializedPacket with functionality in QuicPacketCreator. No functio…

net/quic/quic_packet_creator_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_creator.h"
 
 #include <stdint.h>
 
 #include "base/stl_util.h"
 #include "net/quic/crypto/null_encrypter.h"
@@ skipping 63 matching lines @@
   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;
@@ skipping 781 matching lines @@
         &creator_, kClientDataStreamId1, io_vector, 0u, kOffset, false, &frame);
     EXPECT_EQ(capacity - bytes_free, bytes_consumed);
 
     ASSERT_TRUE(creator_.AddSavedFrame(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;
-    EXPECT_CALL(delegate_, OnSerializedPacket(_))
-        .WillOnce(Invoke(this, &QuicPacketCreatorTest::SaveSerializedPacket));
+    {
+      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);
@@ skipping 615 matching lines @@
   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_));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net