Upstream version 7.36.149.0

[platform/framework/web/crosswalk.git] / src / net / quic / congestion_control / pacing_sender_test.cc

diff --git a/src/net/quic/congestion_control/pacing_sender_test.cc b/src/net/quic/congestion_control/pacing_sender_test.cc
index 0874273..38e5d02 100644 (file)
--- a/src/net/quic/congestion_control/pacing_sender_test.cc
+++ b/src/net/quic/congestion_control/pacing_sender_test.cc
@@ -13,10 +13,13 @@
 
 using testing::Return;
 using testing::StrictMock;
+using testing::_;
 
 namespace net {
 namespace test {
 
+const QuicByteCount kBytesInFlight = 1024;
+
 class PacingSenderTest : public ::testing::Test {
  protected:
   PacingSenderTest()
@@ -36,22 +39,21 @@ class PacingSenderTest : public ::testing::Test {
     // In order for the packet to be sendable, the underlying sender must
     // permit it to be sent immediately.
     EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(),
-                                             NOT_RETRANSMISSION,
-                                             HAS_RETRANSMITTABLE_DATA,
-                                             NOT_HANDSHAKE))
+                                             kBytesInFlight,
+                                             HAS_RETRANSMITTABLE_DATA))
         .WillOnce(Return(zero_time_));
     // Verify that the packet can be sent immediately.
     EXPECT_EQ(zero_time_,
-              pacing_sender_->TimeUntilSend(clock_.Now(), NOT_RETRANSMISSION,
-                                            HAS_RETRANSMITTABLE_DATA,
-                                            NOT_HANDSHAKE));
+              pacing_sender_->TimeUntilSend(clock_.Now(),
+                                            kBytesInFlight,
+                                            HAS_RETRANSMITTABLE_DATA));
 
     // Actually send the packet.
     EXPECT_CALL(*mock_sender_,
-                OnPacketSent(clock_.Now(), sequence_number_, kMaxPacketSize,
-                             NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA));
-    pacing_sender_->OnPacketSent(clock_.Now(), sequence_number_++,
-                                 kMaxPacketSize, NOT_RETRANSMISSION,
+                OnPacketSent(clock_.Now(), kBytesInFlight, sequence_number_,
+                             kMaxPacketSize, HAS_RETRANSMITTABLE_DATA));
+    pacing_sender_->OnPacketSent(clock_.Now(), kBytesInFlight,
+                                 sequence_number_++, kMaxPacketSize,
                                  HAS_RETRANSMITTABLE_DATA);
   }
 
@@ -59,22 +61,21 @@ class PacingSenderTest : public ::testing::Test {
     // In order for the ack to be sendable, the underlying sender must
     // permit it to be sent immediately.
     EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(),
-                                             NOT_RETRANSMISSION,
-                                             NO_RETRANSMITTABLE_DATA,
-                                             NOT_HANDSHAKE))
+                                             0,
+                                             NO_RETRANSMITTABLE_DATA))
         .WillOnce(Return(zero_time_));
     // Verify that the ACK can be sent immediately.
     EXPECT_EQ(zero_time_,
-              pacing_sender_->TimeUntilSend(clock_.Now(), NOT_RETRANSMISSION,
-                                            NO_RETRANSMITTABLE_DATA,
-                                            NOT_HANDSHAKE));
+              pacing_sender_->TimeUntilSend(clock_.Now(),
+                                            0,
+                                            NO_RETRANSMITTABLE_DATA));
 
     // Actually send the packet.
     EXPECT_CALL(*mock_sender_,
-                OnPacketSent(clock_.Now(), sequence_number_, kMaxPacketSize,
-                             NOT_RETRANSMISSION, NO_RETRANSMITTABLE_DATA));
-    pacing_sender_->OnPacketSent(clock_.Now(), sequence_number_++,
-                                 kMaxPacketSize, NOT_RETRANSMISSION,
+                OnPacketSent(clock_.Now(), 0, sequence_number_,
+                             kMaxPacketSize, NO_RETRANSMITTABLE_DATA));
+    pacing_sender_->OnPacketSent(clock_.Now(), 0,
+                                 sequence_number_++, kMaxPacketSize,
                                  NO_RETRANSMITTABLE_DATA);
   }
 
@@ -82,15 +83,14 @@ class PacingSenderTest : public ::testing::Test {
     // In order for the packet to be sendable, the underlying sender must
     // permit it to be sent immediately.
     EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(),
-                                             NOT_RETRANSMISSION,
-                                             HAS_RETRANSMITTABLE_DATA,
-                                             NOT_HANDSHAKE))
+                                             kBytesInFlight,
+                                             HAS_RETRANSMITTABLE_DATA))
         .WillOnce(Return(zero_time_));
     // Verify that the packet is delayed.
     EXPECT_EQ(delay.ToMicroseconds(),
-              pacing_sender_->TimeUntilSend(clock_.Now(), NOT_RETRANSMISSION,
-                                            HAS_RETRANSMITTABLE_DATA,
-                                            NOT_HANDSHAKE).ToMicroseconds());
+              pacing_sender_->TimeUntilSend(
+                  clock_.Now(), kBytesInFlight,
+                  HAS_RETRANSMITTABLE_DATA).ToMicroseconds());
   }
 
   const QuicTime::Delta zero_time_;
@@ -103,26 +103,24 @@ class PacingSenderTest : public ::testing::Test {
 
 TEST_F(PacingSenderTest, NoSend) {
   EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(),
-                                           NOT_RETRANSMISSION,
-                                           HAS_RETRANSMITTABLE_DATA,
-                                           NOT_HANDSHAKE))
+                                           kBytesInFlight,
+                                           HAS_RETRANSMITTABLE_DATA))
       .WillOnce(Return(infinite_time_));
   EXPECT_EQ(infinite_time_,
-            pacing_sender_->TimeUntilSend(clock_.Now(), NOT_RETRANSMISSION,
-                                          HAS_RETRANSMITTABLE_DATA,
-                                          NOT_HANDSHAKE));
+            pacing_sender_->TimeUntilSend(clock_.Now(),
+                                          kBytesInFlight,
+                                          HAS_RETRANSMITTABLE_DATA));
 }
 
 TEST_F(PacingSenderTest, SendNow) {
   EXPECT_CALL(*mock_sender_, TimeUntilSend(clock_.Now(),
-                                           NOT_RETRANSMISSION,
-                                           HAS_RETRANSMITTABLE_DATA,
-                                           NOT_HANDSHAKE))
+                                           kBytesInFlight,
+                                           HAS_RETRANSMITTABLE_DATA))
       .WillOnce(Return(zero_time_));
   EXPECT_EQ(zero_time_,
-            pacing_sender_->TimeUntilSend(clock_.Now(), NOT_RETRANSMISSION,
-                                          HAS_RETRANSMITTABLE_DATA,
-                                          NOT_HANDSHAKE));
+            pacing_sender_->TimeUntilSend(clock_.Now(),
+                                          kBytesInFlight,
+                                          HAS_RETRANSMITTABLE_DATA));
 }
 
 TEST_F(PacingSenderTest, VariousSending) {
@@ -138,9 +136,9 @@ TEST_F(PacingSenderTest, VariousSending) {
   }
 
   // Now update the RTT and verify that packets are actually paced.
-  QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(1);
-  EXPECT_CALL(*mock_sender_, UpdateRtt(rtt));
-  pacing_sender_->UpdateRtt(rtt);
+  EXPECT_CALL(*mock_sender_, OnCongestionEvent(true, kBytesInFlight, _, _));
+  SendAlgorithmInterface::CongestionMap empty_map;
+  pacing_sender_->OnCongestionEvent(true, kBytesInFlight, empty_map, empty_map);
 
   CheckPacketIsSentImmediately();
   CheckPacketIsSentImmediately();