Filter QUIC alternative service if the versions advertised by the server

net/spdy/chromium/spdy_session.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/spdy/chromium/spdy_session.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <utility>
@@ skipping 711 matching lines @@
       TransportSecurityState::CT_REQUIREMENTS_MET) {
     return false;
   }
 
   return true;
 }
 
 SpdySession::SpdySession(const SpdySessionKey& spdy_session_key,
                          HttpServerProperties* http_server_properties,
                          TransportSecurityState* transport_security_state,
+                         const QuicVersionVector& quic_supported_versions,
                          bool enable_sending_initial_data,
                          bool enable_ping_based_connection_checking,
                          size_t session_max_recv_window_size,
                          const SettingsMap& initial_settings,
                          TimeFunc time_func,
                          ServerPushDelegate* push_delegate,
                          ProxyDelegate* proxy_delegate,
                          NetLog* net_log)
     : in_io_loop_(false),
       spdy_session_key_(spdy_session_key),
@@ skipping 31 matching lines @@
       session_send_window_size_(0),
       session_max_recv_window_size_(session_max_recv_window_size),
       session_recv_window_size_(0),
       session_unacked_recv_window_bytes_(0),
       stream_initial_send_window_size_(kDefaultInitialWindowSize),
       max_header_table_size_(initial_settings.at(SETTINGS_HEADER_TABLE_SIZE)),
       stream_max_recv_window_size_(
           initial_settings.at(SETTINGS_INITIAL_WINDOW_SIZE)),
       net_log_(
           NetLogWithSource::Make(net_log, NetLogSourceType::HTTP2_SESSION)),
+      quic_supported_versions_(quic_supported_versions),
       enable_sending_initial_data_(enable_sending_initial_data),
       enable_ping_based_connection_checking_(
           enable_ping_based_connection_checking),
       connection_at_risk_of_loss_time_(
           base::TimeDelta::FromSeconds(kDefaultConnectionAtRiskOfLossSeconds)),
       hung_interval_(base::TimeDelta::FromSeconds(kHungIntervalSeconds)),
       proxy_delegate_(proxy_delegate),
       time_func_(time_func),
       weak_factory_(this) {
   net_log_.BeginEvent(
@@ skipping 2212 matching lines @@
       return;
     const GURL& gurl(it->second->url());
     if (!gurl.SchemeIs("https"))
       return;
     scheme_host_port = url::SchemeHostPort(gurl);
   }
 
   AlternativeServiceInfoVector alternative_service_info_vector;
   alternative_service_info_vector.reserve(altsvc_vector.size());
   const base::Time now(base::Time::Now());
+  DCHECK(!quic_supported_versions_.empty());
   for (const SpdyAltSvcWireFormat::AlternativeService& altsvc : altsvc_vector) {
     const NextProto protocol = NextProtoFromString(altsvc.protocol_id);
     if (protocol == kProtoUnknown)
       continue;
+
+    // TODO(zhongyi): refactor the QUIC version filtering to a single function
+    // so that SpdySession::OnAltSvc and
+    // HttpStreamFactory::ProcessAlternativeServices
+    // could use the the same function.
+    // Check if QUIC version is supported.
+    if (protocol == kProtoQUIC && !altsvc.version.empty()) {
+      bool match_found = false;
+      for (const QuicVersion& supported : quic_supported_versions_) {
+        for (const uint16_t& advertised : altsvc.version) {
+          if (supported == advertised) {
+            match_found = true;
+            break;
+          }
+        }
+        if (match_found) {
+          break;
+        }
+      }
+      if (!match_found) {
+        continue;
+      }
+    }
+
     const AlternativeService alternative_service(protocol, altsvc.host,
                                                  altsvc.port);
     const base::Time expiration =
         now + base::TimeDelta::FromSeconds(altsvc.max_age);
     alternative_service_info_vector.push_back(
         AlternativeServiceInfo(alternative_service, expiration));
   }
   http_server_properties_->SetAlternativeServices(
       scheme_host_port, alternative_service_info_vector);
 }
@@ skipping 201 matching lines @@
     if (!queue->empty()) {
       SpdyStreamId stream_id = queue->front();
       queue->pop_front();
       return stream_id;
     }
   }
   return 0;
 }
 
 }  // namespace net