Land Recent QUIC Changes

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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "net/base/net_errors.h"
@@ skipping 2993 matching lines @@
 
   QuicGoAwayFrame goaway;
   goaway.last_good_stream_id = 1;
   goaway.error_code = QUIC_PEER_GOING_AWAY;
   goaway.reason_phrase = "Going away.";
   EXPECT_CALL(visitor_, OnGoAway(_));
   ProcessGoAwayPacket(&goaway);
 }
 
 TEST_P(QuicConnectionTest, WindowUpdate) {
-  if (version() < QUIC_VERSION_14) {
+  if (version() == QUIC_VERSION_13) {
     return;
   }
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   QuicWindowUpdateFrame window_update;
   window_update.stream_id = 3;
   window_update.byte_offset = 1234;
   EXPECT_CALL(visitor_, OnWindowUpdateFrames(_));
   ProcessFramePacket(QuicFrame(&window_update));
 }
 
 TEST_P(QuicConnectionTest, Blocked) {
-  if (version() < QUIC_VERSION_14) {
+  if (version() == QUIC_VERSION_13) {
     return;
   }
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   QuicBlockedFrame blocked;
   blocked.stream_id = 3;
   EXPECT_CALL(visitor_, OnBlockedFrames(_));
   ProcessFramePacket(QuicFrame(&blocked));
 }
 
@@ skipping 554 matching lines @@
   EXPECT_TRUE(writer_->IsWriteBlocked());
   TriggerConnectionClose();
   EXPECT_EQ(1u, writer_->packets_write_attempts());
 }
 
 TEST_P(QuicConnectionTest, AckNotifierTriggerCallback) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   // Create a delegate which we expect to be called.
   scoped_refptr<MockAckNotifierDelegate> delegate(new MockAckNotifierDelegate);
-  EXPECT_CALL(*delegate, OnAckNotification()).Times(1);
+  EXPECT_CALL(*delegate, OnAckNotification(_, _, _, _)).Times(1);
 
   // Send some data, which will register the delegate to be notified.
   connection_.SendStreamDataWithString(1, "foo", 0, !kFin, delegate.get());
 
   // Process an ACK from the server which should trigger the callback.
   EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _)).Times(1);
   QuicAckFrame frame = InitAckFrame(1, 0);
   ProcessAckPacket(&frame);
 }
 
 TEST_P(QuicConnectionTest, AckNotifierFailToTriggerCallback) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   // Create a delegate which we don't expect to be called.
   scoped_refptr<MockAckNotifierDelegate> delegate(new MockAckNotifierDelegate);
-  EXPECT_CALL(*delegate, OnAckNotification()).Times(0);
+  EXPECT_CALL(*delegate, OnAckNotification(_, _, _, _)).Times(0);
 
   EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _)).Times(2);
 
   // Send some data, which will register the delegate to be notified. This will
   // not be ACKed and so the delegate should never be called.
   connection_.SendStreamDataWithString(1, "foo", 0, !kFin, delegate.get());
 
   // Send some other data which we will ACK.
   connection_.SendStreamDataWithString(1, "foo", 0, !kFin, NULL);
@@ skipping 10 matching lines @@
   EXPECT_CALL(*send_algorithm_, OnPacketLost(1, _));
   EXPECT_CALL(*send_algorithm_, OnPacketAbandoned(1, _));
   ProcessAckPacket(&frame);
 }
 
 TEST_P(QuicConnectionTest, AckNotifierCallbackAfterRetransmission) {
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   // Create a delegate which we expect to be called.
   scoped_refptr<MockAckNotifierDelegate> delegate(new MockAckNotifierDelegate);
-  EXPECT_CALL(*delegate, OnAckNotification()).Times(1);
+  EXPECT_CALL(*delegate, OnAckNotification(_, _, _, _)).Times(1);
 
   // Send four packets, and register to be notified on ACK of packet 2.
   connection_.SendStreamDataWithString(3, "foo", 0, !kFin, NULL);
   connection_.SendStreamDataWithString(3, "bar", 0, !kFin, delegate.get());
   connection_.SendStreamDataWithString(3, "baz", 0, !kFin, NULL);
   connection_.SendStreamDataWithString(3, "qux", 0, !kFin, NULL);
 
   // Now we receive ACK for packets 1, 3, and 4 and lose 2.
   QuicAckFrame frame = InitAckFrame(4, 0);
   NackPacket(2, &frame);
@@ skipping 22 matching lines @@
 //                ACK) triggers notification on our end.
 TEST_P(QuicConnectionTest, AckNotifierCallbackAfterFECRecovery) {
   if (version() < QUIC_VERSION_15) {
     return;
   }
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
   EXPECT_CALL(visitor_, OnCanWrite());
 
   // Create a delegate which we expect to be called.
   scoped_refptr<MockAckNotifierDelegate> delegate(new MockAckNotifierDelegate);
-  EXPECT_CALL(*delegate, OnAckNotification()).Times(1);
+  EXPECT_CALL(*delegate, OnAckNotification(_, _, _, _)).Times(1);
 
   // Expect ACKs for 1 packet.
   EXPECT_CALL(*send_algorithm_, UpdateRtt(_));
   EXPECT_CALL(*send_algorithm_, OnPacketAcked(_, _)).Times(1);
 
   // Send one packet, and register to be notified on ACK.
   connection_.SendStreamDataWithString(1, "foo", 0, !kFin, delegate.get());
 
   // Ack packet gets dropped, but we receive an FEC packet that covers it.
   // Should recover the Ack packet and trigger the notification callback.
@@ skipping 22 matching lines @@
   // FEC packet which allows the ACK packet to be recovered.
   ProcessFecPacket(2, 1, true, !kEntropyFlag, packet);
 }
 
 class MockQuicConnectionDebugVisitor
     : public QuicConnectionDebugVisitorInterface {
  public:
   MOCK_METHOD1(OnFrameAddedToPacket,
                void(const QuicFrame&));
 
-  MOCK_METHOD4(OnPacketSent,
+  MOCK_METHOD5(OnPacketSent,
                void(QuicPacketSequenceNumber,
                     EncryptionLevel,
+                    TransmissionType,
                     const QuicEncryptedPacket&,
                     WriteResult));
 
   MOCK_METHOD2(OnPacketRetransmitted,
                void(QuicPacketSequenceNumber,
                     QuicPacketSequenceNumber));
 
   MOCK_METHOD3(OnPacketReceived,
                void(const IPEndPoint&,
                     const IPEndPoint&,
@@ skipping 48 matching lines @@
 
   TestConnection server(connection_id_, IPEndPoint(), helper_.get(),
                         writer_.get(), true, version());
   TestConnection client(connection_id_, IPEndPoint(), helper_.get(),
                         writer_.get(), false, version());
   EXPECT_TRUE(client.sent_packet_manager().using_pacing());
   EXPECT_FALSE(server.sent_packet_manager().using_pacing());
 }
 
 TEST_P(QuicConnectionTest, ControlFramesInstigateAcks) {
-  if (version() < QUIC_VERSION_14) {
+  if (version() == QUIC_VERSION_13) {
     return;
   }
   EXPECT_CALL(visitor_, OnSuccessfulVersionNegotiation(_));
 
   // Send a WINDOW_UPDATE frame.
   QuicWindowUpdateFrame window_update;
   window_update.stream_id = 3;
   window_update.byte_offset = 1234;
   EXPECT_CALL(visitor_, OnWindowUpdateFrames(_));
   ProcessFramePacket(QuicFrame(&window_update));
 
   // Ensure that this has caused the ACK alarm to be set.
   QuicAlarm* ack_alarm = QuicConnectionPeer::GetAckAlarm(&connection_);
   EXPECT_TRUE(ack_alarm->IsSet());
 
   // Cancel alarm, and try again with BLOCKED frame.
   ack_alarm->Cancel();
   QuicBlockedFrame blocked;
   blocked.stream_id = 3;
   EXPECT_CALL(visitor_, OnBlockedFrames(_));
   ProcessFramePacket(QuicFrame(&blocked));
   EXPECT_TRUE(ack_alarm->IsSet());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net