Add QuicSentPacketManagerInterface, and QuicSentPacketManager implements it. No functional change e…

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 27 matching lines @@
 #include "net/quic/quic_blocked_writer_interface.h"
 #include "net/quic/quic_fec_group.h"
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_one_block_arena.h"
 #include "net/quic/quic_packet_creator.h"
 #include "net/quic/quic_packet_generator.h"
 #include "net/quic/quic_packet_writer.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_received_packet_manager.h"
 #include "net/quic/quic_sent_entropy_manager.h"
-#include "net/quic/quic_sent_packet_manager.h"
+#include "net/quic/quic_sent_packet_manager_interface.h"
 #include "net/quic/quic_time.h"
 #include "net/quic/quic_types.h"
 
 namespace net {
 
 class QuicClock;
 class QuicConfig;
 class QuicConnection;
 class QuicEncrypter;
 class QuicRandom;
@@ skipping 96 matching lines @@
 
   // Called to ask if any streams are open in this visitor, excluding the
   // reserved crypto and headers stream.
   virtual bool HasOpenDynamicStreams() const = 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 QuicConnectionDebugVisitor
-    : public QuicSentPacketManager::DebugDelegate {
+    : public QuicSentPacketManagerInterface::DebugDelegate {
  public:
   ~QuicConnectionDebugVisitor() override {}
 
   // Called when a packet has been sent.
   virtual void OnPacketSent(const SerializedPacket& serialized_packet,
                             QuicPathId original_path_id,
                             QuicPacketNumber original_packet_number,
                             TransmissionType transmission_type,
                             QuicTime sent_time) {}
 
@@ skipping 292 matching lines @@
   // case this is when the SHLO has been ACKed. Clients call this on receipt of
   // the SHLO.
   void OnHandshakeComplete();
 
   // Accessors
   void set_visitor(QuicConnectionVisitorInterface* visitor) {
     visitor_ = visitor;
   }
   void set_debug_visitor(QuicConnectionDebugVisitor* debug_visitor) {
     debug_visitor_ = debug_visitor;
-    sent_packet_manager_.set_debug_delegate(debug_visitor);
+    sent_packet_manager_->SetDebugDelegate(debug_visitor);
   }
   // Used in Chromium, but not internally.
   void set_creator_debug_delegate(QuicPacketCreator::DebugDelegate* visitor) {
     packet_generator_.set_debug_delegate(visitor);
   }
   const IPEndPoint& self_address() const { return self_address_; }
   const IPEndPoint& peer_address() const { return peer_address_; }
   QuicConnectionId connection_id() const { return connection_id_; }
   const QuicClock* clock() const { return clock_; }
   QuicRandom* random_generator() const { return random_generator_; }
@@ skipping 96 matching lines @@
   const QuicDecrypter* alternative_decrypter() const;
 
   Perspective perspective() const { return perspective_; }
 
   // Allow easy overriding of truncated connection IDs.
   void set_can_truncate_connection_ids(bool can) {
     can_truncate_connection_ids_ = can;
   }
 
   // Returns the underlying sent packet manager.
-  const QuicSentPacketManager& sent_packet_manager() const {
-    return sent_packet_manager_;
+  const QuicSentPacketManagerInterface& sent_packet_manager() const {
+    return *sent_packet_manager_;
   }
 
   bool CanWrite(HasRetransmittableData retransmittable);
 
   // 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.
@@ skipping 70 matching lines @@
 
   const IPEndPoint& last_packet_source_address() const {
     return last_packet_source_address_;
   }
 
  protected:
   // Send a packet to the peer, and takes ownership of the packet if the packet
   // cannot be written immediately.
   virtual void SendOrQueuePacket(SerializedPacket* packet);
 
-  // Called after a packet is received from a new peer address and is
-  // decrypted. Starts validation of peer's address change.
-  virtual void StartPeerMigration(PeerAddressChangeType peer_migration_type);
+  // Called after a packet is received from a new peer address on existing
+  // |path_id| and is decrypted. Starts validation of peer's address change.
+  virtual void StartPeerMigration(QuicPathId path_id,
+                                  PeerAddressChangeType peer_migration_type);
 
-  // Called when a peer migration is validated.
-  virtual void OnPeerMigrationValidated();
+  // Called when a peer address migration is validated on |path_id|.
+  virtual void OnPeerMigrationValidated(QuicPathId path_id);
 
   // 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);
 
   // 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
@@ skipping 83 matching lines @@
   void ProcessStopWaitingFrame(const QuicStopWaitingFrame& stop_waiting);
 
   // 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();
 
   // Queue an ack or set the ack alarm if needed.  |was_missing| is true if
   // the most recently received packet was formerly missing.
   void MaybeQueueAck(bool was_missing);
 
-  // Gets the least unacked packet number, which is the next packet number
-  // to be sent if there are no outstanding packets.
-  QuicPacketNumber GetLeastUnacked() const;
+  // Gets the least unacked packet number of |path_id|, which is the next packet
+  // number to be sent if there are no outstanding packets.
+  QuicPacketNumber GetLeastUnacked(QuicPathId path_id) const;
 
   // Sets the timeout alarm to the appropriate value, if any.
   void SetTimeoutAlarm();
 
   // Sets the ping alarm to the appropriate value, if any.
   void SetPingAlarm();
 
   // Sets the retransmission alarm based on SentPacketManager.
   void SetRetransmissionAlarm();
 
@@ skipping 25 matching lines @@
   void OnPathClosed(QuicPathId path_id);
 
   // Do any work which logically would be done in OnPacket but can not be
   // safely done until the packet is validated. Returns true if packet can be
   // handled, false otherwise.
   bool ProcessValidatedPacket(const QuicPacketHeader& header);
 
   // Consider receiving crypto frame on non crypto stream as memory corruption.
   bool MaybeConsiderAsMemoryCorruption(const QuicStreamFrame& frame);
 
+  const QuicTime::Delta DelayedAckTime();
+
   QuicFramer framer_;
   QuicConnectionHelperInterface* helper_;  // Not owned.
   QuicAlarmFactory* alarm_factory_;        // 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_;
@@ skipping 150 matching lines @@
   // |time_of_last_received_packet_|.
   QuicTime last_send_for_timeout_;
 
   // packet number of the last sent packet.  Packets are guaranteed to be sent
   // in packet number order.
   QuicPacketNumber packet_number_of_last_sent_packet_;
 
   // Sent packet manager which tracks the status of packets sent by this
   // connection and contains the send and receive algorithms to determine when
   // to send packets.
-  QuicSentPacketManager sent_packet_manager_;
+  std::unique_ptr<QuicSentPacketManagerInterface> sent_packet_manager_;
 
   // The state of connection in version negotiation finite state machine.
   QuicVersionNegotiationState version_negotiation_state_;
 
   // Tracks if the connection was created by the server or the client.
   Perspective perspective_;
 
   // True by default.  False if we've received or sent an explicit connection
   // close.
   bool connected_;
@@ skipping 36 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_