Disable SPDY/3.1.

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 "base/metrics/field_trial.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 14 matching lines @@
 // 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";
 
 const char kQuicFieldTrialName[] = "QUIC";
 const char kQuicFieldTrialEnabledGroupName[] = "Enabled";
 const char kQuicFieldTrialHttpsEnabledGroupName[] = "HttpsEnabled";
 
-// The SPDY trial composes two different trial plus control groups:
-//  * A "holdback" group with SPDY disabled, and corresponding control
-//  (SPDY/3.1). The primary purpose of the holdback group is to encourage site
-//  operators to do feature detection rather than UA-sniffing. As such, this
-//  trial runs continuously.
-//  * A SPDY/4 experiment, for SPDY/4 (aka HTTP/2) vs SPDY/3.1 comparisons and
-//  eventual SPDY/4 deployment.
-const char kSpdyFieldTrialName[] = "SPDY";
-const char kSpdyFieldTrialHoldbackGroupNamePrefix[] = "SpdyDisabled";
-const char kSpdyFieldTrialSpdy31GroupNamePrefix[] = "Spdy31Enabled";
-const char kSpdyFieldTrialSpdy4GroupNamePrefix[] = "Spdy4Enabled";
-const char kSpdyFieldTrialParametrizedPrefix[] = "Parametrized";
+// Field trial for HTTP/2.
+const char kHttp2FieldTrialName[] = "HTTP2";
+const char kHttp2FieldTrialDisablePrefix[] = "Disable";
 
 // Field trial for NPN.
 const char kNpnTrialName[] = "NPN";
 const char kNpnTrialEnabledGroupNamePrefix[] = "Enable";
 const char kNpnTrialDisabledGroupNamePrefix[] = "Disable";
 
 // Field trial for priority dependencies.
 const char kSpdyDependenciesFieldTrial[] = "SpdyEnableDependencies";
 const char kSpdyDependenciesFieldTrialEnable[] = "Enable";
 const char kSpdyDepencenciesFieldTrialDisable[] = "Disable";
@@ skipping 19 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;
 }
 
-void ConfigureSpdyParams(const base::CommandLine& command_line,
-                         base::StringPiece spdy_trial_group,
-                         const VariationParameters& spdy_trial_params,
-                         bool is_spdy_allowed_by_policy,
-                         net::HttpNetworkSession::Params* params) {
-  // Only handle SPDY field trial parameters and command line flags if
-  // "spdy.disabled" preference is not forced via policy.
-  if (!is_spdy_allowed_by_policy) {
-    params->enable_spdy31 = false;
-    return;
-  }
-
+void ConfigureHttp2Params(const base::CommandLine& command_line,
+                          base::StringPiece http2_trial_group,
+                          net::HttpNetworkSession::Params* params) {
   if (command_line.HasSwitch(switches::kIgnoreUrlFetcherCertRequests))
     net::URLFetcher::SetIgnoreCertificateRequests(true);
 
   if (command_line.HasSwitch(switches::kDisableHttp2)) {
-    params->enable_spdy31 = false;
     params->enable_http2 = false;
     return;
   }
 
-  if (spdy_trial_group.starts_with(kSpdyFieldTrialHoldbackGroupNamePrefix)) {
-    net::HttpStreamFactory::set_spdy_enabled(false);
-    return;
-  }
-  if (spdy_trial_group.starts_with(kSpdyFieldTrialSpdy31GroupNamePrefix)) {
-    params->enable_spdy31 = true;
+  if (http2_trial_group.starts_with(kHttp2FieldTrialDisablePrefix)) {
     params->enable_http2 = false;
-    return;
-  }
-  if (spdy_trial_group.starts_with(kSpdyFieldTrialSpdy4GroupNamePrefix)) {
-    params->enable_spdy31 = true;
-    params->enable_http2 = true;
-    return;
-  }
-  if (spdy_trial_group.starts_with(kSpdyFieldTrialParametrizedPrefix)) {
-    bool spdy_enabled = false;
-    params->enable_spdy31 = false;
-    params->enable_http2 = false;
-    if (base::LowerCaseEqualsASCII(
-            GetVariationParam(spdy_trial_params, "enable_http2"), "true")) {
-      spdy_enabled = true;
-      params->enable_http2 = true;
-    }
-    if (base::LowerCaseEqualsASCII(
-            GetVariationParam(spdy_trial_params, "enable_spdy31"), "true")) {
-      spdy_enabled = true;
-      params->enable_spdy31 = true;
-    }
-    // TODO(bnc): https://crbug.com/521597
-    // HttpStreamFactory::spdy_enabled_ is redundant with params->enable_http2
-    // and enable_spdy31, can it be eliminated?
-    net::HttpStreamFactory::set_spdy_enabled(spdy_enabled);
-    return;
   }
 }
 
 void ConfigureNPNParams(const base::CommandLine& command_line,
                         base::StringPiece npn_trial_group,
                         net::HttpNetworkSession::Params* params) {
   if (npn_trial_group.starts_with(kNpnTrialEnabledGroupNamePrefix)) {
     params->enable_npn = true;
   } else if (npn_trial_group.starts_with(kNpnTrialDisabledGroupNamePrefix)) {
     params->enable_npn = false;
@@ skipping 346 matching lines @@
         params->origins_to_force_quic_on.insert(net::HostPortPair());
       net::HostPortPair quic_origin = net::HostPortPair::FromString(host_port);
       if (!quic_origin.IsEmpty())
         params->origins_to_force_quic_on.insert(quic_origin);
     }
   }
 }
 
 void ParseFieldTrialsAndCommandLineInternal(
     const base::CommandLine& command_line,
-    bool is_spdy_allowed_by_policy,
     bool is_quic_allowed_by_policy,
     const std::string& quic_user_agent_id,
     net::HttpNetworkSession::Params* params) {
   // Parameters only controlled by command line.
   if (command_line.HasSwitch(switches::kIgnoreCertificateErrors))
     params->ignore_certificate_errors = true;
   if (command_line.HasSwitch(switches::kTestingFixedHttpPort)) {
     params->testing_fixed_http_port =
         GetSwitchValueAsInt(command_line, switches::kTestingFixedHttpPort);
   }
   if (command_line.HasSwitch(switches::kTestingFixedHttpsPort)) {
     params->testing_fixed_https_port =
         GetSwitchValueAsInt(command_line, switches::kTestingFixedHttpsPort);
   }
 
   // Always fetch the field trial groups to ensure they are reported correctly.
   // The command line flags will be associated with a group that is reported so
   // long as trial is actually queried.
 
   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(command_line, quic_trial_group, quic_trial_params,
                       is_quic_allowed_by_policy, quic_user_agent_id, params);
 
-  if (!is_spdy_allowed_by_policy) {
-    base::FieldTrial* trial = base::FieldTrialList::Find(kSpdyFieldTrialName);
-    if (trial)
-      trial->Disable();
-  }
-  std::string spdy_trial_group =
-      base::FieldTrialList::FindFullName(kSpdyFieldTrialName);
-  VariationParameters spdy_trial_params;
-  if (!variations::GetVariationParams(kSpdyFieldTrialName, &spdy_trial_params))
-    spdy_trial_params.clear();
-  ConfigureSpdyParams(command_line, spdy_trial_group, spdy_trial_params,
-                      is_spdy_allowed_by_policy, params);
+  std::string http2_trial_group =
+      base::FieldTrialList::FindFullName(kHttp2FieldTrialName);
+  ConfigureHttp2Params(command_line, http2_trial_group, params);
 
   const std::string tfo_trial_group =
       base::FieldTrialList::FindFullName(kTCPFastOpenFieldTrialName);
   ConfigureTCPFastOpenParams(tfo_trial_group, params);
 
   std::string npn_trial_group =
       base::FieldTrialList::FindFullName(kNpnTrialName);
   ConfigureNPNParams(command_line, npn_trial_group, params);
 
   std::string priority_dependencies_trial_group =
       base::FieldTrialList::FindFullName(kSpdyDependenciesFieldTrial);
   ConfigurePriorityDependencies(priority_dependencies_trial_group, params);
 }
 
 }  // anonymous namespace
 
 namespace network_session_configurator {
 
-void ParseFieldTrials(bool is_spdy_allowed_by_policy,
-                      bool is_quic_allowed_by_policy,
+void ParseFieldTrials(bool is_quic_allowed_by_policy,
                       const std::string& quic_user_agent_id,
                       net::HttpNetworkSession::Params* params) {
   const base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
   ParseFieldTrialsAndCommandLineInternal(
-      command_line, is_spdy_allowed_by_policy, is_quic_allowed_by_policy,
-      quic_user_agent_id, params);
+      command_line, is_quic_allowed_by_policy, quic_user_agent_id, params);
 }
 
-void ParseFieldTrialsAndCommandLine(bool is_spdy_allowed_by_policy,
-                                    bool is_quic_allowed_by_policy,
+void ParseFieldTrialsAndCommandLine(bool is_quic_allowed_by_policy,
                                     const std::string& quic_user_agent_id,
                                     net::HttpNetworkSession::Params* params) {
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
   ParseFieldTrialsAndCommandLineInternal(
-      command_line, is_spdy_allowed_by_policy, is_quic_allowed_by_policy,
-      quic_user_agent_id, params);
+      command_line, is_quic_allowed_by_policy, quic_user_agent_id, params);
 }
 
 }  // namespace network_session_configurator