Landing Recent QUIC changes until Mon Nov 14 04:43:50 2016 +0000

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 <memory>
 #include <ostream>
 #include <string>
 
@@ skipping 519 matching lines @@
   EXPECT_CALL(*time_wait_list_manager_, AddConnectionIdToTimeWait(_, _, _, _))
       .Times(1);
   // A packet whose packet number is one to large to be allowed to start a
   // connection.
   ProcessPacket(client_address, connection_id, true, false, SerializeCHLO(),
                 PACKET_8BYTE_CONNECTION_ID, PACKET_6BYTE_PACKET_NUMBER,
                 kDefaultPathId,
                 QuicDispatcher::kMaxReasonableInitialPacketNumber + 1);
 }
 
+TEST_F(QuicDispatcherTest, SupportedVersionsChangeInFlight) {
+  DCHECK_EQ(3u, arraysize(kSupportedQuicVersions));
+  FLAGS_quic_fix_version_manager = true;
+  FLAGS_quic_enable_version_36_v3 = true;
+  IPEndPoint client_address(Loopback4(), 1);
+  server_address_ = IPEndPoint(Any4(), 5);
+  QuicConnectionId connection_id = 1;
+
+  EXPECT_CALL(*dispatcher_, CreateQuicSession(connection_id, client_address))
+      .Times(0);
+  ProcessPacket(client_address, connection_id, true,
+                static_cast<QuicVersion>(QuicVersionMin() - 1), SerializeCHLO(),
+                PACKET_8BYTE_CONNECTION_ID, PACKET_6BYTE_PACKET_NUMBER, 1);
+  ++connection_id;
+  EXPECT_CALL(*dispatcher_, CreateQuicSession(connection_id, client_address))
+      .WillOnce(testing::Return(CreateSession(
+          dispatcher_.get(), config_, connection_id, client_address,
+          &mock_helper_, &mock_alarm_factory_, &crypto_config_,
+          QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_)));
+  EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
+              ProcessUdpPacket(_, _, _))
+      .WillOnce(testing::WithArgs<2>(
+          Invoke(CreateFunctor(&QuicDispatcherTest::ValidatePacket,
+                               base::Unretained(this), connection_id))));
+  ProcessPacket(client_address, connection_id, true, QuicVersionMin(),
+                SerializeCHLO(), PACKET_8BYTE_CONNECTION_ID,
+                PACKET_6BYTE_PACKET_NUMBER, 1);
+  ++connection_id;
+  EXPECT_CALL(*dispatcher_, CreateQuicSession(connection_id, client_address))
+      .WillOnce(testing::Return(CreateSession(
+          dispatcher_.get(), config_, connection_id, client_address,
+          &mock_helper_, &mock_alarm_factory_, &crypto_config_,
+          QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_)));
+  EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
+              ProcessUdpPacket(_, _, _))
+      .WillOnce(testing::WithArgs<2>(
+          Invoke(CreateFunctor(&QuicDispatcherTest::ValidatePacket,
+                               base::Unretained(this), connection_id))));
+  ProcessPacket(client_address, connection_id, true, QuicVersionMax(),
+                SerializeCHLO(), PACKET_8BYTE_CONNECTION_ID,
+                PACKET_6BYTE_PACKET_NUMBER, 1);
+  // Turn off version 36.
+  FLAGS_quic_enable_version_36_v3 = false;
+  ++connection_id;
+  EXPECT_CALL(*dispatcher_, CreateQuicSession(connection_id, client_address))
+      .Times(0);
+  ProcessPacket(client_address, connection_id, true, QUIC_VERSION_36,
+                SerializeCHLO(), PACKET_8BYTE_CONNECTION_ID,
+                PACKET_6BYTE_PACKET_NUMBER, 1);
+
+  // Turn on version 36.
+  FLAGS_quic_enable_version_36_v3 = true;
+  ++connection_id;
+  EXPECT_CALL(*dispatcher_, CreateQuicSession(connection_id, client_address))
+      .WillOnce(testing::Return(CreateSession(
+          dispatcher_.get(), config_, connection_id, client_address,
+          &mock_helper_, &mock_alarm_factory_, &crypto_config_,
+          QuicDispatcherPeer::GetCache(dispatcher_.get()), &session1_)));
+  EXPECT_CALL(*reinterpret_cast<MockQuicConnection*>(session1_->connection()),
+              ProcessUdpPacket(_, _, _))
+      .WillOnce(testing::WithArgs<2>(
+          Invoke(CreateFunctor(&QuicDispatcherTest::ValidatePacket,
+                               base::Unretained(this), connection_id))));
+  ProcessPacket(client_address, connection_id, true, QUIC_VERSION_35,
+                SerializeCHLO(), PACKET_8BYTE_CONNECTION_ID,
+                PACKET_6BYTE_PACKET_NUMBER, 1);
+}
+
 // Enables mocking of the handshake-confirmation for stateless rejects.
 class MockQuicCryptoServerStream : public QuicCryptoServerStream {
  public:
   MockQuicCryptoServerStream(const QuicCryptoServerConfig& crypto_config,
                              QuicCompressedCertsCache* compressed_certs_cache,
                              QuicServerSessionBase* session,
                              QuicCryptoServerStream::Helper* helper)
       : QuicCryptoServerStream(&crypto_config,
                                compressed_certs_cache,
                                FLAGS_enable_quic_stateless_reject_support,
@@ skipping 507 matching lines @@
 }
 
 // A dispatcher whose stateless rejector will always ACCEPTs CHLO.
 class BufferedPacketStoreTest
     : public QuicDispatcherTest,
       public ::testing::WithParamInterface<BufferedPacketStoreTestParams> {
  public:
   BufferedPacketStoreTest()
       : QuicDispatcherTest(),
         client_addr_(Loopback4(), 1234),
-        proof_(new QuicCryptoProof) {
+        signed_config_(new QuicSignedServerConfig) {
     FLAGS_quic_use_cheap_stateless_rejects =
         GetParam().support_cheap_stateless_reject;
     FLAGS_enable_quic_stateless_reject_support =
         GetParam().enable_stateless_rejects_via_flag;
   }
 
   void SetUp() override {
     QuicDispatcherTest::SetUp();
     clock_ = QuicDispatcherPeer::GetHelper(dispatcher_.get())->GetClock();
 
     QuicVersion version = AllSupportedVersions().front();
     CryptoHandshakeMessage chlo = CryptoTestUtils::GenerateDefaultInchoateCHLO(
         clock_, version, &crypto_config_);
     chlo.SetVector(net::kCOPT, net::QuicTagVector{net::kSREJ});
     // Pass an inchoate CHLO.
     CryptoTestUtils::GenerateFullCHLO(
         chlo, &crypto_config_, server_ip_, client_addr_, version, clock_,
-        proof_, QuicDispatcherPeer::GetCache(dispatcher_.get()), &full_chlo_);
+        signed_config_, QuicDispatcherPeer::GetCache(dispatcher_.get()),
+        &full_chlo_);
   }
 
   string SerializeFullCHLO() {
     return full_chlo_.GetSerialized().AsStringPiece().as_string();
   }
 
  protected:
   IPAddress server_ip_;
   IPEndPoint client_addr_;
-  scoped_refptr<QuicCryptoProof> proof_;
+  scoped_refptr<QuicSignedServerConfig> signed_config_;
   const QuicClock* clock_;
   CryptoHandshakeMessage full_chlo_;
 };
 
 INSTANTIATE_TEST_CASE_P(
     BufferedPacketStoreTests,
     BufferedPacketStoreTest,
     ::testing::ValuesIn(GetBufferedPacketStoreTestParams()));
 
 TEST_P(BufferedPacketStoreTest, ProcessNonChloPacketsUptoLimitAndProcessChlo) {
@@ skipping 399 matching lines @@
 
 // Test which exercises the async GetProof codepaths, especially in the context
 // of stateless rejection.
 class AsyncGetProofTest : public QuicDispatcherTest {
  public:
   AsyncGetProofTest()
       : QuicDispatcherTest(
             std::unique_ptr<FakeProofSource>(new FakeProofSource())),
         client_addr_(net::test::Loopback4(), 1234),
         crypto_config_peer_(&crypto_config_),
-        proof_(new QuicCryptoProof) {
+        signed_config_(new QuicSignedServerConfig) {
     FLAGS_enable_async_get_proof = true;
     FLAGS_enable_quic_stateless_reject_support = true;
     FLAGS_quic_use_cheap_stateless_rejects = true;
     FLAGS_quic_create_session_after_insertion = true;
   }
 
   void SetUp() override {
     QuicDispatcherTest::SetUp();
 
     clock_ = QuicDispatcherPeer::GetHelper(dispatcher_.get())->GetClock();
     QuicVersion version = AllSupportedVersions().front();
     chlo_ = CryptoTestUtils::GenerateDefaultInchoateCHLO(clock_, version,
                                                          &crypto_config_);
     chlo_.SetVector(net::kCOPT, net::QuicTagVector{net::kSREJ});
     // Pass an inchoate CHLO.
     CryptoTestUtils::GenerateFullCHLO(
         chlo_, &crypto_config_, server_ip_, client_addr_, version, clock_,
-        proof_, QuicDispatcherPeer::GetCache(dispatcher_.get()), &full_chlo_);
+        signed_config_, QuicDispatcherPeer::GetCache(dispatcher_.get()),
+        &full_chlo_);
 
     GetFakeProofSource()->Activate();
   }
 
   FakeProofSource* GetFakeProofSource() const {
     return static_cast<FakeProofSource*>(crypto_config_peer_.GetProofSource());
   }
 
   string SerializeFullCHLO() {
     return full_chlo_.GetSerialized().AsStringPiece().as_string();
@@ skipping 29 matching lines @@
     CHECK(ok);
     return session;
   }
 
  protected:
   const IPEndPoint client_addr_;
 
  private:
   QuicCryptoServerConfigPeer crypto_config_peer_;
   IPAddress server_ip_;
-  scoped_refptr<QuicCryptoProof> proof_;
+  scoped_refptr<QuicSignedServerConfig> signed_config_;
   const QuicClock* clock_;
   CryptoHandshakeMessage chlo_;
   CryptoHandshakeMessage full_chlo_;
 
   struct SessionInfo {
     TestQuicSpdyServerSession* session;
     std::unique_ptr<MockQuicCryptoServerStream> crypto_stream;
   };
   std::map<QuicConnectionId, SessionInfo> sessions_;
 };
@@ skipping 390 matching lines @@
   check.Call(2);
   GetFakeProofSource()->InvokePendingCallback(0);
   ASSERT_EQ(GetFakeProofSource()->NumPendingCallbacks(), 0);
   EXPECT_FALSE(store->HasBufferedPackets(conn_id));
   EXPECT_FALSE(time_wait_list_manager_->IsConnectionIdInTimeWait(conn_id));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net