Cleanup usage of canonical_suffixes in HttpServerPropertiesImpl

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 <algorithm>
 #include <memory>
 #include <utility>
 
@@ skipping 88 matching lines @@
   for (AlternativeServiceMap::reverse_iterator input_it =
            new_alternative_service_map.rbegin();
        input_it != new_alternative_service_map.rend(); ++input_it) {
     if (alternative_service_map_.Get(input_it->first) ==
         alternative_service_map_.end()) {
       alternative_service_map_.Put(input_it->first, input_it->second);
     }
   }
 
   // Attempt to find canonical servers. Canonical suffix only apply to HTTPS.
-  uint16_t canonical_port = 443;
-  const char* canonical_scheme = "https";
-  for (size_t i = 0; i < canonical_suffixes_.size(); ++i) {
-    std::string canonical_suffix = canonical_suffixes_[i];
-    url::SchemeHostPort canonical_server(canonical_scheme, canonical_suffix,
-                                         canonical_port);
+  const uint16_t kCanonicalPort = 443;
+  const char* kCanonicalScheme = "https";
+  for (const std::string& canonical_suffix : canonical_suffixes_) {
+    url::SchemeHostPort canonical_server(kCanonicalScheme, canonical_suffix,
+                                         kCanonicalPort);
     // If we already have a valid canonical server, we're done.
     if (ContainsKey(canonical_host_to_origin_map_, canonical_server) &&
         (alternative_service_map_.Peek(
              canonical_host_to_origin_map_[canonical_server]) !=
          alternative_service_map_.end())) {
       continue;
     }
     // Now attempt to find a server which matches this origin and set it as
     // canonical.
     for (AlternativeServiceMap::const_iterator it =
              alternative_service_map_.begin();
          it != alternative_service_map_.end(); ++it) {
-      if (base::EndsWith(it->first.host(), canonical_suffixes_[i],
+      if (base::EndsWith(it->first.host(), canonical_suffix,
                          base::CompareCase::INSENSITIVE_ASCII) &&
           it->first.scheme() == canonical_server.scheme()) {
         canonical_host_to_origin_map_[canonical_server] = it->first;
         break;
       }
     }
   }
 }
 
 void HttpServerPropertiesImpl::InitializeSpdySettingsServers(
@@ skipping 162 matching lines @@
   http11_servers_.insert(host_port_pair);
 }
 
 void HttpServerPropertiesImpl::MaybeForceHTTP11(const HostPortPair& server,
                                                 SSLConfig* ssl_config) {
   if (RequiresHTTP11(server)) {
     ForceHTTP11(ssl_config);
   }
 }
 
-std::string HttpServerPropertiesImpl::GetCanonicalSuffix(
-    const std::string& host) {
+const std::string* HttpServerPropertiesImpl::GetCanonicalSuffix(
+    const std::string& host) const {
   // 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 (base::EndsWith(host, canonical_suffixes_[i],
+  for (const std::string& canonical_suffix : canonical_suffixes_) {
+    if (base::EndsWith(host, canonical_suffix,
                        base::CompareCase::INSENSITIVE_ASCII)) {
-      return canonical_suffix;
+      return &canonical_suffix;
     }
   }
-  return std::string();
+  return nullptr;
 }
 
 AlternativeServiceVector HttpServerPropertiesImpl::GetAlternativeServices(
     const url::SchemeHostPort& origin) {
   // Copy valid alternative services into |valid_alternative_services|.
   AlternativeServiceVector valid_alternative_services;
   const base::Time now = base::Time::Now();
   AlternativeServiceMap::iterator map_it = alternative_service_map_.Get(origin);
   if (map_it != alternative_service_map_.end()) {
     HostPortPair host_port_pair(origin.host(), origin.port());
@@ skipping 100 matching lines @@
   if (previously_no_alternative_services &&
       !GetAlternativeServices(origin).empty()) {
     // 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);
   }
 
   // If this host ends with a canonical suffix, then set it as the
   // canonical host.
-  const char* canonical_scheme = "https";
-  for (size_t i = 0; i < canonical_suffixes_.size(); ++i) {
-    std::string canonical_suffix = canonical_suffixes_[i];
-    // canonical suffixes only apply to HTTPS.
-    if (origin.scheme() == canonical_scheme &&
-        base::EndsWith(origin.host(), canonical_suffixes_[i],
-                       base::CompareCase::INSENSITIVE_ASCII)) {
-      url::SchemeHostPort canonical_server(canonical_scheme, canonical_suffix,
+  const char* kCanonicalScheme = "https";
+  if (origin.scheme() == kCanonicalScheme) {
+    const std::string* canonical_suffix = GetCanonicalSuffix(origin.host());
+    if (canonical_suffix != nullptr) {
+      url::SchemeHostPort canonical_server(kCanonicalScheme, *canonical_suffix,
                                            origin.port());
       canonical_host_to_origin_map_[canonical_server] = origin;
-      break;
     }
   }
-
   return changed;
 }
 
 void HttpServerPropertiesImpl::MarkAlternativeServiceBroken(
     const AlternativeService& alternative_service) {
   // Empty host means use host of origin, callers are supposed to substitute.
   DCHECK(!alternative_service.host.empty());
   if (alternative_service.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL) {
     LOG(DFATAL) << "Trying to mark unknown alternate protocol broken.";
     return;
@@ skipping 240 matching lines @@
     }
   }
 
   RemoveCanonicalHost(canonical_server);
   return alternative_service_map_.end();
 }
 
 HttpServerPropertiesImpl::CanonicalHostMap::const_iterator
 HttpServerPropertiesImpl::GetCanonicalHost(
     const url::SchemeHostPort& server) const {
-  const char* canonical_scheme = "https";
-  if (server.scheme() != canonical_scheme)
+  const char* kCanonicalScheme = "https";
+  if (server.scheme() != kCanonicalScheme)
     return canonical_host_to_origin_map_.end();
 
-  for (size_t i = 0; i < canonical_suffixes_.size(); ++i) {
-    std::string canonical_suffix = canonical_suffixes_[i];
-    if (base::EndsWith(server.host(), canonical_suffixes_[i],
-                       base::CompareCase::INSENSITIVE_ASCII)) {
-      url::SchemeHostPort canonical_server(canonical_scheme, canonical_suffix,
-                                           server.port());
-      return canonical_host_to_origin_map_.find(canonical_server);
-    }
-  }
+  const std::string* canonical_suffix = GetCanonicalSuffix(server.host());
+  if (canonical_suffix == nullptr)
+    return canonical_host_to_origin_map_.end();
 
-  return canonical_host_to_origin_map_.end();
+  url::SchemeHostPort canonical_server(kCanonicalScheme, *canonical_suffix,
+                                       server.port());
+  return canonical_host_to_origin_map_.find(canonical_server);
 }
 
 void HttpServerPropertiesImpl::RemoveCanonicalHost(
     const url::SchemeHostPort& server) {
   CanonicalHostMap::const_iterator canonical = GetCanonicalHost(server);
   if (canonical == canonical_host_to_origin_map_.end())
     return;
 
   canonical_host_to_origin_map_.erase(canonical->first);
 }
@@ skipping 53 matching lines @@
   base::TimeDelta delay = when > now ? when - now : base::TimeDelta();
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(
           &HttpServerPropertiesImpl::ExpireBrokenAlternateProtocolMappings,
           weak_ptr_factory_.GetWeakPtr()),
       delay);
 }
 
 }  // namespace net