Make GetAlternateProtocol return AlternativeService.

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 160 matching lines @@
     const HostPortPair& host_port_pair) {
   DCHECK(CalledOnValidThread());
   if (host_port_pair.host().empty())
     return false;
 
   SpdyServerHostPortMap::iterator spdy_host_port =
       spdy_servers_map_.Get(host_port_pair.ToString());
   if (spdy_host_port != spdy_servers_map_.end() && spdy_host_port->second)
     return true;
 
-  const AlternateProtocolInfo info = GetAlternateProtocol(host_port_pair);
-  return info.protocol == QUIC;
+  const AlternativeService alternative_service =
+      GetAlternativeService(host_port_pair);
+  return alternative_service.protocol == QUIC;
 }
 
 void HttpServerPropertiesImpl::SetSupportsSpdy(
     const HostPortPair& host_port_pair,
     bool support_spdy) {
   DCHECK(CalledOnValidThread());
   if (host_port_pair.host().empty())
     return;
 
   SpdyServerHostPortMap::iterator spdy_host_port =
@@ skipping 37 matching lines @@
   // suffix.
   for (size_t i = 0; i < canonical_suffixes_.size(); ++i) {
     std::string canonical_suffix = canonical_suffixes_[i];
     if (EndsWith(host, canonical_suffixes_[i], false)) {
       return canonical_suffix;
     }
   }
   return std::string();
 }
 
-AlternateProtocolInfo HttpServerPropertiesImpl::GetAlternateProtocol(
-    const HostPortPair& server) {
+AlternativeService HttpServerPropertiesImpl::GetAlternativeService(
+    const HostPortPair& origin) {
   AlternateProtocolMap::const_iterator it =
-      GetAlternateProtocolIterator(server);
+      GetAlternateProtocolIterator(origin);
   if (it != alternate_protocol_map_.end() &&
       it->second.probability >= alternate_protocol_probability_threshold_)
-    return it->second;
+    return AlternativeService(it->second.protocol, origin.host(),
+                              it->second.port);
 
   if (g_forced_alternate_protocol)
-    return *g_forced_alternate_protocol;
+    return AlternativeService(g_forced_alternate_protocol->protocol,
+                              origin.host(), g_forced_alternate_protocol->port);
 
-  AlternateProtocolInfo uninitialized_alternate_protocol;
-  return uninitialized_alternate_protocol;
+  AlternativeService uninitialize_alternative_service;
+  return uninitialize_alternative_service;
 }
 
 void HttpServerPropertiesImpl::SetAlternateProtocol(
     const HostPortPair& server,
     uint16 alternate_port,
     AlternateProtocol alternate_protocol,
     double alternate_probability) {
   const AlternativeService alternative_service(alternate_protocol,
                                                server.host(), alternate_port);
   if (IsAlternativeServiceBroken(alternative_service)) {
@@ skipping 37 matching lines @@
     if (EndsWith(server.host(), canonical_suffixes_[i], false)) {
       HostPortPair canonical_host(canonical_suffix, server.port());
       canonical_host_to_origin_map_[canonical_host] = server;
       break;
     }
   }
 }
 
 void HttpServerPropertiesImpl::SetBrokenAlternateProtocol(
     const HostPortPair& server) {
-  const AlternateProtocolInfo alternate = GetAlternateProtocol(server);
-  if (alternate.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL) {
+  const AlternativeService alternative_service = GetAlternativeService(server);
+  if (alternative_service.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL) {
     LOG(DFATAL) << "Trying to mark unknown alternate protocol broken.";
     return;
   }
-  const AlternativeService alternative_service(alternate.protocol,
-                                               server.host(), alternate.port);
   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;
   }
@@ skipping 15 matching lines @@
     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& server) {
-  const AlternateProtocolInfo alternate_protocol = GetAlternateProtocol(server);
-  if (alternate_protocol.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL)
+  const AlternativeService alternative_service = GetAlternativeService(server);
+  if (alternative_service.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL)
     return false;
-  const AlternativeService alternative_service(
-      alternate_protocol.protocol, server.host(), alternate_protocol.port);
   return ContainsKey(recently_broken_alternative_services_,
                      alternative_service);
 }
 
 void HttpServerPropertiesImpl::ConfirmAlternateProtocol(
     const HostPortPair& server) {
-  const AlternateProtocolInfo alternate_protocol = GetAlternateProtocol(server);
-  if (alternate_protocol.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL)
+  const AlternativeService alternative_service = GetAlternativeService(server);
+  if (alternative_service.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL)
     return;
-  const AlternativeService alternative_service(
-      alternate_protocol.protocol, server.host(), alternate_protocol.port);
   broken_alternative_services_.erase(alternative_service);
   recently_broken_alternative_services_.erase(alternative_service);
 }
 
 void HttpServerPropertiesImpl::ClearAlternateProtocol(
     const HostPortPair& server) {
   RemoveCanonicalHost(server);
 
   AlternateProtocolMap::iterator it = alternate_protocol_map_.Peek(server);
   if (it == alternate_protocol_map_.end()) {
@@ skipping 177 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