Implement HTTP/2 settings field trial parameters.

components/network_session_configurator/network_session_configurator.cc

 // Copyright 2016 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 "components/network_session_configurator/network_session_configurator.h"
 
 #include <map>
+#include <unordered_set>
 
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "components/data_reduction_proxy/core/common/data_reduction_proxy_params.h"
 #include "components/variations/variations_associated_data.h"
 #include "components/version_info/version_info.h"
 #include "net/http/http_stream_factory.h"
 #include "net/quic/chromium/quic_utils_chromium.h"
 #include "net/quic/core/quic_packets.h"
+#include "net/spdy/spdy_protocol.h"
 #include "net/url_request/url_fetcher.h"
 
 namespace {
 
 // Map from name to value for all parameters associate with a field trial.
 using VariationParameters = std::map<std::string, std::string>;
 
 const char kTCPFastOpenFieldTrialName[] = "TCPFastOpen";
 const char kTCPFastOpenHttpsEnabledGroupName[] = "HttpsEnabled";
 
@@ skipping 16 matching lines @@
 
   return it->second;
 }
 
 void ConfigureTCPFastOpenParams(base::StringPiece tfo_trial_group,
                                 net::HttpNetworkSession::Params* params) {
   if (tfo_trial_group == kTCPFastOpenHttpsEnabledGroupName)
     params->enable_tcp_fast_open_for_ssl = true;
 }
 
+net::SettingsMap GetHttp2Settings(
+    const VariationParameters& http2_trial_params) {
+  net::SettingsMap http2_settings;
+
+  const std::string settings_string =
+      GetVariationParam(http2_trial_params, "http2_settings");
+
+  base::StringPairs key_value_pairs;
+  if (!base::SplitStringIntoKeyValuePairs(settings_string, ':', ',',
+                                          &key_value_pairs)) {
+    return http2_settings;
+  }
+
+  for (auto key_value : key_value_pairs) {
+    uint32_t key;
+    if (!base::StringToUint(key_value.first, &key))
+      continue;
+    uint32_t value;
+    if (!base::StringToUint(key_value.second, &value))
+      continue;
+    http2_settings[static_cast<net::SpdySettingsIds>(key)] = value;
+  }
+
+  return http2_settings;
+}
+
 void ConfigureHttp2Params(base::StringPiece http2_trial_group,
+                          const VariationParameters& http2_trial_params,
                           net::HttpNetworkSession::Params* params) {
   if (http2_trial_group.starts_with(kHttp2FieldTrialDisablePrefix)) {
     params->enable_http2 = false;
+    return;
   }
+  params->http2_settings = GetHttp2Settings(http2_trial_params);
 }
 
 bool ShouldEnableQuic(base::StringPiece quic_trial_group,
                       bool is_quic_force_disabled,
                       bool is_quic_force_enabled) {
   if (is_quic_force_disabled)
     return false;
   if (is_quic_force_enabled)
     return true;
 
@@ skipping 133 matching lines @@
           GetVariationParam(quic_trial_params,
                             "packet_reader_yield_after_duration_milliseconds"),
           &value)) {
     return value;
   }
   return 0;
 }
 
 bool ShouldQuicRaceCertVerification(
     const VariationParameters& quic_trial_params) {
-   return base::LowerCaseEqualsASCII(
-      GetVariationParam(quic_trial_params, "race_cert_verification"),
-      "true");
+  return base::LowerCaseEqualsASCII(
+      GetVariationParam(quic_trial_params, "race_cert_verification"), "true");
 }
 
-bool ShouldQuicDoNotFragment(
-    const VariationParameters& quic_trial_params) {
-   return base::LowerCaseEqualsASCII(
-      GetVariationParam(quic_trial_params, "do_not_fragment"),
-      "true");
+bool ShouldQuicDoNotFragment(const VariationParameters& quic_trial_params) {
+  return base::LowerCaseEqualsASCII(
+      GetVariationParam(quic_trial_params, "do_not_fragment"), "true");
 }
 
 bool ShouldQuicDisablePreConnectIfZeroRtt(
     const VariationParameters& quic_trial_params) {
   return base::LowerCaseEqualsASCII(
       GetVariationParam(quic_trial_params, "disable_preconnect_if_0rtt"),
       "true");
 }
 
 std::unordered_set<std::string> GetQuicHostWhitelist(
@@ skipping 158 matching lines @@
       base::FieldTrialList::FindFullName(kQuicFieldTrialName);
   VariationParameters quic_trial_params;
   if (!variations::GetVariationParams(kQuicFieldTrialName, &quic_trial_params))
     quic_trial_params.clear();
   ConfigureQuicParams(quic_trial_group, quic_trial_params,
                       is_quic_force_disabled, is_quic_force_enabled,
                       quic_user_agent_id, params);
 
   std::string http2_trial_group =
       base::FieldTrialList::FindFullName(kHttp2FieldTrialName);
-  ConfigureHttp2Params(http2_trial_group, params);
+  VariationParameters http2_trial_params;
+  if (!variations::GetVariationParams(kHttp2FieldTrialName,
+                                      &http2_trial_params))
+    http2_trial_params.clear();
+  ConfigureHttp2Params(http2_trial_group, http2_trial_params, params);
 
   const std::string tfo_trial_group =
       base::FieldTrialList::FindFullName(kTCPFastOpenFieldTrialName);
   ConfigureTCPFastOpenParams(tfo_trial_group, params);
 }
 
 }  // namespace network_session_configurator