QUIC - Disable Preconnect when QUIC can be spoken to a server with 0RTT

net/quic/quic_stream_factory_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/quic/quic_stream_factory.h"
 
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/base/test_data_directory.h"
@@ skipping 10 matching lines @@
 #include "net/quic/crypto/properties_based_quic_server_info.h"
 #include "net/quic/crypto/quic_crypto_client_config.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/crypto/quic_server_info.h"
 #include "net/quic/quic_http_stream.h"
 #include "net/quic/quic_server_id.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/mock_crypto_client_stream_factory.h"
 #include "net/quic/test_tools/mock_random.h"
+#include "net/quic/test_tools/quic_stream_factory_peer.h"
 #include "net/quic/test_tools/quic_test_packet_maker.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/test_task_runner.h"
 #include "net/socket/socket_test_util.h"
 #include "net/spdy/spdy_session_test_util.h"
 #include "net/spdy/spdy_test_utils.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/default_channel_id_store.h"
 #include "net/test/cert_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 32 matching lines @@
   QuicVersionVector all_supported_versions = QuicSupportedVersions();
   for (const QuicVersion version : all_supported_versions) {
     params.push_back(TestParams(version, false));
     params.push_back(TestParams(version, true));
   }
   return params;
 }
 
 }  // namespace anonymous
 
-class QuicStreamFactoryPeer {
- public:
-  static const QuicConfig* GetConfig(QuicStreamFactory* factory) {
-    return &factory->config_;
-  }
-
-  static QuicCryptoClientConfig* GetCryptoConfig(QuicStreamFactory* factory) {
-    return &factory->crypto_config_;
-  }
-
-  static bool HasActiveSession(QuicStreamFactory* factory,
-                               const HostPortPair& host_port_pair) {
-    QuicServerId server_id(host_port_pair, PRIVACY_MODE_DISABLED);
-    return factory->HasActiveSession(server_id);
-  }
-
-  static QuicChromiumClientSession* GetActiveSession(
-      QuicStreamFactory* factory,
-      const HostPortPair& host_port_pair) {
-    QuicServerId server_id(host_port_pair, PRIVACY_MODE_DISABLED);
-    DCHECK(factory->HasActiveSession(server_id));
-    return factory->active_sessions_[server_id];
-  }
-
-  static scoped_ptr<QuicHttpStream> CreateFromSession(
-      QuicStreamFactory* factory,
-      QuicChromiumClientSession* session) {
-    return factory->CreateFromSession(session);
-  }
-
-  static bool IsLiveSession(QuicStreamFactory* factory,
-                            QuicChromiumClientSession* session) {
-    for (QuicStreamFactory::SessionIdMap::iterator it =
-             factory->all_sessions_.begin();
-         it != factory->all_sessions_.end(); ++it) {
-      if (it->first == session)
-        return true;
-    }
-    return false;
-  }
-
-  static void SetTaskRunner(QuicStreamFactory* factory,
-                            base::TaskRunner* task_runner) {
-    factory->task_runner_ = task_runner;
-  }
-
-  static int GetNumberOfLossyConnections(QuicStreamFactory* factory,
-                                         uint16 port) {
-    return factory->number_of_lossy_connections_[port];
-  }
-
-  static bool IsQuicDisabled(QuicStreamFactory* factory, uint16 port) {
-    return factory->IsQuicDisabled(port);
-  }
-
-  static bool GetDelayTcpRace(QuicStreamFactory* factory) {
-    return factory->delay_tcp_race_;
-  }
-
-  static void SetDelayTcpRace(QuicStreamFactory* factory, bool delay_tcp_race) {
-    factory->delay_tcp_race_ = delay_tcp_race;
-  }
-
-  static void SetYieldAfterPackets(QuicStreamFactory* factory,
-                                   int yield_after_packets) {
-    factory->yield_after_packets_ = yield_after_packets;
-  }
-
-  static void SetYieldAfterDuration(QuicStreamFactory* factory,
-                                    QuicTime::Delta yield_after_duration) {
-    factory->yield_after_duration_ = yield_after_duration;
-  }
-
-  static size_t GetNumberOfActiveJobs(QuicStreamFactory* factory,
-                                      const QuicServerId& server_id) {
-    return (factory->active_jobs_[server_id]).size();
-  }
-
-  static int GetNumTimeoutsWithOpenStreams(QuicStreamFactory* factory) {
-    return factory->num_timeouts_with_open_streams_;
-  }
-
-  static int GetNumPublicResetsPostHandshake(QuicStreamFactory* factory) {
-    return factory->num_public_resets_post_handshake_;
-  }
-
-  static void MaybeInitialize(QuicStreamFactory* factory) {
-    factory->MaybeInitialize();
-  }
-
-  static bool HasInitializedData(QuicStreamFactory* factory) {
-    return factory->has_initialized_data_;
-  }
-
-  static bool SupportsQuicAtStartUp(QuicStreamFactory* factory,
-                                    HostPortPair host_port_pair) {
-    return ContainsKey(factory->quic_supported_servers_at_startup_,
-                       host_port_pair);
-  }
-
-  static bool CryptoConfigCacheIsEmpty(QuicStreamFactory* factory,
-                                       QuicServerId& quic_server_id) {
-    return factory->CryptoConfigCacheIsEmpty(quic_server_id);
-  }
-};
-
 class MockQuicServerInfo : public QuicServerInfo {
  public:
   MockQuicServerInfo(const QuicServerId& server_id)
       : QuicServerInfo(server_id) {}
   ~MockQuicServerInfo() override {}
 
   void Start() override {}
 
   int WaitForDataReady(const CompletionCallback& callback) override {
     return ERR_IO_PENDING;
@@ skipping 2530 matching lines @@
       crypto_config->LookupOrCreate(quic_server_id);
   EXPECT_FALSE(cached->server_config().empty());
   EXPECT_TRUE(cached->GetServerConfig());
   EXPECT_EQ(server_config, cached->server_config());
   EXPECT_EQ(source_address_token, cached->source_address_token());
   EXPECT_EQ(signature, cached->signature());
   ASSERT_EQ(1U, cached->certs().size());
   EXPECT_EQ(test_cert, cached->certs()[0]);
 }
 
+TEST_P(QuicStreamFactoryTest, QuicDoingZeroRTT) {
+  Initialize();
+
+  factory_->set_require_confirmation(true);
+  QuicServerId quic_server_id(host_port_pair_, PRIVACY_MODE_DISABLED);
+  EXPECT_FALSE(factory_->ZeroRTTEnabledFor(quic_server_id));
+
+  factory_->set_require_confirmation(false);
+  EXPECT_FALSE(factory_->ZeroRTTEnabledFor(quic_server_id));
+
+  // Load server config and verify QUIC will do 0RTT.
+  QuicStreamFactoryPeer::CacheDummyServerConfig(factory_.get(), quic_server_id);
+  EXPECT_TRUE(factory_->ZeroRTTEnabledFor(quic_server_id));
+}
+
 TEST_P(QuicStreamFactoryTest, YieldAfterPackets) {
   Initialize();
   QuicStreamFactoryPeer::SetYieldAfterPackets(factory_.get(), 0);
 
   scoped_ptr<QuicEncryptedPacket> close_packet(
       ConstructConnectionClosePacket(0));
   vector<MockRead> reads;
   reads.push_back(
       MockRead(SYNCHRONOUS, close_packet->data(), close_packet->length(), 0));
   reads.push_back(MockRead(ASYNC, OK, 1));
@@ skipping 73 matching lines @@
   EXPECT_EQ(1u, observer.executed_count());
 
   scoped_ptr<QuicHttpStream> stream = request.ReleaseStream();
   EXPECT_TRUE(stream.get());
   EXPECT_TRUE(socket_data.AllReadDataConsumed());
   EXPECT_TRUE(socket_data.AllWriteDataConsumed());
 }
 
 }  // namespace test
 }  // namespace net