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 14 matching lines @@
 #include "base/hash_tables.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/linked_hash_map.h"
 #include "net/quic/congestion_control/quic_congestion_manager.h"
 #include "net/quic/quic_blocked_writer_interface.h"
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_packet_creator.h"
 #include "net/quic/quic_packet_entropy_manager.h"
 #include "net/quic/quic_packet_generator.h"
 #include "net/quic/quic_protocol.h"
+#include "net/quic/quic_stats.h"
 
 namespace net {
 
 class QuicClock;
 class QuicConnection;
 class QuicFecGroup;
 class QuicRandom;
 
 namespace test {
 class QuicConnectionPeer;
@@ skipping 37 matching lines @@
 class NET_EXPORT_PRIVATE QuicConnectionDebugVisitorInterface {
  public:
   virtual ~QuicConnectionDebugVisitorInterface() {}
 
   // Called when a packet has been received, but before it is
   // validated or parsed.
   virtual void OnPacketReceived(const IPEndPoint& self_address,
                                 const IPEndPoint& peer_address,
                                 const QuicEncryptedPacket& packet) = 0;
 
-  // Called when the header of a packet has been parsed.
+  // Called when the protocol version on the received packet doensn't match
+  // current protocol version of the connection.
+  virtual void OnProtocolVersionMismatch(
+      QuicVersionTag version) = 0;
+
+  // Called when the complete header of a packet has been parsed.
   virtual void OnPacketHeader(const QuicPacketHeader& header) = 0;
 
   // Called when a StreamFrame has been parsed.
   virtual void OnStreamFrame(const QuicStreamFrame& frame) = 0;
 
   // Called when a AckFrame has been parsed.
   virtual void OnAckFrame(const QuicAckFrame& frame) = 0;
 
   // Called when a CongestionFeedbackFrame has been parsed.
   virtual void OnCongestionFeedbackFrame(
       const QuicCongestionFeedbackFrame& frame) = 0;
 
   // Called when a RstStreamFrame has been parsed.
   virtual void OnRstStreamFrame(const QuicRstStreamFrame& frame) = 0;
 
   // Called when a ConnectionCloseFrame has been parsed.
   virtual void OnConnectionCloseFrame(
       const QuicConnectionCloseFrame& frame) = 0;
 
   // Called when a public reset packet has been received.
   virtual void OnPublicResetPacket(const QuicPublicResetPacket& packet) = 0;
 
+  // Called when a version negotiation packet has been received.
+  virtual void OnVersionNegotiationPacket(
+      const QuicVersionNegotiationPacket& packet) = 0;
+
   // Called after a packet has been successfully parsed which results
   // in the revival of a packet via FEC.
   virtual void OnRevivedPacket(const QuicPacketHeader& revived_header,
                                base::StringPiece payload) = 0;
 };
 
 class NET_EXPORT_PRIVATE QuicConnectionHelperInterface {
  public:
   virtual ~QuicConnectionHelperInterface() {}
 
@@ skipping 50 matching lines @@
 
 class NET_EXPORT_PRIVATE QuicConnection
     : public QuicFramerVisitorInterface,
       public QuicBlockedWriterInterface,
       public QuicPacketGenerator::DelegateInterface {
  public:
   // Constructs a new QuicConnection for the specified |guid| and |address|.
   // |helper| will be owned by this connection.
   QuicConnection(QuicGuid guid,
                  IPEndPoint address,
-                 QuicConnectionHelperInterface* helper);
+                 QuicConnectionHelperInterface* helper,
+                 bool is_server);
   virtual ~QuicConnection();
 
   static void DeleteEnclosedFrame(QuicFrame* frame);
 
   // Send the data payload to the peer.
   // Returns a pair with the number of bytes consumed from data, and a boolean
   // indicating if the fin bit was consumed.  This does not indicate the data
   // has been sent on the wire: it may have been turned into a packet and queued
   // if the socket was unexpectedly blocked.
   QuicConsumedData SendStreamData(QuicStreamId id,
@@ skipping 14 matching lines @@
   // calling CloseConnection(notifying the visitor as it does so).
   virtual void SendConnectionClose(QuicErrorCode error);
   virtual void SendConnectionCloseWithDetails(QuicErrorCode error,
                                               const std::string& details);
   // Notifies the visitor of the close and marks the connection as disconnected.
   void CloseConnection(QuicErrorCode error, bool from_peer);
   virtual void SendGoAway(QuicErrorCode error,
                           QuicStreamId last_good_stream_id,
                           const std::string& reason);
 
+  // Returns statistics tracked for this connection.
+  const QuicConnectionStats& GetStats();
+
   // Processes an incoming UDP packet (consisting of a QuicEncryptedPacket) from
   // the peer.  If processing this packet permits a packet to be revived from
   // its FEC group that packet will be revived and processed.
   virtual void ProcessUdpPacket(const IPEndPoint& self_address,
                                 const IPEndPoint& peer_address,
                                 const QuicEncryptedPacket& packet);
 
   // QuicBlockedWriterInterface
   // Called when the underlying connection becomes writable to allow
   // queued writes to happen.  Returns false if the socket has become blocked.
   virtual bool OnCanWrite() OVERRIDE;
 
+  QuicVersionTag version() const {
+    return quic_version_;
+  }
+
   // From QuicFramerVisitorInterface
   virtual void OnError(QuicFramer* framer) OVERRIDE;
+  virtual bool OnProtocolVersionMismatch(
+      QuicVersionTag received_version) OVERRIDE;
   virtual void OnPacket() OVERRIDE;
   virtual void OnPublicResetPacket(
       const QuicPublicResetPacket& packet) OVERRIDE;
+  virtual void OnVersionNegotiationPacket(
+      const QuicVersionNegotiationPacket& packet) OVERRIDE;
   virtual void OnRevivedPacket() OVERRIDE;
   virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE;
   virtual void OnFecProtectedPayload(base::StringPiece payload) OVERRIDE;
   virtual void OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE;
   virtual void OnAckFrame(const QuicAckFrame& frame) OVERRIDE;
   virtual void OnCongestionFeedbackFrame(
       const QuicCongestionFeedbackFrame& frame) OVERRIDE;
   virtual void OnRstStreamFrame(const QuicRstStreamFrame& frame) OVERRIDE;
   virtual void OnGoAwayFrame(const QuicGoAwayFrame& frame) OVERRIDE;
   virtual void OnConnectionCloseFrame(
@@ skipping 104 matching lines @@
 
   QuicConnectionHelperInterface* helper() { return helper_; }
 
  private:
   friend class test::QuicConnectionPeer;
 
   // Packets which have not been written to the wire.
   // Owns the QuicPacket* packet.
   struct QueuedPacket {
     QueuedPacket(QuicPacketSequenceNumber sequence_number,
-                 QuicPacket* packet)
+                 QuicPacket* packet,
+                 bool has_retransmittable_data)
         : sequence_number(sequence_number),
-          packet(packet) {
+          packet(packet),
+          has_retransmittable_data(has_retransmittable_data) {
     }
 
     QuicPacketSequenceNumber sequence_number;
     QuicPacket* packet;
+    bool has_retransmittable_data;
   };
 
   struct RetransmissionInfo {
     explicit RetransmissionInfo(QuicPacketSequenceNumber sequence_number)
         : sequence_number(sequence_number),
           scheduled_time(QuicTime::Zero()),
           number_nacks(0),
           number_retransmissions(0) {
     }
 
@@ skipping 17 matching lines @@
   typedef linked_hash_map<QuicPacketSequenceNumber,
                           RetransmittableFrames*> UnackedPacketMap;
   typedef std::map<QuicFecGroupNumber, QuicFecGroup*> FecGroupMap;
   typedef base::hash_map<QuicPacketSequenceNumber,
                          RetransmissionInfo> RetransmissionMap;
   typedef std::priority_queue<RetransmissionInfo,
                               std::vector<RetransmissionInfo>,
                               RetransmissionInfoComparator>
       RetransmissionTimeouts;
 
+  // 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 QuicVersionTagList& available_versions);
+  // Sends a version negotiation packet to the peer.
+  void SendVersionNegotiationPacket();
+
   // Checks if a packet can be written now, and sets the timer if necessary.
-  virtual bool CanWrite(bool is_retransmission) OVERRIDE;
+  virtual bool CanWrite(bool is_retransmission,
+                        bool has_retransmittable_data) OVERRIDE;
 
   void MaybeSetupRetransmission(QuicPacketSequenceNumber sequence_number);
   bool IsRetransmission(QuicPacketSequenceNumber sequence_number);
+  void RetransmitAllUnackedPackets();
 
   // Writes as many queued packets as possible.  The connection must not be
   // blocked when this is called.
   bool WriteQueuedPackets();
 
   // If a packet can be revived from the current FEC group, then
   // revive and process the packet.
   void MaybeProcessRevivedPacket();
 
   void UpdateOutgoingAck();
@@ skipping 73 matching lines @@
   QuicPacketEntropyManager entropy_manager_;
 
   QuicConnectionVisitorInterface* visitor_;
   QuicConnectionDebugVisitorInterface* debug_visitor_;
   QuicPacketCreator packet_creator_;
   QuicPacketGenerator packet_generator_;
 
   // Network idle time before we kill of this connection.
   const QuicTime::Delta timeout_;
 
+  // Statistics for this session.
+  QuicConnectionStats stats_;
+
   // The time that we got a packet for this connection.
   QuicTime time_of_last_received_packet_;
 
   // The time that we last sent a packet for this connection.
   QuicTime time_of_last_sent_packet_;
 
   // Congestion manager which controls the rate the connection sends packets
   // as well as collecting and generating congestion feedback.
   QuicCongestionManager congestion_manager_;
 
+  // The state of connection in version negotiation finite state machine.
+  QuicVersionNegotiationState version_negotiation_state_;
+
+  // The version of the protocol this connection is using.
+  QuicVersionTag quic_version_;
+
+  // Tracks if the connection was created by the server.
+  bool is_server_;
+
   // True by default.  False if we've received or sent an explicit connection
   // close.
   bool connected_;
 
   // True if the last ack received from the peer may have been truncated.  False
   // otherwise.
   bool received_truncated_ack_;
 
   bool send_ack_in_response_to_packet_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicConnection);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_CONNECTION_H_