s/use_alternate_protocols/use_alternative_services/g

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 326 matching lines @@
     if (option == kExclude) {
       globals->forced_spdy_exclusions.insert(
           net::HostPortPair::FromURL(GURL(value.as_string())));
       continue;
     }
     if (option == kDisableCompression) {
       globals->enable_spdy_compression.set(false);
       continue;
     }
     if (option == kDisableAltProtocols) {
-      globals->use_alternate_protocols.set(false);
+      globals->use_alternative_services.set(false);
       continue;
     }
     if (option == kInitialMaxConcurrentStreams) {
       int streams;
       if (base::StringToInt(value, &streams)) {
         globals->initial_max_spdy_concurrent_streams.set(streams);
         continue;
       }
     }
     LOG(DFATAL) << "Unrecognized spdy option: " << option.as_string();
@@ skipping 631 matching lines @@
     globals->next_protos.push_back(net::kProtoQUIC1SPDY3);
   }
 
   // No SPDY command-line flags have been specified. Examine trial groups.
   if (spdy_trial_group.starts_with(kSpdyFieldTrialHoldbackGroupNamePrefix)) {
     net::HttpStreamFactory::set_spdy_enabled(false);
     return;
   }
   if (spdy_trial_group.starts_with(kSpdyFieldTrialSpdy31GroupNamePrefix)) {
     globals->next_protos.push_back(net::kProtoSPDY31);
-    globals->use_alternate_protocols.set(true);
+    globals->use_alternative_services.set(true);
     return;
   }
   if (spdy_trial_group.starts_with(kSpdyFieldTrialSpdy4GroupNamePrefix)) {
     globals->next_protos.push_back(net::kProtoSPDY31);
     globals->next_protos.push_back(net::kProtoHTTP2_14);
     globals->next_protos.push_back(net::kProtoHTTP2);
-    globals->use_alternate_protocols.set(true);
+    globals->use_alternative_services.set(true);
     return;
   }
   if (spdy_trial_group.starts_with(kSpdyFieldTrialParametrizedPrefix)) {
     bool spdy_enabled = false;
     if (base::LowerCaseEqualsASCII(
             GetVariationParam(spdy_trial_params, "enable_spdy31"), "true")) {
       globals->next_protos.push_back(net::kProtoSPDY31);
       spdy_enabled = true;
     }
     if (base::LowerCaseEqualsASCII(
             GetVariationParam(spdy_trial_params, "enable_http2_14"), "true")) {
       globals->next_protos.push_back(net::kProtoHTTP2_14);
       spdy_enabled = true;
     }
     if (base::LowerCaseEqualsASCII(
             GetVariationParam(spdy_trial_params, "enable_http2"), "true")) {
       globals->next_protos.push_back(net::kProtoHTTP2);
       spdy_enabled = true;
     }
     // TODO(bnc): HttpStreamFactory::spdy_enabled_ is redundant with
     // globals->next_protos, can it be eliminated?
     net::HttpStreamFactory::set_spdy_enabled(spdy_enabled);
-    globals->use_alternate_protocols.set(true);
+    globals->use_alternative_services.set(true);
     return;
   }
 
   // By default, enable HTTP/2.
   globals->next_protos.push_back(net::kProtoSPDY31);
   globals->next_protos.push_back(net::kProtoHTTP2_14);
   globals->next_protos.push_back(net::kProtoHTTP2);
-  globals->use_alternate_protocols.set(true);
+  globals->use_alternative_services.set(true);
 }
 
 // static
 void IOThread::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterStringPref(prefs::kAuthSchemes,
                                "basic,digest,ntlm,negotiate");
   registry->RegisterBooleanPref(prefs::kDisableAuthNegotiateCnameLookup, false);
   registry->RegisterBooleanPref(prefs::kEnableAuthNegotiatePort, false);
   registry->RegisterStringPref(prefs::kAuthServerWhitelist, std::string());
   registry->RegisterStringPref(prefs::kAuthNegotiateDelegateWhitelist,
@@ skipping 73 matching lines @@
       &params->spdy_initial_max_concurrent_streams);
   globals.enable_spdy_compression.CopyToIfSet(
       &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.use_alternative_services.CopyToIfSet(
+      &params->use_alternative_services);
   globals.alternative_service_probability_threshold.CopyToIfSet(
       &params->alternative_service_probability_threshold);
 
   globals.enable_quic.CopyToIfSet(&params->enable_quic);
   globals.enable_insecure_quic.CopyToIfSet(&params->enable_insecure_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);
@@ skipping 450 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;
 }