Add support for parsing IETF format of alt-svc header advertising QUIC

This CL lands internal change 166256846 by wangyix.

BUG=488484

Change-Id: Idb25c187d402edc5e6c180c529fc3eede2c416bf
Reviewed-on: https://chromium-review.googlesource.com/620201
Commit-Queue: Yixin Wang <wangyix@chromium.org>
Reviewed-by: Ryan Hamilton <rch@chromium.org>
Cr-Commit-Position: refs/heads/master@{#510184}

components/network_session_configurator/browser/network_session_configurator.cc

@@ -145,6 +145,13 @@ bool ShouldRetryWithoutAltSvcOnQuicErrors(
       "true");
 }
 
+bool ShouldSupportIetfFormatQuicAltSvc(
+    const VariationParameters& quic_trial_params) {
+  return base::LowerCaseEqualsASCII(
+      GetVariationParam(quic_trial_params, "support_ietf_format_quic_altsvc"),
+      "true");
+}
+
 net::QuicTagVector GetQuicConnectionOptions(
     const VariationParameters& quic_trial_params) {
   VariationParameters::const_iterator it =
@@ -268,6 +275,9 @@ void ConfigureQuicParams(base::StringPiece quic_trial_group,
   params->retry_without_alt_svc_on_quic_errors =
       ShouldRetryWithoutAltSvcOnQuicErrors(quic_trial_params);
 
+  params->support_ietf_format_quic_altsvc =
+      ShouldSupportIetfFormatQuicAltSvc(quic_trial_params);
+
   if (params->enable_quic) {
     params->quic_connection_options =
         GetQuicConnectionOptions(quic_trial_params);

components/network_session_configurator/browser/network_session_configurator_unittest.cc

@@ -87,6 +87,7 @@ TEST_F(NetworkSessionConfiguratorTest, EnableQuicFromFieldTrialGroup) {
   EXPECT_TRUE(params_.enable_quic);
   EXPECT_FALSE(params_.mark_quic_broken_when_network_blackholes);
   EXPECT_FALSE(params_.retry_without_alt_svc_on_quic_errors);
+  EXPECT_FALSE(params_.support_ietf_format_quic_altsvc);
   EXPECT_EQ(1350u, params_.quic_max_packet_length);
   EXPECT_EQ(net::QuicTagVector(), params_.quic_connection_options);
   EXPECT_EQ(net::QuicTagVector(), params_.quic_client_connection_options);
@@ -150,6 +151,17 @@ TEST_F(NetworkSessionConfiguratorTest, RetryWithoutAltSvcOnQuicErrors) {
   EXPECT_TRUE(params_.retry_without_alt_svc_on_quic_errors);
 }
 
+TEST_F(NetworkSessionConfiguratorTest, SupportIetfFormatQuicAltSvc) {
+  std::map<std::string, std::string> field_trial_params;
+  field_trial_params["support_ietf_format_quic_altsvc"] = "true";
+  variations::AssociateVariationParams("QUIC", "Enabled", field_trial_params);
+  base::FieldTrialList::CreateFieldTrial("QUIC", "Enabled");
+
+  ParseFieldTrials();
+
+  EXPECT_TRUE(params_.support_ietf_format_quic_altsvc);
+}
+
 TEST_F(NetworkSessionConfiguratorTest,
        QuicIdleConnectionTimeoutSecondsFieldTrialParams) {
   std::map<std::string, std::string> field_trial_params;

net/http/http_network_session.cc

@@ -112,6 +112,7 @@ HttpNetworkSession::Params::Params()
       quic_max_server_configs_stored_in_properties(0u),
       mark_quic_broken_when_network_blackholes(false),
       retry_without_alt_svc_on_quic_errors(false),
+      support_ietf_format_quic_altsvc(false),
       quic_idle_connection_timeout_seconds(kIdleConnectionTimeoutSeconds),
       quic_reduced_ping_timeout_seconds(kPingTimeoutSecs),
       quic_connect_using_default_network(false),
@@ -204,6 +205,7 @@ HttpNetworkSession::HttpNetworkSession(const Params& params,
                          context.transport_security_state,
                          params.quic_supported_versions,
                          params.enable_spdy_ping_based_connection_checking,
+                         params.support_ietf_format_quic_altsvc,
                          params.spdy_session_max_recv_window_size,
                          AddDefaultHttp2Settings(params.http2_settings),
                          params.time_func,

net/http/http_network_session.h

@@ -144,6 +144,9 @@ class NET_EXPORT HttpNetworkSession : public base::MemoryCoordinatorClient {
     // Retry requests which fail with QUIC_PROTOCOL_ERROR, and mark QUIC
     // broken if the retry succeeds.
     bool retry_without_alt_svc_on_quic_errors;
+    // If true, alt-svc headers advertising QUIC in IETF format will be
+    // supported.
+    bool support_ietf_format_quic_altsvc;
     // Specifies QUIC idle connection state lifetime.
     int quic_idle_connection_timeout_seconds;
     // Specifies the reduced ping timeout subsequent connections should use when

net/http/http_stream_factory.cc

@@ -15,6 +15,7 @@
 #include "net/base/port_util.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_response_headers.h"
+#include "net/quic/chromium/quic_http_utils.h"
 #include "net/quic/core/quic_packets.h"
 #include "net/spdy/core/spdy_alt_svc_wire_format.h"
 #include "url/gurl.h"
@@ -54,19 +55,11 @@ void HttpStreamFactory::ProcessAlternativeServices(
     // Check if QUIC version is supported. Filter supported QUIC versions.
     QuicTransportVersionVector advertised_versions;
     if (protocol == kProtoQUIC && !alternative_service_entry.version.empty()) {
-      bool match_found = false;
-      for (QuicTransportVersion supported :
-           session->params().quic_supported_versions) {
-        for (uint16_t advertised : alternative_service_entry.version) {
-          if (supported == advertised) {
-            match_found = true;
-            advertised_versions.push_back(supported);
-          }
-        }
-      }
-      if (!match_found) {
+      advertised_versions = FilterSupportedAltSvcVersions(
+          alternative_service_entry, session->params().quic_supported_versions,
+          session->params().support_ietf_format_quic_altsvc);
+      if (advertised_versions.empty())
         continue;
-      }
     }
     AlternativeService alternative_service(protocol,
                                            alternative_service_entry.host,

net/quic/chromium/quic_http_utils.cc

@@ -6,6 +6,8 @@
 
 #include <utility>
 
+#include "net/quic/platform/api/quic_endian.h"
+
 namespace net {
 
 SpdyPriority ConvertRequestPriorityToQuicPriority(
@@ -35,4 +37,34 @@ std::unique_ptr<base::Value> QuicRequestNetLogCallback(
   return std::move(dict);
 }
 
+QuicTransportVersionVector FilterSupportedAltSvcVersions(
+    const SpdyAltSvcWireFormat::AlternativeService& quic_alt_svc,
+    const QuicTransportVersionVector& supported_versions,
+    bool support_ietf_format_quic_altsvc) {
+  QuicTransportVersionVector supported_alt_svc_versions;
+  if (support_ietf_format_quic_altsvc && quic_alt_svc.protocol_id == "hq") {
+    // Using IETF format for advertising QUIC. In this case,
+    // |alternative_service_entry.version| will store QUIC version labels.
+    for (uint32_t quic_version_label : quic_alt_svc.version) {
+      for (QuicTransportVersion supported : supported_versions) {
+        QuicVersionLabel supported_version_label_network_order =
+            FLAGS_quic_reloadable_flag_quic_use_net_byte_order_version_label
+                ? QuicVersionToQuicVersionLabel(supported)
+                : QuicEndian::HostToNet32(
+                      QuicVersionToQuicVersionLabel(supported));
+        if (supported_version_label_network_order == quic_version_label)
+          supported_alt_svc_versions.push_back(supported);
+      }
+    }
+  } else if (quic_alt_svc.protocol_id == "quic") {
+    for (uint32_t quic_version : quic_alt_svc.version) {
+      for (QuicTransportVersion supported : supported_versions) {
+        if (static_cast<uint32_t>(supported) == quic_version)
+          supported_alt_svc_versions.push_back(supported);
+      }
+    }
+  }
+  return supported_alt_svc_versions;
+}
+
 }  // namespace net

net/quic/chromium/quic_http_utils.h

@@ -27,6 +27,13 @@ NET_EXPORT std::unique_ptr<base::Value> QuicRequestNetLogCallback(
     SpdyPriority priority,
     NetLogCaptureMode capture_mode);
 
+// Parses |alt_svc_versions| into a QuicTransportVersionVector and removes
+// all entries that aren't found in |supported_versions|.
+NET_EXPORT QuicTransportVersionVector FilterSupportedAltSvcVersions(
+    const SpdyAltSvcWireFormat::AlternativeService& quic_alt_svc,
+    const QuicTransportVersionVector& supported_versions,
+    bool support_ietf_format_quic_altsvc);
+
 }  // namespace net
 
 #endif  // NET_QUIC_CHROMIUM_QUIC_HTTP_UTILS_H_

net/quic/chromium/quic_http_utils_test.cc

@@ -8,6 +8,8 @@
 
 #include <limits>
 
+#include "net/quic/platform/api/quic_endian.h"
+#include "net/spdy/core/spdy_alt_svc_wire_format.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
@@ -35,5 +37,48 @@ TEST(QuicHttpUtilsTest, ConvertQuicPriorityToRequestPriority) {
   }
 }
 
+TEST(QuicHttpUtilsTest, FilterSupportedAltSvcVersions) {
+  QuicTransportVersionVector supported_versions = {
+      QUIC_VERSION_37, QUIC_VERSION_38, QUIC_VERSION_39, QUIC_VERSION_41};
+
+  std::vector<uint32_t> alt_svc_versions_google = {
+      QUIC_VERSION_38, QUIC_VERSION_41, QUIC_VERSION_42};
+  std::vector<uint32_t> alt_svc_versions_ietf = {
+      QuicVersionToQuicVersionLabel(QUIC_VERSION_38),
+      QuicVersionToQuicVersionLabel(QUIC_VERSION_41),
+      QuicVersionToQuicVersionLabel(QUIC_VERSION_42)};
+
+  if (!FLAGS_quic_reloadable_flag_quic_use_net_byte_order_version_label) {
+    for (uint32_t& version_label : alt_svc_versions_ietf) {
+      version_label = QuicEndian::HostToNet32(version_label);
+    }
+  }
+
+  QuicTransportVersionVector supported_alt_svc_versions = {QUIC_VERSION_38,
+                                                           QUIC_VERSION_41};
+  SpdyAltSvcWireFormat::AlternativeService altsvc;
+
+  altsvc.protocol_id = "quic";
+  altsvc.version = alt_svc_versions_google;
+  EXPECT_EQ(supported_alt_svc_versions,
+            FilterSupportedAltSvcVersions(altsvc, supported_versions, true));
+  EXPECT_EQ(supported_alt_svc_versions,
+            FilterSupportedAltSvcVersions(altsvc, supported_versions, false));
+
+  altsvc.protocol_id = "hq";
+  altsvc.version = alt_svc_versions_ietf;
+  EXPECT_EQ(supported_alt_svc_versions,
+            FilterSupportedAltSvcVersions(altsvc, supported_versions, true));
+  EXPECT_EQ(QuicTransportVersionVector(),
+            FilterSupportedAltSvcVersions(altsvc, supported_versions, false));
+
+  altsvc.protocol_id = "invalid_protocol";
+  altsvc.version = alt_svc_versions_ietf;
+  EXPECT_EQ(QuicTransportVersionVector(),
+            FilterSupportedAltSvcVersions(altsvc, supported_versions, true));
+  EXPECT_EQ(QuicTransportVersionVector(),
+            FilterSupportedAltSvcVersions(altsvc, supported_versions, false));
+}
+
 }  // namespace test
 }  // namespace net

net/socket/next_proto.cc

@@ -12,7 +12,7 @@ NextProto NextProtoFromString(base::StringPiece proto_string) {
   if (proto_string == "h2") {
     return kProtoHTTP2;
   }
-  if (proto_string == "quic")
+  if (proto_string == "quic" || proto_string == "hq")
     return kProtoQUIC;
 
   return kProtoUnknown;

net/spdy/chromium/spdy_session.cc

@@ -40,6 +40,7 @@
 #include "net/log/net_log_source_type.h"
 #include "net/log/net_log_with_source.h"
 #include "net/proxy/proxy_server.h"
+#include "net/quic/chromium/quic_http_utils.h"
 #include "net/socket/socket.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/spdy/chromium/header_coalescer.h"
@@ -727,6 +728,7 @@ SpdySession::SpdySession(
     const QuicTransportVersionVector& quic_supported_versions,
     bool enable_sending_initial_data,
     bool enable_ping_based_connection_checking,
+    bool support_ietf_format_quic_altsvc,
     size_t session_max_recv_window_size,
     const SettingsMap& initial_settings,
     TimeFunc time_func,
@@ -779,6 +781,7 @@ SpdySession::SpdySession(
       enable_sending_initial_data_(enable_sending_initial_data),
       enable_ping_based_connection_checking_(
           enable_ping_based_connection_checking),
+      support_ietf_format_quic_altsvc_(support_ietf_format_quic_altsvc),
       connection_at_risk_of_loss_time_(
           base::TimeDelta::FromSeconds(kDefaultConnectionAtRiskOfLossSeconds)),
       hung_interval_(base::TimeDelta::FromSeconds(kHungIntervalSeconds)),
@@ -2964,25 +2967,13 @@ void SpdySession::OnAltSvc(
     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. Filter supported QUIC versions.
     QuicTransportVersionVector advertised_versions;
     if (protocol == kProtoQUIC && !altsvc.version.empty()) {
-      bool match_found = false;
-      for (const QuicTransportVersion& supported : quic_supported_versions_) {
-        for (const uint16_t& advertised : altsvc.version) {
-          if (supported == advertised) {
-            match_found = true;
-            advertised_versions.push_back(supported);
-          }
-        }
-      }
-      if (!match_found) {
+      advertised_versions = FilterSupportedAltSvcVersions(
+          altsvc, quic_supported_versions_, support_ietf_format_quic_altsvc_);
+      if (advertised_versions.empty())
         continue;
-      }
     }
 
     const AlternativeService alternative_service(protocol, altsvc.host,

net/spdy/chromium/spdy_session.h

@@ -300,14 +300,14 @@ class NET_EXPORT SpdySession : public BufferedSpdyFramerVisitorInterface,
   // Create a new SpdySession.
   // |spdy_session_key| is the host/port that this session connects to, privacy
   // and proxy configuration settings that it's using.
-  // |session| is the HttpNetworkSession.  |net_log| is the NetLog that we log
-  // network events to.
+  // |net_log| is the NetLog that we log network events to.
   SpdySession(const SpdySessionKey& spdy_session_key,
               HttpServerProperties* http_server_properties,
               TransportSecurityState* transport_security_state,
               const QuicTransportVersionVector& quic_supported_versions,
               bool enable_sending_initial_data,
               bool enable_ping_based_connection_checking,
+              bool support_ietf_format_quic_altsvc,
               size_t session_max_recv_window_size,
               const SettingsMap& initial_settings,
               TimeFunc time_func,
@@ -1164,6 +1164,9 @@ class NET_EXPORT SpdySession : public BufferedSpdyFramerVisitorInterface,
   bool enable_sending_initial_data_;
   bool enable_ping_based_connection_checking_;
 
+  // If true, alt-svc headers advertising QUIC in IETF format will be supported.
+  bool support_ietf_format_quic_altsvc_;
+
   // |connection_at_risk_of_loss_time_| is an optimization to avoid sending
   // wasteful preface pings (when we just got some data).
   //

net/spdy/chromium/spdy_session_pool.cc

@@ -50,6 +50,7 @@ SpdySessionPool::SpdySessionPool(
     TransportSecurityState* transport_security_state,
     const QuicTransportVersionVector& quic_supported_versions,
     bool enable_ping_based_connection_checking,
+    bool support_ietf_format_quic_altsvc,
     size_t session_max_recv_window_size,
     const SettingsMap& initial_settings,
     SpdySessionPool::TimeFunc time_func,
@@ -62,6 +63,7 @@ SpdySessionPool::SpdySessionPool(
       enable_sending_initial_data_(true),
       enable_ping_based_connection_checking_(
           enable_ping_based_connection_checking),
+      support_ietf_format_quic_altsvc_(support_ietf_format_quic_altsvc),
       session_max_recv_window_size_(session_max_recv_window_size),
       initial_settings_(initial_settings),
       time_func_(time_func),
@@ -102,9 +104,9 @@ base::WeakPtr<SpdySession> SpdySessionPool::CreateAvailableSessionFromSocket(
   auto new_session = std::make_unique<SpdySession>(
       key, http_server_properties_, transport_security_state_,
       quic_supported_versions_, enable_sending_initial_data_,
-      enable_ping_based_connection_checking_, session_max_recv_window_size_,
-      initial_settings_, time_func_, push_delegate_, proxy_delegate_,
-      net_log.net_log());
+      enable_ping_based_connection_checking_, support_ietf_format_quic_altsvc_,
+      session_max_recv_window_size_, initial_settings_, time_func_,
+      push_delegate_, proxy_delegate_, net_log.net_log());
 
   new_session->InitializeWithSocket(std::move(connection), this);
 

net/spdy/chromium/spdy_session_pool.h

@@ -62,6 +62,7 @@ class NET_EXPORT SpdySessionPool
                   TransportSecurityState* transport_security_state,
                   const QuicTransportVersionVector& quic_supported_versions,
                   bool enable_ping_based_connection_checking,
+                  bool support_ietf_format_quic_altsvc,
                   size_t session_max_recv_window_size,
                   const SettingsMap& initial_settings,
                   SpdySessionPool::TimeFunc time_func,
@@ -261,6 +262,9 @@ class NET_EXPORT SpdySessionPool
   bool enable_sending_initial_data_;
   bool enable_ping_based_connection_checking_;
 
+  // If true, alt-svc headers advertising QUIC in IETF format will be supported.
+  bool support_ietf_format_quic_altsvc_;
+
   size_t session_max_recv_window_size_;
 
   // Settings that are sent in the initial SETTINGS frame