Add support for setting QUIC connection options via field trial config.

chrome/browser/io_thread.cc

 // Copyright (c) 2012 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 "chrome/browser/io_thread.h"
 
 #include <vector>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 26 matching lines @@
 #include "chrome/browser/net/pref_proxy_config_tracker.h"
 #include "chrome/browser/net/proxy_service_factory.h"
 #include "chrome/browser/net/sdch_dictionary_fetcher.h"
 #include "chrome/common/chrome_content_client.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/pref_names.h"
 #include "components/data_reduction_proxy/browser/data_reduction_proxy_prefs.h"
 #include "components/data_reduction_proxy/browser/http_auth_handler_data_reduction_proxy.h"
 #include "components/policy/core/common/policy_service.h"
+#include "components/variations/variations_associated_data.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/cookie_store_factory.h"
 #include "net/base/host_mapping_rules.h"
 #include "net/base/net_util.h"
 #include "net/cert/cert_verifier.h"
 #include "net/cert/cert_verify_proc.h"
 #include "net/cert/ct_known_logs.h"
 #include "net/cert/ct_verifier.h"
 #include "net/cert/multi_threaded_cert_verifier.h"
 #include "net/cookies/cookie_store.h"
@@ skipping 223 matching lines @@
 int GetSwitchValueAsInt(const CommandLine& command_line,
                         const std::string& switch_name) {
   int value;
   if (!base::StringToInt(command_line.GetSwitchValueASCII(switch_name),
                          &value)) {
     return 0;
   }
   return value;
 }
 
+// Returns the value associated with |key| in |params| or "" if the
+// key is not present in the map.
+std::string GetVariationParam(const std::map<std::string, std::string>& params,
+                              std::string key) {
+  std::map<std::string, std::string>::const_iterator it = params.find(key);
+  if (it == params.end())
+    return "";
+
+  return it->second;
+}
+
 }  // namespace
 
 class IOThread::LoggingNetworkChangeObserver
     : public net::NetworkChangeNotifier::IPAddressObserver,
       public net::NetworkChangeNotifier::ConnectionTypeObserver,
       public net::NetworkChangeNotifier::NetworkChangeObserver {
  public:
   // |net_log| must remain valid throughout our lifetime.
   explicit LoggingNetworkChangeObserver(net::NetLog* net_log)
       : net_log_(net_log) {
@@ skipping 628 matching lines @@
 void IOThread::ClearHostCache() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   net::HostCache* host_cache = globals_->host_resolver->GetHostCache();
   if (host_cache)
     host_cache->clear();
 }
 
 void IOThread::InitializeNetworkSessionParams(
     net::HttpNetworkSession::Params* params) {
-  params->host_resolver = globals_->host_resolver.get();
-  params->cert_verifier = globals_->cert_verifier.get();
+  InitializeNetworkSessionParamsFromGlobals(*globals_, params);
+}
+
+// static
+void IOThread::InitializeNetworkSessionParamsFromGlobals(
+    const IOThread::Globals& globals,
+    net::HttpNetworkSession::Params* params) {
+  params->host_resolver = globals.host_resolver.get();
+  params->cert_verifier = globals.cert_verifier.get();
   params->server_bound_cert_service =
-      globals_->system_server_bound_cert_service.get();
-  params->transport_security_state = globals_->transport_security_state.get();
-  params->ssl_config_service = globals_->ssl_config_service.get();
-  params->http_auth_handler_factory = globals_->http_auth_handler_factory.get();
+      globals.system_server_bound_cert_service.get();
+  params->transport_security_state = globals.transport_security_state.get();
+  params->ssl_config_service = globals.ssl_config_service.get();
+  params->http_auth_handler_factory = globals.http_auth_handler_factory.get();
   params->http_server_properties =
-      globals_->http_server_properties->GetWeakPtr();
-  params->network_delegate = globals_->system_network_delegate.get();
-  params->host_mapping_rules = globals_->host_mapping_rules.get();
-  params->ignore_certificate_errors = globals_->ignore_certificate_errors;
-  params->testing_fixed_http_port = globals_->testing_fixed_http_port;
-  params->testing_fixed_https_port = globals_->testing_fixed_https_port;
+      globals.http_server_properties->GetWeakPtr();
+  params->network_delegate = globals.system_network_delegate.get();
+  params->host_mapping_rules = globals.host_mapping_rules.get();
+  params->ignore_certificate_errors = globals.ignore_certificate_errors;
+  params->testing_fixed_http_port = globals.testing_fixed_http_port;
+  params->testing_fixed_https_port = globals.testing_fixed_https_port;
 
-  globals_->initial_max_spdy_concurrent_streams.CopyToIfSet(
+  globals.initial_max_spdy_concurrent_streams.CopyToIfSet(
       &params->spdy_initial_max_concurrent_streams);
-  globals_->force_spdy_single_domain.CopyToIfSet(
+  globals.force_spdy_single_domain.CopyToIfSet(
       &params->force_spdy_single_domain);
-  globals_->enable_spdy_compression.CopyToIfSet(
+  globals.enable_spdy_compression.CopyToIfSet(
       &params->enable_spdy_compression);
-  globals_->enable_spdy_ping_based_connection_checking.CopyToIfSet(
+  globals.enable_spdy_ping_based_connection_checking.CopyToIfSet(
       &params->enable_spdy_ping_based_connection_checking);
-  globals_->spdy_default_protocol.CopyToIfSet(
+  globals.spdy_default_protocol.CopyToIfSet(
       &params->spdy_default_protocol);
-  params->next_protos = globals_->next_protos;
-  globals_->trusted_spdy_proxy.CopyToIfSet(&params->trusted_spdy_proxy);
-  globals_->force_spdy_over_ssl.CopyToIfSet(&params->force_spdy_over_ssl);
-  globals_->force_spdy_always.CopyToIfSet(&params->force_spdy_always);
-  globals_->forced_spdy_exclusions = params->forced_spdy_exclusions;
-  globals_->use_alternate_protocols.CopyToIfSet(
+  params->next_protos = globals.next_protos;
+  globals.trusted_spdy_proxy.CopyToIfSet(&params->trusted_spdy_proxy);
+  globals.force_spdy_over_ssl.CopyToIfSet(&params->force_spdy_over_ssl);
+  globals.force_spdy_always.CopyToIfSet(&params->force_spdy_always);
+  params->forced_spdy_exclusions = globals.forced_spdy_exclusions;

[jar (doing other things), 2014/06/20 23:25:12]

Nice bug fix.  +1 for the power of const?

This might be worth a comment in the bug, or almost a separate bug-fix CL....
but I don't know that anyone is really using this much.

[Ryan Hamilton, 2014/06/21 02:45:23]

Yeah, const rocks :>
I'd rather not delay this CL while I wait for the bug-fix CL to land :< Is that
ok?

[jar (doing other things), 2014/06/22 18:48:34]

Comment in this CL (top level) is fine.
thanks!

[Ryan Hamilton, 2014/06/22 19:48:57]

Done. Good idea.

+  globals.use_alternate_protocols.CopyToIfSet(
       &params->use_alternate_protocols);
-  globals_->enable_websocket_over_spdy.CopyToIfSet(
+  globals.enable_websocket_over_spdy.CopyToIfSet(
       &params->enable_websocket_over_spdy);
 
-  globals_->enable_quic.CopyToIfSet(&params->enable_quic);
-  globals_->enable_quic_pacing.CopyToIfSet(
+  globals.enable_quic.CopyToIfSet(&params->enable_quic);
+  globals.enable_quic_pacing.CopyToIfSet(
       &params->enable_quic_pacing);
-  globals_->enable_quic_time_based_loss_detection.CopyToIfSet(
+  globals.enable_quic_time_based_loss_detection.CopyToIfSet(
       &params->enable_quic_time_based_loss_detection);
-  globals_->enable_quic_persist_server_info.CopyToIfSet(
-      &params->enable_quic_persist_server_info);
-  globals_->enable_quic_port_selection.CopyToIfSet(
+  globals.enable_quic_port_selection.CopyToIfSet(
       &params->enable_quic_port_selection);
-  globals_->quic_max_packet_length.CopyToIfSet(&params->quic_max_packet_length);
-  globals_->quic_user_agent_id.CopyToIfSet(&params->quic_user_agent_id);
-  globals_->quic_supported_versions.CopyToIfSet(
+  globals.quic_max_packet_length.CopyToIfSet(&params->quic_max_packet_length);
+  globals.quic_user_agent_id.CopyToIfSet(&params->quic_user_agent_id);
+  globals.quic_supported_versions.CopyToIfSet(
       &params->quic_supported_versions);
-  globals_->origin_to_force_quic_on.CopyToIfSet(
+  params->quic_connection_options = globals.quic_connection_options;
+
+  globals.origin_to_force_quic_on.CopyToIfSet(
       &params->origin_to_force_quic_on);
   params->enable_user_alternate_protocol_ports =
-      globals_->enable_user_alternate_protocol_ports;
+      globals.enable_user_alternate_protocol_ports;
 }
 
 base::TimeTicks IOThread::creation_time() const {
   return creation_time_;
 }
 
 net::SSLConfigService* IOThread::GetSSLConfigService() {
   return ssl_config_service_manager_->Get();
 }
 
@@ skipping 55 matching lines @@
 }
 
 void IOThread::UpdateDnsClientEnabled() {
   globals()->host_resolver->SetDnsClientEnabled(*dns_client_enabled_);
 }
 
 void IOThread::ConfigureQuic(const CommandLine& command_line) {
   // Always fetch the field trial group to ensure it is 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 =
+  std::string group =
       base::FieldTrialList::FindFullName(kQuicFieldTrialName);
+  std::map<std::string, std::string> params;
+  if (!chrome_variations::GetVariationParams(kQuicFieldTrialName, &params)) {
+    params.clear();
+  }
 
+  ConfigureQuicGlobals(command_line, group, params, globals_);
+}
+
+// static
+void IOThread::ConfigureQuicGlobals(
+    const base::CommandLine& command_line,
+    base::StringPiece quic_trial_group,
+    const std::map<std::string, std::string>& quic_trial_params,
+    IOThread::Globals* globals) {
   bool enable_quic = ShouldEnableQuic(command_line, quic_trial_group);
-  globals_->enable_quic.set(enable_quic);
+  globals->enable_quic.set(enable_quic);
   if (enable_quic) {
-    globals_->enable_quic_pacing.set(
-        ShouldEnableQuicPacing(command_line, quic_trial_group));
-    globals_->enable_quic_time_based_loss_detection.set(
-        ShouldEnableQuicTimeBasedLossDetection(command_line, quic_trial_group));
-    globals_->enable_quic_persist_server_info.set(
-        ShouldEnableQuicPersistServerInfo(command_line));
-    globals_->enable_quic_port_selection.set(
+    globals->enable_quic_pacing.set(
+        ShouldEnableQuicPacing(command_line, quic_trial_group,
+                               quic_trial_params));
+    globals->enable_quic_time_based_loss_detection.set(
+        ShouldEnableQuicTimeBasedLossDetection(command_line, quic_trial_group,
+                                               quic_trial_params));
+    globals->enable_quic_port_selection.set(
         ShouldEnableQuicPortSelection(command_line));
+    globals->quic_connection_options =
+        GetQuicConnectionOptions(command_line, quic_trial_params);
   }
 
   size_t max_packet_length = GetQuicMaxPacketLength(command_line,
-                                                    quic_trial_group);
+                                                    quic_trial_group,
+                                                    quic_trial_params);
   if (max_packet_length != 0) {
-    globals_->quic_max_packet_length.set(max_packet_length);
+    globals->quic_max_packet_length.set(max_packet_length);
   }
 
   std::string quic_user_agent_id =
       chrome::VersionInfo::GetVersionStringModifier();
   quic_user_agent_id.append(1, ' ');
   chrome::VersionInfo version_info;
   quic_user_agent_id.append(version_info.ProductNameAndVersionForUserAgent());
-  globals_->quic_user_agent_id.set(quic_user_agent_id);
+  globals->quic_user_agent_id.set(quic_user_agent_id);
 
-  net::QuicVersion version = GetQuicVersion(command_line);
+  net::QuicVersion version = GetQuicVersion(command_line, quic_trial_params);
   if (version != net::QUIC_VERSION_UNSUPPORTED) {
     net::QuicVersionVector supported_versions;
     supported_versions.push_back(version);
-    globals_->quic_supported_versions.set(supported_versions);
+    globals->quic_supported_versions.set(supported_versions);
   }
 
   if (command_line.HasSwitch(switches::kOriginToForceQuicOn)) {
     net::HostPortPair quic_origin =
         net::HostPortPair::FromString(
             command_line.GetSwitchValueASCII(switches::kOriginToForceQuicOn));
     if (!quic_origin.IsEmpty()) {
-      globals_->origin_to_force_quic_on.set(quic_origin);
+      globals->origin_to_force_quic_on.set(quic_origin);
     }
   }
 }
 
 bool IOThread::ShouldEnableQuic(const CommandLine& command_line,
                                 base::StringPiece quic_trial_group) {
   if (command_line.HasSwitch(switches::kDisableQuic))
     return false;
 
   if (command_line.HasSwitch(switches::kEnableQuic))
     return true;
 
   return quic_trial_group.starts_with(kQuicFieldTrialEnabledGroupName) ||
       quic_trial_group.starts_with(kQuicFieldTrialHttpsEnabledGroupName);
 }
 
 bool IOThread::ShouldEnableQuicPortSelection(
       const CommandLine& command_line) {
   if (command_line.HasSwitch(switches::kDisableQuicPortSelection))
     return false;
 
   if (command_line.HasSwitch(switches::kEnableQuicPortSelection))
     return true;
 
   return false;  // Default to disabling port selection on all channels.
 }
 
-bool IOThread::ShouldEnableQuicPacing(const CommandLine& command_line,
-                                      base::StringPiece quic_trial_group) {
+bool IOThread::ShouldEnableQuicPacing(
+    const CommandLine& command_line,
+    base::StringPiece quic_trial_group,
+    const std::map<std::string, std::string>& quic_trial_params) {
   if (command_line.HasSwitch(switches::kEnableQuicPacing))
     return true;
 
   if (command_line.HasSwitch(switches::kDisableQuicPacing))
     return false;
 
-  return quic_trial_group.ends_with(kQuicFieldTrialPacingSuffix);
+  if (quic_trial_group.ends_with(kQuicFieldTrialPacingSuffix))

[jar (doing other things), 2014/06/20 23:25:12]

I don't think you're consistent about whether "old" (name based) or "new"
(params based) selection has priority.

In this case, you give precedence to the name.

Line 1250, you give precedence to params.

Probably better would be consistency... and since we want params to be the
future... I'd suggest letting them take the lead (be checked first).

[Ryan Hamilton, 2014/06/21 02:45:23]

Good point. Done.

+    return true;
+
+  return LowerCaseEqualsASCII(
+      GetVariationParam(quic_trial_params, "enable_pacing"),
+      "true");
+}
+
+net::QuicTagVector IOThread::GetQuicConnectionOptions(
+    const CommandLine& command_line,
+    const std::map<std::string, std::string>& quic_trial_params) {
+  net::QuicTagVector options;
+
+  std::map<std::string, std::string>::const_iterator it =
+      quic_trial_params.find("congestion_options");
+  if (it == quic_trial_params.end())
+    return options;
+
+  std::vector<std::string> tokens;
+  base::SplitString(it->second, ',', &tokens);
+  for (std::vector<std::string>::iterator token = tokens.begin();

[jar (doing other things), 2014/06/20 23:25:12]

nit: Add comment that tokens are expected to be no more than 4 characters in
length... but we handle oversize gracefully.

[Ryan Hamilton, 2014/06/21 02:45:23]

Done.

+       token != tokens.end(); ++token) {
+    uint32 option = 0;
+    for (size_t i = token->length() ; i > 0; --i) {
+      option <<= 8;
+      option |= static_cast<unsigned char>((*token)[i - 1]);
+    }
+    options.push_back(static_cast<net::QuicTag>(option));
+  }
+  return options;
 }
 
 bool IOThread::ShouldEnableQuicTimeBasedLossDetection(
     const CommandLine& command_line,
-    base::StringPiece quic_trial_group) {
+    base::StringPiece quic_trial_group,
+    const std::map<std::string, std::string>& quic_trial_params) {
   if (command_line.HasSwitch(switches::kEnableQuicTimeBasedLossDetection))
     return true;
 
   if (command_line.HasSwitch(switches::kDisableQuicTimeBasedLossDetection))
     return false;
 
-  return quic_trial_group.ends_with(
-      kQuicFieldTrialTimeBasedLossDetectionSuffix);
+  if (quic_trial_group.ends_with(
+          kQuicFieldTrialTimeBasedLossDetectionSuffix))
+    return true;
+
+  return LowerCaseEqualsASCII(
+      GetVariationParam(quic_trial_params, "enable_time_based_loss_detection"),
+      "true");
 }
 
-// TODO(rtenneti): Delete this method after the merge.
-bool IOThread::ShouldEnableQuicPersistServerInfo(
-    const CommandLine& command_line) {
-  return true;
-}
-
-size_t IOThread::GetQuicMaxPacketLength(const CommandLine& command_line,
-                                        base::StringPiece quic_trial_group) {
+size_t IOThread::GetQuicMaxPacketLength(
+    const CommandLine& command_line,
+    base::StringPiece quic_trial_group,
+    const std::map<std::string, std::string>& quic_trial_params) {
   if (command_line.HasSwitch(switches::kQuicMaxPacketLength)) {
     unsigned value;
     if (!base::StringToUint(
             command_line.GetSwitchValueASCII(switches::kQuicMaxPacketLength),
             &value)) {
       return 0;
     }
     return value;
   }
 
+  unsigned value;
+  if (base::StringToUint(GetVariationParam(quic_trial_params,
+                                           "max_packet_length"),
+                         &value)) {
+    return value;
+  }
+
   // Format of the packet length group names is:
   //   (Https)?Enabled<length>BytePackets.
   base::StringPiece length_str(quic_trial_group);
   if (length_str.starts_with(kQuicFieldTrialEnabledGroupName)) {
     length_str.remove_prefix(strlen(kQuicFieldTrialEnabledGroupName));
   } else if (length_str.starts_with(kQuicFieldTrialHttpsEnabledGroupName)) {
     length_str.remove_prefix(strlen(kQuicFieldTrialHttpsEnabledGroupName));
   } else {
     return 0;
   }
   if (!length_str.ends_with(kQuicFieldTrialPacketLengthSuffix)) {
     return 0;
   }
   length_str.remove_suffix(strlen(kQuicFieldTrialPacketLengthSuffix));
-  unsigned value;
   if (!base::StringToUint(length_str, &value)) {
     return 0;
   }
   return value;
 }
 
-net::QuicVersion IOThread::GetQuicVersion(const CommandLine& command_line) {
+net::QuicVersion IOThread::GetQuicVersion(
+    const CommandLine& command_line,
+    const std::map<std::string, std::string>& quic_trial_params) {
   if (!command_line.HasSwitch(switches::kQuicVersion)) {

[jar (doing other things), 2014/06/22 18:48:34]

This looks questionable (probably shouldn't have been at this mid-patch)... but
the latest refactor got rid of it.  If I misunderstand... please comment.

[Ryan Hamilton, 2014/06/22 19:48:57]

Yeah, that was ... wrong :> As you surmised, it's fixed now.

     return net::QUIC_VERSION_UNSUPPORTED;
   }
   net::QuicVersionVector supported_versions = net::QuicSupportedVersions();
   std::string version_flag =
       command_line.GetSwitchValueASCII(switches::kQuicVersion);
   for (size_t i = 0; i < supported_versions.size(); ++i) {
     net::QuicVersion version = supported_versions[i];
     if (net::QuicVersionToString(version) == version_flag) {
       return version;
     }
   }
+
+  version_flag = GetVariationParam(quic_trial_params, "quic_version");
+  for (size_t i = 0; i < supported_versions.size(); ++i) {
+    net::QuicVersion version = supported_versions[i];
+    if (net::QuicVersionToString(version) == version_flag) {
+      return version;
+    }
+  }
   return net::QUIC_VERSION_UNSUPPORTED;
 }