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

net/quic/quic_packet_creator.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 <algorithm>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 435 matching lines @@
 void QuicPacketCreator::Flush() {
   if (!HasPendingFrames()) {
     return;
   }
 
   // TODO(rtenneti): Change the default 64 alignas value (used the default
   // value from CACHELINE_SIZE).
   ALIGNAS(64) char seralized_packet_buffer[kMaxPacketSize];
   SerializedPacket serialized_packet =
       SerializePacket(seralized_packet_buffer, kMaxPacketSize);
-  delegate_->OnSerializedPacket(&serialized_packet);
+  OnSerializedPacket(&serialized_packet);
+}
+
+void QuicPacketCreator::OnSerializedPacket(SerializedPacket* packet) {
+  if (packet->packet == nullptr) {
+    LOG(DFATAL) << "Failed to SerializePacket. fec_policy:" << fec_send_policy()
+                << " should_fec_protect_:" << should_fec_protect_next_packet();
+    delegate_->CloseConnection(QUIC_FAILED_TO_SERIALIZE_PACKET, false);
+    return;
+  }
+  // There may be AckListeners interested in this packet.
+  packet->listeners.swap(ack_listeners_);
+  DCHECK(ack_listeners_.empty());
+  delegate_->OnSerializedPacket(packet);
+  has_ack_ = false;
+  has_stop_waiting_ = false;
+  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 (CanSetMaxPacketLength()) {
+    SetMaxPacketLength(max_packet_length_);
+  }
 }
 
 bool QuicPacketCreator::HasPendingFrames() const {
   return !queued_frames_.empty();
 }
 
 bool QuicPacketCreator::HasPendingRetransmittableFrames() const {
   return queued_retransmittable_frames_.get() != nullptr &&
          !queued_retransmittable_frames_->frames().empty();
 }
@@ skipping 35 matching lines @@
 }
 
 bool QuicPacketCreator::AddPaddedSavedFrame(const QuicFrame& frame) {
   if (AddFrame(frame, /*save_retransmittable_frames=*/true)) {
     needs_padding_ = true;
     return true;
   }
   return false;
 }
 
+void QuicPacketCreator::AddAckListener(QuicAckListenerInterface* listener,
+                                       QuicPacketLength length) {
+  DCHECK(!queued_frames_.empty());
+  ack_listeners_.push_back(AckListenerWrapper(listener, length));
+}
+
 SerializedPacket QuicPacketCreator::SerializePacket(
     char* encrypted_buffer,
     size_t encrypted_buffer_len) {
   DCHECK_LT(0u, encrypted_buffer_len);
   LOG_IF(DFATAL, queued_frames_.empty())
       << "Attempt to serialize empty packet";
   if (fec_group_.get() != nullptr) {
     DCHECK_GE(packet_number_ + 1, fec_group_->FecGroupNumber());
   }
   QuicPacketHeader header;
@@ skipping 51 matching lines @@
   }
 
   // Update |needs_padding_| flag of |queued_retransmittable_frames_| here, and
   // not in AddFrame, because when the first padded frame is added to the queue,
   // it might not be retransmittable, and hence the flag would end up being not
   // set.
   if (queued_retransmittable_frames_.get() != nullptr) {
     queued_retransmittable_frames_->set_needs_padding(needs_padding_);
   }
 
-  const bool has_ack = has_ack_;
-  const bool has_stop_waiting = has_stop_waiting_;
-  has_ack_ = false;
-  has_stop_waiting_ = false;
   packet_size_ = 0;
   queued_frames_.clear();
   needs_padding_ = false;
   return SerializedPacket(
       header.packet_number, header.public_header.packet_number_length,
       encrypted_buffer, encrypted_length, /* owns_buffer*/ false,
       QuicFramer::GetPacketEntropyHash(header),
-      queued_retransmittable_frames_.release(), has_ack, has_stop_waiting,
+      queued_retransmittable_frames_.release(), has_ack_, has_stop_waiting_,
       encryption_level_);
 }
 
 SerializedPacket QuicPacketCreator::SerializeFec(char* buffer,
                                                  size_t buffer_len) {
   DCHECK_LT(0u, buffer_len);
   if (fec_group_.get() == nullptr || fec_group_->NumReceivedPackets() <= 0) {
     LOG(DFATAL) << "SerializeFEC called but no group or zero packets in group.";
     // TODO(jri): Make this a public method of framer?
     return NoPacket();
@@ skipping 139 matching lines @@
   if (ShouldSendFec(force_send_fec)) {
     if (fec_send_policy_ == FEC_ALARM_TRIGGER && !is_fec_timeout) {
       ResetFecGroup();
       delegate_->OnResetFecGroup();
     } else {
       // TODO(zhongyi): Change the default 64 alignas value (used the default
       // value from CACHELINE_SIZE).
       ALIGNAS(64) char seralized_fec_buffer[kMaxPacketSize];
       SerializedPacket serialized_fec =
           SerializeFec(seralized_fec_buffer, kMaxPacketSize);
-      delegate_->OnSerializedPacket(&serialized_fec);
+      OnSerializedPacket(&serialized_fec);
     }
   }
 
   if (!should_fec_protect_next_packet_ && fec_protect_ && !IsFecGroupOpen()) {
     StopFecProtectingPackets();
   }
 }
 
 QuicTime::Delta QuicPacketCreator::GetFecTimeout(
     QuicPacketNumber packet_number) {
@@ skipping 39 matching lines @@
   hash_map<QuicPathId, QuicPacketNumber>::iterator it =
       multipath_packet_number_.find(path_id);
   // If path_id is not in the map, it's a new path. Set packet_number to 0.
   packet_number_ = it == multipath_packet_number_.end() ? 0 : it->second;
   current_path_ = path_id;
   // Switching path needs to update packet number length.
   UpdatePacketNumberLength(least_packet_awaited_by_peer, max_packets_in_flight);
 }
 
 }  // namespace net