IOThread: Use URLRequestContextBuilder::NetworkSessionParams.

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"
@@ skipping 31 matching lines @@
 const std::string& GetVariationParam(
     const std::map<std::string, std::string>& params,
     const std::string& key) {
   std::map<std::string, std::string>::const_iterator it = params.find(key);
   if (it == params.end())
     return base::EmptyString();
 
   return it->second;
 }
 
-void ConfigureTCPFastOpenParams(base::StringPiece tfo_trial_group,
-                                net::HttpNetworkSession::Params* params) {
+void ConfigureTCPFastOpenParams(
+    base::StringPiece tfo_trial_group,
+    net::URLRequestContextBuilder::HttpNetworkSessionParams* 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");
@@ skipping 10 matching lines @@
       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) {
+void ConfigureHttp2Params(
+    base::StringPiece http2_trial_group,
+    const VariationParameters& http2_trial_params,
+    net::URLRequestContextBuilder::HttpNetworkSessionParams* 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,
                       const VariationParameters& quic_trial_params,
                       bool is_quic_force_disabled,
@@ skipping 136 matching lines @@
       GetVariationParam(quic_trial_params, "quic_version"));
 }
 
 bool ShouldEnableServerPushCancelation(
     const VariationParameters& quic_trial_params) {
   return base::LowerCaseEqualsASCII(
       GetVariationParam(quic_trial_params, "enable_server_push_cancellation"),
       "true");
 }
 
-void ConfigureQuicParams(base::StringPiece quic_trial_group,
-                         const VariationParameters& quic_trial_params,
-                         bool is_quic_force_disabled,
-                         bool is_quic_force_enabled,
-                         const std::string& quic_user_agent_id,
-                         net::HttpNetworkSession::Params* params) {
+void ConfigureQuicParams(
+    base::StringPiece quic_trial_group,
+    const VariationParameters& quic_trial_params,
+    bool is_quic_force_disabled,
+    bool is_quic_force_enabled,
+    const std::string& quic_user_agent_id,
+    net::URLRequestContextBuilder::HttpNetworkSessionParams* params) {
   params->enable_quic = ShouldEnableQuic(
       quic_trial_group, quic_trial_params, is_quic_force_disabled,
       is_quic_force_enabled);
   params->mark_quic_broken_when_network_blackholes =
       ShouldMarkQuicBrokenWhenNetworkBlackholes(quic_trial_params);
 
   params->enable_server_push_cancellation =
       ShouldEnableServerPushCancelation(quic_trial_params);
 
   params->retry_without_alt_svc_on_quic_errors =
@@ skipping 61 matching lines @@
   for (size_t i = 0; i < supported_versions.size(); ++i) {
     net::QuicVersion version = supported_versions[i];
     if (net::QuicVersionToString(version) == quic_version) {
       return version;
     }
   }
 
   return net::QUIC_VERSION_UNSUPPORTED;
 }
 
-void ParseFieldTrials(bool is_quic_force_disabled,
-                      bool is_quic_force_enabled,
-                      const std::string& quic_user_agent_id,
-                      net::HttpNetworkSession::Params* params) {
+void ParseFieldTrials(
+    bool is_quic_force_disabled,
+    bool is_quic_force_enabled,
+    const std::string& quic_user_agent_id,
+    net::URLRequestContextBuilder::HttpNetworkSessionParams* params) {
   std::string quic_trial_group =
       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);
   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