Update from https://crrev.com/316786

net/tools/quic/quic_dispatcher_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/tools/quic/quic_dispatcher.h"
 
 #include <string>
 
 #include "base/strings/string_piece.h"
 #include "net/quic/crypto/crypto_handshake.h"
@@ skipping 79 matching lines @@
   *session = new MockSession(connection);
   ON_CALL(*connection, SendConnectionClose(_)).WillByDefault(
       WithoutArgs(Invoke(
           connection, &MockServerConnection::UnregisterOnConnectionClosed)));
   EXPECT_CALL(*reinterpret_cast<MockConnection*>((*session)->connection()),
               ProcessUdpPacket(_, client_address, _));
 
   return *session;
 }
 
+class MockTimeWaitListManager : public QuicTimeWaitListManager {
+ public:
+  MockTimeWaitListManager(QuicPacketWriter* writer,
+                          QuicServerSessionVisitor* visitor,
+                          EpollServer* eps)
+      : QuicTimeWaitListManager(writer, visitor, eps, QuicSupportedVersions()) {
+  }
+
+  MOCK_METHOD5(ProcessPacket,
+               void(const IPEndPoint& server_address,
+                    const IPEndPoint& client_address,
+                    QuicConnectionId connection_id,
+                    QuicPacketSequenceNumber sequence_number,
+                    const QuicEncryptedPacket& packet));
+};
+
 class QuicDispatcherTest : public ::testing::Test {
  public:
   QuicDispatcherTest()
       : crypto_config_(QuicCryptoServerConfig::TESTING,
                        QuicRandom::GetInstance()),
         dispatcher_(config_, crypto_config_, &eps_),
+        time_wait_list_manager_(nullptr),
         session1_(nullptr),
         session2_(nullptr) {
     dispatcher_.Initialize(1);
   }
 
   ~QuicDispatcherTest() override {}
 
   MockConnection* connection1() {
     return reinterpret_cast<MockConnection*>(session1_->connection());
   }
@@ skipping 10 matching lines @@
         connection_id, has_version_flag, false, 1, data));
     data_ = string(packet->data(), packet->length());
     dispatcher_.ProcessPacket(server_address_, client_address, *packet);
   }
 
   void ValidatePacket(const QuicEncryptedPacket& packet) {
     EXPECT_EQ(data_.length(), packet.AsStringPiece().length());
     EXPECT_EQ(data_, packet.AsStringPiece());
   }
 
+  void CreateTimeWaitListManager() {
+    time_wait_list_manager_ = new MockTimeWaitListManager(
+        QuicDispatcherPeer::GetWriter(&dispatcher_), &dispatcher_, &eps_);
+    // dispatcher takes the ownership of time_wait_list_manager.
+    QuicDispatcherPeer::SetTimeWaitListManager(&dispatcher_,
+                                               time_wait_list_manager_);
+  }
+
   EpollServer eps_;
   QuicConfig config_;
   QuicCryptoServerConfig crypto_config_;
   IPEndPoint server_address_;
   TestDispatcher dispatcher_;
+  MockTimeWaitListManager* time_wait_list_manager_;
   MockSession* session1_;
   MockSession* session2_;
   string data_;
 };
 
 TEST_F(QuicDispatcherTest, ProcessPackets) {
   IPEndPoint client_address(net::test::Loopback4(), 1);
   IPAddressNumber any4;
   CHECK(net::ParseIPLiteralToNumber("0.0.0.0", &any4));
   server_address_ = IPEndPoint(any4, 5);
@@ skipping 26 matching lines @@
                     &dispatcher_, 1, client_address, &session1_)));
 
   ProcessPacket(client_address, 1, true, "foo");
 
   EXPECT_CALL(*reinterpret_cast<MockConnection*>(session1_->connection()),
               SendConnectionClose(QUIC_PEER_GOING_AWAY));
 
   dispatcher_.Shutdown();
 }
 
-class MockTimeWaitListManager : public QuicTimeWaitListManager {
- public:
-  MockTimeWaitListManager(QuicPacketWriter* writer,
-                          QuicServerSessionVisitor* visitor,
-                          EpollServer* eps)
-      : QuicTimeWaitListManager(writer, visitor, eps, QuicSupportedVersions()) {
-  }
+TEST_F(QuicDispatcherTest, TimeWaitListManager) {
+  CreateTimeWaitListManager();
 
-  MOCK_METHOD5(ProcessPacket, void(const IPEndPoint& server_address,
-                                   const IPEndPoint& client_address,
-                                   QuicConnectionId connection_id,
-                                   QuicPacketSequenceNumber sequence_number,
-                                   const QuicEncryptedPacket& packet));
-};
-
-TEST_F(QuicDispatcherTest, TimeWaitListManager) {
-  MockTimeWaitListManager* time_wait_list_manager =
-      new MockTimeWaitListManager(
-          QuicDispatcherPeer::GetWriter(&dispatcher_), &dispatcher_, &eps_);
-  // dispatcher takes the ownership of time_wait_list_manager.
-  QuicDispatcherPeer::SetTimeWaitListManager(&dispatcher_,
-                                             time_wait_list_manager);
   // Create a new session.
   IPEndPoint client_address(net::test::Loopback4(), 1);
   QuicConnectionId connection_id = 1;
   EXPECT_CALL(dispatcher_, CreateQuicSession(connection_id, _, client_address))
       .WillOnce(testing::Return(CreateSession(
                     &dispatcher_, connection_id, client_address, &session1_)));
   ProcessPacket(client_address, connection_id, true, "foo");
 
   // Close the connection by sending public reset packet.
   QuicPublicResetPacket packet;
   packet.public_header.connection_id = connection_id;
   packet.public_header.reset_flag = true;
   packet.public_header.version_flag = false;
   packet.rejected_sequence_number = 19191;
   packet.nonce_proof = 132232;
   scoped_ptr<QuicEncryptedPacket> encrypted(
       QuicFramer::BuildPublicResetPacket(packet));
   EXPECT_CALL(*session1_, OnConnectionClosed(QUIC_PUBLIC_RESET, true)).Times(1)
       .WillOnce(WithoutArgs(Invoke(
           reinterpret_cast<MockServerConnection*>(session1_->connection()),
           &MockServerConnection::UnregisterOnConnectionClosed)));
   EXPECT_CALL(*reinterpret_cast<MockConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
       .WillOnce(Invoke(
           reinterpret_cast<MockConnection*>(session1_->connection()),
           &MockConnection::ReallyProcessUdpPacket));
   dispatcher_.ProcessPacket(IPEndPoint(), client_address, *encrypted);
-  EXPECT_TRUE(time_wait_list_manager->IsConnectionIdInTimeWait(connection_id));
+  EXPECT_TRUE(time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id));
 
   // Dispatcher forwards subsequent packets for this connection_id to the time
   // wait list manager.
-  EXPECT_CALL(*time_wait_list_manager,
+  EXPECT_CALL(*time_wait_list_manager_,
               ProcessPacket(_, _, connection_id, _, _)).Times(1);
   ProcessPacket(client_address, connection_id, true, "foo");
 }
 
 TEST_F(QuicDispatcherTest, StrayPacketToTimeWaitListManager) {
-  MockTimeWaitListManager* time_wait_list_manager =
-      new MockTimeWaitListManager(
-          QuicDispatcherPeer::GetWriter(&dispatcher_), &dispatcher_, &eps_);
-  // dispatcher takes the ownership of time_wait_list_manager.
-  QuicDispatcherPeer::SetTimeWaitListManager(&dispatcher_,
-                                             time_wait_list_manager);
+  CreateTimeWaitListManager();
 
   IPEndPoint client_address(net::test::Loopback4(), 1);
   QuicConnectionId connection_id = 1;
   // Dispatcher forwards all packets for this connection_id to the time wait
   // list manager.
   EXPECT_CALL(dispatcher_, CreateQuicSession(_, _, _)).Times(0);
-  EXPECT_CALL(*time_wait_list_manager,
+  EXPECT_CALL(*time_wait_list_manager_,
               ProcessPacket(_, _, connection_id, _, _)).Times(1);
   string data = "foo";
   ProcessPacket(client_address, connection_id, false, "foo");
 }
 
+TEST_F(QuicDispatcherTest, ProcessPacketWithBogusPort) {
+  CreateTimeWaitListManager();
+
+  IPEndPoint client_address(net::test::Loopback4(), 0);
+  IPAddressNumber any4;
+  CHECK(net::ParseIPLiteralToNumber("0.0.0.0", &any4));
+  server_address_ = IPEndPoint(any4, 5);
+
+  EXPECT_CALL(dispatcher_, CreateQuicSession(1, _, client_address)).Times(0);
+  EXPECT_CALL(*time_wait_list_manager_, ProcessPacket(_, _, _, _, _)).Times(0);
+  ProcessPacket(client_address, 1, true, "foo");
+  EXPECT_EQ(client_address, dispatcher_.current_client_address());
+  EXPECT_EQ(server_address_, dispatcher_.current_server_address());
+}
+
 class BlockingWriter : public QuicPacketWriterWrapper {
  public:
   BlockingWriter() : write_blocked_(false) {}
 
   bool IsWriteBlocked() const override { return write_blocked_; }
   void SetWritable() override { write_blocked_ = false; }
 
   WriteResult WritePacket(const char* buffer,
                           size_t buf_len,
                           const IPAddressNumber& self_client_address,
@@ skipping 178 matching lines @@
   // And we'll resume where we left off when we get another call.
   EXPECT_CALL(*connection2(), OnCanWrite());
   dispatcher_.OnCanWrite();
   EXPECT_FALSE(dispatcher_.HasPendingWrites());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net