Update monet.

net/proxy/proxy_bypass_rules.cc

 // Copyright (c) 2011 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/proxy/proxy_bypass_rules.h"
 
 #include "base/stl_util.h"
+#include "base/strings/pattern.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_util.h"
 
 namespace net {
 
@@ skipping 11 matching lines @@
 
   bool Matches(const GURL& url) const override {
     if (optional_port_ != -1 && url.EffectiveIntPort() != optional_port_)
       return false;  // Didn't match port expectation.
 
     if (!optional_scheme_.empty() && url.scheme() != optional_scheme_)
       return false;  // Didn't match scheme expectation.
 
     // Note it is necessary to lower-case the host, since GURL uses capital
     // letters for percent-escaped characters.
-    return MatchPattern(base::StringToLowerASCII(url.host()),
-                        hostname_pattern_);
+    return base::MatchPattern(base::StringToLowerASCII(url.host()),
+                              hostname_pattern_);
   }
 
   std::string ToString() const override {
     std::string str;
     if (!optional_scheme_.empty())
       base::StringAppendF(&str, "%s://", optional_scheme_.c_str());
     str += hostname_pattern_;
     if (optional_port_ != -1)
       base::StringAppendF(&str, ":%d", optional_port_);
     return str;
@@ skipping 205 matching lines @@
 }
 
 bool ProxyBypassRules::AddRuleFromStringInternal(
     const std::string& raw_untrimmed,
     bool use_hostname_suffix_matching) {
   std::string raw;
   base::TrimWhitespaceASCII(raw_untrimmed, base::TRIM_ALL, &raw);
 
   // This is the special syntax used by WinInet's bypass list -- we allow it
   // on all platforms and interpret it the same way.
-  if (LowerCaseEqualsASCII(raw, "<local>")) {
+  if (base::LowerCaseEqualsASCII(raw, "<local>")) {
     AddRuleToBypassLocal();
     return true;
   }
 
   // Extract any scheme-restriction.
   std::string::size_type scheme_pos = raw.find("://");
   std::string scheme;
   if (scheme_pos != std::string::npos) {
     scheme = raw.substr(0, scheme_pos);
     raw = raw.substr(scheme_pos + 3);
@@ skipping 43 matching lines @@
                                              raw.end()),
                            &port) ||
         (port < 0 || port > 0xFFFF)) {
       return false;  // Port was invalid.
     }
     raw = raw.substr(0, pos_colon);
   }
 
   // Special-case hostnames that begin with a period.
   // For example, we remap ".google.com" --> "*.google.com".
-  if (StartsWithASCII(raw, ".", false))
+  if (base::StartsWith(raw, ".", base::CompareCase::SENSITIVE))
     raw = "*" + raw;
 
   // If suffix matching was asked for, make sure the pattern starts with a
   // wildcard.
-  if (use_hostname_suffix_matching && !StartsWithASCII(raw, "*", false))
+  if (use_hostname_suffix_matching &&
+      !base::StartsWith(raw, "*", base::CompareCase::SENSITIVE))
     raw = "*" + raw;
 
   return AddRuleForHostname(scheme, raw, port);
 }
 
 bool ProxyBypassRules::AddRuleFromStringInternalWithLogging(
     const std::string& raw,
     bool use_hostname_suffix_matching) {
   return AddRuleFromStringInternal(raw, use_hostname_suffix_matching);
 }
 
 }  // namespace net