Rename methods and members and const variables to alternative service.

net/http/http_server_properties_impl.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 "net/http/http_server_properties_impl.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 
 namespace net {
 
 namespace {
 
 const uint64 kBrokenAlternativeProtocolDelaySecs = 300;
 
 }  // namespace
 
 HttpServerPropertiesImpl::HttpServerPropertiesImpl()
     : spdy_servers_map_(SpdyServerHostPortMap::NO_AUTO_EVICT),
       alternative_service_map_(AlternativeServiceMap::NO_AUTO_EVICT),
       spdy_settings_map_(SpdySettingsMap::NO_AUTO_EVICT),
       server_network_stats_map_(ServerNetworkStatsMap::NO_AUTO_EVICT),
-      alternate_protocol_probability_threshold_(1),
+      alternative_service_probability_threshold_(1.0),
       weak_ptr_factory_(this) {
   canonical_suffixes_.push_back(".c.youtube.com");
   canonical_suffixes_.push_back(".googlevideo.com");
   canonical_suffixes_.push_back(".googleusercontent.com");
 }
 
 HttpServerPropertiesImpl::~HttpServerPropertiesImpl() {
 }
 
 void HttpServerPropertiesImpl::InitializeSpdyServers(
@@ skipping 179 matching lines @@
     }
   }
   return std::string();
 }
 
 AlternativeService HttpServerPropertiesImpl::GetAlternativeService(
     const HostPortPair& origin) {
   AlternativeServiceMap::const_iterator it =
       alternative_service_map_.Get(origin);
   if (it != alternative_service_map_.end()) {
-    if (it->second.probability < alternate_protocol_probability_threshold_) {
+    if (it->second.probability < alternative_service_probability_threshold_) {
       return AlternativeService();
     }
     AlternativeService alternative_service(it->second.alternative_service);
     if (alternative_service.host.empty()) {
       alternative_service.host = origin.host();
     }
     return alternative_service;
   }
 
   CanonicalHostMap::const_iterator canonical = GetCanonicalHost(origin);
   if (canonical == canonical_host_to_origin_map_.end()) {
     return AlternativeService();
   }
   it = alternative_service_map_.Get(canonical->second);
   if (it == alternative_service_map_.end()) {
     return AlternativeService();
   }
-  if (it->second.probability < alternate_protocol_probability_threshold_) {
+  if (it->second.probability < alternative_service_probability_threshold_) {
     return AlternativeService();
   }
   AlternativeService alternative_service(it->second.alternative_service);
   if (alternative_service.host.empty()) {
     alternative_service.host = canonical->second.host();
   }
   if (IsAlternativeServiceBroken(alternative_service)) {
     RemoveCanonicalHost(canonical->second);
     return AlternativeService();
   }
@@ skipping 24 matching lines @@
       GetAlternateProtocolIterator(origin);
   if (it != alternative_service_map_.end()) {
     const AlternativeServiceInfo existing_alternative_service_info = it->second;
     if (existing_alternative_service_info != alternative_service_info) {
       LOG(WARNING) << "Changing the alternative service for: "
                    << origin.ToString() << " from "
                    << existing_alternative_service_info.ToString() << " to "
                    << alternative_service_info.ToString() << ".";
     }
   } else {
-    if (alternative_probability >= alternate_protocol_probability_threshold_) {
+    if (alternative_probability >= alternative_service_probability_threshold_) {
       // TODO(rch): Consider the case where multiple requests are started
       // before the first completes. In this case, only one of the jobs
       // would reach this code, whereas all of them should should have.
       HistogramAlternateProtocolUsage(ALTERNATE_PROTOCOL_USAGE_MAPPING_MISSING);
     }
   }
 
   alternative_service_map_.Put(origin, alternative_service_info);
 
   // If this host ends with a canonical suffix, then set it as the
@@ skipping 195 matching lines @@
     return NULL;
   }
   return &it->second;
 }
 
 const ServerNetworkStatsMap&
 HttpServerPropertiesImpl::server_network_stats_map() const {
   return server_network_stats_map_;
 }
 
-void HttpServerPropertiesImpl::SetAlternateProtocolProbabilityThreshold(
+void HttpServerPropertiesImpl::SetAlternativeServiceProbabilityThreshold(
     double threshold) {
-  alternate_protocol_probability_threshold_ = threshold;
+  alternative_service_probability_threshold_ = threshold;
 }
 
 AlternativeServiceMap::const_iterator
 HttpServerPropertiesImpl::GetAlternateProtocolIterator(
     const HostPortPair& server) {
   AlternativeServiceMap::const_iterator it =
       alternative_service_map_.Get(server);
   if (it != alternative_service_map_.end())
     return it;
 
@@ skipping 72 matching lines @@
   base::TimeDelta delay = when > now ? when - now : base::TimeDelta();
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(
           &HttpServerPropertiesImpl::ExpireBrokenAlternateProtocolMappings,
           weak_ptr_factory_.GetWeakPtr()),
       delay);
 }
 
 }  // namespace net