Landing Recent QUIC changes until Mon Apr 17 2017

net/quic/core/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.
 
 #ifndef NET_QUIC_CORE_QUIC_PACKET_CREATOR_H_
 #define NET_QUIC_CORE_QUIC_PACKET_CREATOR_H_
 
@@ skipping 184 matching lines @@
   // 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.
   void SetMaxPacketLength(QuicByteCount length);
 
+  // Increases pending_padding_bytes by |size|. Pending padding will be sent by
+  // MaybeAddPadding().
+  void AddPendingPadding(QuicByteCount size);
+
   void set_debug_delegate(DebugDelegate* debug_delegate) {
     debug_delegate_ = debug_delegate;
   }
 
   bool latched_flag_no_stop_waiting_frames() const {
     return latched_flag_no_stop_waiting_frames_;
   }
 
+  QuicByteCount pending_padding_bytes() const { return pending_padding_bytes_; }
+
  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|.
   // 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 own.
@@ skipping 12 matching lines @@
                            size_t length,
                            char* buffer);
 
   void FillPacketHeader(QuicPacketHeader* header);
 
   // Adds a |frame| if there is space and returns false and flushes all pending
   // 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.
+  // Adds a padding frame to the current packet (if there is space) when (1)
+  // current packet needs full padding or (2) there are pending paddings.
   void MaybeAddPadding();
 
   // Serializes all frames which have been added and adds any which should be
   // retransmitted to packet_.retransmittable_frames. All frames must fit into
   // a single packet.
   // Fails if |buffer_len| isn't long enough for the encrypted packet.
   void SerializePacket(char* encrypted_buffer, size_t buffer_len);
 
   // Called after a new SerialiedPacket is created to call the delegate's
   // OnSerializedPacket and reset state.
@@ skipping 38 matching lines @@
   // QuicEncryptedPacket has been flattened into SerializedPacket.
   size_t packet_size_;
   QuicConnectionId connection_id_;
 
   // Packet used to invoke OnSerializedPacket.
   SerializedPacket packet_;
 
   // The latched value of FLAGS_quic_reloadable_flag_quic_no_stop_waiting_frames
   bool latched_flag_no_stop_waiting_frames_;
 
+  // Pending padding bytes to send. Pending padding bytes will be sent in next
+  // packet(s) (after all other frames) if current constructed packet does not
+  // have room to send all of them.
+  QuicByteCount pending_padding_bytes_;
+
+  // Indicates whether current constructed packet needs full padding to max
+  // packet size. Please note, full padding does not consume pending padding
+  // bytes.
+  bool needs_full_padding_;
+
   DISALLOW_COPY_AND_ASSIGN(QuicPacketCreator);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CORE_QUIC_PACKET_CREATOR_H_