Remove some legacy versions of StartsWith and EndsWith.

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 "base/bind.h"
 #include "base/location.h"
@@ skipping 99 matching lines @@
           (alternative_service_map_.Peek(
                canonical_host_to_origin_map_[canonical_host]) !=
            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], false)) {
+        if (base::EndsWith(it->first.host(), canonical_suffixes_[i],
+                           base::CompareCase::INSENSITIVE_ASCII)) {
           canonical_host_to_origin_map_[canonical_host] = it->first;
           break;
         }
       }
     }
   }
 }
 
 void HttpServerPropertiesImpl::InitializeSpdySettingsServers(
     SpdySettingsMap* spdy_settings_map) {
@@ skipping 122 matching lines @@
     ForceHTTP11(ssl_config);
   }
 }
 
 std::string HttpServerPropertiesImpl::GetCanonicalSuffix(
     const std::string& host) {
   // 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], false)) {
+    if (base::EndsWith(host, canonical_suffixes_[i],
+                       base::CompareCase::INSENSITIVE_ASCII)) {
       return canonical_suffix;
     }
   }
   return std::string();
 }
 
 AlternativeServiceVector HttpServerPropertiesImpl::GetAlternativeServices(
     const HostPortPair& origin) {
   // Copy alternative services with probability greater than or equal to the
   // threshold into |alternative_services_above_threshold|.
@@ skipping 87 matching lines @@
     // 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.
   for (size_t i = 0; i < canonical_suffixes_.size(); ++i) {
     std::string canonical_suffix = canonical_suffixes_[i];
-    if (base::EndsWith(origin.host(), canonical_suffixes_[i], false)) {
+    if (base::EndsWith(origin.host(), canonical_suffixes_[i],
+                       base::CompareCase::INSENSITIVE_ASCII)) {
       HostPortPair canonical_host(canonical_suffix, origin.port());
       canonical_host_to_origin_map_[canonical_host] = origin;
       break;
     }
   }
 
   return changed;
 }
 
 void HttpServerPropertiesImpl::MarkAlternativeServiceBroken(
@@ skipping 222 matching lines @@
   }
 
   RemoveCanonicalHost(canonical_host_port);
   return alternative_service_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 (base::EndsWith(server.host(), canonical_suffixes_[i], false)) {
+    if (base::EndsWith(server.host(), canonical_suffixes_[i],
+                       base::CompareCase::INSENSITIVE_ASCII)) {
       HostPortPair canonical_host(canonical_suffix, server.port());
       return canonical_host_to_origin_map_.find(canonical_host);
     }
   }
 
   return canonical_host_to_origin_map_.end();
 }
 
 void HttpServerPropertiesImpl::RemoveCanonicalHost(
     const HostPortPair& server) {
@@ skipping 35 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