Update monet.

net/base/net_util_icu.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 <map>
 #include <vector>
 
 #include "base/i18n/time_formatting.h"
@@ skipping 589 matching lines @@
   }
   if (is_dir) {
     result.append(",1,");
   } else {
     result.append(",0,");
   }
 
   // Negative size means unknown or not applicable (e.g. directory).
   base::string16 size_string;
   if (size >= 0)
-    size_string = FormatBytesUnlocalized(size);
+    size_string = base::FormatBytesUnlocalized(size);
   base::EscapeJSONString(size_string, true, &result);
 
   result.append(",");
 
   base::string16 modified_str;
   // |modified| can be NULL in FTP listings.
   if (!modified.is_null()) {
     modified_str = base::TimeFormatShortDateAndTime(modified);
   }
   base::EscapeJSONString(modified_str, true, &result);
@@ skipping 48 matching lines @@
     new_parsed = &parsed_temp;
   else
     *new_parsed = url::Parsed();
 
   // Special handling for view-source:.  Don't use content::kViewSourceScheme
   // because this library shouldn't depend on chrome.
   const char kViewSource[] = "view-source";
   // Reject "view-source:view-source:..." to avoid deep recursion.
   const char kViewSourceTwice[] = "view-source:view-source:";
   if (url.SchemeIs(kViewSource) &&
-      !StartsWithASCII(url.possibly_invalid_spec(), kViewSourceTwice, false)) {
+      !base::StartsWithASCII(url.possibly_invalid_spec(), kViewSourceTwice,
+                             false)) {
     return FormatViewSourceUrl(url, languages, format_types,
                                unescape_rules, new_parsed, prefix_end,
                                adjustments);
   }
 
   // We handle both valid and invalid URLs (this will give us the spec
   // regardless of validity).
   const std::string& spec = url.possibly_invalid_spec();
   const url::Parsed& parsed = url.parsed_for_possibly_invalid_spec();
 
   // Scheme & separators.  These are ASCII.
   base::string16 url_string;
   url_string.insert(
       url_string.end(), spec.begin(),
       spec.begin() + parsed.CountCharactersBefore(url::Parsed::USERNAME, true));
   const char kHTTP[] = "http://";
   const char kFTP[] = "ftp.";
   // url_fixer::FixupURL() treats "ftp.foo.com" as ftp://ftp.foo.com.  This
   // means that if we trim "http://" off a URL whose host starts with "ftp." and
   // the user inputs this into any field subject to fixup (which is basically
   // all input fields), the meaning would be changed.  (In fact, often the
   // formatted URL is directly pre-filled into an input field.)  For this reason
   // we avoid stripping "http://" in this case.
   bool omit_http = (format_types & kFormatUrlOmitHTTP) &&
-      EqualsASCII(url_string, kHTTP) &&
-      !StartsWithASCII(url.host(), kFTP, true);
+                   EqualsASCII(url_string, kHTTP) &&
+                   !base::StartsWithASCII(url.host(), kFTP, true);
   new_parsed->scheme = parsed.scheme;
 
   // Username & password.
   if ((format_types & kFormatUrlOmitUsernamePassword) != 0) {
     // Remove the username and password fields. We don't want to display those
     // to the user since they can be used for attacks,
     // e.g. "http://google.com:search@evil.ru/"
     new_parsed->username.reset();
     new_parsed->password.reset();
     // Update the adjustments based on removed username and/or password.
@@ skipping 66 matching lines @@
                            &url_string, &new_parsed->query, adjustments);
 
   // Ref.  This is valid, unescaped UTF-8, so we can just convert.
   if (parsed.ref.is_valid())
     url_string.push_back('#');
   AppendFormattedComponent(spec, parsed.ref,
                            NonHostComponentTransform(UnescapeRule::NONE),
                            &url_string, &new_parsed->ref, adjustments);
 
   // If we need to strip out http do it after the fact.
-  if (omit_http && StartsWith(url_string, base::ASCIIToUTF16(kHTTP), true)) {
+  if (omit_http && base::StartsWith(url_string, base::ASCIIToUTF16(kHTTP),
+                                    base::CompareCase::SENSITIVE)) {
     const size_t kHTTPSize = arraysize(kHTTP) - 1;
     url_string = url_string.substr(kHTTPSize);
     // Because offsets in the |adjustments| are already calculated with respect
     // to the string with the http:// prefix in it, those offsets remain correct
     // after stripping the prefix.  The only thing necessary is to add an
     // adjustment to reflect the stripped prefix.
     adjustments->insert(adjustments->begin(),
         base::OffsetAdjuster::Adjustment(0, kHTTPSize, 0));
 
     if (prefix_end)
@@ skipping 20 matching lines @@
   if (offset_for_adjustment)
     offsets.push_back(*offset_for_adjustment);
   base::string16 result = FormatUrlWithOffsets(url, languages, format_types,
       unescape_rules, new_parsed, prefix_end, &offsets);
   if (offset_for_adjustment)
     *offset_for_adjustment = offsets[0];
   return result;
 }
 
 }  // namespace net