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

net/quic/quic_packet_creator.h

 // 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.
 //
 // Accumulates frames for the next packet until more frames no longer fit or
 // it's time to create a packet from them.  Also provides packet creation of
 // FEC packets based on previously created packets. If multipath enabled, only
 // creates packets on one path at the same time. Currently, next packet number
 // is tracked per-path.
 
@@ skipping 20 matching lines @@
 class QuicRandom;
 class QuicRandomBoolSource;
 
 class NET_EXPORT_PRIVATE QuicPacketCreator {
  public:
   // A delegate interface for further processing serialized packet.
   class NET_EXPORT_PRIVATE DelegateInterface {
    public:
     virtual ~DelegateInterface() {}
     // Called when a packet is serialized. Delegate does not take the ownership
-    // of |serialized_packet|.
+    // of |serialized_packet|, but may take ownership of |packet.packet|
+    // and |packet.retransmittable_frames|.  If it does so, they must be set
+    // to nullptr.
     virtual void OnSerializedPacket(SerializedPacket* serialized_packet) = 0;
+    virtual void CloseConnection(QuicErrorCode error, bool from_peer) = 0;
     // Called when current FEC group is reset (closed).
     virtual void OnResetFecGroup() = 0;
   };
 
   // Interface which gets callbacks from the QuicPacketCreator at interesting
   // points.  Implementations must not mutate the state of the creator
   // as a result of these callbacks.
   class NET_EXPORT_PRIVATE DebugDelegate {
    public:
     virtual ~DebugDelegate() {}
@@ skipping 117 matching lines @@
   size_t PacketSize() const;
 
   // Tries to add |frame| to the packet creator's list of frames to be
   // serialized. If the frame does not fit into the current packet, flushes the
   // packet and returns false.
   bool AddSavedFrame(const QuicFrame& frame);
 
   // Identical to AddSavedFrame, but allows the frame to be padded.
   bool AddPaddedSavedFrame(const QuicFrame& frame);
 
+  // Adds |listener| to the next serialized packet and notifies the
+  // std::listener
+  // with |length| as the number of acked bytes.
+  void AddAckListener(QuicAckListenerInterface* listener,
+                      QuicPacketLength length);
+
   // Creates a version negotiation packet which supports |supported_versions|.
   // Caller owns the created  packet. Also, sets the entropy hash of the
   // serialized packet to a random bool and returns that value as a member of
   // SerializedPacket.
   QuicEncryptedPacket* SerializeVersionNegotiationPacket(
       const QuicVersionVector& supported_versions);
 
   // Returns a dummy packet that is valid but contains no useful information.
   static SerializedPacket NoPacket();
 
@@ skipping 134 matching lines @@
   // Serializes all frames which have been added and adds any which should be
   // retransmitted to queued_retransmittable_frames_ if it's not nullptr. All
   // frames must fit into a single packet. Sets the entropy hash of the
   // serialized packet to a random bool and returns that value as a member of
   // SerializedPacket. Also, sets |serialized_frames| in the SerializedPacket to
   // the corresponding RetransmittableFrames if any frames are to be
   // retransmitted.
   // Fails if |buffer_len| isn't long enough for the encrypted packet.
   SerializedPacket SerializePacket(char* encrypted_buffer, size_t buffer_len);
 
+  // Called after a new SerialiedPacket is created to call the delegate's
+  // OnSerializedPacket, reset state, and potentially flush FEC groups.
+  void OnSerializedPacket(SerializedPacket* packet);
+
   // Turn on FEC protection for subsequent packets. If no FEC group is currently
   // open, this method flushes current open packet and then turns FEC on.
   void MaybeStartFecProtection();
 
   // Turn on FEC protection for subsequently created packets. FEC should be
   // enabled first (max_packets_per_fec_group should be non-zero) for FEC
   // protection to start.
   void StartFecProtectingPackets();
 
   // Turn off FEC protection for subsequently created packets. If the creator
@@ skipping 58 matching lines @@
   // is empty.
   mutable QuicPacketNumberLength packet_number_length_;
   // packet_size_ is mutable because it's just a cache of the current size.
   // packet_size should never be read directly, use PacketSize() instead.
   mutable size_t packet_size_;
   mutable size_t max_plaintext_size_;
   QuicFrames queued_frames_;
   scoped_ptr<RetransmittableFrames> queued_retransmittable_frames_;
   // If true, the packet will be padded up to |max_packet_length_|.
   bool needs_padding_;
+  // Stores ack std::listeners that should be attached to the next packet.
+  std::list<AckListenerWrapper> ack_listeners_;
+
   // FEC policy that specifies when to send FEC packet.
   FecSendPolicy fec_send_policy_;
   // Timeout used for FEC alarm. Can be set to zero initially or if the SRTT has
   // not yet been set.
   QuicTime::Delta fec_timeout_;
   // The multiplication factor for FEC timeout based on RTT.
   // TODO(rtenneti): Delete this code after the 0.25 RTT FEC experiment.
   float rtt_multiplier_for_fec_timeout_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicPacketCreator);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_PACKET_CREATOR_H_