Add ConsumeData method to QuicPacketCreator, ConsumeData wraps both CreateStreamFrame and AddFrame.…

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 56 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.
+  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
+  // stream |id| at |offset|, false otherwise.
   bool HasRoomForStreamFrame(QuicStreamId id, QuicStreamOffset offset) const;
 
-  // Converts a raw payload to a frame which fits into the currently 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,
-                           QuicFrame* frame,
-                           UniqueStreamBuffer* buffer);
-
   // 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.
@@ skipping 125 matching lines @@
 
   // Returns the currently 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
+  // 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,
+                           QuicFrame* frame,
+                           UniqueStreamBuffer* buffer);
+
   // Copies |length| bytes from iov starting at offset |iov_offset| into buffer.
   // |iov| must be at least iov_offset+length total length and buffer must be
   // at least |length| long.
   static void CopyToBuffer(QuicIOVector iov,
                            size_t iov_offset,
                            size_t length,
                            char* buffer);
 
   // Updates lengths and also starts an FEC group if FEC protection is on and
   // there is not already an FEC group open.
@@ skipping 54 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_