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.
 //
 // On the client side, the Connection handles the raw reads, as well as the
 // processing.
 //
 // Note: this class is not thread-safe.
 
 #ifndef NET_QUIC_QUIC_CONNECTION_H_
 #define NET_QUIC_QUIC_CONNECTION_H_
 
 #include <deque>
 #include <list>
 #include <map>
 #include <queue>
 #include <set>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
+#include "net/base/iovec.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_ack_notifier.h"
 #include "net/quic/quic_alarm.h"
 #include "net/quic/quic_blocked_writer_interface.h"
 #include "net/quic/quic_connection_stats.h"
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_packet_creator.h"
 #include "net/quic/quic_packet_generator.h"
@@ skipping 32 matching lines @@
   virtual void OnGoAway(const QuicGoAwayFrame& frame) = 0;
 
   // Called when the connection is closed either locally by the framer, or
   // remotely by the peer.
   virtual void ConnectionClose(QuicErrorCode error,
                                bool from_peer) = 0;
 
   // Called when packets are acked by the peer.
   virtual void OnAck(const SequenceNumberSet& acked_packets) = 0;
 
+  // Called once a specific QUIC version is agreed by both endpoints.
+  virtual void OnSuccessfulVersionNegotiation(const QuicVersion& version) = 0;
+
   // Called when a blocked socket becomes writable.  If all pending bytes for
   // this visitor are consumed by the connection successfully this should
   // return true, otherwise it should return false.
   virtual bool OnCanWrite() = 0;
 };
 
 // Interface which gets callbacks from the QuicConnection at interesting
 // points.  Implementations must not mutate the state of the connection
 // as a result of these callbacks.
 class NET_EXPORT_PRIVATE QuicConnectionDebugVisitorInterface
@@ skipping 109 matching lines @@
 
   // Constructs a new QuicConnection for the specified |guid| and |address|.
   // |helper| will be owned by this connection.
   QuicConnection(QuicGuid guid,
                  IPEndPoint address,
                  QuicConnectionHelperInterface* helper,
                  bool is_server,
                  QuicVersion version);
   virtual ~QuicConnection();
 
-  // Send the data payload to the peer.
+  // Send the data in |iov| to the peer in as few packets as possible.
   // 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,
-                                  base::StringPiece data,
-                                  QuicStreamOffset offset,
-                                  bool fin);
+  QuicConsumedData SendvStreamData(QuicStreamId id,
+                                   const struct iovec* iov,
+                                   int count,
+                                   QuicStreamOffset offset,
+                                   bool fin);
+
   // Same as above, except that the provided delegate will be informed once ACKs
   // have been received for all the packets written.
   // The |delegate| is not owned by the QuicConnection and must outlive it.
   QuicConsumedData SendStreamDataAndNotifyWhenAcked(
       QuicStreamId id,
       base::StringPiece data,
       QuicStreamOffset offset,
       bool fin,
       QuicAckNotifier::DelegateInterface* delegate);
 
   // Send a stream reset frame to the peer.
   virtual void SendRstStream(QuicStreamId id,
                              QuicRstStreamErrorCode error);
 
   // Sends the connection close packet without affecting the state of the
   // connection.  This should only be called if the session is actively being
   // destroyed: otherwise call SendConnectionCloseWithDetails instead.
   virtual void SendConnectionClosePacket(QuicErrorCode error,
                                          const std::string& details);
 
   // Sends a connection close frame to the peer, and closes the connection by
   // 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 CloseConnection(QuicErrorCode error, bool from_peer) OVERRIDE;
   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.
@@ skipping 74 matching lines @@
 
   QuicPacketCreator::Options* options() { return packet_creator_.options(); }
 
   bool connected() { return connected_; }
 
   size_t NumFecGroups() const { return group_map_.size(); }
 
   // Testing only.
   size_t NumQueuedPackets() const { return queued_packets_.size(); }
 
+  // Flush any queued frames immediately.  Preserves the batch write mode and
+  // does nothing if there are no pending frames.
+  void Flush();
+
   // 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 SetIdleNetworkTimeout(QuicTime::Delta timeout);
   // Sets (or resets) the total time delta the connection can be alive for.
   // Also, checks and times out the connection if timer has expired for
   // |timeout|. Used to limit the time a connection can be alive before crypto
   // handshake finishes.
@@ skipping 370 matching lines @@
   // Once a given QuicAckNotifier has seen all the sequence numbers it is
   // interested in, it will be deleted, and removed from this list.
   AckNotifierList ack_notifiers_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicConnection);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_CONNECTION_H_