[Password Manager] Switch password manager code to use the Feature framework.

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/password_manager/core/common/password_manager_features.h"
 #include "components/url_formatter/elide_url.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"
 
 namespace password_manager {
 
 namespace {
 
@@ skipping 257 matching lines @@
   if (a.size() != b.size())
     return false;
 
   std::vector<FacetURI> a_sorted(a.begin(), a.end());
   std::vector<FacetURI> b_sorted(b.begin(), b.end());
   std::sort(a_sorted.begin(), a_sorted.end());
   std::sort(b_sorted.begin(), b_sorted.end());
   return std::equal(a_sorted.begin(), a_sorted.end(), b_sorted.begin());
 }
 
-bool IsAffiliationBasedMatchingEnabled(const base::CommandLine& command_line) {
+bool IsAffiliationBasedMatchingEnabled() {
   // Note: It is important to always query the field trial state, to ensure that
   // UMA reports the correct group.
   const std::string group_name =
       base::FieldTrialList::FindFullName(kFieldTrialName);
 
-  if (command_line.HasSwitch(switches::kDisableAffiliationBasedMatching))
+  if (base::FeatureList::IsEnabled(features::kDisableAffiliationBasedMatching))
     return false;
-  if (command_line.HasSwitch(switches::kEnableAffiliationBasedMatching))
+  if (base::FeatureList::IsEnabled(features::kEnableAffiliationBasedMatching))
     return true;
   return !base::StartsWith(group_name, "Disabled",
                            base::CompareCase::INSENSITIVE_ASCII);
 }
 
-bool IsPropagatingPasswordChangesToWebCredentialsEnabled(
-    const base::CommandLine& command_line) {
+bool IsPropagatingPasswordChangesToWebCredentialsEnabled() {
   // 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))
+  if (base::FeatureList::IsEnabled(features::kDisableAffiliationBasedMatching))
     return false;
-  if (command_line.HasSwitch(switches::kEnableAffiliationBasedMatching))
+  if (base::FeatureList::IsEnabled(features::kEnableAffiliationBasedMatching))
     return true;
   return !base::LowerCaseEqualsASCII(update_enabled, "disabled");
 }
 
 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) {
   FacetURI facet_uri =
       FacetURI::FromPotentiallyInvalidSpec(password_form.signon_realm);
   if (facet_uri.IsValidAndroidFacetURI())
     return GetHumanReadableOriginForAndroidUri(facet_uri);
 
   return base::UTF16ToUTF8(url_formatter::FormatUrlForSecurityDisplay(
       password_form.origin, languages));
 }
 
 std::string GetHumanReadableOriginForAndroidUri(const FacetURI facet_uri) {
   DCHECK(facet_uri.IsValidAndroidFacetURI());
   return facet_uri.scheme() + "://" + facet_uri.android_package_name();
 }
 
 }  // namespace password_manager