Roll Chrome into Mojo.

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 209 matching lines @@
                                                 SSLConfig* ssl_config) {
   if (RequiresHTTP11(server)) {
     ForceHTTP11(ssl_config);
   }
 }
 
 bool HttpServerPropertiesImpl::HasAlternateProtocol(
     const HostPortPair& server) {
   if (g_forced_alternate_protocol)
     return true;
-  AlternateProtocolMap::const_iterator it = alternate_protocol_map_.Get(server);
-  if (it != alternate_protocol_map_.end())
-    return it->second.probability >= alternate_protocol_probability_threshold_;
-
-  auto canonical = GetCanonicalHost(server);
-  if (canonical == canonical_host_to_origin_map_.end() ||
-      canonical->second.Equals(server)) {
-    return false;
-  }
-
-  return HasAlternateProtocol(canonical->second);
+  AlternateProtocolMap::const_iterator it =
+      GetAlternateProtocolIterator(server);
+  return it != alternate_protocol_map_.end() &&
+         it->second.probability >= alternate_protocol_probability_threshold_;
 }
 
 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 < canonical_suffixes_.size(); ++i) {
     std::string canonical_suffix = canonical_suffixes_[i];
     if (EndsWith(server.host(), canonical_suffixes_[i], false)) {
       return canonical_suffix;
     }
   }
   return std::string();
 }
 
 AlternateProtocolInfo
 HttpServerPropertiesImpl::GetAlternateProtocol(
     const HostPortPair& server) {
   DCHECK(HasAlternateProtocol(server));
 
-  // First check the map.
-  AlternateProtocolMap::iterator it = alternate_protocol_map_.Get(server);
+  AlternateProtocolMap::const_iterator it =
+      GetAlternateProtocolIterator(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) {
 
   AlternateProtocolInfo alternate(alternate_port,
                                   alternate_protocol,
                                   alternate_probability);
-  if (HasAlternateProtocol(server)) {
-    const AlternateProtocolInfo existing_alternate =
-        GetAlternateProtocol(server);
+  AlternateProtocolMap::const_iterator it =
+      GetAlternateProtocolIterator(server);
+  if (it != alternate_protocol_map_.end()) {
+    const AlternateProtocolInfo existing_alternate = it->second;
 
     if (existing_alternate.is_broken) {
       DVLOG(1) << "Ignore alternate protocol since it's known to be broken.";
       return;
     }
 
     if (!existing_alternate.Equals(alternate)) {
       LOG(WARNING) << "Changing the alternate protocol for: "
                    << server.ToString()
                    << " from [Port: " << existing_alternate.port
@@ skipping 173 matching lines @@
 const ServerNetworkStatsMap&
 HttpServerPropertiesImpl::server_network_stats_map() const {
   return server_network_stats_map_;
 }
 
 void HttpServerPropertiesImpl::SetAlternateProtocolProbabilityThreshold(
     double threshold) {
   alternate_protocol_probability_threshold_ = threshold;
 }
 
+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);
+
+  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 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