Enable support for QUIC 13.

net/quic/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/quic_stream_factory.h"
 
 #include <set>
 
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 238 matching lines @@
   return OK;
 }
 
 QuicStreamFactory::QuicStreamFactory(
     HostResolver* host_resolver,
     ClientSocketFactory* client_socket_factory,
     base::WeakPtr<HttpServerProperties> http_server_properties,
     QuicCryptoClientStreamFactory* quic_crypto_client_stream_factory,
     QuicRandom* random_generator,
     QuicClock* clock,
-    size_t max_packet_length)
+    size_t max_packet_length,
+    const QuicVersionVector& supported_versions)
     : require_confirmation_(true),
       host_resolver_(host_resolver),
       client_socket_factory_(client_socket_factory),
       http_server_properties_(http_server_properties),
       quic_crypto_client_stream_factory_(quic_crypto_client_stream_factory),
       random_generator_(random_generator),
       clock_(clock),
       max_packet_length_(max_packet_length),
-      weak_factory_(this),
-      port_seed_(random_generator_->RandUint64()) {
+      supported_versions_(supported_versions),
+      port_seed_(random_generator_->RandUint64()),
+      weak_factory_(this) {
   config_.SetDefaults();
   config_.set_idle_connection_state_lifetime(
       QuicTime::Delta::FromSeconds(30),
       QuicTime::Delta::FromSeconds(30));
 
   cannoncial_suffixes_.push_back(string(".c.youtube.com"));
   cannoncial_suffixes_.push_back(string(".googlevideo.com"));
 }
 
 QuicStreamFactory::~QuicStreamFactory() {
@@ skipping 208 matching lines @@
       new QuicDefaultPacketWriter(socket.get()));
 
   if (!helper_.get()) {
     helper_.reset(new QuicConnectionHelper(
         base::MessageLoop::current()->message_loop_proxy().get(),
         clock_.get(), random_generator_));
   }
 
   QuicConnection* connection = new QuicConnection(guid, addr, helper_.get(),
                                                   writer.get(), false,
-                                                  QuicSupportedVersions());
+                                                  supported_versions_);
   writer->SetConnection(connection);
   connection->options()->max_packet_length = max_packet_length_;
 
   QuicCryptoClientConfig* crypto_config =
       GetOrCreateCryptoConfig(host_port_proxy_pair);
   DCHECK(crypto_config);
 
   *session = new QuicClientSession(
       connection, socket.Pass(), writer.Pass(), this,
       quic_crypto_client_stream_factory_, host_port_proxy_pair.first.host(),
@@ skipping 70 matching lines @@
   // Copy the CachedState for the canonical server from canonical_crypto_config
   // as the initial CachedState for the server_hostname in crypto_config.
   crypto_config->InitializeFrom(server_hostname,
                                 canonical_host_port_proxy_pair.first.host(),
                                 canonical_crypto_config);
   // Update canonical version to point at the "most recent" crypto_config.
   canonical_hostname_to_origin_map_[canonical_host_port] = host_port_proxy_pair;
 }
 
 }  // namespace net