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 75 matching lines @@
   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 protocol version on the received packet doensn't match
   // current protocol version of the connection.
-  virtual void OnProtocolVersionMismatch(
-      QuicVersionTag version) = 0;
+  virtual void OnProtocolVersionMismatch(QuicTag 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;
 
@@ skipping 143 matching lines @@
   // 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_;
-  }
+  QuicTag version() const { return quic_version_; }
 
   // From QuicFramerVisitorInterface
   virtual void OnError(QuicFramer* framer) OVERRIDE;
-  virtual bool OnProtocolVersionMismatch(
-      QuicVersionTag received_version) OVERRIDE;
+  virtual bool OnProtocolVersionMismatch(QuicTag 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 bool OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE;
   virtual bool OnAckFrame(const QuicAckFrame& frame) OVERRIDE;
@@ skipping 44 matching lines @@
   bool connected() { return connected_; }
 
   size_t NumFecGroups() const { return group_map_.size(); }
 
   // Testing only.
   size_t NumQueuedPackets() const { return queued_packets_.size(); }
 
   // Returns true if the connection has queued packets or frames.
   bool HasQueuedData() const;
 
+  // Sets (or resets) the idle state connection timeout. Also, checks and times
+  // out the connection if network timer has expired for |timeout|.
+  void SetConnectionTimeout(QuicTime::Delta timeout);
+
   // If the connection has timed out, this will close the connection and return
   // true.  Otherwise, it will return false and will reset the timeout alarm.
   bool CheckForTimeout();
 
   // Returns true of the next packet to be sent should be "lost" by
   // not actually writing it to the wire.
   bool ShouldSimulateLostPacket();
 
   // Sets up a packet with an QuicAckFrame and sends it out.
   void SendAck();
@@ skipping 70 matching lines @@
   // state.
   //
   // Updates internal state based on incoming_ack.received_info
   void UpdatePacketInformationReceivedByPeer(
       const QuicAckFrame& incoming_ack);
   // Updates internal state based in incoming_ack.sent_info
   void UpdatePacketInformationSentByPeer(const QuicAckFrame& incoming_ack);
 
   QuicConnectionHelperInterface* helper() { return helper_.get(); }
 
+ protected:
+  QuicFramer framer_;
+
  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,
                  EncryptionLevel level,
                  HasRetransmittableData retransmittable)
@@ skipping 40 matching lines @@
   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);
+  bool SelectMutualVersion(const QuicTagVector& available_versions);
   // Sends a version negotiation packet to the peer.
   void SendVersionNegotiationPacket();
 
   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();
 
   void MaybeSendAckInResponseToPacket();
 
   // Get the FEC group associate with the last processed packet.
   QuicFecGroup* GetFecGroup();
 
   // Closes any FEC groups protecting packets before |sequence_number|.
   void CloseFecGroupsBefore(QuicPacketSequenceNumber sequence_number);
 
   scoped_ptr<QuicConnectionHelperInterface> helper_;
-  QuicFramer framer_;
   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_;
   IPEndPoint peer_address_;
   // Address on the last(currently being processed) packet received. Not
@@ skipping 51 matching lines @@
   FecGroupMap group_map_;
 
   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_;
+  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_;
 
   // Member holding the time we received the largest_observed sequence number.
   // Needed for calculating delta_time_largest_observed.
   QuicTime time_largest_observed_;
 
   // 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_;
+  QuicTag 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_