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

net/quic/quic_packet_generator.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 "base/basictypes.h"
 #include "base/logging.h"
 #include "net/quic/quic_fec_group.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
 
 namespace net {
 
 class QuicAckNotifier;
 
 QuicPacketGenerator::QuicPacketGenerator(QuicConnectionId connection_id,
                                          QuicFramer* framer,
                                          QuicRandom* random_generator,
                                          DelegateInterface* delegate)
     : delegate_(delegate),
-      packet_creator_(connection_id, framer, random_generator, this),
+      packet_creator_(connection_id, framer, random_generator, delegate),
       batch_mode_(false),
       should_send_ack_(false),
       should_send_stop_waiting_(false),
       max_packet_length_(kDefaultMaxPacketSize) {}
 
 QuicPacketGenerator::~QuicPacketGenerator() {
   for (QuicFrame& frame : queued_control_frames_) {
     switch (frame.type) {
       case PADDING_FRAME:
       case MTU_DISCOVERY_FRAME:
@@ skipping 90 matching lines @@
     QuicFrame frame;
     if (!packet_creator_.ConsumeData(id, iov, total_bytes_consumed,
                                      offset + total_bytes_consumed, fin,
                                      has_handshake, &frame, fec_protection)) {
       // Current packet is full and flushed.
       continue;
     }
 
     // A stream frame is created and added.
     size_t bytes_consumed = frame.stream_frame->frame_length;
-
     if (listener != nullptr) {
-      ack_listeners_.push_back(AckListenerWrapper(listener, bytes_consumed));
+      packet_creator_.AddAckListener(listener, bytes_consumed);
     }
-
     total_bytes_consumed += bytes_consumed;
     fin_consumed = fin && total_bytes_consumed == iov.total_length;
     DCHECK(total_bytes_consumed == iov.total_length ||
            (bytes_consumed > 0 && packet_creator_.HasPendingFrames()));
 
     if (!InBatchMode()) {
       // TODO(rtenneti): remove MaybeSendFecPacketAndCloseGroup() from inside
       // SerializeAndSendPacket() and make it an explicit call here (and
       // elsewhere where we call SerializeAndSendPacket?).
       packet_creator_.Flush();
@@ skipping 35 matching lines @@
 
   // The MTU discovery frame is allocated on the stack, since it is going to be
   // serialized within this function.
   QuicMtuDiscoveryFrame mtu_discovery_frame;
   QuicFrame frame(mtu_discovery_frame);
 
   // Send the probe packet with the new length.
   SetMaxPacketLength(target_mtu, /*force=*/true);
   const bool success = packet_creator_.AddPaddedSavedFrame(frame);
   if (listener != nullptr) {
-    ack_listeners_.push_back(AckListenerWrapper(listener, 0));
+    packet_creator_.AddAckListener(listener, 0);
   }
   packet_creator_.Flush();
   // The only reason AddFrame can fail is that the packet is too full to fit in
   // a ping.  This is not possible for any sane MTU.
   DCHECK(success);
 
   // Reset the packet length back.
   SetMaxPacketLength(current_mtu, /*force=*/true);
 }
 
@@ skipping 163 matching lines @@
 
 void QuicPacketGenerator::set_encryption_level(EncryptionLevel level) {
   packet_creator_.set_encryption_level(level);
 }
 
 void QuicPacketGenerator::SetEncrypter(EncryptionLevel level,
                                        QuicEncrypter* encrypter) {
   packet_creator_.SetEncrypter(level, encrypter);
 }
 
-void QuicPacketGenerator::OnSerializedPacket(
-    SerializedPacket* serialized_packet) {
-  if (serialized_packet->packet == nullptr) {
-    LOG(DFATAL) << "Failed to SerializePacket. fec_policy:" << fec_send_policy()
-                << " should_fec_protect_:"
-                << packet_creator_.should_fec_protect_next_packet();
-    delegate_->CloseConnection(QUIC_FAILED_TO_SERIALIZE_PACKET, false);
-    return;
-  }
-
-  // There may be AckListeners interested in this packet.
-  serialized_packet->listeners.swap(ack_listeners_);
-  ack_listeners_.clear();
-
-  delegate_->OnSerializedPacket(*serialized_packet);
-  packet_creator_.MaybeSendFecPacketAndCloseGroup(/*force_send_fec=*/false,
-                                                  /*is_fec_timeout=*/false);
-
-  // Maximum packet size may be only enacted while no packet is currently being
-  // constructed, so here we have a good opportunity to actually change it.
-  if (packet_creator_.CanSetMaxPacketLength()) {
-    packet_creator_.SetMaxPacketLength(max_packet_length_);
-  }
-}
-
-void QuicPacketGenerator::OnResetFecGroup() {
-  delegate_->OnResetFecGroup();
-}
-
 void QuicPacketGenerator::SetCurrentPath(
     QuicPathId path_id,
     QuicPacketNumber least_packet_awaited_by_peer,
     QuicPacketCount max_packets_in_flight) {
   packet_creator_.SetCurrentPath(path_id, least_packet_awaited_by_peer,
                                  max_packets_in_flight);
 }
 
 void QuicPacketGenerator::set_rtt_multiplier_for_fec_timeout(
     float rtt_multiplier_for_fec_timeout) {
   packet_creator_.set_rtt_multiplier_for_fec_timeout(
       rtt_multiplier_for_fec_timeout);
 }
 
 FecSendPolicy QuicPacketGenerator::fec_send_policy() {
   return packet_creator_.fec_send_policy();
 }
 
 void QuicPacketGenerator::set_fec_send_policy(FecSendPolicy fec_send_policy) {
   packet_creator_.set_fec_send_policy(fec_send_policy);
 }
 
 }  // namespace net