Land Recent QUIC Changes.

Add helper methods to QUIC test client and peers that allow access to
information needed to test 0-Rtt behavior when talking to cluster-wide
strike registers.

QUIC testing infrastructure.

Merge internal change: 58551796
https://codereview.chromium.org/124183003/

Release QuicCryptoServerConfig::strike_register_client_lock_ before
doing calls to VerifyNonceIsValidAndUnique in order to minimize the
amount of work that happens while strike_register_client_lock_ is
locked.  This is important because VerifyNonceIsValidAndUnique may
invoke the done callback before returning, which may take arbitrary
time or create a lock cycle if invoked while the lock is held.

Relax strike_register_client_ locking requirements.

Merge internal change: 58551166
https://codereview.chromium.org/110753005/

Rename GetIncomingReliableStream to GetIncomingDataStream.

Merge internal change: 58538145
https://codereview.chromium.org/111283004/

Suppress noisy messages in QuicTimeWaitListManagerTest.

Merge internal change: 58422536
https://codereview.chromium.org/123623002/

Implement a TCP tail loss probe which will fire twice before the RTO
fires.  The tail loss probe gets re-armed every time a packet is
sent.

Merge internal change: 58420170
https://codereview.chromium.org/123523004/

Move all the packet parsing logic into QuicDispatcher from the
QuicServer / QuicDispatcher / QuicTimeWaitListManager.

Merge internal change: 58413216
https://codereview.chromium.org/123303003/

R=rch@chromium.org

Review URL: https://codereview.chromium.org/124003005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@242987 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 41 insertions, 7 deletions

diff --git a/net/tools/quic/quic_dispatcher_test.cc b/net/tools/quic/quic_dispatcher_test.cc
index 74cab69..8e1a08a 100644
--- a/net/tools/quic/quic_dispatcher_test.cc
+++ b/net/tools/quic/quic_dispatcher_test.cc
@@ -105,17 +105,52 @@ class QuicDispatcherTest : public ::testing::Test {
     return reinterpret_cast<MockConnection*>(session2_->connection());
   }
 
+  QuicEncryptedPacket* ConstructEncryptedPacket(
+      QuicGuid guid,
+      bool version_flag,
+      bool reset_flag,
+      QuicPacketSequenceNumber sequence_number,
+      const string& data) {
+    QuicPacketHeader header;
+    header.public_header.guid = guid;
+    header.public_header.guid_length = PACKET_8BYTE_GUID;
+    header.public_header.version_flag = version_flag;
+    header.public_header.reset_flag = reset_flag;
+    header.public_header.sequence_number_length = PACKET_6BYTE_SEQUENCE_NUMBER;
+    header.packet_sequence_number = sequence_number;
+    header.entropy_flag = false;
+    header.entropy_hash = 0;
+    header.fec_flag = false;
+    header.is_in_fec_group = NOT_IN_FEC_GROUP;
+    header.fec_group = 0;
+    QuicStreamFrame stream_frame(1, false, 0, MakeIOVector(data));
+    QuicFrame frame(&stream_frame);
+    QuicFrames frames;
+    frames.push_back(frame);
+    QuicFramer framer(QuicSupportedVersions(), QuicTime::Zero(), false);
+    scoped_ptr<QuicPacket> packet(
+        framer.BuildUnsizedDataPacket(header, frames).packet);
+    EXPECT_TRUE(packet != NULL);
+    QuicEncryptedPacket* encrypted = framer.EncryptPacket(ENCRYPTION_NONE,
+                                                          sequence_number,
+                                                          *packet);
+    EXPECT_TRUE(encrypted != NULL);
+    data_ = string(encrypted->data(), encrypted->length());
+    return encrypted;
+  }
+
   void ProcessPacket(IPEndPoint addr,
                      QuicGuid guid,
                      bool has_version_flag,
                      const string& data) {
-    dispatcher_.ProcessPacket(
-        IPEndPoint(), addr, guid, has_version_flag,
-        QuicEncryptedPacket(data.data(), data.length()));
+    scoped_ptr<QuicEncryptedPacket> packet(
+        ConstructEncryptedPacket(guid, has_version_flag, false, 1, data));
+    dispatcher_.ProcessPacket(IPEndPoint(), addr, *packet.get());
   }
 
   void ValidatePacket(const QuicEncryptedPacket& packet) {
-    EXPECT_TRUE(packet.AsStringPiece().find(data_) != StringPiece::npos);
+    EXPECT_EQ(data_.length(), packet.AsStringPiece().length());
+    EXPECT_EQ(data_, packet.AsStringPiece());
   }
 
   EpollServer eps_;
@@ -140,7 +175,6 @@ TEST_F(QuicDispatcherTest, ProcessPackets) {
                     &dispatcher_, 2, addr, &session2_)));
   ProcessPacket(addr, 2, true, "bar");
 
-  data_ = "eep";
   EXPECT_CALL(*reinterpret_cast<MockConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _)).Times(1).
       WillOnce(testing::WithArgs<2>(Invoke(
@@ -173,7 +207,7 @@ class MockTimeWaitListManager : public QuicTimeWaitListManager {
   MOCK_METHOD4(ProcessPacket, void(const IPEndPoint& server_address,
                                    const IPEndPoint& client_address,
                                    QuicGuid guid,
-                                   const QuicEncryptedPacket& packet));
+                                   QuicPacketSequenceNumber sequence_number));
 };
 
 TEST_F(QuicDispatcherTest, TimeWaitListManager) {
@@ -209,7 +243,7 @@ TEST_F(QuicDispatcherTest, TimeWaitListManager) {
       .WillOnce(Invoke(
           reinterpret_cast<MockConnection*>(session1_->connection()),
           &MockConnection::ReallyProcessUdpPacket));
-  dispatcher_.ProcessPacket(IPEndPoint(), addr, guid, true, *encrypted);
+  dispatcher_.ProcessPacket(IPEndPoint(), addr, *encrypted);
   EXPECT_TRUE(time_wait_list_manager->IsGuidInTimeWait(guid));
 
   // Dispatcher forwards subsequent packets for this guid to the time wait list