QuicPacketCreator knows when to start FEC protection.

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 34 matching lines @@
                     QuicFramer* framer,
                     QuicRandom* random_generator,
                     DelegateInterface* delegate);
 
   ~QuicPacketCreator();
 
   // Checks if it's time to send an FEC packet.  |force_close| forces this to
   // return true if an FEC group is open.
   bool ShouldSendFec(bool force_close) const;
 
-  // 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();
-
   // If ShouldSendFec returns true, serializes currently constructed FEC packet
   // and calls the delegate on the packet. Resets current FEC group if FEC
   // protection policy is FEC_ALARM_TRIGGER but |is_fec_timeout| is false.
-  // Also tries to turn off FEC protection if should_fec_protect_ is false.
+  // Also tries to turn off FEC protection if should_fec_protect_next_packet is
+  // false.
   void MaybeSendFecPacketAndCloseGroup(bool force_send_fec,
                                        bool is_fec_timeout);
 
   // Returns true if an FEC packet is under construction.
   bool IsFecGroupOpen() const;
 
   // Called after sending |packet_number| to determine whether an FEC alarm
   // should be set for sending out an FEC packet. Returns a positive and finite
   // timeout if an FEC alarm should be set, and infinite if no alarm should be
   // set.
@@ skipping 13 matching lines @@
       bool include_version,
       QuicPacketNumberLength packet_number_length,
       QuicStreamOffset offset,
       InFecGroup is_in_fec_group);
 
   // 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|.
+  // Also tries to start FEC protection depends on |fec_protection|.
   bool ConsumeData(QuicStreamId id,
                    QuicIOVector iov,
                    size_t iov_offset,
                    QuicStreamOffset offset,
                    bool fin,
                    bool needs_padding,
-                   QuicFrame* frame);
+                   QuicFrame* frame,
+                   FecProtection fec_protection);
 
   // 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,
@@ skipping 118 matching lines @@
 
   void set_fec_send_policy(FecSendPolicy fec_send_policy) {
     fec_send_policy_ = fec_send_policy;
   }
 
   void set_rtt_multiplier_for_fec_timeout(
       float rtt_multiplier_for_fec_timeout) {
     rtt_multiplier_for_fec_timeout_ = rtt_multiplier_for_fec_timeout;
   }
 
-  bool should_fec_protect() { return should_fec_protect_; }
+  bool should_fec_protect_next_packet() {
+    return should_fec_protect_next_packet_;
+  }
 
-  void set_should_fec_protect(bool should_fec_protect) {
-    should_fec_protect_ = should_fec_protect;
+  void set_should_fec_protect_next_packet(bool should_fec_protect_next_packet) {
+    should_fec_protect_next_packet_ = should_fec_protect_next_packet;
   }
 
  private:
   friend class test::QuicPacketCreatorPeer;
 
   static bool ShouldRetransmit(const QuicFrame& frame);
 
   // 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.
@@ skipping 45 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);
 
+  // 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
   // has any open FEC group, call will fail. It is the caller's responsibility
   // to flush out FEC packets in generation, and to verify with ShouldSendFec()
   // that there is no open FEC group.
   void StopFecProtectingPackets();
 
   // Resets (closes) the FEC group. This method should only be called on a
   // packet boundary.
   void ResetFecGroup();
 
   // 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);
 
   // Does not own this delegate.
   DelegateInterface* delegate_;
   QuicConnectionId connection_id_;
   EncryptionLevel encryption_level_;
   QuicFramer* framer_;
   scoped_ptr<QuicRandomBoolSource> random_bool_source_;
   QuicPacketNumber packet_number_;
   // True when creator is requested to turn on FEC protection. False otherwise.
-  // There could be a time difference between should_fec_protect_ is true/false
-  // and FEC is actually turned on/off (e.g., The creator may have an open FEC
-  // group even if this variable is false).
-  bool should_fec_protect_;
+  // There is a time difference between should_fec_protect_next_packet is
+  // true/false and FEC is actually turned on/off (e.g., The creator may have an
+  // open FEC group even if this variable is false).
+  bool should_fec_protect_next_packet_;
   // If true, any created packets will be FEC protected.
-  // TODO(fayang): Combine should_fec_protect_ and fec_protect_ to one variable.
+  // TODO(fayang): Combine should_fec_protect_next_packet and fec_protect_ to
+  // one variable.
   bool fec_protect_;
   scoped_ptr<QuicFecGroup> fec_group_;
   // Controls whether protocol version should be included while serializing the
   // packet.
   bool send_version_in_packet_;
   // Maximum length including headers and encryption (UDP payload length.)
   QuicByteCount max_packet_length_;
   // 0 indicates FEC is disabled.
   size_t max_packets_per_fec_group_;
   // Length of connection_id to send over the wire.
@@ skipping 23 matching lines @@
   // 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_