Revert of Add a probability to Alternate-Protocol support.

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/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 
 namespace net {
 
 namespace {
 
 const uint64 kBrokenAlternateProtocolDelaySecs = 300;
 
 }  // namespace
 
 HttpServerPropertiesImpl::HttpServerPropertiesImpl()
     : spdy_servers_map_(SpdyServerHostPortMap::NO_AUTO_EVICT),
       alternate_protocol_map_(AlternateProtocolMap::NO_AUTO_EVICT),
       alternate_protocol_experiment_(
           ALTERNATE_PROTOCOL_NOT_PART_OF_EXPERIMENT),
       spdy_settings_map_(SpdySettingsMap::NO_AUTO_EVICT),
-      alternate_protocol_probability_threshold_(0),
       weak_ptr_factory_(this) {
   canoncial_suffixes_.push_back(".c.youtube.com");
   canoncial_suffixes_.push_back(".googlevideo.com");
   canoncial_suffixes_.push_back(".googleusercontent.com");
 }
 
 HttpServerPropertiesImpl::~HttpServerPropertiesImpl() {
 }
 
 void HttpServerPropertiesImpl::InitializeSpdyServers(
@@ skipping 84 matching lines @@
 // static
 std::string HttpServerPropertiesImpl::GetFlattenedSpdyServer(
     const net::HostPortPair& host_port_pair) {
   std::string spdy_server;
   spdy_server.append(host_port_pair.host());
   spdy_server.append(":");
   base::StringAppendF(&spdy_server, "%d", host_port_pair.port());
   return spdy_server;
 }
 
-static const AlternateProtocolInfo* g_forced_alternate_protocol = NULL;
+static const PortAlternateProtocolPair* g_forced_alternate_protocol = NULL;
 
 // static
 void HttpServerPropertiesImpl::ForceAlternateProtocol(
-    const AlternateProtocolInfo& info) {
+    const PortAlternateProtocolPair& pair) {
   // Note: we're going to leak this.
   if (g_forced_alternate_protocol)
     delete g_forced_alternate_protocol;
-  g_forced_alternate_protocol = new AlternateProtocolInfo(info);
+  g_forced_alternate_protocol = new PortAlternateProtocolPair(pair);
 }
 
 // static
 void HttpServerPropertiesImpl::DisableForcedAlternateProtocol() {
   delete g_forced_alternate_protocol;
   g_forced_alternate_protocol = NULL;
 }
 
 base::WeakPtr<HttpServerProperties> HttpServerPropertiesImpl::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
@@ skipping 34 matching lines @@
   if ((spdy_host_port != spdy_servers_map_.end()) &&
       (spdy_host_port->second == support_spdy)) {
     return;
   }
   // Cache the data.
   spdy_servers_map_.Put(spdy_server, support_spdy);
 }
 
 bool HttpServerPropertiesImpl::HasAlternateProtocol(
     const HostPortPair& server) {
-  if (g_forced_alternate_protocol)
+  if (alternate_protocol_map_.Get(server) != alternate_protocol_map_.end() ||
+      g_forced_alternate_protocol)
     return true;
-  AlternateProtocolMap::const_iterator it = alternate_protocol_map_.Get(server);
-  if (it != alternate_protocol_map_.end() &&
-      it->second.probability > alternate_protocol_probability_threshold_) {
-    return true;
-  }
 
   return GetCanonicalHost(server) != canonical_host_to_origin_map_.end();
 }
 
 std::string HttpServerPropertiesImpl::GetCanonicalSuffix(
     const HostPortPair& server) {
   // If this host ends with a canonical suffix, then return the canonical
   // suffix.
   for (size_t i = 0; i < canoncial_suffixes_.size(); ++i) {
     std::string canonical_suffix = canoncial_suffixes_[i];
     if (EndsWith(server.host(), canoncial_suffixes_[i], false)) {
       return canonical_suffix;
     }
   }
   return std::string();
 }
 
-AlternateProtocolInfo
+PortAlternateProtocolPair
 HttpServerPropertiesImpl::GetAlternateProtocol(
     const HostPortPair& server) {
   DCHECK(HasAlternateProtocol(server));
 
   // First check the map.
   AlternateProtocolMap::iterator it = alternate_protocol_map_.Get(server);
   if (it != alternate_protocol_map_.end())
     return it->second;
 
   // Next check the canonical host.
   CanonicalHostMap::const_iterator canonical_host = GetCanonicalHost(server);
   if (canonical_host != canonical_host_to_origin_map_.end())
     return alternate_protocol_map_.Get(canonical_host->second)->second;
 
   // We must be forcing an alternate.
   DCHECK(g_forced_alternate_protocol);
   return *g_forced_alternate_protocol;
 }
 
 void HttpServerPropertiesImpl::SetAlternateProtocol(
     const HostPortPair& server,
     uint16 alternate_port,
-    AlternateProtocol alternate_protocol,
-    double alternate_probability) {
+    AlternateProtocol alternate_protocol) {
   if (alternate_protocol == ALTERNATE_PROTOCOL_BROKEN) {
     LOG(DFATAL) << "Call SetBrokenAlternateProtocol() instead.";
     return;
   }
 
-  AlternateProtocolInfo alternate(alternate_port,
-                                  alternate_protocol,
-                                  alternate_probability);
+  PortAlternateProtocolPair alternate;
+  alternate.port = alternate_port;
+  alternate.protocol = alternate_protocol;
   if (HasAlternateProtocol(server)) {
-    const AlternateProtocolInfo existing_alternate =
+    const PortAlternateProtocolPair existing_alternate =
         GetAlternateProtocol(server);
 
     if (existing_alternate.protocol == ALTERNATE_PROTOCOL_BROKEN) {
       DVLOG(1) << "Ignore alternate protocol since it's known to be broken.";
       return;
     }
 
     if (alternate_protocol != ALTERNATE_PROTOCOL_BROKEN &&
         !existing_alternate.Equals(alternate)) {
       LOG(WARNING) << "Changing the alternate protocol for: "
                    << server.ToString()
                    << " from [Port: " << existing_alternate.port
                    << ", Protocol: " << existing_alternate.protocol
-                   << ", Probability: " << existing_alternate.probability
                    << "] to [Port: " << alternate_port
                    << ", Protocol: " << alternate_protocol
-                   << ", Probability: " << alternate_probability
                    << "].";
     }
   } else {
     // 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,
                                     alternate_protocol_experiment_);
   }
 
@@ skipping 10 matching lines @@
     }
   }
 }
 
 void HttpServerPropertiesImpl::SetBrokenAlternateProtocol(
     const HostPortPair& server) {
   AlternateProtocolMap::iterator it = alternate_protocol_map_.Get(server);
   if (it != alternate_protocol_map_.end()) {
     it->second.protocol = ALTERNATE_PROTOCOL_BROKEN;
   } else {
-    AlternateProtocolInfo alternate(server.port(),
-                                    ALTERNATE_PROTOCOL_BROKEN,
-                                    1);
+    PortAlternateProtocolPair alternate;
+    alternate.protocol = ALTERNATE_PROTOCOL_BROKEN;
     alternate_protocol_map_.Put(server, alternate);
   }
   int count = ++broken_alternate_protocol_map_[server];
   base::TimeDelta delay =
       base::TimeDelta::FromSeconds(kBrokenAlternateProtocolDelaySecs);
   BrokenAlternateProtocolEntry entry;
   entry.server = server;
   entry.when = base::TimeTicks::Now() + delay * (1 << (count - 1));
   broken_alternate_protocol_list_.push_back(entry);
 
@@ skipping 100 matching lines @@
 HttpServerPropertiesImpl::GetServerNetworkStats(
     const HostPortPair& host_port_pair) const {
   ServerNetworkStatsMap::const_iterator it =
       server_network_stats_map_.find(host_port_pair);
   if (it == server_network_stats_map_.end()) {
     return NULL;
   }
   return &it->second;
 }
 
-void HttpServerPropertiesImpl::SetAlternateProtocolProbabilityThreshold(
-    double threshold) {
-  alternate_protocol_probability_threshold_ = threshold;
-}
-
 HttpServerPropertiesImpl::CanonicalHostMap::const_iterator
 HttpServerPropertiesImpl::GetCanonicalHost(HostPortPair server) const {
   for (size_t i = 0; i < canoncial_suffixes_.size(); ++i) {
     std::string canonical_suffix = canoncial_suffixes_[i];
     if (EndsWith(server.host(), canoncial_suffixes_[i], false)) {
       HostPortPair canonical_host(canonical_suffix, server.port());
       return canonical_host_to_origin_map_.find(canonical_host);
     }
   }
 
@@ skipping 37 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