Move LowerCaseEqualsASCII to base namespace

components/omnibox/autocomplete_input.cc

 // Copyright 2014 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/autocomplete_input.h"
 
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/metrics/proto/omnibox_event.pb.h"
 #include "components/omnibox/autocomplete_scheme_classifier.h"
@@ skipping 151 matching lines @@
   // system isn't going to be able to produce a navigable URL match for it.
   // So we just return QUERY immediately in these cases.
   GURL placeholder_canonicalized_url;
   if (!canonicalized_url)
     canonicalized_url = &placeholder_canonicalized_url;
   *canonicalized_url =
       url_fixer::FixupURL(base::UTF16ToUTF8(text), desired_tld);
   if (!canonicalized_url->is_valid())
     return metrics::OmniboxInputType::QUERY;
 
-  if (LowerCaseEqualsASCII(parsed_scheme_utf8, url::kFileScheme)) {
+  if (base::LowerCaseEqualsASCII(parsed_scheme_utf8, url::kFileScheme)) {
     // A user might or might not type a scheme when entering a file URL.  In
     // either case, |parsed_scheme_utf8| will tell us that this is a file URL,
     // but |parts->scheme| might be empty, e.g. if the user typed "C:\foo".
     return metrics::OmniboxInputType::URL;
   }
 
   // If the user typed a scheme, and it's HTTP or HTTPS, we know how to parse it
   // well enough that we can fall through to the heuristics below.  If it's
   // something else, we can just determine our action based on what we do with
   // any input of this scheme.  In theory we could do better with some schemes
   // (e.g. "ftp" or "view-source") but I'll wait to spend the effort on that
   // until I run into some cases that really need it.
   if (parts->scheme.is_nonempty() &&
-      !LowerCaseEqualsASCII(parsed_scheme_utf8, url::kHttpScheme) &&
-      !LowerCaseEqualsASCII(parsed_scheme_utf8, url::kHttpsScheme)) {
+      !base::LowerCaseEqualsASCII(parsed_scheme_utf8, url::kHttpScheme) &&
+      !base::LowerCaseEqualsASCII(parsed_scheme_utf8, url::kHttpsScheme)) {
     metrics::OmniboxInputType::Type type =
         scheme_classifier.GetInputTypeForScheme(parsed_scheme_utf8);
     if (type != metrics::OmniboxInputType::INVALID)
       return type;
 
     // We don't know about this scheme.  It might be that the user typed a
     // URL of the form "username:password@foo.com".
     const base::string16 http_scheme_prefix =
         base::ASCIIToUTF16(std::string(url::kHttpScheme) +
                            url::kStandardSchemeSeparator);
@@ skipping 230 matching lines @@
   url::Parsed parts;
   base::string16 scheme_str;
   Parse(text, std::string(), scheme_classifier, &parts, &scheme_str, NULL);
 
   *scheme = parts.scheme;
   *host = parts.host;
 
   int after_scheme_and_colon = parts.scheme.end() + 1;
   // For the view-source scheme, we should emphasize the scheme and host of the
   // URL qualified by the view-source prefix.
-  if (LowerCaseEqualsASCII(scheme_str, kViewSourceScheme) &&
+  if (base::LowerCaseEqualsASCII(scheme_str, kViewSourceScheme) &&
       (static_cast<int>(text.length()) > after_scheme_and_colon)) {
     // Obtain the URL prefixed by view-source and parse it.
     base::string16 real_url(text.substr(after_scheme_and_colon));
     url::Parsed real_parts;
     AutocompleteInput::Parse(real_url, std::string(), scheme_classifier,
                              &real_parts, NULL, NULL);
     if (real_parts.scheme.is_nonempty() || real_parts.host.is_nonempty()) {
       if (real_parts.scheme.is_nonempty()) {
         *scheme = url::Component(
             after_scheme_and_colon + real_parts.scheme.begin,
             real_parts.scheme.len);
       } else {
         scheme->reset();
       }
       if (real_parts.host.is_nonempty()) {
         *host = url::Component(after_scheme_and_colon + real_parts.host.begin,
                                real_parts.host.len);
       } else {
         host->reset();
       }
     }
-  } else if (LowerCaseEqualsASCII(scheme_str, url::kFileSystemScheme) &&
+  } else if (base::LowerCaseEqualsASCII(scheme_str, url::kFileSystemScheme) &&
              parts.inner_parsed() && parts.inner_parsed()->scheme.is_valid()) {
     *host = parts.inner_parsed()->host;
   }
 }
 
 // static
 base::string16 AutocompleteInput::FormattedStringWithEquivalentMeaning(
     const GURL& url,
     const base::string16& formatted_url,
     const AutocompleteSchemeClassifier& scheme_classifier) {
@@ skipping 55 matching lines @@
   current_page_classification_ = metrics::OmniboxEventProto::INVALID_SPEC;
   type_ = metrics::OmniboxInputType::INVALID;
   parts_ = url::Parsed();
   scheme_.clear();
   canonicalized_url_ = GURL();
   prevent_inline_autocomplete_ = false;
   prefer_keyword_ = false;
   allow_exact_keyword_match_ = false;
   want_asynchronous_matches_ = true;
 }