Update HttpServerProperties::*AlternateProtocol* interface.

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"
@@ skipping 237 matching lines @@
                               it->second.port);
 
   if (g_forced_alternate_protocol)
     return AlternativeService(g_forced_alternate_protocol->protocol,
                               origin.host(), g_forced_alternate_protocol->port);
 
   AlternativeService uninitialize_alternative_service;
   return uninitialize_alternative_service;
 }
 
-void HttpServerPropertiesImpl::SetAlternateProtocol(
+void HttpServerPropertiesImpl::SetAlternativeService(
     const HostPortPair& origin,
-    uint16 alternate_port,
-    AlternateProtocol alternate_protocol,
-    double alternate_probability) {
-  const AlternativeService alternative_service(alternate_protocol,
-                                               origin.host(), alternate_port);
+    const AlternativeService& alternative_service,
+    double alternative_probability) {
   if (IsAlternativeServiceBroken(alternative_service)) {
     DVLOG(1) << "Ignore alternative service since it is known to be broken.";
     return;
   }
 
-  const AlternateProtocolInfo alternate(alternate_port, alternate_protocol,
-                                        alternate_probability);
+  const AlternateProtocolInfo alternate(alternative_service.port,
+                                        alternative_service.protocol,
+                                        alternative_probability);
   AlternateProtocolMap::const_iterator it =
       GetAlternateProtocolIterator(origin);
   if (it != alternate_protocol_map_.end()) {
     const AlternateProtocolInfo existing_alternate = it->second;
 
     if (!existing_alternate.Equals(alternate)) {
       LOG(WARNING) << "Changing the alternate protocol for: "
                    << origin.ToString()
                    << " from [Port: " << existing_alternate.port
                    << ", Protocol: " << existing_alternate.protocol
                    << ", Probability: " << existing_alternate.probability
-                   << "] to [Port: " << alternate_port
-                   << ", Protocol: " << alternate_protocol
-                   << ", Probability: " << alternate_probability << "].";
+                   << "] to [Port: " << alternative_service.port
+                   << ", Protocol: " << alternative_service.protocol
+                   << ", Probability: " << alternative_probability << "].";
     }
   } else {
-    if (alternate_probability >= alternate_protocol_probability_threshold_) {
+    if (alternative_probability >= alternate_protocol_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);
     }
   }
 
   alternate_protocol_map_.Put(origin, alternate);
 
   // If this host ends with a canonical suffix, then set it as the
   // canonical host.
   for (size_t i = 0; i < canonical_suffixes_.size(); ++i) {
     std::string canonical_suffix = canonical_suffixes_[i];
     if (EndsWith(origin.host(), canonical_suffixes_[i], false)) {
       HostPortPair canonical_host(canonical_suffix, origin.port());
       canonical_host_to_origin_map_[canonical_host] = origin;
       break;
     }
   }
 }
 
-void HttpServerPropertiesImpl::SetBrokenAlternateProtocol(
-    const HostPortPair& origin) {
-  const AlternativeService alternative_service = GetAlternativeService(origin);
+void HttpServerPropertiesImpl::MarkAlternativeServiceBroken(
+    const AlternativeService& alternative_service) {
   if (alternative_service.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL) {
     LOG(DFATAL) << "Trying to mark unknown alternate protocol broken.";
     return;
   }
   int count = ++recently_broken_alternative_services_[alternative_service];
   base::TimeDelta delay =
       base::TimeDelta::FromSeconds(kBrokenAlternateProtocolDelaySecs);
   base::TimeTicks when = base::TimeTicks::Now() + delay * (1 << (count - 1));
   auto result = broken_alternative_services_.insert(
       std::make_pair(alternative_service, when));
   // Return if alternative service is already in expiration queue.
   if (!result.second) {
     return;
   }
 
-  // Do not leave this host as canonical so that we don't infer the other
-  // hosts are also broken without testing them first.
-  RemoveCanonicalHost(origin);

[Ryan Hamilton, 2015/03/18 22:55:42]

Because of your "Lazy delete" CL you don't need this code, right?

[Bence, 2015/03/19 12:45:39]

Correct.  This part of the diff will disappear once we land the other CL and
rebase this one.

-
   // If this is the only entry in the list, schedule an expiration task.
   // Otherwise it will be rescheduled automatically when the pending task runs.
   if (broken_alternative_services_.size() == 1) {
     ScheduleBrokenAlternateProtocolMappingsExpiration();
   }
 }
 
 void HttpServerPropertiesImpl::MarkAlternativeServiceRecentlyBroken(
     const AlternativeService& alternative_service) {
   if (!ContainsKey(recently_broken_alternative_services_, alternative_service))
     recently_broken_alternative_services_[alternative_service] = 1;
 }
 
 bool HttpServerPropertiesImpl::IsAlternativeServiceBroken(
     const AlternativeService& alternative_service) {
   return ContainsKey(broken_alternative_services_, alternative_service);
 }
 
-bool HttpServerPropertiesImpl::WasAlternateProtocolRecentlyBroken(
-    const HostPortPair& origin) {
-  const AlternativeService alternative_service = GetAlternativeService(origin);
+bool HttpServerPropertiesImpl::WasAlternativeServiceRecentlyBroken(
+    const AlternativeService& alternative_service) {
   if (alternative_service.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL)
     return false;
   return ContainsKey(recently_broken_alternative_services_,
                      alternative_service);
 }
 
-void HttpServerPropertiesImpl::ConfirmAlternateProtocol(
-    const HostPortPair& origin) {
-  const AlternativeService alternative_service = GetAlternativeService(origin);
+void HttpServerPropertiesImpl::ConfirmAlternativeService(
+    const AlternativeService& alternative_service) {
   if (alternative_service.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL)
     return;
   broken_alternative_services_.erase(alternative_service);
   recently_broken_alternative_services_.erase(alternative_service);
 }
 
-void HttpServerPropertiesImpl::ClearAlternateProtocol(
+void HttpServerPropertiesImpl::ClearAlternativeService(
     const HostPortPair& origin) {
   RemoveCanonicalHost(origin);
 
   AlternateProtocolMap::iterator it = alternate_protocol_map_.Peek(origin);
   if (it == alternate_protocol_map_.end()) {
     return;
   }
   const AlternativeService alternative_service(
       it->second.protocol, it->first.host(), it->second.port);
   alternate_protocol_map_.Erase(it);
@@ skipping 107 matching lines @@
 }
 
 AlternateProtocolMap::const_iterator
 HttpServerPropertiesImpl::GetAlternateProtocolIterator(
     const HostPortPair& server) {
   AlternateProtocolMap::const_iterator it = alternate_protocol_map_.Get(server);
   if (it != alternate_protocol_map_.end())
     return it;
 
   CanonicalHostMap::const_iterator canonical = GetCanonicalHost(server);
-  if (canonical != canonical_host_to_origin_map_.end())
-    return alternate_protocol_map_.Get(canonical->second);
+  if (canonical == canonical_host_to_origin_map_.end()) {
+    return alternate_protocol_map_.end();
+  }
 
+  const HostPortPair canonical_host_port = canonical->second;
+  it = alternate_protocol_map_.Get(canonical_host_port);
+  if (it == alternate_protocol_map_.end()) {
+    return alternate_protocol_map_.end();
+  }
+
+  const AlternativeService alternative_service(
+      it->second.protocol, canonical_host_port.host(), it->second.port);
+  if (!IsAlternativeServiceBroken(alternative_service)) {
+    return it;
+  }
+
+  RemoveCanonicalHost(canonical_host_port);

[Ryan Hamilton, 2015/03/18 22:55:42]

Is in your other CL?

[Bence, 2015/03/19 12:45:39]

Correct.  This part of the diff will disappear once we land the other CL and
rebase this one.

   return alternate_protocol_map_.end();
 }
 
 HttpServerPropertiesImpl::CanonicalHostMap::const_iterator
 HttpServerPropertiesImpl::GetCanonicalHost(HostPortPair server) const {
   for (size_t i = 0; i < canonical_suffixes_.size(); ++i) {
     std::string canonical_suffix = canonical_suffixes_[i];
     if (EndsWith(server.host(), canonical_suffixes_[i], false)) {
       HostPortPair canonical_host(canonical_suffix, server.port());
       return canonical_host_to_origin_map_.find(canonical_host);
@@ skipping 19 matching lines @@
   base::TimeTicks now = base::TimeTicks::Now();
   while (!broken_alternative_services_.empty()) {
     BrokenAlternativeServices::iterator it =
         broken_alternative_services_.begin();
     if (now < it->second) {
       break;
     }
 
     const AlternativeService alternative_service = it->first;
     broken_alternative_services_.erase(it);
-    ClearAlternateProtocol(
+    ClearAlternativeService(
         HostPortPair(alternative_service.host, alternative_service.port));
   }
   ScheduleBrokenAlternateProtocolMappingsExpiration();
 }
 
 void
 HttpServerPropertiesImpl::ScheduleBrokenAlternateProtocolMappingsExpiration() {
   if (broken_alternative_services_.empty()) {
     return;
   }
   base::TimeTicks now = base::TimeTicks::Now();
   base::TimeTicks when = broken_alternative_services_.front().second;
   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