[Passwords] Replace Blacklist with Blocklist in Credential Cache

This change replaces mentions of Blacklist with Blocklist in
CredentialCache and OriginCredentialStore.

Bug: 1147799
Change-Id: I3aa875d0bd6c2e54039202348435576da86af4f4
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2579794Reviewed-by: Friedrich [CET] <fhorschig@chromium.org>
Commit-Queue: Jan Wilken Dörrie <jdoerrie@chromium.org>
Cr-Commit-Position: refs/heads/master@{#835210}

chrome/browser/password_manager/android/password_accessory_controller_impl.cc

@@ -56,8 +56,8 @@ using autofill::mojom::FocusedFieldType;
 using password_manager::CredentialCache;
 using password_manager::PasswordStore;
 using password_manager::UiCredential;
-using BlacklistedStatus =
-    password_manager::OriginCredentialStore::BlacklistedStatus;
+using BlocklistedStatus =
+    password_manager::OriginCredentialStore::BlocklistedStatus;
 using FillingSource = ManualFillingController::FillingSource;
 using IsPslMatch = autofill::UserInfo::IsPslMatch;
 
@@ -315,11 +315,11 @@ void PasswordAccessoryControllerImpl::RefreshSuggestionsForField(
       std::move(info_to_add), std::move(footer_commands_to_add));
 
   if (ShouldShowRecoveryToggle(origin)) {
-    BlacklistedStatus blacklisted_status =
-        credential_cache_->GetCredentialStore(origin).GetBlacklistedStatus();
-    if (blacklisted_status == BlacklistedStatus::kWasBlacklisted ||
-        blacklisted_status == BlacklistedStatus::kIsBlacklisted) {
-      bool enabled = (blacklisted_status == BlacklistedStatus::kWasBlacklisted);
+    BlocklistedStatus blocklisted_status =
+        credential_cache_->GetCredentialStore(origin).GetBlocklistedStatus();
+    if (blocklisted_status == BlocklistedStatus::kWasBlocklisted ||
+        blocklisted_status == BlocklistedStatus::kIsBlocklisted) {
+      bool enabled = (blocklisted_status == BlocklistedStatus::kWasBlocklisted);
       if (!enabled) {
         UMA_HISTOGRAM_BOOLEAN(
             "KeyboardAccessory.DisabledSavingAccessoryImpressions", true);

chrome/browser/password_manager/chrome_password_manager_client.cc

@@ -542,10 +542,10 @@ void ChromePasswordManagerClient::NotifyStorePasswordCalled() {
 void ChromePasswordManagerClient::UpdateCredentialCache(
     const url::Origin& origin,
     const std::vector<const PasswordForm*>& best_matches,
-    bool is_blacklisted) {
+    bool is_blocklisted) {
 #if defined(OS_ANDROID)
-  credential_cache_.SaveCredentialsAndBlacklistedForOrigin(
-      best_matches, CredentialCache::IsOriginBlacklisted(is_blacklisted),
+  credential_cache_.SaveCredentialsAndBlocklistedForOrigin(
+      best_matches, CredentialCache::IsOriginBlocklisted(is_blocklisted),
       origin);
 
 #endif
@@ -1257,7 +1257,7 @@ void ChromePasswordManagerClient::DidFinishNavigation(
   AddToWidgetInputEventObservers(
       web_contents()->GetMainFrame()->GetRenderViewHost()->GetWidget(), this);
 #if defined(OS_ANDROID)
-  // This unblacklisted info is only used after form submission to determine
+  // This unblocklisted info is only used after form submission to determine
   // whether to record PasswordManager.SaveUIDismissalReasonAfterUnblacklisting.
   // Therefore it is sufficient to save it only once on navigation and not
   // every time the user changes the UI toggle.

chrome/browser/password_manager/chrome_password_manager_client.h

@@ -139,7 +139,7 @@ class ChromePasswordManagerClient
   void UpdateCredentialCache(
       const url::Origin& origin,
       const std::vector<const password_manager::PasswordForm*>& best_matches,
-      bool is_blacklisted) override;
+      bool is_blocklisted) override;
   void AutomaticPasswordSave(
       std::unique_ptr<password_manager::PasswordFormManagerForUI>
           saved_form_manager) override;

chrome/browser/password_manager/chrome_password_manager_client_unittest.cc

@@ -964,8 +964,8 @@ TEST_F(ChromePasswordManagerClientAndroidTest,
   form.password_value = base::ASCIIToUTF16("S3cr3t");
   GetClient()
       ->GetCredentialCacheForTesting()
-      ->SaveCredentialsAndBlacklistedForOrigin(
-          {&form}, CredentialCache::IsOriginBlacklisted(false), origin);
+      ->SaveCredentialsAndBlocklistedForOrigin(
+          {&form}, CredentialCache::IsOriginBlocklisted(false), origin);
 
   // Check that a navigation within the same document does not clear the cache.
   content::MockNavigationHandle handle(web_contents());

chrome/browser/ui/android/passwords/manual_filling_view_android.cc

@@ -214,7 +214,7 @@ void JNI_ManualFillingComponentBridge_CachePasswordSheetDataForTesting(
     const base::android::JavaParamRef<jobject>& j_web_contents,
     const base::android::JavaParamRef<jobjectArray>& j_usernames,
     const base::android::JavaParamRef<jobjectArray>& j_passwords,
-    jboolean j_blacklisted) {
+    jboolean j_blocklisted) {
   content::WebContents* web_contents =
       content::WebContents::FromJavaWebContents(j_web_contents);
 
@@ -235,9 +235,9 @@ void JNI_ManualFillingComponentBridge_CachePasswordSheetDataForTesting(
   }
   return ChromePasswordManagerClient::FromWebContents(web_contents)
       ->GetCredentialCacheForTesting()
-      ->SaveCredentialsAndBlacklistedForOrigin(
+      ->SaveCredentialsAndBlocklistedForOrigin(
           credentials,
-          password_manager::CredentialCache::IsOriginBlacklisted(j_blacklisted),
+          password_manager::CredentialCache::IsOriginBlocklisted(j_blocklisted),
           origin);
 }
 

components/password_manager/core/browser/credential_cache.cc

@@ -20,9 +20,9 @@ namespace password_manager {
 CredentialCache::CredentialCache() = default;
 CredentialCache::~CredentialCache() = default;
 
-void CredentialCache::SaveCredentialsAndBlacklistedForOrigin(
+void CredentialCache::SaveCredentialsAndBlocklistedForOrigin(
     const std::vector<const PasswordForm*>& best_matches,
-    IsOriginBlacklisted is_blacklisted,
+    IsOriginBlocklisted is_blocklisted,
     const url::Origin& origin) {
   std::vector<UiCredential> credentials;
   credentials.reserve(best_matches.size());
@@ -41,8 +41,8 @@ void CredentialCache::SaveCredentialsAndBlacklistedForOrigin(
                           return credential.origin() == origin;
                         });
   GetOrCreateCredentialStore(origin).SaveCredentials(std::move(credentials));
-  GetOrCreateCredentialStore(origin).SetBlacklistedStatus(
-      is_blacklisted.value());
+  GetOrCreateCredentialStore(origin).SetBlocklistedStatus(
+      is_blocklisted.value());
 }
 
 const OriginCredentialStore& CredentialCache::GetCredentialStore(

components/password_manager/core/browser/credential_cache.h

@@ -21,18 +21,18 @@ class CredentialCache {
  public:
   // TODO(crbug.com/1051553): Consider reusing this alias for other password
   // manager code as well.
-  using IsOriginBlacklisted =
-      base::StrongAlias<class IsOriginBlacklistedTag, bool>;
+  using IsOriginBlocklisted =
+      base::StrongAlias<class IsOriginBlocklistedTag, bool>;
   CredentialCache();
   CredentialCache(const CredentialCache&) = delete;
   CredentialCache& operator=(const CredentialCache&) = delete;
   ~CredentialCache();
 
-  // Saves credentials and blacklisted status for an origin so that they can be
+  // Saves credentials and blocklisted status for an origin so that they can be
   // used in the sheet.
-  void SaveCredentialsAndBlacklistedForOrigin(
+  void SaveCredentialsAndBlocklistedForOrigin(
       const std::vector<const PasswordForm*>& matches,
-      IsOriginBlacklisted is_blacklisted,
+      IsOriginBlocklisted is_blocklisted,
       const url::Origin& origin);
 
   // Returns the credential store for a given origin. If it does not exist, an

components/password_manager/core/browser/credential_cache_unittest.cc

@@ -23,7 +23,7 @@ using url::Origin;
 
 using IsPublicSuffixMatch = UiCredential::IsPublicSuffixMatch;
 using IsAffiliationBasedMatch = UiCredential::IsAffiliationBasedMatch;
-using IsOriginBlacklisted = CredentialCache::IsOriginBlacklisted;
+using IsOriginBlocklisted = CredentialCache::IsOriginBlocklisted;
 
 constexpr char kExampleSite[] = "https://example.com/";
 constexpr char kExampleSite2[] = "https://example.two.com/";
@@ -62,7 +62,7 @@ TEST_F(CredentialCacheTest, ReturnsSameStoreForSameOriginOnly) {
 
 TEST_F(CredentialCacheTest, StoresCredentialsSortedByAplhabetAndOrigins) {
   Origin origin = Origin::Create(GURL(kExampleSite));
-  cache()->SaveCredentialsAndBlacklistedForOrigin(
+  cache()->SaveCredentialsAndBlocklistedForOrigin(
       {CreateEntry("Berta", "30948", GURL(kExampleSite), false, false).get(),
        CreateEntry("Adam", "Pas83B", GURL(kExampleSite), false, false).get(),
        CreateEntry("Dora", "PakudC", GURL(kExampleSite), false, false).get(),
@@ -77,7 +77,7 @@ TEST_F(CredentialCacheTest, StoresCredentialsSortedByAplhabetAndOrigins) {
            .get(),
        CreateEntry("Alf", "R4nd50m", GURL(kExampleSiteMobile), true, false)
            .get()},
-      IsOriginBlacklisted(false), origin);
+      IsOriginBlocklisted(false), origin);
 
   EXPECT_THAT(
       cache()->GetCredentialStore(origin).GetCredentials(),
@@ -111,12 +111,12 @@ TEST_F(CredentialCacheTest, StoredCredentialsForIndependentOrigins) {
   Origin origin = Origin::Create(GURL(kExampleSite));
   Origin origin2 = Origin::Create(GURL(kExampleSite2));
 
-  cache()->SaveCredentialsAndBlacklistedForOrigin(
+  cache()->SaveCredentialsAndBlocklistedForOrigin(
       {CreateEntry("Ben", "S3cur3", GURL(kExampleSite), false, false).get()},
-      IsOriginBlacklisted(false), origin);
-  cache()->SaveCredentialsAndBlacklistedForOrigin(
+      IsOriginBlocklisted(false), origin);
+  cache()->SaveCredentialsAndBlocklistedForOrigin(
       {CreateEntry("Abe", "B4dPW", GURL(kExampleSite2), false, false).get()},
-      IsOriginBlacklisted(false), origin2);
+      IsOriginBlocklisted(false), origin2);
 
   EXPECT_THAT(cache()->GetCredentialStore(origin).GetCredentials(),
               testing::ElementsAre(MakeUiCredential("Ben", "S3cur3")));
@@ -127,9 +127,9 @@ TEST_F(CredentialCacheTest, StoredCredentialsForIndependentOrigins) {
 
 TEST_F(CredentialCacheTest, ClearsCredentials) {
   Origin origin = Origin::Create(GURL(kExampleSite));
-  cache()->SaveCredentialsAndBlacklistedForOrigin(
+  cache()->SaveCredentialsAndBlocklistedForOrigin(
       {CreateEntry("Ben", "S3cur3", GURL(kExampleSite), false, false).get()},
-      IsOriginBlacklisted(false), Origin::Create(GURL(kExampleSite)));
+      IsOriginBlocklisted(false), Origin::Create(GURL(kExampleSite)));
   ASSERT_THAT(cache()->GetCredentialStore(origin).GetCredentials(),
               testing::ElementsAre(MakeUiCredential("Ben", "S3cur3")));
 
@@ -137,13 +137,13 @@ TEST_F(CredentialCacheTest, ClearsCredentials) {
   EXPECT_EQ(cache()->GetCredentialStore(origin).GetCredentials().size(), 0u);
 }
 
-TEST_F(CredentialCacheTest, StoresBlacklistedWithCredentials) {
+TEST_F(CredentialCacheTest, StoresBlocklistedWithCredentials) {
   Origin origin = Origin::Create(GURL(kExampleSite));
-  cache()->SaveCredentialsAndBlacklistedForOrigin(
+  cache()->SaveCredentialsAndBlocklistedForOrigin(
       {CreateEntry("Ben", "S3cur3", GURL(kExampleSite), false, false).get()},
-      IsOriginBlacklisted(true), Origin::Create(GURL(kExampleSite)));
-  EXPECT_EQ(OriginCredentialStore::BlacklistedStatus::kIsBlacklisted,
-            cache()->GetCredentialStore(origin).GetBlacklistedStatus());
+      IsOriginBlocklisted(true), Origin::Create(GURL(kExampleSite)));
+  EXPECT_EQ(OriginCredentialStore::BlocklistedStatus::kIsBlocklisted,
+            cache()->GetCredentialStore(origin).GetBlocklistedStatus());
 }
 
 }  // namespace password_manager

components/password_manager/core/browser/origin_credential_store.cc

@@ -16,7 +16,7 @@
 
 namespace password_manager {
 
-using BlacklistedStatus = OriginCredentialStore::BlacklistedStatus;
+using BlocklistedStatus = OriginCredentialStore::BlocklistedStatus;
 
 UiCredential::UiCredential(base::string16 username,
                            base::string16 password,
@@ -78,19 +78,19 @@ base::span<const UiCredential> OriginCredentialStore::GetCredentials() const {
   return credentials_;
 }
 
-void OriginCredentialStore::SetBlacklistedStatus(bool is_blacklisted) {
-  if (is_blacklisted) {
-    blacklisted_status_ = BlacklistedStatus::kIsBlacklisted;
+void OriginCredentialStore::SetBlocklistedStatus(bool is_blocklisted) {
+  if (is_blocklisted) {
+    blocklisted_status_ = BlocklistedStatus::kIsBlocklisted;
     return;
   }
 
-  if (blacklisted_status_ == BlacklistedStatus::kIsBlacklisted) {
-    blacklisted_status_ = BlacklistedStatus::kWasBlacklisted;
+  if (blocklisted_status_ == BlocklistedStatus::kIsBlocklisted) {
+    blocklisted_status_ = BlocklistedStatus::kWasBlocklisted;
   }
 }
 
-BlacklistedStatus OriginCredentialStore::GetBlacklistedStatus() const {
-  return blacklisted_status_;
+BlocklistedStatus OriginCredentialStore::GetBlocklistedStatus() const {
+  return blocklisted_status_;
 }
 
 void OriginCredentialStore::ClearCredentials() {

components/password_manager/core/browser/origin_credential_store.h

@@ -69,14 +69,14 @@ std::ostream& operator<<(std::ostream& os, const UiCredential& credential);
 // credentials without creating unnecessary copies.
 class OriginCredentialStore {
  public:
-  enum class BlacklistedStatus {
-    // The origin was not blacklisted at the moment this store was initialized.
-    kNeverBlacklisted,
-    // The origin was blacklisted when the store was initialized, but it isn't
-    // currently blacklisted.
-    kWasBlacklisted,
-    // The origin is currently blacklisted.
-    kIsBlacklisted
+  enum class BlocklistedStatus {
+    // The origin was not blocklisted at the moment this store was initialized.
+    kNeverBlocklisted,
+    // The origin was blocklisted when the store was initialized, but it isn't
+    // currently blocklisted.
+    kWasBlocklisted,
+    // The origin is currently blocklisted.
+    kIsBlocklisted
   };
 
   explicit OriginCredentialStore(url::Origin origin);
@@ -90,15 +90,15 @@ class OriginCredentialStore {
   // Returns references to the held credentials (or an empty set if aren't any).
   base::span<const UiCredential> GetCredentials() const;
 
-  // Sets the blacklisted status. The possible transitions are:
-  // (*, is_blacklisted = true) -> kIsBlacklisted
-  // ((kIsBlacklisted|kWasBlacklisted), is_blacklisted = false)
-  //      -> kWasBlacklisted
-  // (kNeverBlacklisted, is_blacklisted = false) -> kNeverBlacklisted
-  void SetBlacklistedStatus(bool is_blacklisted);
+  // Sets the blocklisted status. The possible transitions are:
+  // (*, is_blocklisted = true) -> kIsBlocklisted
+  // ((kIsBlocklisted|kWasBlocklisted), is_blocklisted = false)
+  //      -> kWasBlocklisted
+  // (kNeverBlocklisted, is_blocklisted = false) -> kNeverBlocklisted
+  void SetBlocklistedStatus(bool is_blocklisted);
 
   // Returns the blacklsited status for |origin_|.
-  BlacklistedStatus GetBlacklistedStatus() const;
+  BlocklistedStatus GetBlocklistedStatus() const;
 
   // Removes all credentials from the store.
   void ClearCredentials();
@@ -110,10 +110,10 @@ class OriginCredentialStore {
   // Contains all previously stored of credentials.
   std::vector<UiCredential> credentials_;
 
-  // The blacklisted status for |origin_|.
-  // Used to know whether unblacklisting UI needs to be displayed and what
+  // The blocklisted status for |origin_|.
+  // Used to know whether unblocklisting UI needs to be displayed and what
   // state it should display;
-  BlacklistedStatus blacklisted_status_ = BlacklistedStatus::kNeverBlacklisted;
+  BlocklistedStatus blocklisted_status_ = BlocklistedStatus::kNeverBlocklisted;
 
   // The origin which all stored passwords are related to.
   const url::Origin origin_;

components/password_manager/core/browser/origin_credential_store_unittest.cc

@@ -20,7 +20,7 @@ namespace {
 using base::ASCIIToUTF16;
 using testing::ElementsAre;
 
-using BlacklistedStatus = OriginCredentialStore::BlacklistedStatus;
+using BlocklistedStatus = OriginCredentialStore::BlocklistedStatus;
 using IsPublicSuffixMatch = UiCredential::IsPublicSuffixMatch;
 using IsAffiliationBasedMatch = UiCredential::IsAffiliationBasedMatch;
 
@@ -102,45 +102,45 @@ TEST_F(OriginCredentialStoreTest, ClearsCredentials) {
   EXPECT_EQ(store()->GetCredentials().size(), 0u);
 }
 
-TEST_F(OriginCredentialStoreTest, SetBlacklistedAfterNeverBlacklisted) {
-  store()->SetBlacklistedStatus(true);
-  EXPECT_EQ(BlacklistedStatus::kIsBlacklisted, store()->GetBlacklistedStatus());
+TEST_F(OriginCredentialStoreTest, SetBlocklistedAfterNeverBlocklisted) {
+  store()->SetBlocklistedStatus(true);
+  EXPECT_EQ(BlocklistedStatus::kIsBlocklisted, store()->GetBlocklistedStatus());
 }
 
-TEST_F(OriginCredentialStoreTest, CorrectlyUpdatesBlacklistedStatus) {
-  store()->SetBlacklistedStatus(true);
-  ASSERT_EQ(BlacklistedStatus::kIsBlacklisted, store()->GetBlacklistedStatus());
+TEST_F(OriginCredentialStoreTest, CorrectlyUpdatesBlocklistedStatus) {
+  store()->SetBlocklistedStatus(true);
+  ASSERT_EQ(BlocklistedStatus::kIsBlocklisted, store()->GetBlocklistedStatus());
 
-  store()->SetBlacklistedStatus(false);
-  EXPECT_EQ(BlacklistedStatus::kWasBlacklisted,
-            store()->GetBlacklistedStatus());
+  store()->SetBlocklistedStatus(false);
+  EXPECT_EQ(BlocklistedStatus::kWasBlocklisted,
+            store()->GetBlocklistedStatus());
 
-  store()->SetBlacklistedStatus(true);
-  EXPECT_EQ(BlacklistedStatus::kIsBlacklisted, store()->GetBlacklistedStatus());
+  store()->SetBlocklistedStatus(true);
+  EXPECT_EQ(BlocklistedStatus::kIsBlocklisted, store()->GetBlocklistedStatus());
 }
 
-TEST_F(OriginCredentialStoreTest, WasBlacklistedStaysTheSame) {
-  store()->SetBlacklistedStatus(true);
-  ASSERT_EQ(BlacklistedStatus::kIsBlacklisted, store()->GetBlacklistedStatus());
+TEST_F(OriginCredentialStoreTest, WasBlocklistedStaysTheSame) {
+  store()->SetBlocklistedStatus(true);
+  ASSERT_EQ(BlocklistedStatus::kIsBlocklisted, store()->GetBlocklistedStatus());
 
-  store()->SetBlacklistedStatus(false);
-  ASSERT_EQ(BlacklistedStatus::kWasBlacklisted,
-            store()->GetBlacklistedStatus());
+  store()->SetBlocklistedStatus(false);
+  ASSERT_EQ(BlocklistedStatus::kWasBlocklisted,
+            store()->GetBlocklistedStatus());
 
-  // If unblacklisting is communicated twice in a row, the status shouldn't
+  // If unblocklisting is communicated twice in a row, the status shouldn't
   // change.
-  store()->SetBlacklistedStatus(false);
-  EXPECT_EQ(BlacklistedStatus::kWasBlacklisted,
-            store()->GetBlacklistedStatus());
+  store()->SetBlocklistedStatus(false);
+  EXPECT_EQ(BlocklistedStatus::kWasBlocklisted,
+            store()->GetBlocklistedStatus());
 }
 
-TEST_F(OriginCredentialStoreTest, NeverBlacklistedStaysTheSame) {
-  ASSERT_EQ(BlacklistedStatus::kNeverBlacklisted,
-            store()->GetBlacklistedStatus());
+TEST_F(OriginCredentialStoreTest, NeverBlocklistedStaysTheSame) {
+  ASSERT_EQ(BlocklistedStatus::kNeverBlocklisted,
+            store()->GetBlocklistedStatus());
 
-  store()->SetBlacklistedStatus(false);
-  EXPECT_EQ(BlacklistedStatus::kNeverBlacklisted,
-            store()->GetBlacklistedStatus());
+  store()->SetBlocklistedStatus(false);
+  EXPECT_EQ(BlocklistedStatus::kNeverBlocklisted,
+            store()->GetBlocklistedStatus());
 }
 
 }  // namespace password_manager

components/password_manager/core/browser/password_manager.cc

@@ -64,8 +64,8 @@ using autofill::UNKNOWN_TYPE;
 using autofill::USERNAME;
 using autofill::mojom::SubmissionIndicatorEvent;
 using base::NumberToString;
-using BlacklistedStatus =
-    password_manager::OriginCredentialStore::BlacklistedStatus;
+using BlocklistedStatus =
+    password_manager::OriginCredentialStore::BlocklistedStatus;
 using password_manager::metrics_util::GaiaPasswordHashChange;
 
 namespace password_manager {
@@ -317,8 +317,8 @@ void PasswordManager::MarkWasUnblacklistedInFormManagers(
     const OriginCredentialStore& credential_store =
         credential_cache->GetCredentialStore(
             url::Origin::Create(owned_submitted_form_manager_->GetURL()));
-    if (credential_store.GetBlacklistedStatus() ==
-        BlacklistedStatus::kWasBlacklisted) {
+    if (credential_store.GetBlocklistedStatus() ==
+        BlocklistedStatus::kWasBlocklisted) {
       owned_submitted_form_manager_->MarkWasUnblacklisted();
     }
   }
@@ -327,8 +327,8 @@ void PasswordManager::MarkWasUnblacklistedInFormManagers(
     const OriginCredentialStore& credential_store =
         credential_cache->GetCredentialStore(
             url::Origin::Create(form_manager->GetURL()));
-    if (credential_store.GetBlacklistedStatus() ==
-        BlacklistedStatus::kWasBlacklisted) {
+    if (credential_store.GetBlocklistedStatus() ==
+        BlocklistedStatus::kWasBlocklisted) {
       form_manager->MarkWasUnblacklisted();
     }
   }

components/password_manager/core/browser/password_manager_client.cc

@@ -44,7 +44,7 @@ void PasswordManagerClient::GeneratePassword(
 void PasswordManagerClient::UpdateCredentialCache(
     const url::Origin& origin,
     const std::vector<const PasswordForm*>& best_matches,
-    bool is_blacklisted) {}
+    bool is_blocklisted) {}
 
 void PasswordManagerClient::PasswordWasAutofilled(
     const std::vector<const PasswordForm*>& best_matches,

components/password_manager/core/browser/password_manager_client.h

@@ -214,7 +214,7 @@ class PasswordManagerClient {
   virtual void UpdateCredentialCache(
       const url::Origin& origin,
       const std::vector<const PasswordForm*>& best_matches,
-      bool is_blacklisted);
+      bool is_blocklisted);
 
   // Called when a password is saved in an automated fashion. Embedder may
   // inform the user that this save has occurred.