Update monet.

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 69 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 (EndsWith(it->first.host(), canonical_suffixes_[i], false)) {
+        if (base::EndsWith(it->first.host(), canonical_suffixes_[i],
+                           base::CompareCase::SENSITIVE)) {
           canonical_host_to_origin_map_[canonical_host] = it->first;
           break;
         }
       }
     }
   }
 }
 
 void HttpServerPropertiesImpl::InitializeSpdySettingsServers(
     SpdySettingsMap* spdy_settings_map) {
@@ skipping 107 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 (EndsWith(host, canonical_suffixes_[i], false)) {
+    if (base::EndsWith(host, canonical_suffixes_[i],
+                       base::CompareCase::SENSITIVE)) {
       return canonical_suffix;
     }
   }
   return std::string();
 }
 
 AlternativeService HttpServerPropertiesImpl::GetAlternativeService(
     const HostPortPair& origin) {
   AlternativeServiceMap::const_iterator it =
       alternative_service_map_.Get(origin);
@@ skipping 68 matching lines @@
       HistogramAlternateProtocolUsage(ALTERNATE_PROTOCOL_USAGE_MAPPING_MISSING);
     }
   }
 
   alternative_service_map_.Put(origin, alternative_service_info);
 
   // 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)) {
+    if (base::EndsWith(origin.host(), canonical_suffixes_[i],
+                       base::CompareCase::SENSITIVE)) {
       HostPortPair canonical_host(canonical_suffix, origin.port());
       canonical_host_to_origin_map_[canonical_host] = origin;
       break;
     }
   }
 }
 
 void HttpServerPropertiesImpl::MarkAlternativeServiceBroken(
     const AlternativeService& alternative_service) {
   if (alternative_service.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL) {
@@ skipping 220 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 (EndsWith(server.host(), canonical_suffixes_[i], false)) {
+    if (base::EndsWith(server.host(), canonical_suffixes_[i],
+                       base::CompareCase::SENSITIVE)) {
       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::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(
           &HttpServerPropertiesImpl::ExpireBrokenAlternateProtocolMappings,
           weak_ptr_factory_.GetWeakPtr()),
       delay);
 }
 
 }  // namespace net