Landing Recent QUIC changes until 01/26/2016 18:14 UTC

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 114 matching lines @@
 
   // Called when a blocked socket becomes writable.
   virtual void OnCanWrite() = 0;
 
   // Called when the connection experiences a change in congestion window.
   virtual void OnCongestionWindowChange(QuicTime now) = 0;
 
   // Called when the connection receives a packet from a migrated client.
   virtual void OnConnectionMigration() = 0;
 
+  // Called after OnStreamFrame, OnRstStream, OnGoAway, OnWindowUpdateFrame,
+  // OnBlockedFrame, and OnCanWrite to allow post-processing once the work has
+  // been done.
+  virtual void PostProcessAfterData() = 0;
+
   // Called to ask if the visitor wants to schedule write resumption as it both
   // has pending data to write, and is able to write (e.g. based on flow control
   // limits).
   // Writes may be pending because they were write-blocked, congestion-throttled
   // or yielded to other connections.
   virtual bool WillingAndAbleToWrite() const = 0;
 
   // Called to ask if any handshake messages are pending in this visitor.
   virtual bool HasPendingHandshake() const = 0;
 
@@ skipping 532 matching lines @@
   bool SelectMutualVersion(const QuicVersionVector& available_versions);
 
   bool peer_ip_changed() const { return peer_ip_changed_; }
 
   bool peer_port_changed() const { return peer_port_changed_; }
 
   const IPAddressNumber& migrating_peer_ip() const {
     return migrating_peer_ip_;
   }
 
+  // Returns the current per-packet options for the connection.
+  PerPacketOptions* per_packet_options() { return per_packet_options_; }
+  // Sets the current per-packet options for the connection. The QuicConnection
+  // does not take ownership of |options|; |options| must live for as long as
+  // the QuicConnection is in use.
+  void set_per_packet_options(PerPacketOptions* options) {
+    per_packet_options_ = options;
+  }
+
  private:
   friend class test::QuicConnectionPeer;
   friend class test::PacketSavingConnection;
 
   typedef std::list<SerializedPacket> QueuedPacketList;
   typedef std::map<QuicFecGroupNumber, QuicFecGroup*> FecGroupMap;
 
   // Writes the given packet to socket, encrypted with packet's
   // encryption_level. Returns true on successful write, and false if the writer
   // was blocked and the write needs to be tried again. Notifies the
@@ skipping 105 matching lines @@
   // frame is sent or received. Stops receiving packets on closed path. Drops
   // receive side of a closed path, and packets with retransmittable frames on a
   // closed path are marked as retransmissions which will be transmitted on
   // other paths.
   // TODO(fayang): complete OnPathClosed once QuicMultipathSentPacketManager and
   // QuicMultipathReceivedPacketManager are landed in QuicConnection.
   void OnPathClosed(QuicPathId path_id);
 
   QuicFramer framer_;
   QuicConnectionHelperInterface* helper_;  // Not owned.
+  PerPacketOptions* per_packet_options_;   // Not owned.
   QuicPacketWriter* writer_;  // Owned or not depending on |owns_writer_|.
   bool owns_writer_;
   // Encryption level for new packets. Should only be changed via
   // SetDefaultEncryptionLevel().
   EncryptionLevel encryption_level_;
   bool has_forward_secure_encrypter_;
   // The packet number of the first packet which will be encrypted with the
   // foward-secure encrypter, even if the peer has not started sending
   // forward-secure packets.
   QuicPacketNumber first_required_forward_secure_packet_;
@@ skipping 192 matching lines @@
 
   // If true, multipath is enabled for this connection.
   bool multipath_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicConnection);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_CONNECTION_H_