Add a probability to Alternate-Protocol support.

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 848 matching lines @@
     } else if (option == kDisablePing) {
       globals_->enable_spdy_ping_based_connection_checking.set(false);
     } else if (option == kExclude) {
       globals_->forced_spdy_exclusions.insert(
           net::HostPortPair::FromURL(GURL(value)));
     } else if (option == kDisableCompression) {
       globals_->enable_spdy_compression.set(false);
     } else if (option == kDisableAltProtocols) {
       globals_->use_alternate_protocols.set(false);
     } else if (option == kForceAltProtocols) {
-      net::PortAlternateProtocolPair pair;
-      pair.port = 443;
-      pair.protocol = net::NPN_SPDY_3;
+      net::AlternateProtocolInfo pair(443, net::NPN_SPDY_3, 1);
       net::HttpServerPropertiesImpl::ForceAlternateProtocol(pair);
     } else if (option == kSingleDomain) {
       DVLOG(1) << "FORCING SINGLE DOMAIN";
       globals_->force_spdy_single_domain.set(true);
     } else if (option == kInitialMaxConcurrentStreams) {
       int streams;
       if (base::StringToInt(value, &streams))
         globals_->initial_max_spdy_concurrent_streams.set(streams);
     } else if (option.empty() && it == spdy_options.begin()) {
       continue;
@@ skipping 102 matching lines @@
       &params->enable_spdy_ping_based_connection_checking);
   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);
   params->forced_spdy_exclusions = globals.forced_spdy_exclusions;
   globals.use_alternate_protocols.CopyToIfSet(
       &params->use_alternate_protocols);
+  globals.alternate_protocol_probability_threshold.CopyToIfSet(
+      &params->alternate_protocol_probability_threshold);
   globals.enable_websocket_over_spdy.CopyToIfSet(
       &params->enable_websocket_over_spdy);
 
   globals.enable_quic.CopyToIfSet(&params->enable_quic);
   globals.enable_quic_pacing.CopyToIfSet(
       &params->enable_quic_pacing);
   globals.enable_quic_time_based_loss_detection.CopyToIfSet(
       &params->enable_quic_time_based_loss_detection);
   globals.enable_quic_port_selection.CopyToIfSet(
       &params->enable_quic_port_selection);
@@ skipping 131 matching lines @@
   quic_user_agent_id.append(version_info.ProductNameAndVersionForUserAgent());
   globals->quic_user_agent_id.set(quic_user_agent_id);
 
   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);
   }
 
+  double threshold =
+      GetAlternateProtocolProbabilityThreshold(command_line, quic_trial_params);
+  if (threshold >=0 & threshold <= 1) {
+    globals->alternate_protocol_probability_threshold.set(threshold);
+    globals->http_server_properties->SetAlternateProtocolProbabilityThreshold(
+        threshold);
+  }
+
   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);
     }
   }
 }
 
@@ skipping 47 matching lines @@
   }
 
   VariationParameters::const_iterator it =
       quic_trial_params.find("congestion_options");
   if (it == quic_trial_params.end())
     return net::QuicTagVector();
 
   return ParseQuicConnectionOptions(it->second);
 }
 
+// static
 net::QuicTagVector IOThread::ParseQuicConnectionOptions(
     const std::string& connection_options) {
   net::QuicTagVector options;
   std::vector<std::string> tokens;
   base::SplitString(connection_options, ',', &tokens);
   // Tokens are expected to be no more than 4 characters long, but we
   // handle overflow gracefully.
   for (std::vector<std::string>::iterator token = tokens.begin();
        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;
 }
 
+// static
+double IOThread::GetAlternateProtocolProbabilityThreshold(
+    const base::CommandLine& command_line,
+    const VariationParameters& quic_trial_params) {
+  double value;
+  if (command_line.HasSwitch(
+          switches::kAlternateProtocolProbabilityThreshold)) {
+    if (base::StringToDouble(
+            command_line.GetSwitchValueASCII(
+                switches::kAlternateProtocolProbabilityThreshold),
+            &value)) {
+      return value;
+    }
+  }
+  if (base::StringToDouble(
+          GetVariationParam(quic_trial_params,
+                            "alternate_protocol_probability_threshold"),
+          &value)) {
+    return value;
+  }
+  return -1;
+}
+
+// static
 bool IOThread::ShouldEnableQuicTimeBasedLossDetection(
     const CommandLine& command_line,
     base::StringPiece quic_trial_group,
     const VariationParameters& quic_trial_params) {
   if (command_line.HasSwitch(switches::kEnableQuicTimeBasedLossDetection))
     return true;
 
   if (command_line.HasSwitch(switches::kDisableQuicTimeBasedLossDetection))
     return false;
 
   if (LowerCaseEqualsASCII(
       GetVariationParam(quic_trial_params, "enable_time_based_loss_detection"),
       "true"))
     return true;
 
   return quic_trial_group.ends_with(
       kQuicFieldTrialTimeBasedLossDetectionSuffix);
 }
 
+// static
 size_t IOThread::GetQuicMaxPacketLength(
     const CommandLine& command_line,
     base::StringPiece quic_trial_group,
     const VariationParameters& quic_trial_params) {
   if (command_line.HasSwitch(switches::kQuicMaxPacketLength)) {
     unsigned value;
     if (!base::StringToUint(
             command_line.GetSwitchValueASCII(switches::kQuicMaxPacketLength),
             &value)) {
       return 0;
@@ skipping 21 matching lines @@
   if (!length_str.ends_with(kQuicFieldTrialPacketLengthSuffix)) {
     return 0;
   }
   length_str.remove_suffix(strlen(kQuicFieldTrialPacketLengthSuffix));
   if (!base::StringToUint(length_str, &value)) {
     return 0;
   }
   return value;
 }
 
+// static
 net::QuicVersion IOThread::GetQuicVersion(
     const CommandLine& command_line,
     const VariationParameters& quic_trial_params) {
   if (command_line.HasSwitch(switches::kQuicVersion)) {
     return ParseQuicVersion(
         command_line.GetSwitchValueASCII(switches::kQuicVersion));
   }
 
   return ParseQuicVersion(GetVariationParam(quic_trial_params, "quic_version"));
 }
 
+// static
 net::QuicVersion IOThread::ParseQuicVersion(const std::string& quic_version) {
   net::QuicVersionVector supported_versions = net::QuicSupportedVersions();
   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;
 }