Change from re-transmitting an packet with a retransmit number to sending a new packet with a new s…

net/quic/quic_connection_helper_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_helper.h"
 
 #include <vector>
 
 #include "base/stl_util.h"
 #include "net/base/net_errors.h"
@@ skipping 36 matching lines @@
   void SendAck() {
     QuicConnectionPeer::SendAck(this);
   }
 
   void SetScheduler(QuicSendScheduler* scheduler) {
     QuicConnectionPeer::SetScheduler(this, scheduler);
   }
 
   bool SendPacket(QuicPacketSequenceNumber sequence_number,
                   QuicPacket* packet,
-                  bool resend,
-                  bool force) {
-    return QuicConnection::SendPacket(sequence_number, packet, resend, force);
+                  bool should_resend,
+                  bool force,
+                  bool is_retransmit) {
+    return QuicConnection::SendPacket(
+        sequence_number, packet, should_resend, force, is_retransmit);
   }
 };
 
 class TestConnectionHelper : public QuicConnectionHelper {
  public:
   TestConnectionHelper(base::TaskRunner* runner,
                        QuicClock* clock,
                        MockUDPClientSocket* socket)
       : QuicConnectionHelper(runner, clock, socket) {
   }
@@ skipping 34 matching lines @@
         frame1_(1, false, 0, data1) {
     connection_.set_visitor(&visitor_);
     connection_.SetScheduler(scheduler_);
   }
 
   QuicPacket* ConstructDataPacket(QuicPacketSequenceNumber number,
                                   QuicFecGroupNumber fec_group) {
     header_.guid = guid_;
     header_.packet_sequence_number = number;
     header_.transmission_time = 0;
-    header_.retransmission_count = 0;
     header_.flags = PACKET_FLAGS_NONE;
     header_.fec_group = fec_group;
 
     QuicFrames frames;
     QuicFrame frame(&frame1_);
     frames.push_back(frame);
     QuicPacket* packet;
-    framer_.ConstructFragementDataPacket(header_, frames, &packet);
+    framer_.ConstructFrameDataPacket(header_, frames, &packet);
     return packet;
   }
 
   QuicGuid guid_;
   QuicFramer framer_;
   QuicPacketCreator creator_;
   QuicPacketHeader header_;
 
   BoundNetLog net_log_;
   StaticSocketDataProvider empty_data_;
@@ skipping 25 matching lines @@
   helper_->SetSendAlarm(0);
   helper_->UnregisterSendAlarmIfRegistered() ;
   EXPECT_FALSE(helper_->IsSendAlarmSet());
 }
 
 TEST_F(QuicConnectionHelperTest, TestResend) {
   //FLAGS_fake_packet_loss_percentage = 100;
   const uint64 kDefaultResendTimeMs = 500;
 
   connection_.SendStreamData(1, "foo", 0, false, NULL);
-  EXPECT_EQ(0u, helper_->header()->retransmission_count);
   EXPECT_EQ(0u, helper_->header()->transmission_time);
 
   runner_->RunNextTask();
-
-  EXPECT_EQ(1u, helper_->header()->retransmission_count);
+  EXPECT_EQ(2u, helper_->header()->packet_sequence_number);
   EXPECT_EQ(kDefaultResendTimeMs * 1000,
             helper_->header()->transmission_time);
 }
 
 TEST_F(QuicConnectionHelperTest, InitialTimeout) {
   // Verify that a single task was posted.
   EXPECT_EQ(1u, runner_->tasks()->size());
   EXPECT_EQ(base::TimeDelta::FromMicroseconds(kDefaultTimeout),
             runner_->GetTask(0).delta);
 
@@ skipping 26 matching lines @@
   EXPECT_CALL(visitor_, ConnectionClose(QUIC_CONNECTION_TIMED_OUT, false));
   runner_->RunNextTask();
   EXPECT_EQ(kDefaultTimeout + 5000, clock_.NowInUsec());
   EXPECT_FALSE(connection_.connected());
 }
 
 TEST_F(QuicConnectionHelperTest, SendSchedulerDelayThenSend) {
   // Test that if we send a packet with a delay, it ends up queued.
   scoped_ptr<QuicPacket> packet(ConstructDataPacket(1, 0));
   EXPECT_CALL(*scheduler_, TimeUntilSend(true)).WillOnce(testing::Return(1));
-  bool resend = true;
+
+  bool should_resend = true;
   bool force = false;
-  connection_.SendPacket(1, packet.get(), resend, force);
+  bool is_retransmit = false;
+  connection_.SendPacket(1, packet.get(), should_resend, force, is_retransmit);
   EXPECT_EQ(1u, connection_.NumQueuedPackets());
 
   // Advance the clock to fire the alarm, and configure the scheduler
   // to permit the packet to be sent.
   EXPECT_CALL(*scheduler_, TimeUntilSend(true)).WillOnce(testing::Return(0));
   runner_->RunNextTask();
   EXPECT_EQ(0u, connection_.NumQueuedPackets());
 }
 
 }  // namespace test
 
 }  // namespace net