Add and persist a new field in AlternativeServiceInfo to list QUIC verisons advertised

net/http/http_stream_factory.cc

Index: net/http/http_stream_factory.cc
diff --git a/net/http/http_stream_factory.cc b/net/http/http_stream_factory.cc
index 2c7eed610948b07a67249626b36baebbdd9c03dd..4c21ffcef890c2565ee561e7c357f085483c9588 100644
--- a/net/http/http_stream_factory.cc
+++ b/net/http/http_stream_factory.cc
@@ -51,19 +51,17 @@ void HttpStreamFactory::ProcessAlternativeServices(
         !IsPortValid(alternative_service_entry.port)) {
       continue;
     }
-    // Check if QUIC version is supported.
+    // Check if QUIC version is supported. Filter supported QUIC versions.

[Bence, 2017/06/16 14:43:40]

I think this whole |match_found| logic should be removed, and all the versions
supported by the server persisted verbatim, even if there is no overlap.  This
way if Chrome supports a QUIC version after an update, it can immediately use
the QUIC advertisement previously made by the server.

[Zhongyi Shi, 2017/06/20 23:23:37]

That's a fair good point. I have considered this before. However, this will be
an additional behavior change. Besides, this might cause us to persist a lot of
of alt svc in disk but not actually use them if we don't check mutual support.
Think about the case that we are currently supporting QUIC_VERSION_37, and
Alt-Svc headers advertise a lot of alt svc servers only supporting
QUIC_VERSION_40, which is a valid version, but won't be supported in the near
future. This won't bring us much gain.

We might consider to persist the full advertised version list if one of the
versions is matching our supported versions. But the gain is also unclear. I
would prefer to consider this as a follow-up idea after multi-version is
implemented. WDYT? 

[Bence, 2017/06/21 12:39:25]

Thank you for the explanation.

Given that restarts (for which persistence is relevant) are expected to be much
more frequent than updates (for which persisting currently unsupported versions
would be relevant), also the typical expiration time for AltSvc is shorter than
typical update frequency, I found your argument convincing.  Thank you.

+    QuicVersionVector advertised_versions;
     if (protocol == kProtoQUIC && !alternative_service_entry.version.empty()) {
       bool match_found = false;
       for (QuicVersion supported : session->params().quic_supported_versions) {
         for (uint16_t advertised : alternative_service_entry.version) {
           if (supported == advertised) {
             match_found = true;
-            break;
+            advertised_versions.push_back(supported);
           }
         }
-        if (match_found) {
-          break;
-        }
       }
       if (!match_found) {
         continue;
@@ -75,8 +73,16 @@ void HttpStreamFactory::ProcessAlternativeServices(
     base::Time expiration =
         base::Time::Now() +
         base::TimeDelta::FromSeconds(alternative_service_entry.max_age);
-    AlternativeServiceInfo alternative_service_info(alternative_service,
-                                                    expiration);
+    AlternativeServiceInfo alternative_service_info;
+    if (protocol == kProtoQUIC) {
+      alternative_service_info =
+          AlternativeServiceInfo::CreateQuicAlternativeServiceInfo(
+              alternative_service, expiration, advertised_versions);
+    } else {
+      alternative_service_info =
+          AlternativeServiceInfo::CreateHttp2AlternativeServiceInfo(
+              alternative_service, expiration);
+    }
     alternative_service_info_vector.push_back(alternative_service_info);
   }