Update monet.

net/base/net_util.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/base/net_util.h"
 
 #include <errno.h>
 #include <string.h>
 
 #include <algorithm>
@@ skipping 262 matching lines @@
     } else if (!IsHostCharAlphanumeric(c) && (c != '-') && (c != '_')) {
       return false;
     }
   }
 
   return most_recent_component_started_alphanumeric;
 }
 
 base::string16 StripWWW(const base::string16& text) {
   const base::string16 www(base::ASCIIToUTF16("www."));
-  return StartsWith(text, www, true) ? text.substr(www.length()) : text;
+  return base::StartsWith(text, www, base::CompareCase::SENSITIVE)
+             ? text.substr(www.length())
+             : text;
 }
 
 base::string16 StripWWWFromHost(const GURL& url) {
   DCHECK(url.is_valid());
   return StripWWW(base::ASCIIToUTF16(url.host()));
 }
 
 bool IsPortValid(int port) {
   return port >= 0 && port <= std::numeric_limits<uint16>::max();
 }
@@ skipping 406 matching lines @@
 
   std::multiset<int> ports;
   size_t last = 0;
   size_t size = allowed_ports.size();
   // The comma delimiter.
   const std::string::value_type kComma = ',';
 
   // Overflow is still possible for evil user inputs.
   for (size_t i = 0; i <= size; ++i) {
     // The string should be composed of only digits and commas.
-    if (i != size && !IsAsciiDigit(allowed_ports[i]) &&
+    if (i != size && !base::IsAsciiDigit(allowed_ports[i]) &&
         (allowed_ports[i] != kComma))
       return;
     if (i == size || allowed_ports[i] == kComma) {
       if (i > last) {
         int port;
         base::StringToInt(base::StringPiece(allowed_ports.begin() + last,
                                             allowed_ports.begin() + i),
                           &port);
         ports.insert(port);
       }
@@ skipping 292 matching lines @@
   if (host.empty())
     return false;
 
   size_t host_len = host.size();
   if (*host.rbegin() == '.')
     --host_len;
   if (host_len < kLocalhostTLDLength)
     return false;
 
   const char* host_suffix = host.data() + host_len - kLocalhostTLDLength;
-  return base::strncasecmp(host_suffix, kLocalhostTLD, kLocalhostTLDLength) ==
-         0;
+  return strncasecmp(host_suffix, kLocalhostTLD, kLocalhostTLDLength) == 0;
 }
 
 bool HasGoogleHost(const GURL& url) {
   static const char* kGoogleHostSuffixes[] = {
       ".google.com",
       ".youtube.com",
       ".gmail.com",
       ".doubleclick.net",
       ".gstatic.com",
       ".googlevideo.com",
       ".googleusercontent.com",
       ".googlesyndication.com",
       ".google-analytics.com",
       ".googleadservices.com",
       ".googleapis.com",
       ".ytimg.com",
   };
   const std::string& host = url.host();
   for (const char* suffix : kGoogleHostSuffixes) {
-    if (EndsWith(host, suffix, false))
+    if (base::EndsWith(host, suffix, base::CompareCase::INSENSITIVE_ASCII))
       return true;
   }
   return false;
 }
 
 NetworkInterface::NetworkInterface()
     : type(NetworkChangeNotifier::CONNECTION_UNKNOWN), prefix_length(0) {
 }
 
 NetworkInterface::NetworkInterface(const std::string& name,
@@ skipping 34 matching lines @@
 
 unsigned MaskPrefixLength(const IPAddressNumber& mask) {
   IPAddressNumber all_ones(mask.size(), 0xFF);
   return CommonPrefixLength(mask, all_ones);
 }
 
 ScopedWifiOptions::~ScopedWifiOptions() {
 }
 
 }  // namespace net