Cleanup: remove BlockedWriterInterface from QuicPacketWriter.

net/tools/quic/quic_time_wait_list_manager_test.cc

 // Copyright 2013 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/tools/quic/quic_time_wait_list_manager.h"
 
 #include <errno.h>
 
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/null_encrypter.h"
@@ skipping 182 matching lines @@
 
 TEST_F(QuicTimeWaitListManagerTest, SendConnectionClose) {
   size_t kConnectionCloseLength = 100;
   AddGuid(guid_,
           net::test::QuicVersionMax(),
           new QuicEncryptedPacket(
               new char[kConnectionCloseLength], kConnectionCloseLength, true));
   const int kRandomSequenceNumber = 1;
   EXPECT_CALL(writer_, WritePacket(_, kConnectionCloseLength,
                                    server_address_.address(),
-                                   client_address_,
-                                   &time_wait_list_manager_))
+                                   client_address_))
       .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 1)));
 
   ProcessPacket(guid_, kRandomSequenceNumber);
 }
 
 TEST_F(QuicTimeWaitListManagerTest, SendPublicReset) {
   AddGuid(guid_);
   const int kRandomSequenceNumber = 1;
   EXPECT_CALL(writer_, WritePacket(_, _,
                                    server_address_.address(),
-                                   client_address_,
-                                   &time_wait_list_manager_))
+                                   client_address_))
       .With(Args<0, 1>(PublicResetPacketEq(guid_,
                                            kRandomSequenceNumber)))
       .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 0)));
 
   ProcessPacket(guid_, kRandomSequenceNumber);
 }
 
 TEST_F(QuicTimeWaitListManagerTest, SendPublicResetWithExponentialBackOff) {
   AddGuid(guid_);
   for (int sequence_number = 1; sequence_number < 101; ++sequence_number) {
     if ((sequence_number & (sequence_number - 1)) == 0) {
-      EXPECT_CALL(writer_, WritePacket(_, _, _, _, _))
+      EXPECT_CALL(writer_, WritePacket(_, _, _, _))
           .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 1)));
     }
     ProcessPacket(guid_, sequence_number);
     // Send public reset with exponential back off.
     if ((sequence_number & (sequence_number - 1)) == 0) {
       EXPECT_TRUE(QuicTimeWaitListManagerPeer::ShouldSendResponse(
                       &time_wait_list_manager_, sequence_number));
     } else {
       EXPECT_FALSE(QuicTimeWaitListManagerPeer::ShouldSendResponse(
                        &time_wait_list_manager_, sequence_number));
@@ skipping 37 matching lines @@
 
 TEST_F(QuicTimeWaitListManagerTest, SendQueuedPackets) {
   QuicGuid guid = 1;
   AddGuid(guid);
   QuicPacketSequenceNumber sequence_number = 234;
   scoped_ptr<QuicEncryptedPacket> packet(
       ConstructEncryptedPacket(ENCRYPTION_NONE, guid, sequence_number));
   // Let first write through.
   EXPECT_CALL(writer_, WritePacket(_, _,
                                    server_address_.address(),
-                                   client_address_,
-                                   &time_wait_list_manager_))
+                                   client_address_))
       .With(Args<0, 1>(PublicResetPacketEq(guid,
                                            sequence_number)))
       .WillOnce(Return(WriteResult(WRITE_STATUS_OK, packet->length())));
   ProcessPacket(guid, sequence_number);
 
   // write block for the next packet.
   EXPECT_CALL(writer_, WritePacket(_, _,
                                    server_address_.address(),
-                                   client_address_,
-                                   &time_wait_list_manager_))
+                                   client_address_))
       .With(Args<0, 1>(PublicResetPacketEq(guid,
                                            sequence_number)))
       .WillOnce(DoAll(
           Assign(&writer_is_blocked_, true),
           Return(WriteResult(WRITE_STATUS_BLOCKED, EAGAIN))));
   EXPECT_CALL(visitor_, OnWriteBlocked(&time_wait_list_manager_));
   ProcessPacket(guid, sequence_number);
   // 3rd packet. No public reset should be sent;
   ProcessPacket(guid, sequence_number);
 
   // write packet should not be called since we are write blocked but the
   // should be queued.
   QuicGuid other_guid = 2;
   AddGuid(other_guid);
   QuicPacketSequenceNumber other_sequence_number = 23423;
   scoped_ptr<QuicEncryptedPacket> other_packet(
       ConstructEncryptedPacket(
           ENCRYPTION_NONE, other_guid, other_sequence_number));
-  EXPECT_CALL(writer_, WritePacket(_, _, _, _, _))
+  EXPECT_CALL(writer_, WritePacket(_, _, _, _))
       .Times(0);
   EXPECT_CALL(visitor_, OnWriteBlocked(&time_wait_list_manager_));
   ProcessPacket(other_guid, other_sequence_number);
 
   // Now expect all the write blocked public reset packets to be sent again.
   writer_is_blocked_ = false;
   EXPECT_CALL(writer_, WritePacket(_, _,
                                    server_address_.address(),
-                                   client_address_,
-                                   &time_wait_list_manager_))
+                                   client_address_))
       .With(Args<0, 1>(PublicResetPacketEq(guid,
                                            sequence_number)))
       .WillOnce(Return(WriteResult(WRITE_STATUS_OK, packet->length())));
   EXPECT_CALL(writer_, WritePacket(_, _,
                                    server_address_.address(),
-                                   client_address_,
-                                   &time_wait_list_manager_))
+                                   client_address_))
       .With(Args<0, 1>(PublicResetPacketEq(other_guid,
                                            other_sequence_number)))
       .WillOnce(Return(WriteResult(WRITE_STATUS_OK,
                                    other_packet->length())));
   time_wait_list_manager_.OnCanWrite();
 }
 
 TEST_F(QuicTimeWaitListManagerTest, GetQuicVersionFromMap) {
   const int kGuid1 = 123;
   const int kGuid2 = 456;
@@ skipping 22 matching lines @@
   size_t kConnectionCloseLength = 100;
   AddGuid(guid_,
           net::test::QuicVersionMax(),
           new QuicEncryptedPacket(
               new char[kConnectionCloseLength], kConnectionCloseLength, true));
   EXPECT_TRUE(IsGuidInTimeWait(guid_));
 
   EXPECT_CALL(writer_, WritePacket(_,
                                    kConnectionCloseLength,
                                    server_address_.address(),
-                                   client_address_,
-                                   &time_wait_list_manager_))
+                                   client_address_))
       .WillOnce(Return(WriteResult(WRITE_STATUS_OK, 1)));
 
   const int kRandomSequenceNumber = 1;
   ProcessPacket(guid_, kRandomSequenceNumber);
 
   const QuicTime::Delta time_wait_period =
       QuicTimeWaitListManagerPeer::time_wait_period(&time_wait_list_manager_);
 
   QuicTime::Delta offset = QuicTime::Delta::FromMicroseconds(39);
   // Now set the current time as time_wait_period + offset usecs.
@@ skipping 30 matching lines @@
   EXPECT_CALL(epoll_server_, RegisterAlarm(_, _));
 
   time_wait_list_manager_.CleanUpOldGuids();
   EXPECT_FALSE(IsGuidInTimeWait(kGuid1));
   EXPECT_TRUE(IsGuidInTimeWait(kGuid2));
 }
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net