Make TimeWaitListManager use PacketWriter's socket writability state.

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"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/quic_data_reader.h"
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_packet_writer.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/tools/quic/test_tools/mock_epoll_server.h"
 #include "net/tools/quic/test_tools/quic_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using net::test::FramerVisitorCapturingPublicReset;
 using testing::_;
 using testing::Args;
+using testing::Assign;
+using testing::DoAll;
 using testing::Matcher;
 using testing::MatcherInterface;
 using testing::NiceMock;
 using testing::Return;
+using testing::ReturnPointee;
 using testing::SetArgPointee;
 using testing::StrictMock;
 using testing::Truly;
 
 namespace net {
 namespace tools {
 namespace test {
 
 class QuicTimeWaitListManagerPeer {
  public:
-  static bool is_write_blocked(QuicTimeWaitListManager* manager) {
-    return manager->is_write_blocked_;
-  }
-
   static bool ShouldSendResponse(QuicTimeWaitListManager* manager,
                           int received_packet_count) {
     return manager->ShouldSendResponse(received_packet_count);
   }
 
   static QuicTime::Delta time_wait_period(QuicTimeWaitListManager* manager) {
     return manager->kTimeWaitPeriod_;
   }
 
   static QuicVersion GetQuicVersionFromGuid(QuicTimeWaitListManager* manager,
@@ skipping 17 matching lines @@
   MOCK_METHOD2(RegisterAlarm, void(int64 timeout_in_us,
                                    EpollAlarmCallbackInterface* alarm));
 };
 
 class QuicTimeWaitListManagerTest : public testing::Test {
  protected:
   QuicTimeWaitListManagerTest()
       : time_wait_list_manager_(
           &writer_, &epoll_server_, QuicSupportedVersions()),
         framer_(QuicSupportedVersions(), QuicTime::Zero(), true),
-        guid_(45) {
-  }
+        guid_(45),
+        writer_is_blocked_(false) {}
 
   virtual ~QuicTimeWaitListManagerTest() {}
 
+  virtual void SetUp() {
+    EXPECT_CALL(writer_, IsWriteBlocked())
+        .WillRepeatedly(ReturnPointee(&writer_is_blocked_));
+    EXPECT_CALL(writer_, IsWriteBlockedDataBuffered())
+        .WillRepeatedly(Return(false));
+  }
+
   void AddGuid(QuicGuid guid) {
     AddGuid(guid, net::test::QuicVersionMax(), NULL);
   }
 
   void AddGuid(QuicGuid guid,
                QuicVersion version,
                QuicEncryptedPacket* packet) {
     time_wait_list_manager_.AddGuidToTimeWait(guid, version, packet);
   }
 
@@ skipping 38 matching lines @@
     return encrypted;
   }
 
   NiceMock<MockFakeTimeEpollServer> epoll_server_;
   StrictMock<MockPacketWriter> writer_;
   QuicTimeWaitListManager time_wait_list_manager_;
   QuicFramer framer_;
   QuicGuid guid_;
   IPEndPoint server_address_;
   IPEndPoint client_address_;
+  bool writer_is_blocked_;
 };
 
 class ValidatePublicResetPacketPredicate
     : public MatcherInterface<const std::tr1::tuple<const char*, int> > {
  public:
   explicit ValidatePublicResetPacketPredicate(QuicGuid guid,
                                               QuicPacketSequenceNumber number)
       : guid_(guid), sequence_number_(number) {
   }
 
@@ skipping 128 matching lines @@
       ConstructEncryptedPacket(ENCRYPTION_NONE, guid, sequence_number));
   // Let first write through.
   EXPECT_CALL(writer_, WritePacket(_, _,
                                    server_address_.address(),
                                    client_address_,
                                    &time_wait_list_manager_))
       .With(Args<0, 1>(PublicResetPacketEq(guid,
                                            sequence_number)))
       .WillOnce(Return(WriteResult(WRITE_STATUS_OK, packet->length())));
   ProcessPacket(guid, sequence_number);
-  EXPECT_FALSE(
-      QuicTimeWaitListManagerPeer::is_write_blocked(&time_wait_list_manager_));
 
   // write block for the next packet.
   EXPECT_CALL(writer_, WritePacket(_, _,
                                    server_address_.address(),
                                    client_address_,
                                    &time_wait_list_manager_))
       .With(Args<0, 1>(PublicResetPacketEq(guid,
                                            sequence_number)))
-      .WillOnce(Return(WriteResult(WRITE_STATUS_BLOCKED, EAGAIN)));
+      .WillOnce(DoAll(
+          Assign(&writer_is_blocked_, true),
+          Return(WriteResult(WRITE_STATUS_BLOCKED, EAGAIN))));
   ProcessPacket(guid, sequence_number);
   // 3rd packet. No public reset should be sent;
   ProcessPacket(guid, sequence_number);
-  EXPECT_TRUE(
-      QuicTimeWaitListManagerPeer::is_write_blocked(&time_wait_list_manager_));
 
-  // write packet should not be called since already write blocked but the
+  // 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(_, _, _, _, _))
       .Times(0);
   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_))
       .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_))
       .With(Args<0, 1>(PublicResetPacketEq(other_guid,
                                            other_sequence_number)))
       .WillOnce(Return(WriteResult(WRITE_STATUS_OK,
                                    other_packet->length())));
   time_wait_list_manager_.OnCanWrite();
-  EXPECT_FALSE(
-      QuicTimeWaitListManagerPeer::is_write_blocked(&time_wait_list_manager_));
 }
 
 TEST_F(QuicTimeWaitListManagerTest, GetQuicVersionFromMap) {
   const int kGuid1 = 123;
   const int kGuid2 = 456;
   const int kGuid3 = 789;
 
   AddGuid(kGuid1, net::test::QuicVersionMin(), NULL);
   AddGuid(kGuid2, net::test::QuicVersionMax(), NULL);
   AddGuid(kGuid3, net::test::QuicVersionMax(), NULL);
 
   EXPECT_EQ(net::test::QuicVersionMin(),
             QuicTimeWaitListManagerPeer::GetQuicVersionFromGuid(
                 &time_wait_list_manager_, kGuid1));
   EXPECT_EQ(net::test::QuicVersionMax(),
             QuicTimeWaitListManagerPeer::GetQuicVersionFromGuid(
                 &time_wait_list_manager_, kGuid2));
   EXPECT_EQ(net::test::QuicVersionMax(),
             QuicTimeWaitListManagerPeer::GetQuicVersionFromGuid(
                 &time_wait_list_manager_, kGuid3));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net