Landing Recent QUIC changes until 01/28/2016 18:41 UTC

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.
 
 #ifndef NET_QUIC_QUIC_PACKET_CREATOR_H_
 #define NET_QUIC_QUIC_PACKET_CREATOR_H_
 
 #include <stddef.h>
 
 #include <string>
+#include <unordered_map>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_piece.h"
 #include "net/quic/quic_fec_group.h"
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_protocol.h"
 
@@ skipping 93 matching lines @@
                    QuicIOVector iov,
                    size_t iov_offset,
                    QuicStreamOffset offset,
                    bool fin,
                    bool needs_padding,
                    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,
-                                      char* buffer,
-                                      size_t buffer_len);
+  bool HasRoomForStreamFrame(QuicStreamId id, QuicStreamOffset offset);
 
   // 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 PendingRetransmission& retransmission,
       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;
 
   // Returns the number of bytes which are available to be used by additional
   // frames in the packet.  Since stream frames are slightly smaller when they
   // are the last frame in a packet, this method will return a different
   // value than max_packet_size - PacketSize(), in this case.
-  size_t BytesFree() const;
+  size_t BytesFree();
 
   // Returns the number of bytes that the packet will expand by if a new frame
   // is added to the packet. If the last frame was a stream frame, it will
   // expand slightly when a new frame is added, and this method returns the
   // amount of expected expansion. If the packet is in an FEC group, no
   // expansion happens and this method always returns zero.
   size_t ExpansionOnNewFrame() const;
 
   // 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;
+  size_t PacketSize();
 
   // 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
@@ skipping 13 matching lines @@
   static SerializedPacket NoPacket();
 
   // Called when the congestion window has changed.
   void OnCongestionWindowChange(QuicPacketCount max_packets_in_flight);
 
   // Called when the RTT may have changed.
   void OnRttChange(QuicTime::Delta rtt);
 
   // Sets the encryption level that will be applied to new packets.
   void set_encryption_level(EncryptionLevel level) {
-    encryption_level_ = level;
+    packet_.encryption_level = level;
   }
 
   // packet number of the last created packet, or 0 if no packets have been
   // created.
-  QuicPacketNumber packet_number() const { return packet_number_; }
+  QuicPacketNumber packet_number() const { return packet_.packet_number; }
 
   QuicConnectionIdLength connection_id_length() const {
     return connection_id_length_;
   }
 
   void set_connection_id_length(QuicConnectionIdLength length) {
     connection_id_length_ = length;
   }
 
   QuicByteCount max_packet_length() const { return max_packet_length_; }
 
-  bool has_ack() const { return has_ack_; }
+  bool has_ack() const { return packet_.has_ack; }
 
-  bool has_stop_waiting() const { return has_stop_waiting_; }
+  bool has_stop_waiting() const { return packet_.has_stop_waiting; }
 
   // Sets the encrypter to use for the encryption level and updates the max
   // plaintext size.
   void SetEncrypter(EncryptionLevel level, QuicEncrypter* encrypter);
 
   // Indicates whether the packet creator is in a state where it can change
   // current maximum packet length.
   bool CanSetMaxPacketLength() const;
 
   // Sets the maximum packet length.
@@ skipping 77 matching lines @@
   // frames if there isn't room. If |save_retransmittable_frames| is true,
   // saves the |frame| in the next SerializedPacket.
   bool AddFrame(const QuicFrame& frame, bool save_retransmittable_frames);
 
   // 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.
+  // retransmitted to packet_.retransmittable_frames. All frames must fit into
+  // a single packet. Sets the entropy hash of the serialized packet to a
+  // random bool.
   // Fails if |buffer_len| isn't long enough for the encrypted packet.
-  SerializedPacket SerializePacket(char* encrypted_buffer, size_t buffer_len);
+  void 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);
+  void OnSerializedPacket();
+
+  // Clears all fields of packet_ that should be cleared between serializations.
+  void ClearPacket();
 
   // 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.
+  // Packetize FEC data. Sets the entropy hash of the serialized packet to a
+  // random bool.
   // Fails if |buffer_len| isn't long enough for the encrypted packet.
-  SerializedPacket SerializeFec(char* buffer, size_t buffer_len);
+  void SerializeFec(char* buffer, size_t buffer_len);
 
   // Does not own these delegates or the framer.
   DelegateInterface* delegate_;
   DebugDelegate* debug_delegate_;
   QuicFramer* framer_;
 
   scoped_ptr<QuicRandomBoolSource> random_bool_source_;
   QuicBufferAllocator* const buffer_allocator_;
 
   // Controls whether version should be included while serializing the packet.
   bool send_version_in_packet_;
   // Controls whether path id should be included while serializing the packet.
   bool send_path_id_in_packet_;
   // Staging variable to hold next packet number length. When sequence
   // number length is to be changed, this variable holds the new length until
   // a packet or FEC group boundary, when the creator's packet_number_length_
   // can be changed to this new value.
   QuicPacketNumberLength next_packet_number_length_;
   // Maximum length including headers and encryption (UDP payload length.)
   QuicByteCount max_packet_length_;
-  mutable size_t max_plaintext_size_;
+  size_t max_plaintext_size_;
+  // Length of connection_id to send over the wire.
+  QuicConnectionIdLength connection_id_length_;
 
   // Frames to be added to the next SerializedPacket
   QuicFrames queued_frames_;
 
-  // Fields used to populate SerializedPacket.
+  // packet_size should never be read directly, use PacketSize() instead.
+  // TODO(ianswett): Move packet_size_ into SerializedPacket once
+  // QuicEncryptedPacket has been flattened into SerializedPacket.
+  size_t packet_size_;
   QuicConnectionId connection_id_;
-  EncryptionLevel encryption_level_;
-  // True if an ack is queued in queued_frames_.
-  bool has_ack_;
-  // True if a stop waiting frame is queued in queued_frames_.
-  bool has_stop_waiting_;
-  // The path which current constructed packet will be sent on.
-  QuicPathId current_path_;
-  QuicPacketNumber packet_number_;
-  // Length of connection_id to send over the wire.
-  QuicConnectionIdLength connection_id_length_;
-  // packet number length for the current packet and for the current FEC group
-  // when FEC is enabled. Mutable so PacketSize() can adjust it when the packet
-  // 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_;
-  scoped_ptr<QuicFrames> queued_retransmittable_frames_;
-  // If true, the packet will be padded up to |max_packet_length_|.
-  bool needs_padding_;
-  IsHandshake has_crypto_handshake_;
-  // Stores ack std::listeners that should be attached to the next packet.
-  std::list<AckListenerWrapper> ack_listeners_;
+
+  // Packet used to invoke OnSerializedPacket.
+  SerializedPacket packet_;
 
   // Map mapping path_id to last sent packet number on the path.
-  hash_map<QuicPathId, QuicPacketNumber> multipath_packet_number_;
+  std::unordered_map<QuicPathId, QuicPacketNumber> multipath_packet_number_;
 
   // FEC related fields.
   // True when creator is requested to turn on FEC protection. False otherwise.
   // 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_next_packet and fec_protect_ to
   // one variable.
   bool fec_protect_;
   scoped_ptr<QuicFecGroup> fec_group_;
   // 0 indicates FEC is disabled.
   size_t max_packets_per_fec_group_;
   // 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_