Change QuicStreamRequest::Request() to take a preferred QuicVersion so that

net/quic/chromium/quic_stream_factory.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/chromium/quic_stream_factory.h"
 
 #include <algorithm>
 #include <tuple>
 #include <utility>
 
@@ skipping 308 matching lines @@
   base::WeakPtrFactory<CertVerifierJob> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CertVerifierJob);
 };
 
 // Responsible for creating a new QUIC session to the specified server, and
 // for notifying any associated requests when complete.
 class QuicStreamFactory::Job {
  public:
   Job(QuicStreamFactory* factory,
+      const QuicVersion& quic_version,
       HostResolver* host_resolver,
       const QuicSessionKey& key,
       bool was_alternative_service_recently_broken,
       int cert_verify_flags,
       const NetLogWithSource& net_log);
 
   ~Job();
 
   int Run(const CompletionCallback& callback);
 
@@ skipping 20 matching lines @@
   enum IoState {
     STATE_NONE,
     STATE_RESOLVE_HOST,
     STATE_RESOLVE_HOST_COMPLETE,
     STATE_CONNECT,
     STATE_CONNECT_COMPLETE,
   };
   IoState io_state_;
 
   QuicStreamFactory* factory_;
+  QuicVersion quic_version_;
   HostResolver* host_resolver_;
   std::unique_ptr<HostResolver::Request> request_;
   const QuicSessionKey key_;
   const int cert_verify_flags_;
   const bool was_alternative_service_recently_broken_;
   const NetLogWithSource net_log_;
   int num_sent_client_hellos_;
   QuicChromiumClientSession* session_;
   CompletionCallback callback_;
   AddressList address_list_;
   base::TimeTicks dns_resolution_start_time_;
   base::TimeTicks dns_resolution_end_time_;
   base::WeakPtrFactory<Job> weak_factory_;
   DISALLOW_COPY_AND_ASSIGN(Job);
 };
 
 QuicStreamFactory::Job::Job(QuicStreamFactory* factory,
+                            const QuicVersion& quic_version,
                             HostResolver* host_resolver,
                             const QuicSessionKey& key,
                             bool was_alternative_service_recently_broken,
                             int cert_verify_flags,
                             const NetLogWithSource& net_log)
     : io_state_(STATE_RESOLVE_HOST),
       factory_(factory),
+      quic_version_(quic_version),
       host_resolver_(host_resolver),
       key_(key),
       cert_verify_flags_(cert_verify_flags),
       was_alternative_service_recently_broken_(
           was_alternative_service_recently_broken),
       net_log_(
           NetLogWithSource::Make(net_log.net_log(),
                                  NetLogSourceType::QUIC_STREAM_FACTORY_JOB)),
       num_sent_client_hellos_(0),
       session_(nullptr),
@@ skipping 98 matching lines @@
 
 int QuicStreamFactory::Job::DoConnect() {
   io_state_ = STATE_CONNECT_COMPLETE;
 
   bool require_confirmation = factory_->require_confirmation() ||
                               was_alternative_service_recently_broken_;
   net_log_.BeginEvent(
       NetLogEventType::QUIC_STREAM_FACTORY_JOB_CONNECT,
       NetLog::BoolCallback("require_confirmation", require_confirmation));
 
-  int rv =
-      factory_->CreateSession(key_, cert_verify_flags_, require_confirmation,
-                              address_list_, dns_resolution_start_time_,
-                              dns_resolution_end_time_, net_log_, &session_);
+  DCHECK_NE(quic_version_, QUIC_VERSION_UNSUPPORTED);
+  int rv = factory_->CreateSession(
+      key_, quic_version_, cert_verify_flags_, require_confirmation,
+      address_list_, dns_resolution_start_time_, dns_resolution_end_time_,
+      net_log_, &session_);
   if (rv != OK) {
     DCHECK(rv != ERR_IO_PENDING);
     DCHECK(!session_);
     return rv;
   }
 
   if (!session_->connection()->connected())
     return ERR_CONNECTION_CLOSED;
 
   session_->StartReading();
@@ skipping 49 matching lines @@
 
 QuicStreamRequest::QuicStreamRequest(QuicStreamFactory* factory)
     : factory_(factory) {}
 
 QuicStreamRequest::~QuicStreamRequest() {
   if (factory_ && !callback_.is_null())
     factory_->CancelRequest(this);
 }
 
 int QuicStreamRequest::Request(const HostPortPair& destination,
+                               QuicVersion quic_version,
                                PrivacyMode privacy_mode,
                                int cert_verify_flags,
                                const GURL& url,
                                QuicStringPiece method,
                                const NetLogWithSource& net_log,
                                const CompletionCallback& callback) {
+  DCHECK_NE(quic_version, QUIC_VERSION_UNSUPPORTED);
   DCHECK(callback_.is_null());
   DCHECK(factory_);
   server_id_ = QuicServerId(HostPortPair::FromURL(url), privacy_mode);
 
-  int rv = factory_->Create(server_id_, destination, cert_verify_flags, url,
-                            method, net_log, this);
+  int rv = factory_->Create(server_id_, destination, quic_version,
+                            cert_verify_flags, url, method, net_log, this);
   if (rv == ERR_IO_PENDING) {
     net_log_ = net_log;
     callback_ = callback;
   } else {
     factory_ = nullptr;
   }
   if (rv == OK)
     DCHECK(session_);
   return rv;
 }
@@ skipping 39 matching lines @@
     CTPolicyEnforcer* ct_policy_enforcer,
     ChannelIDService* channel_id_service,
     TransportSecurityState* transport_security_state,
     CTVerifier* cert_transparency_verifier,
     SocketPerformanceWatcherFactory* socket_performance_watcher_factory,
     QuicCryptoClientStreamFactory* quic_crypto_client_stream_factory,
     QuicRandom* random_generator,
     QuicClock* clock,
     size_t max_packet_length,
     const std::string& user_agent_id,
-    const QuicVersionVector& supported_versions,
     bool store_server_configs_in_properties,
     bool close_sessions_on_ip_change,
     bool mark_quic_broken_when_network_blackholes,
     int idle_connection_timeout_seconds,
     int reduced_ping_timeout_seconds,
     int packet_reader_yield_after_duration_milliseconds,
     bool migrate_sessions_on_network_change,
     bool migrate_sessions_early,
     bool allow_server_migration,
     bool force_hol_blocking,
@@ skipping 16 matching lines @@
       max_packet_length_(max_packet_length),
       clock_skew_detector_(base::TimeTicks::Now(), base::Time::Now()),
       socket_performance_watcher_factory_(socket_performance_watcher_factory),
       config_(InitializeQuicConfig(connection_options,
                                    idle_connection_timeout_seconds)),
       crypto_config_(base::WrapUnique(
           new ProofVerifierChromium(cert_verifier,
                                     ct_policy_enforcer,
                                     transport_security_state,
                                     cert_transparency_verifier))),
-      supported_versions_(supported_versions),
       mark_quic_broken_when_network_blackholes_(
           mark_quic_broken_when_network_blackholes),
       store_server_configs_in_properties_(store_server_configs_in_properties),
       ping_timeout_(QuicTime::Delta::FromSeconds(kPingTimeoutSecs)),
       reduced_ping_timeout_(
           QuicTime::Delta::FromSeconds(reduced_ping_timeout_seconds)),
       yield_after_packets_(kQuicYieldAfterPacketsRead),
       yield_after_duration_(QuicTime::Delta::FromMilliseconds(
           packet_reader_yield_after_duration_milliseconds)),
       close_sessions_on_ip_change_(close_sessions_on_ip_change),
@@ skipping 139 matching lines @@
         session->CanPool(server_id.host(), server_id.privacy_mode())) {
       return true;
     }
   }
 
   return false;
 }
 
 int QuicStreamFactory::Create(const QuicServerId& server_id,
                               const HostPortPair& destination,
+                              QuicVersion quic_version,
                               int cert_verify_flags,
                               const GURL& url,
                               QuicStringPiece method,
                               const NetLogWithSource& net_log,
                               QuicStreamRequest* request) {
   if (clock_skew_detector_.ClockSkewDetected(base::TimeTicks::Now(),
                                              base::Time::Now())) {
     while (!active_sessions_.empty()) {
       QuicChromiumClientSession* session = active_sessions_.begin()->second;
       OnSessionGoingAway(session);
@@ skipping 58 matching lines @@
 
   // TODO(rtenneti): |task_runner_| is used by the Job. Initialize task_runner_
   // in the constructor after WebRequestActionWithThreadsTest.* tests are fixed.
   if (!task_runner_)
     task_runner_ = base::ThreadTaskRunnerHandle::Get().get();
 
   ignore_result(StartCertVerifyJob(server_id, cert_verify_flags, net_log));
 
   QuicSessionKey key(destination, server_id);
   std::unique_ptr<Job> job = base::MakeUnique<Job>(
-      this, host_resolver_, key, WasQuicRecentlyBroken(server_id),
+      this, quic_version, host_resolver_, key, WasQuicRecentlyBroken(server_id),
       cert_verify_flags, net_log);
   int rv = job->Run(base::Bind(&QuicStreamFactory::OnJobComplete,
                                base::Unretained(this), job.get()));
   if (rv == ERR_IO_PENDING) {
     job_requests_map_[server_id].insert(request);
     active_jobs_[server_id] = std::move(job);
     return rv;
   }
   if (rv == OK) {
     // TODO(rtenneti): crbug.com/498823 - revert active_sessions_.empty()
@@ skipping 510 matching lines @@
     IPAddress last_address;
     if (http_server_properties_->GetSupportsQuic(&last_address) &&
         last_address == local_address_.address()) {
       require_confirmation_ = false;
     }
   }
 
   return OK;
 }
 
-int QuicStreamFactory::CreateSession(
-    const QuicSessionKey& key,
-    int cert_verify_flags,
-    bool require_confirmation,
-    const AddressList& address_list,
-    base::TimeTicks dns_resolution_start_time,
-    base::TimeTicks dns_resolution_end_time,
-    const NetLogWithSource& net_log,
-    QuicChromiumClientSession** session) {
+int QuicStreamFactory::CreateSession(const QuicSessionKey& key,
+                                     const QuicVersion& quic_version,
+                                     int cert_verify_flags,
+                                     bool require_confirmation,
+                                     const AddressList& address_list,
+                                     base::TimeTicks dns_resolution_start_time,
+                                     base::TimeTicks dns_resolution_end_time,
+                                     const NetLogWithSource& net_log,
+                                     QuicChromiumClientSession** session) {
   TRACE_EVENT0(kNetTracingCategory, "QuicStreamFactory::CreateSession");
   IPEndPoint addr = *address_list.begin();
   const QuicServerId& server_id = key.server_id();
   DatagramSocket::BindType bind_type = DatagramSocket::DEFAULT_BIND;
   std::unique_ptr<DatagramClientSocket> socket(
       client_socket_factory_->CreateDatagramClientSocket(
           bind_type, RandIntCallback(), net_log.net_log(), net_log.source()));
 
   // Passing in kInvalidNetworkHandle binds socket to default network.
   int rv = ConfigureSocket(socket.get(), addr,
@@ skipping 15 matching lines @@
   if (store_server_configs_in_properties_) {
     server_info = base::MakeUnique<PropertiesBasedQuicServerInfo>(
         server_id, http_server_properties_);
   }
   InitializeCachedStateInCryptoConfig(server_id, server_info, &connection_id);
 
   QuicChromiumPacketWriter* writer = new QuicChromiumPacketWriter(socket.get());
   QuicConnection* connection = new QuicConnection(
       connection_id, QuicSocketAddress(QuicSocketAddressImpl(addr)),
       helper_.get(), alarm_factory_.get(), writer, true /* owns_writer */,
-      Perspective::IS_CLIENT, supported_versions_);
+      Perspective::IS_CLIENT, {quic_version});
   connection->set_ping_timeout(ping_timeout_);
   connection->SetMaxPacketLength(max_packet_length_);
 
   QuicConfig config = config_;
   config.set_max_undecryptable_packets(kMaxUndecryptablePackets);
   config.SetInitialSessionFlowControlWindowToSend(
       kQuicSessionMaxRecvWindowSize);
   config.SetInitialStreamFlowControlWindowToSend(kQuicStreamMaxRecvWindowSize);
   config.SetBytesForConnectionIdToSend(0);
   ConfigureInitialRttEstimate(server_id, &config);
@@ skipping 197 matching lines @@
   // Since the session was active, there's no longer an
   // HttpStreamFactoryImpl::Job running which can mark it broken, unless the TCP
   // job also fails. So to avoid not using QUIC when we otherwise could, we mark
   // it as recently broken, which means that 0-RTT will be disabled but we'll
   // still race.
   http_server_properties_->MarkAlternativeServiceRecentlyBroken(
       alternative_service);
 }
 
 }  // namespace net