Optionally defer responding to a QUIC ACK until all ACK processing has completed for an EpollServer…

net/quic/quic_connection_test.cc

 // 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.
 
 #include "net/quic/quic_connection.h"
 
 #include <ostream>
 
 #include "base/bind.h"
 #include "base/macros.h"
@@ skipping 599 matching lines @@
     return reinterpret_cast<TestConnectionHelper::TestAlarm*>(
         QuicConnectionPeer::GetTimeoutAlarm(this));
   }
 
   TestConnectionHelper::TestAlarm* GetMtuDiscoveryAlarm() {
     return reinterpret_cast<TestConnectionHelper::TestAlarm*>(
         QuicConnectionPeer::GetMtuDiscoveryAlarm(this));
   }
 
   using QuicConnection::SelectMutualVersion;
+  using QuicConnection::set_defer_send_in_response_to_packets;
 
  private:
   TestPacketWriter* writer() {
     return static_cast<TestPacketWriter*>(QuicConnection::writer());
   }
 
   DISALLOW_COPY_AND_ASSIGN(TestConnection);
 };
 
 // Used for testing packets revived from FEC packets.
 class FecQuicConnectionDebugVisitor : public QuicConnectionDebugVisitor {
  public:
   void OnRevivedPacket(const QuicPacketHeader& header,
                        StringPiece data) override {
     revived_header_ = header;
   }
 
   // Public accessor method.
   QuicPacketHeader revived_header() const { return revived_header_; }
 
  private:
   QuicPacketHeader revived_header_;
 };
 
-// Run tests with combinations of {QuicVersion, fec_send_policy}.
+enum class AckResponse { kDefer, kImmediate };
+
+// Run tests with combinations of {QuicVersion, fec_send_policy,
+// AckResponse}.
 struct TestParams {
-  TestParams(QuicVersion version, FecSendPolicy fec_send_policy)
-      : version(version), fec_send_policy(fec_send_policy) {}
+  TestParams(QuicVersion version,
+             FecSendPolicy fec_send_policy,
+             AckResponse ack_response)
+      : version(version),
+        fec_send_policy(fec_send_policy),
+        ack_response(ack_response) {}
 
   friend ostream& operator<<(ostream& os, const TestParams& p) {
     os << "{ client_version: " << QuicVersionToString(p.version)
-       << " fec_send_policy: " << p.fec_send_policy << " }";
+       << " fec_send_policy: " << p.fec_send_policy << " ack_response: "
+       << (p.ack_response == AckResponse::kDefer ? "defer" : "immediate")
+       << " }";
     return os;
   }
 
   QuicVersion version;
   FecSendPolicy fec_send_policy;
+  AckResponse ack_response;
 };
 
 // Constructs various test permutations.
 vector<TestParams> GetTestParams() {
   vector<TestParams> params;
   QuicVersionVector all_supported_versions = QuicSupportedVersions();
   for (size_t i = 0; i < all_supported_versions.size(); ++i) {
-    params.push_back(TestParams(all_supported_versions[i], FEC_ANY_TRIGGER));
-    params.push_back(TestParams(all_supported_versions[i], FEC_ALARM_TRIGGER));
+    for (FecSendPolicy fec_send_policy : {FEC_ANY_TRIGGER, FEC_ALARM_TRIGGER}) {
+      for (AckResponse ack_response :
+           {AckResponse::kDefer, AckResponse::kImmediate}) {
+        params.push_back(TestParams(all_supported_versions[i], fec_send_policy,
+                                    ack_response));
+      }
+    }
   }
   return params;
 }
 
 class QuicConnectionTest : public ::testing::TestWithParam<TestParams> {
  protected:
   QuicConnectionTest()
       : connection_id_(42),
         framer_(SupportedVersions(version()),
                 QuicTime::Zero(),
@@ skipping 13 matching lines @@
                     writer_.get(),
                     Perspective::IS_CLIENT,
                     version()),
         creator_(QuicConnectionPeer::GetPacketCreator(&connection_)),
         generator_(QuicConnectionPeer::GetPacketGenerator(&connection_)),
         manager_(QuicConnectionPeer::GetSentPacketManager(&connection_)),
         frame1_(1, false, 0, StringPiece(data1)),
         frame2_(1, false, 3, StringPiece(data2)),
         packet_number_length_(PACKET_6BYTE_PACKET_NUMBER),
         connection_id_length_(PACKET_8BYTE_CONNECTION_ID) {
+    connection_.set_defer_send_in_response_to_packets(GetParam().ack_response ==
+                                                      AckResponse::kDefer);
     FLAGS_quic_always_log_bugs_for_tests = true;
     connection_.set_visitor(&visitor_);
     connection_.SetSendAlgorithm(send_algorithm_);
     connection_.SetLossAlgorithm(loss_algorithm_);
     framer_.set_received_entropy_calculator(&entropy_calculator_);
     generator_->set_fec_send_policy(GetParam().fec_send_policy);
     EXPECT_CALL(*send_algorithm_, TimeUntilSend(_, _, _))
         .WillRepeatedly(Return(QuicTime::Delta::Zero()));
     EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
         .Times(AnyNumber());
@@ skipping 46 matching lines @@
       return 0;
     }
     return writer_->stop_waiting_frames()[0].least_unacked;
   }
 
   void use_tagging_decrypter() { writer_->use_tagging_decrypter(); }
 
   void ProcessPacket(QuicPathId path_id, QuicPacketNumber number) {
     EXPECT_CALL(visitor_, OnStreamFrame(_)).Times(1);
     ProcessDataPacket(path_id, number, 0, !kEntropyFlag);
+    if (connection_.GetSendAlarm()->IsSet()) {
+      connection_.GetSendAlarm()->Fire();
+    }
   }
 
   QuicPacketEntropyHash ProcessFramePacket(QuicFrame frame) {
     return ProcessFramePacketWithAddresses(frame, kSelfAddress, kPeerAddress);
   }
 
   QuicPacketEntropyHash ProcessFramePacketWithAddresses(
       QuicFrame frame,
       IPEndPoint self_address,
       IPEndPoint peer_address) {
     QuicFrames frames;
     frames.push_back(QuicFrame(frame));
     QuicPacketCreatorPeer::SetSendVersionInPacket(
         &peer_creator_, connection_.perspective() == Perspective::IS_SERVER);
 
     char buffer[kMaxPacketSize];
     SerializedPacket serialized_packet =
         QuicPacketCreatorPeer::SerializeAllFrames(&peer_creator_, frames,
                                                   buffer, kMaxPacketSize);
     connection_.ProcessUdpPacket(
         self_address, peer_address,
         QuicEncryptedPacket(serialized_packet.encrypted_buffer,
                             serialized_packet.encrypted_length));
+    if (connection_.GetSendAlarm()->IsSet()) {
+      connection_.GetSendAlarm()->Fire();
+    }
     return serialized_packet.entropy_hash;
   }
 
   QuicPacketEntropyHash ProcessFramePacketAtLevel(QuicPathId path_id,
                                                   QuicPacketNumber number,
                                                   QuicFrame frame,
                                                   EncryptionLevel level) {
     QuicPacketHeader header;
     header.public_header.connection_id = connection_id_;
     header.public_header.packet_number_length = packet_number_length_;
@@ skipping 29 matching lines @@
                                   bool has_stop_waiting,
                                   EncryptionLevel level) {
     scoped_ptr<QuicPacket> packet(ConstructDataPacket(
         path_id, number, fec_group, entropy_flag, has_stop_waiting));
     char buffer[kMaxPacketSize];
     size_t encrypted_length = framer_.EncryptPayload(
         level, path_id, number, *packet, buffer, kMaxPacketSize);
     connection_.ProcessUdpPacket(
         kSelfAddress, kPeerAddress,
         QuicEncryptedPacket(buffer, encrypted_length, false));
+    if (connection_.GetSendAlarm()->IsSet()) {
+      connection_.GetSendAlarm()->Fire();
+    }
     return encrypted_length;
   }
 
   void ProcessClosePacket(QuicPathId path_id,
                           QuicPacketNumber number,
                           QuicFecGroupNumber fec_group) {
     scoped_ptr<QuicPacket> packet(ConstructClosePacket(number, fec_group));
     char buffer[kMaxPacketSize];
     size_t encrypted_length = framer_.EncryptPayload(
         ENCRYPTION_NONE, path_id, number, *packet, buffer, kMaxPacketSize);
@@ skipping 92 matching lines @@
 
     scoped_ptr<QuicPacket> fec_packet(
         framer_.BuildFecPacket(header, data_packet->FecProtectedData()));
     char buffer[kMaxPacketSize];
     size_t encrypted_length = framer_.EncryptPayload(
         level, path_id, number, *fec_packet, buffer, kMaxPacketSize);
 
     connection_.ProcessUdpPacket(
         kSelfAddress, kPeerAddress,
         QuicEncryptedPacket(buffer, encrypted_length, false));
+    if (connection_.GetSendAlarm()->IsSet()) {
+      connection_.GetSendAlarm()->Fire();
+    }
     return encrypted_length;
   }
 
   QuicByteCount SendStreamDataToPeer(QuicStreamId id,
                                      StringPiece data,
                                      QuicStreamOffset offset,
                                      bool fin,
                                      QuicPacketNumber* last_packet) {
     QuicByteCount packet_size;
     EXPECT_CALL(*send_algorithm_, OnPacketSent(_, _, _, _, _))
@@ skipping 4668 matching lines @@
   // result in multiple attempts to close the connection - it will be marked as
   // disconnected after the first call.
   EXPECT_CALL(visitor_, OnConnectionClosed(_, _)).Times(1);
   connection_.SendConnectionCloseWithDetails(QUIC_NO_ERROR, "no reason");
   connection_.SendConnectionCloseWithDetails(QUIC_NO_ERROR, "no reason");
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net