Make QuicPacketCreator be able to serialize packet itself when it does not have room for next strea…

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.
 
 #ifndef NET_QUIC_QUIC_PACKET_CREATOR_H_
 #define NET_QUIC_QUIC_PACKET_CREATOR_H_
@@ skipping 11 matching lines @@
 namespace net {
 namespace test {
 class QuicPacketCreatorPeer;
 }
 
 class QuicRandom;
 class QuicRandomBoolSource;
 
 class NET_EXPORT_PRIVATE QuicPacketCreator {
  public:
+  // A delegate interface for further processing serialized packet.
+  class DelegateInterface {
+   public:
+    virtual ~DelegateInterface() {}
+    // Called when a packet is serialized. Delegate does not take the ownership
+    // of |serialized_packet|.
+    virtual void OnSerializedPacket(SerializedPacket* serialized_packet) = 0;
+  };
+
   // QuicRandom* required for packet entropy.
   QuicPacketCreator(QuicConnectionId connection_id,
                     QuicFramer* framer,
-                    QuicRandom* random_generator);
+                    QuicRandom* random_generator,
+                    DelegateInterface* delegate);
 
   ~QuicPacketCreator();
 
   // 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
   // has any open FEC group, call will fail. It is the caller's responsibility
@@ skipping 21 matching lines @@
                                 QuicPacketCount max_packets_in_flight);
 
   // The overhead the framing will add for a packet with one frame.
   static size_t StreamFramePacketOverhead(
       QuicConnectionIdLength connection_id_length,
       bool include_version,
       QuicPacketNumberLength packet_number_length,
       QuicStreamOffset offset,
       InFecGroup is_in_fec_group);
 
-  // Converts a raw payload to a stream frame (which fits into the currently
-  // open packet) and adds the frame to the packet. The payload begins at
-  // |iov_offset| into the |iov|.
-  // Creates |frame| and returns true if succeeds, false otherwise.
+  // Returns false and flushes all pending frames if current open packet is
+  // full.
+  // If current packet is not full, converts a raw payload into a stream frame
+  // that fits into the open packet and adds it to the packet.
+  // The payload begins at |iov_offset| into the |iov|.
   bool ConsumeData(QuicStreamId id,
                    QuicIOVector iov,
                    size_t iov_offset,
                    QuicStreamOffset offset,
                    bool fin,
                    bool needs_padding,
                    QuicFrame* frame);
 
-  // Returns true if currently open packet can accommodate more stream frames of
+  // Returns true if current open packet can accommodate more stream frames of
   // stream |id| at |offset|, false otherwise.
   bool HasRoomForStreamFrame(QuicStreamId id, QuicStreamOffset offset) const;
 
   // Serializes all frames into a single packet. All frames must fit into a
   // single packet. Also, sets the entropy hash of the serialized packet to a
   // random bool and returns that value as a member of SerializedPacket.
   // Never returns a RetransmittableFrames in SerializedPacket.
   SerializedPacket SerializeAllFrames(const QuicFrames& frames,
                                       char* buffer,
                                       size_t buffer_len);
 
   // Re-serializes frames with the original packet's packet number length.
   // Used for retransmitting packets to ensure they aren't too long.
   // Caller must ensure that any open FEC group is closed before calling this
   // method.
   SerializedPacket ReserializeAllFrames(const RetransmittableFrames& frames,
                                         QuicPacketNumberLength original_length,
                                         char* buffer,
                                         size_t buffer_len);
 
+  // Serializes all added frames into a single packet and invokes the delegate_
+  // to further process the SerializedPacket.
+  void Flush();
+
   // Returns true if there are frames pending to be serialized.
   bool HasPendingFrames() const;
 
   // Returns true if there are retransmittable frames pending to be serialized.
   bool HasPendingRetransmittableFrames() const;
 
   // TODO(jri): Remove this method.
   // Returns whether FEC protection is currently enabled. Note: Enabled does not
   // mean that an FEC group is currently active; i.e., IsFecProtected() may
   // still return false.
@@ skipping 19 matching lines @@
 
   // Returns the number of bytes in the current packet, including the header,
   // if serialized with the current frames.  Adding a frame to the packet
   // may change the serialized length of existing frames, as per the comment
   // in BytesFree.
   size_t PacketSize() const;
 
   // TODO(jri): AddSavedFrame calls AddFrame, which only saves the frame
   // if it is a stream frame, not other types of frames. Fix this API;
   // add a AddNonSavedFrame method.
-  // Adds |frame| to the packet creator's list of frames to be serialized.
-  // Returns false if the frame doesn't fit into the current packet.
+  // Tries to add |frame| to the packet creator's std::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 takes ownership of the buffer.
   bool AddSavedFrame(const QuicFrame& frame, UniqueStreamBuffer buffer);
 
   // Identical to AddSavedFrame, but takes ownership of the buffer, and allows
   // to cause the packet to be padded.
   bool AddPaddedSavedFrame(const QuicFrame& frame, UniqueStreamBuffer buffer);
 
-  // Serializes all frames which have been added and adds any which should be
-  // retransmitted to |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);
-
   // Packetize FEC data. All frames must fit into a single packet. Also, sets
   // the entropy hash of the serialized packet to a random bool and returns
   // that value as a member of SerializedPacket.
   // Fails if |buffer_len| isn't long enough for the encrypted packet.
   SerializedPacket SerializeFec(char* buffer, size_t buffer_len);
 
   // 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.
@@ skipping 39 matching lines @@
   size_t max_packets_per_fec_group() const {
       return max_packets_per_fec_group_;
   }
 
   // Sets creator's max number of packets covered by an FEC group.
   // Note: While there are no constraints on |max_packets_per_fec_group|,
   // this setter enforces a min value of kLowestMaxPacketsPerFecGroup.
   // To turn off FEC protection, use StopFecProtectingPackets().
   void set_max_packets_per_fec_group(size_t max_packets_per_fec_group);
 
-  // Returns the currently open FEC group's number.  Returns 0 when FEC is
+  // Returns the current open FEC group's number.  Returns 0 when FEC is
   // disabled or no FEC group is open.
   QuicFecGroupNumber fec_group_number();
 
  private:
   friend class test::QuicPacketCreatorPeer;
 
   static bool ShouldRetransmit(const QuicFrame& frame);
 
-  // Converts a raw payload to a frame which fits into the currently open
+  // Converts a raw payload to a frame which fits into the current open
   // packet.  The payload begins at |iov_offset| into the |iov|.
   // Returns the number of bytes consumed from data.
   // If data is empty and fin is true, the expected behavior is to consume the
   // fin but return 0.  If any data is consumed, it will be copied into a
   // new buffer that |frame| will point to and will be stored in |buffer|.
   size_t CreateStreamFrame(QuicStreamId id,
                            QuicIOVector iov,
                            size_t iov_offset,
                            QuicStreamOffset offset,
                            bool fin,
@@ skipping 16 matching lines @@
   // |payload| is the non-encrypted FEC protected payload of the packet.
   void OnBuiltFecProtectedPayload(const QuicPacketHeader& header,
                                   base::StringPiece payload);
 
   void FillPacketHeader(QuicFecGroupNumber fec_group,
                         bool fec_flag,
                         QuicPacketHeader* header);
 
   // Allows a frame to be added without creating retransmittable frames.
   // Particularly useful for retransmits using SerializeAllFrames().
+  // If current open packet cannot accommodate |frame|, returns false and
+  // flushes all pending frames.
   bool AddFrame(const QuicFrame& frame,
                 bool save_retransmittable_frames,
                 bool needs_padding,
                 UniqueStreamBuffer buffer);
 
   // Adds a padding frame to the current packet only if the current packet
   // contains a handshake message, and there is sufficient room to fit a
   // padding frame.
   void MaybeAddPadding();
 
+  // 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);
+
+  // Does not own this delegate.
+  DelegateInterface* delegate_;
   QuicConnectionId connection_id_;
   EncryptionLevel encryption_level_;
   QuicFramer* framer_;
   scoped_ptr<QuicRandomBoolSource> random_bool_source_;
   QuicPacketNumber packet_number_;
   // If true, any created packets will be FEC protected.
   bool should_fec_protect_;
   scoped_ptr<QuicFecGroup> fec_group_;
   // Controls whether protocol version should be included while serializing the
   // packet.
@@ skipping 21 matching lines @@
   scoped_ptr<RetransmittableFrames> queued_retransmittable_frames_;
   // If true, the packet will be padded up to |max_packet_length_|.
   bool needs_padding_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicPacketCreator);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_PACKET_CREATOR_H_