Add the client address to the Public Reset packet.

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/quic_utils.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;
@@ skipping 36 matching lines @@
                                    EpollAlarmCallbackInterface* alarm));
 };
 
 class QuicTimeWaitListManagerTest : public testing::Test {
  protected:
   QuicTimeWaitListManagerTest()
       : time_wait_list_manager_(&writer_, &visitor_,
                                 &epoll_server_, QuicSupportedVersions()),
         framer_(QuicSupportedVersions(), QuicTime::Zero(), true),
         guid_(45),
+        client_address_(net::test::TestPeerIPAddress(), kTestPort),
         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));
   }
@@ skipping 75 matching lines @@
     QuicFramer framer(QuicSupportedVersions(),
                       QuicTime::Zero(),
                       false);
     framer.set_visitor(&visitor);
     QuicEncryptedPacket encrypted(std::tr1::get<0>(packet_buffer),
                                   std::tr1::get<1>(packet_buffer));
     framer.ProcessPacket(encrypted);
     QuicPublicResetPacket packet = visitor.public_reset_packet();
     return guid_ == packet.public_header.guid &&
         packet.public_header.reset_flag && !packet.public_header.version_flag &&
-        sequence_number_ == packet.rejected_sequence_number;
+        sequence_number_ == packet.rejected_sequence_number &&
+        net::test::TestPeerIPAddress() == packet.client_address.address() &&
+        kTestPort == packet.client_address.port();
   }
 
   virtual void DescribeTo(::std::ostream* os) const { }
 
   virtual void DescribeNegationTo(::std::ostream* os) const { }
 
  private:
   QuicGuid guid_;
   QuicPacketSequenceNumber sequence_number_;
 };
@@ skipping 232 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