Land Recent QUIC Changes.

net/quic/quic_connection.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.
 //
 // The entity that handles framing writes for a Quic client or server.
 // Each QuicSession will have a connection associated with it.
 //
 // On the server side, the Dispatcher handles the raw reads, and hands off
 // packets via ProcessUdpPacket for framing and processing.
 //
@@ skipping 409 matching lines @@
   // Deletes |packet| if WritePacket call succeeds, or transfers ownership to
   // QueuedPacket, ultimately deleted in WriteQueuedPackets. Updates the
   // entropy map corresponding to |sequence_number| using |entropy_hash|.
   // |transmission_type| and |retransmittable| are supplied to the congestion
   // manager, and when |forced| is true, it bypasses the congestion manager.
   // TODO(wtc): none of the callers check the return value.
   virtual bool SendOrQueuePacket(EncryptionLevel level,
                                  const SerializedPacket& packet,
                                  TransmissionType transmission_type);
 
-  // Writes the given packet to socket, encrypted with |level|, with the help
-  // of helper. Returns true on successful write, false otherwise. However,
-  // behavior is undefined if connection is not established or broken. In any
-  // circumstances, a return value of true implies that |packet| has been
-  // transmitted and may be destroyed. If |sequence_number| is present in
-  // |retransmission_map_| it also sets up retransmission of the given packet
-  // in case of successful write. If |force| is FORCE, then the packet will be
-  // sent immediately and the send scheduler will not be consulted.
-  bool WritePacket(EncryptionLevel level,
-                   QuicPacketSequenceNumber sequence_number,
-                   const QuicPacket& packet,
-                   TransmissionType transmission_type,
-                   HasRetransmittableData retransmittable,
-                   IsHandshake handshake,
-                   Force force);
-
-  // Make sure an ack we got from our peer is sane.
-  bool ValidateAckFrame(const QuicAckFrame& incoming_ack);
-
   QuicConnectionHelperInterface* helper() { return helper_; }
 
   // Selects and updates the version of the protocol being used by selecting a
   // version from |available_versions| which is also supported. Returns true if
   // such a version exists, false otherwise.
   bool SelectMutualVersion(const QuicVersionVector& available_versions);
 
-  QuicFramer framer_;
-
  private:
   // Stores current batch state for connection, puts the connection
   // into batch mode, and destruction restores the stored batch state.
   // While the bundler is in scope, any generated frames are bundled
   // as densely as possible into packets.  In addition, this bundler
   // can be configured to ensure that an ACK frame is included in the
   // first packet created, if there's new ack information to be sent.
   class ScopedPacketBundler {
    public:
     // In addition to all outgoing frames being bundled when the
@@ skipping 57 matching lines @@
     TransmissionType transmission_type;
     HasRetransmittableData retransmittable;
     EncryptionLevel level;
     bool is_fec_packet;
     size_t length;
   };
 
   typedef std::list<QueuedPacket> QueuedPacketList;
   typedef std::map<QuicFecGroupNumber, QuicFecGroup*> FecGroupMap;
 
+  // Writes the given packet to socket, encrypted with |level|. Returns true on
+  // successful write. Behavior is undefined if connection is not established or
+  // broken. In any circumstance, a return value of true implies that |packet|
+  // has been transmitted and may be destroyed. If |sequence_number| is present
+  // in |retransmission_map_| it also sets up retransmission of the given packet
+  // in case of successful write. If |force| is FORCE, then the packet will be
+  // sent immediately and the send scheduler will not be consulted.
+  bool WritePacket(EncryptionLevel level,
+                   QuicPacketSequenceNumber sequence_number,
+                   const QuicPacket& packet,
+                   TransmissionType transmission_type,
+                   HasRetransmittableData retransmittable,
+                   IsHandshake handshake,
+                   Force force);
+
+  // Make sure an ack we got from our peer is sane.
+  bool ValidateAckFrame(const QuicAckFrame& incoming_ack);
+
   // Sends a version negotiation packet to the peer.
   void SendVersionNegotiationPacket();
 
   // Clears any accumulated frames from the last received packet.
   void ClearLastFrames();
 
   // Calculates the smallest sequence number length that can also represent four
   // times the maximum of the congestion window and the difference between the
   // least_packet_awaited_by_peer_ and |sequence_number|.
   QuicSequenceNumberLength CalculateSequenceNumberLength(
@@ skipping 26 matching lines @@
 
   // If a packet can be revived from the current FEC group, then
   // revive and process the packet.
   void MaybeProcessRevivedPacket();
 
   void ProcessAckFrame(const QuicAckFrame& incoming_ack);
 
   // Update the |sent_info| for an outgoing ack.
   void UpdateSentPacketInfo(SentPacketInfo* sent_info);
 
+  // Queues an ack or sets the ack alarm when an incoming packet arrives that
+  // should be acked.
+  void MaybeQueueAck();
+
   // Checks if the last packet should instigate an ack.
   bool ShouldLastPacketInstigateAck();
 
   // Sends any packets which are a response to the last packet, including both
   // acks and pending writes if an ack opened the congestion window.
-  void MaybeSendInResponseToPacket(bool send_ack_immediately,
-                                   bool last_packet_should_instigate_ack);
+  void MaybeSendInResponseToPacket();
 
   // Get the FEC group associate with the last processed packet or NULL, if the
   // group has already been deleted.
   QuicFecGroup* GetFecGroup();
 
   // Closes any FEC groups protecting packets before |sequence_number|.
   void CloseFecGroupsBefore(QuicPacketSequenceNumber sequence_number);
 
+  QuicFramer framer_;
   QuicConnectionHelperInterface* helper_;  // Not owned.
   QuicPacketWriter* writer_;  // Not owned.
   EncryptionLevel encryption_level_;
   const QuicClock* clock_;
   QuicRandom* random_generator_;
 
   const QuicGuid guid_;
   // Address on the last successfully processed packet received from the
   // client.
   IPEndPoint self_address_;
@@ skipping 34 matching lines @@
   scoped_ptr<PendingWrite> pending_write_;
 
   // Contains the connection close packet if the connection has been closed.
   scoped_ptr<QuicEncryptedPacket> connection_close_packet_;
 
   FecGroupMap group_map_;
 
   QuicReceivedPacketManager received_packet_manager_;
   QuicSentEntropyManager sent_entropy_manager_;
 
+  // Indicates whether an ack should be sent the next time we try to write.
+  bool ack_queued_;
+
   // An alarm that fires when an ACK should be sent to the peer.
   scoped_ptr<QuicAlarm> ack_alarm_;
   // An alarm that fires when a packet needs to be retransmitted.
   scoped_ptr<QuicAlarm> retransmission_alarm_;
   // An alarm that is scheduled when the sent scheduler requires a
   // a delay before sending packets and fires when the packet may be sent.
   scoped_ptr<QuicAlarm> send_alarm_;
   // An alarm that is scheduled when the connection can still write and there
   // may be more data to send.
   scoped_ptr<QuicAlarm> resume_writes_alarm_;
@@ skipping 50 matching lines @@
   // If non-empty this contains the set of versions received in a
   // version negotiation packet.
   QuicVersionVector server_supported_versions_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicConnection);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_CONNECTION_H_