Update base::StartsWith calls to new form

components/omnibox/builtin_provider.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 "components/omnibox/builtin_provider.h"
 
 #include <algorithm>
 
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 24 matching lines @@
   const base::string16 kAbout =
       base::ASCIIToUTF16(url::kAboutScheme) +
       base::ASCIIToUTF16(url::kStandardSchemeSeparator);
   const base::string16 embedderAbout =
       base::UTF8ToUTF16(client_->GetEmbedderRepresentationOfAboutScheme()) +
       base::ASCIIToUTF16(url::kStandardSchemeSeparator);
 
   const int kUrl = ACMatchClassification::URL;
   const int kMatch = kUrl | ACMatchClassification::MATCH;
 
-  base::string16 text = input.text();
-  bool starting_about = base::StartsWith(embedderAbout, text, false);
-  if (starting_about || base::StartsWith(kAbout, text, false)) {
+  const base::string16 text = input.text();
+  bool starting_about = base::StartsWith(embedderAbout, text,
+                                         base::CompareCase::INSENSITIVE_ASCII);
+  if (starting_about ||
+      base::StartsWith(kAbout, text, base::CompareCase::INSENSITIVE_ASCII)) {
     ACMatchClassifications styles;
     // Highlight the input portion matching |embedderAbout|; or if the user has
     // input "about:" (with optional slashes), highlight the whole
     // |embedderAbout|.
     bool highlight = starting_about || text.length() > kAboutSchemeLength;
     styles.push_back(ACMatchClassification(0, highlight ? kMatch : kUrl));
     size_t offset = starting_about ? text.length() : embedderAbout.length();
     if (highlight)
       styles.push_back(ACMatchClassification(offset, kUrl));
     // Include some common builtin URLs as the user types the scheme.
     for (base::string16 url : client_->GetBuiltinsToProvideAsUserTypes())
       AddMatch(url, base::string16(), styles);
   } else {
     // Match input about: or |embedderAbout| URL input against builtin URLs.
     GURL url = url_fixer::FixupURL(base::UTF16ToUTF8(text), std::string());
     // BuiltinProvider doesn't know how to suggest valid ?query or #fragment
     // extensions to builtin URLs.
     if (url.SchemeIs(
             client_->GetEmbedderRepresentationOfAboutScheme().c_str()) &&
         url.has_host() && !url.has_query() && !url.has_ref()) {
       // Suggest about:blank for substrings, taking URL fixup into account.
       // Chrome does not support trailing slashes or paths for about:blank.
       const base::string16 blank_host = base::ASCIIToUTF16("blank");
       const base::string16 host = base::UTF8ToUTF16(url.host());
       if (base::StartsWith(text, base::ASCIIToUTF16(url::kAboutScheme),
-                           false) &&
-          base::StartsWith(blank_host, host, false) &&
+                           base::CompareCase::INSENSITIVE_ASCII) &&
+          base::StartsWith(blank_host, host,
+                           base::CompareCase::INSENSITIVE_ASCII) &&
           (url.path().length() <= 1) &&
-          !base::EndsWith(text, base::ASCIIToUTF16("/"), false)) {
+          !base::EndsWith(text, base::ASCIIToUTF16("/"),
+                          base::CompareCase::SENSITIVE)) {
         ACMatchClassifications styles;
         styles.push_back(ACMatchClassification(0, kMatch));
         base::string16 match = base::ASCIIToUTF16(url::kAboutBlankURL);
         // Measure the length of the matching host after the "about:" scheme.
         const size_t corrected_length = kAboutSchemeLength + 1 + host.length();
         if (blank_host.length() > host.length())
           styles.push_back(ACMatchClassification(corrected_length, kUrl));
         AddMatch(match, match.substr(corrected_length), styles);
       }
 
       // Include the path for sub-pages (e.g. "chrome://settings/browser").
       base::string16 host_and_path = base::UTF8ToUTF16(url.host() + url.path());
       base::TrimString(host_and_path, base::ASCIIToUTF16("/"), &host_and_path);
       size_t match_length = embedderAbout.length() + host_and_path.length();
       for (Builtins::const_iterator i(builtins_.begin());
           (i != builtins_.end()) && (matches_.size() < kMaxMatches); ++i) {
-        if (base::StartsWith(*i, host_and_path, false)) {
+        if (base::StartsWith(*i, host_and_path,
+                             base::CompareCase::INSENSITIVE_ASCII)) {
           ACMatchClassifications styles;
           // Highlight |embedderAbout|, even for input "about:foo".
           styles.push_back(ACMatchClassification(0, kMatch));
           base::string16 match_string = embedderAbout + *i;
           if (match_string.length() > match_length)
             styles.push_back(ACMatchClassification(match_length, kUrl));
           AddMatch(match_string, match_string.substr(match_length), styles);
         }
       }
     }
@@ skipping 18 matching lines @@
                                const ACMatchClassifications& styles) {
   AutocompleteMatch match(this, kRelevance, false,
                           AutocompleteMatchType::NAVSUGGEST);
   match.fill_into_edit = match_string;
   match.inline_autocompletion = inline_completion;
   match.destination_url = GURL(match_string);
   match.contents = match_string;
   match.contents_class = styles;
   matches_.push_back(match);
 }