Move LowerCaseEqualsASCII to base namespace

components/password_manager/core/browser/affiliation_utils.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/password_manager/core/browser/affiliation_utils.h"
 
 #include <algorithm>
 #include <ostream>
 
 #include "base/base64.h"
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "components/autofill/core/common/password_form.h"
 #include "components/password_manager/core/common/password_manager_switches.h"
 #include "components/variations/variations_associated_data.h"
 #include "net/base/escape.h"
 #include "url/third_party/mozilla/url_parse.h"
 #include "url/url_canon_stdstring.h"
-#include "url/url_util.h"
 
 namespace password_manager {
 
 namespace {
 
 // The scheme used for identifying Android applications.
 const char kAndroidAppScheme[] = "android";
 
 // The name of the field trial controlling affiliation-based matching.
 const char kFieldTrialName[] = "AffiliationBasedMatching";
@@ skipping 144 matching lines @@
 bool ParseAndCanonicalizeFacetURI(const std::string& input_uri,
                                   std::string* canonical_uri) {
   DCHECK(canonical_uri);
   canonical_uri->clear();
   canonical_uri->reserve(input_uri.size() + 32);
 
   url::Parsed input_parsed;
   url::ParseStandardURL(input_uri.c_str(), input_uri.size(), &input_parsed);
 
   base::StringPiece scheme = ComponentString(input_uri, input_parsed.scheme);
-  if (url::LowerCaseEqualsASCII(scheme.begin(), scheme.end(),
-                                url::kHttpsScheme)) {
+  if (base::LowerCaseEqualsASCII(scheme.begin(), scheme.end(),
+                                 url::kHttpsScheme)) {
     return CanonicalizeWebFacetURI(input_uri, input_parsed, canonical_uri);
-  } else if (url::LowerCaseEqualsASCII(scheme.begin(), scheme.end(),
-                                       kAndroidAppScheme)) {
+  } else if (base::LowerCaseEqualsASCII(scheme.begin(), scheme.end(),
+                                        kAndroidAppScheme)) {
     return CanonicalizeAndroidFacetURI(input_uri, input_parsed, canonical_uri);
   }
   return false;
 }
 
 }  // namespace
 
 
 // FacetURI -------------------------------------------------------------------
 
@@ skipping 110 matching lines @@
   // Note: It is important to always query the variation param first, which, in
   // turn, queries the field trial state, which ensures that UMA reports the
   // correct group if it is forced by a command line flag.
   const std::string update_enabled = variations::GetVariationParamValue(
       kFieldTrialName, "propagate_password_changes_to_web");
 
   if (command_line.HasSwitch(switches::kDisableAffiliationBasedMatching))
     return false;
   if (command_line.HasSwitch(switches::kEnableAffiliationBasedMatching))
     return true;
-  return LowerCaseEqualsASCII(update_enabled, "enabled");
+  return base::LowerCaseEqualsASCII(update_enabled, "enabled");
 }
 
 bool IsAffiliationRequestsForDummyFacetsEnabled(
     const base::CommandLine& command_line) {
   const std::string synthesizing_enabled = variations::GetVariationParamValue(
       kFieldTrialName, "affiliation_requests_for_dummy_facets");
   if (command_line.HasSwitch(switches::kDisableAffiliationBasedMatching))
     return false;
   if (command_line.HasSwitch(switches::kEnableAffiliationBasedMatching))
     return true;
-  return LowerCaseEqualsASCII(synthesizing_enabled, "enabled");
+  return base::LowerCaseEqualsASCII(synthesizing_enabled, "enabled");
 }
 
 bool IsValidAndroidFacetURI(const std::string& url) {
   FacetURI facet = FacetURI::FromPotentiallyInvalidSpec(url);
   return facet.IsValidAndroidFacetURI();
 }
 
 std::string GetHumanReadableOrigin(const autofill::PasswordForm& password_form,
                                    const std::string& languages) {
   password_manager::FacetURI facet_uri =
       password_manager::FacetURI::FromPotentiallyInvalidSpec(
           password_form.signon_realm);
   if (facet_uri.IsValidAndroidFacetURI())
     return facet_uri.scheme() + "://" + facet_uri.android_package_name();
   return base::UTF16ToUTF8(net::FormatUrl(password_form.origin, languages));
 }
 }  // namespace password_manager