Rename methods and members and const variables to alternative service.

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 309 matching lines @@
   return group_name == "RequirementEnforced";
 }
 
 // Parse kUseSpdy command line flag options, which may contain the following:
 //
 //   "off"                      : Disables SPDY support entirely.
 //   "no-ping"                  : Disables SPDY ping connection testing.
 //   "exclude=<host>"           : Disables SPDY support for the host <host>.
 //   "no-compress"              : Disables SPDY header compression.
 //   "no-alt-protocols          : Disables alternate protocol support.
-//   "force-alt-protocols       : Forces an alternate protocol of SPDY/3
-//                                on port 443.
 //   "init-max-streams=<limit>" : Specifies the maximum number of concurrent
 //                                streams for a SPDY session, unless the
 //                                specifies a different value via SETTINGS.
 void ConfigureSpdyGlobalsFromUseSpdyArgument(const std::string& mode,
                                              IOThread::Globals* globals) {
   static const char kOff[] = "off";
   static const char kDisablePing[] = "no-ping";
   static const char kExclude[] = "exclude";  // Hosts to exclude
   static const char kDisableCompression[] = "no-compress";
   static const char kDisableAltProtocols[] = "no-alt-protocols";
@@ skipping 810 matching lines @@
       &params->enable_spdy_compression);
   globals.enable_spdy_ping_based_connection_checking.CopyToIfSet(
       &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);
   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.alternative_service_probability_threshold.CopyToIfSet(
+      &params->alternative_service_probability_threshold);
 
   globals.enable_quic.CopyToIfSet(&params->enable_quic);
   globals.enable_quic_for_proxies.CopyToIfSet(&params->enable_quic_for_proxies);
   globals.quic_always_require_handshake_confirmation.CopyToIfSet(
       &params->quic_always_require_handshake_confirmation);
   globals.quic_disable_connection_pooling.CopyToIfSet(
       &params->quic_disable_connection_pooling);
   globals.quic_load_server_info_timeout_srtt_multiplier.CopyToIfSet(
       &params->quic_load_server_info_timeout_srtt_multiplier);
   globals.quic_enable_connection_racing.CopyToIfSet(
@@ skipping 174 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);
+  double threshold = GetAlternativeProtocolProbabilityThreshold(
+      command_line, quic_trial_params);
   if (threshold >=0 && threshold <= 1) {
-    globals->alternate_protocol_probability_threshold.set(threshold);
-    globals->http_server_properties->SetAlternateProtocolProbabilityThreshold(
+    globals->alternative_service_probability_threshold.set(threshold);
+    globals->http_server_properties->SetAlternativeServiceProbabilityThreshold(
         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 67 matching lines @@
   VariationParameters::const_iterator it =
       quic_trial_params.find("connection_options");
   if (it == quic_trial_params.end()) {
     return net::QuicTagVector();
   }
 
   return net::QuicUtils::ParseQuicConnectionOptions(it->second);
 }
 
 // static
-double IOThread::GetAlternateProtocolProbabilityThreshold(
+double IOThread::GetAlternativeProtocolProbabilityThreshold(
     const base::CommandLine& command_line,
     const VariationParameters& quic_trial_params) {
   double value;
   if (command_line.HasSwitch(
-          switches::kAlternateProtocolProbabilityThreshold)) {
+          switches::kAlternativeServiceProbabilityThreshold)) {
     if (base::StringToDouble(
             command_line.GetSwitchValueASCII(
-                switches::kAlternateProtocolProbabilityThreshold),
+                switches::kAlternativeServiceProbabilityThreshold),
             &value)) {
       return value;
     }
   }
   if (command_line.HasSwitch(switches::kEnableQuic)) {
     return 0;
   }
   if (base::StringToDouble(
           GetVariationParam(quic_trial_params,
-                            "alternate_protocol_probability_threshold"),
+                            "alternative_service_probability_threshold"),
           &value)) {
     return value;
   }
   return -1;
 }
 
 // static
 bool IOThread::ShouldQuicAlwaysRequireHandshakeConfirmation(
     const VariationParameters& quic_trial_params) {
   return LowerCaseEqualsASCII(
@@ skipping 121 matching lines @@
   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;
 }