Rename GetAffiliations to GetAffiliationsAndBranding

This change renames |GetAffiliations| to |GetAffiliationsAndBranding|
and also changes the name of related methods.

Bug: 628988
Change-Id: Id3e38a209d63a8e07903eccf4005f70186b34a09
Reviewed-on: https://chromium-review.googlesource.com/574370
Commit-Queue: Jan Wilken Dörrie <jdoerrie@chromium.org>
Reviewed-by: Balazs Engedy <engedy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#487467}

components/password_manager/core/browser/android_affiliation/affiliated_match_helper.cc

@@ -63,7 +63,7 @@ void AffiliatedMatchHelper::GetAffiliatedAndroidRealms(
   if (IsValidWebCredential(observed_form)) {
     FacetURI facet_uri(
         FacetURI::FromPotentiallyInvalidSpec(observed_form.signon_realm));
-    affiliation_service_->GetAffiliations(
+    affiliation_service_->GetAffiliationsAndBranding(
         facet_uri, AffiliationService::StrategyOnCacheMiss::FAIL,
         base::Bind(&AffiliatedMatchHelper::CompleteGetAffiliatedAndroidRealms,
                    weak_ptr_factory_.GetWeakPtr(), facet_uri, result_callback));
@@ -76,7 +76,7 @@ void AffiliatedMatchHelper::GetAffiliatedWebRealms(
     const PasswordStore::FormDigest& android_form,
     const AffiliatedRealmsCallback& result_callback) {
   if (IsValidAndroidCredential(android_form)) {
-    affiliation_service_->GetAffiliations(
+    affiliation_service_->GetAffiliationsAndBranding(
         FacetURI::FromPotentiallyInvalidSpec(android_form.signon_realm),
         AffiliationService::StrategyOnCacheMiss::FETCH_OVER_NETWORK,
         base::Bind(&AffiliatedMatchHelper::CompleteGetAffiliatedWebRealms,
@@ -99,9 +99,7 @@ void AffiliatedMatchHelper::InjectAffiliationAndBrandingInformation(
   base::Closure barrier_closure =
       base::BarrierClosure(android_credentials.size(), on_get_all_realms);
   for (auto* form : android_credentials) {
-    // TODO(crbug.com/628988): Rename |GetAffiliations| to
-    // |GetAffiliationsAndBranding|.
-    affiliation_service_->GetAffiliations(
+    affiliation_service_->GetAffiliationsAndBranding(
         FacetURI::FromPotentiallyInvalidSpec(form->signon_realm),
         AffiliationService::StrategyOnCacheMiss::FAIL,
         base::Bind(&AffiliatedMatchHelper::

components/password_manager/core/browser/android_affiliation/affiliated_match_helper_unittest.cc

@@ -35,34 +35,35 @@ class MockAffiliationService : public testing::StrictMock<AffiliationService> {
 
   ~MockAffiliationService() override {}
 
-  MOCK_METHOD2(OnGetAffiliationsCalled,
+  MOCK_METHOD2(OnGetAffiliationsAndBrandingCalled,
                AffiliatedFacets(const FacetURI&, StrategyOnCacheMiss));
   MOCK_METHOD2(Prefetch, void(const FacetURI&, const base::Time&));
   MOCK_METHOD2(CancelPrefetch, void(const FacetURI&, const base::Time&));
   MOCK_METHOD1(TrimCacheForFacetURI, void(const FacetURI&));
 
-  void GetAffiliations(const FacetURI& facet_uri,
-                       StrategyOnCacheMiss cache_miss_strategy,
-                       const ResultCallback& result_callback) override {
+  void GetAffiliationsAndBranding(
+      const FacetURI& facet_uri,
+      StrategyOnCacheMiss cache_miss_strategy,
+      const ResultCallback& result_callback) override {
     AffiliatedFacets affiliation =
-        OnGetAffiliationsCalled(facet_uri, cache_miss_strategy);
+        OnGetAffiliationsAndBrandingCalled(facet_uri, cache_miss_strategy);
     result_callback.Run(affiliation, !affiliation.empty());
   }
 
-  void ExpectCallToGetAffiliationsAndSucceedWithResult(
+  void ExpectCallToGetAffiliationsAndBrandingAndSucceedWithResult(
       const FacetURI& expected_facet_uri,
       StrategyOnCacheMiss expected_cache_miss_strategy,
       const AffiliatedFacets& affiliations_to_return) {
-    EXPECT_CALL(*this, OnGetAffiliationsCalled(expected_facet_uri,
-                                               expected_cache_miss_strategy))
+    EXPECT_CALL(*this, OnGetAffiliationsAndBrandingCalled(
+                           expected_facet_uri, expected_cache_miss_strategy))
         .WillOnce(testing::Return(affiliations_to_return));
   }
 
-  void ExpectCallToGetAffiliationsAndEmulateFailure(
+  void ExpectCallToGetAffiliationsAndBrandingAndEmulateFailure(
       const FacetURI& expected_facet_uri,
       StrategyOnCacheMiss expected_cache_miss_strategy) {
-    EXPECT_CALL(*this, OnGetAffiliationsCalled(expected_facet_uri,
-                                               expected_cache_miss_strategy))
+    EXPECT_CALL(*this, OnGetAffiliationsAndBrandingCalled(
+                           expected_facet_uri, expected_cache_miss_strategy))
         .WillOnce(testing::Return(AffiliatedFacets()));
   }
 
@@ -360,9 +361,10 @@ class AffiliatedMatchHelperTest : public testing::Test {
 // applications, and only if the observed form is a secure HTML login form.
 
 TEST_F(AffiliatedMatchHelperTest, GetAffiliatedAndroidRealmsYieldsResults) {
-  mock_affiliation_service()->ExpectCallToGetAffiliationsAndSucceedWithResult(
-      FacetURI::FromCanonicalSpec(kTestWebFacetURIBeta1),
-      StrategyOnCacheMiss::FAIL, GetTestEquivalenceClassBeta());
+  mock_affiliation_service()
+      ->ExpectCallToGetAffiliationsAndBrandingAndSucceedWithResult(
+          FacetURI::FromCanonicalSpec(kTestWebFacetURIBeta1),
+          StrategyOnCacheMiss::FAIL, GetTestEquivalenceClassBeta());
   EXPECT_THAT(GetAffiliatedAndroidRealms(
                   GetTestObservedWebForm(kTestWebRealmBeta1, nullptr)),
               testing::UnorderedElementsAre(kTestAndroidRealmBeta2,
@@ -371,9 +373,10 @@ TEST_F(AffiliatedMatchHelperTest, GetAffiliatedAndroidRealmsYieldsResults) {
 
 TEST_F(AffiliatedMatchHelperTest,
        GetAffiliatedAndroidRealmsYieldsOnlyAndroidApps) {
-  mock_affiliation_service()->ExpectCallToGetAffiliationsAndSucceedWithResult(
-      FacetURI::FromCanonicalSpec(kTestWebFacetURIAlpha1),
-      StrategyOnCacheMiss::FAIL, GetTestEquivalenceClassAlpha());
+  mock_affiliation_service()
+      ->ExpectCallToGetAffiliationsAndBrandingAndSucceedWithResult(
+          FacetURI::FromCanonicalSpec(kTestWebFacetURIAlpha1),
+          StrategyOnCacheMiss::FAIL, GetTestEquivalenceClassAlpha());
   // This verifies that |kTestWebRealmAlpha2| is not returned.
   EXPECT_THAT(GetAffiliatedAndroidRealms(
                   GetTestObservedWebForm(kTestWebRealmAlpha1, nullptr)),
@@ -408,9 +411,10 @@ TEST_F(AffiliatedMatchHelperTest,
 
 TEST_F(AffiliatedMatchHelperTest,
        GetAffiliatedAndroidRealmsYieldsEmptyResultsWhenNoPrefetch) {
-  mock_affiliation_service()->ExpectCallToGetAffiliationsAndEmulateFailure(
-      FacetURI::FromCanonicalSpec(kTestWebFacetURIAlpha1),
-      StrategyOnCacheMiss::FAIL);
+  mock_affiliation_service()
+      ->ExpectCallToGetAffiliationsAndBrandingAndEmulateFailure(
+          FacetURI::FromCanonicalSpec(kTestWebFacetURIAlpha1),
+          StrategyOnCacheMiss::FAIL);
   EXPECT_THAT(GetAffiliatedAndroidRealms(
                   GetTestObservedWebForm(kTestWebRealmAlpha1, nullptr)),
               testing::IsEmpty());
@@ -421,9 +425,11 @@ TEST_F(AffiliatedMatchHelperTest,
 // only web sites, and only if an Android application is queried.
 
 TEST_F(AffiliatedMatchHelperTest, GetAffiliatedWebRealmsYieldsResults) {
-  mock_affiliation_service()->ExpectCallToGetAffiliationsAndSucceedWithResult(
-      FacetURI::FromCanonicalSpec(kTestAndroidFacetURIAlpha3),
-      StrategyOnCacheMiss::FETCH_OVER_NETWORK, GetTestEquivalenceClassAlpha());
+  mock_affiliation_service()
+      ->ExpectCallToGetAffiliationsAndBrandingAndSucceedWithResult(
+          FacetURI::FromCanonicalSpec(kTestAndroidFacetURIAlpha3),
+          StrategyOnCacheMiss::FETCH_OVER_NETWORK,
+          GetTestEquivalenceClassAlpha());
   PasswordStore::FormDigest android_form(
       GetTestAndroidCredentials(kTestAndroidRealmAlpha3));
   EXPECT_THAT(
@@ -432,9 +438,11 @@ TEST_F(AffiliatedMatchHelperTest, GetAffiliatedWebRealmsYieldsResults) {
 }
 
 TEST_F(AffiliatedMatchHelperTest, GetAffiliatedWebRealmsYieldsOnlyWebsites) {
-  mock_affiliation_service()->ExpectCallToGetAffiliationsAndSucceedWithResult(
-      FacetURI::FromCanonicalSpec(kTestAndroidFacetURIBeta2),
-      StrategyOnCacheMiss::FETCH_OVER_NETWORK, GetTestEquivalenceClassBeta());
+  mock_affiliation_service()
+      ->ExpectCallToGetAffiliationsAndBrandingAndSucceedWithResult(
+          FacetURI::FromCanonicalSpec(kTestAndroidFacetURIBeta2),
+          StrategyOnCacheMiss::FETCH_OVER_NETWORK,
+          GetTestEquivalenceClassBeta());
   PasswordStore::FormDigest android_form(
       GetTestAndroidCredentials(kTestAndroidRealmBeta2));
   // This verifies that |kTestAndroidRealmBeta3| is not returned.
@@ -458,27 +466,31 @@ TEST_F(AffiliatedMatchHelperTest, InjectAffiliationAndBrandingInformation) {
 
   forms.push_back(base::MakeUnique<autofill::PasswordForm>(
       GetTestAndroidCredentials(kTestAndroidRealmAlpha3)));
-  mock_affiliation_service()->ExpectCallToGetAffiliationsAndSucceedWithResult(
-      FacetURI::FromCanonicalSpec(kTestAndroidFacetURIAlpha3),
-      StrategyOnCacheMiss::FAIL, GetTestEquivalenceClassAlpha());
+  mock_affiliation_service()
+      ->ExpectCallToGetAffiliationsAndBrandingAndSucceedWithResult(
+          FacetURI::FromCanonicalSpec(kTestAndroidFacetURIAlpha3),
+          StrategyOnCacheMiss::FAIL, GetTestEquivalenceClassAlpha());
 
   forms.push_back(base::MakeUnique<autofill::PasswordForm>(
       GetTestAndroidCredentials(kTestAndroidRealmBeta2)));
-  mock_affiliation_service()->ExpectCallToGetAffiliationsAndSucceedWithResult(
-      FacetURI::FromCanonicalSpec(kTestAndroidFacetURIBeta2),
-      StrategyOnCacheMiss::FAIL, GetTestEquivalenceClassBeta());
+  mock_affiliation_service()
+      ->ExpectCallToGetAffiliationsAndBrandingAndSucceedWithResult(
+          FacetURI::FromCanonicalSpec(kTestAndroidFacetURIBeta2),
+          StrategyOnCacheMiss::FAIL, GetTestEquivalenceClassBeta());
 
   forms.push_back(base::MakeUnique<autofill::PasswordForm>(
       GetTestAndroidCredentials(kTestAndroidRealmBeta3)));
-  mock_affiliation_service()->ExpectCallToGetAffiliationsAndSucceedWithResult(
-      FacetURI::FromCanonicalSpec(kTestAndroidFacetURIBeta3),
-      StrategyOnCacheMiss::FAIL, GetTestEquivalenceClassBeta());
+  mock_affiliation_service()
+      ->ExpectCallToGetAffiliationsAndBrandingAndSucceedWithResult(
+          FacetURI::FromCanonicalSpec(kTestAndroidFacetURIBeta3),
+          StrategyOnCacheMiss::FAIL, GetTestEquivalenceClassBeta());
 
   forms.push_back(base::MakeUnique<autofill::PasswordForm>(
       GetTestAndroidCredentials(kTestAndroidRealmGamma)));
-  mock_affiliation_service()->ExpectCallToGetAffiliationsAndEmulateFailure(
-      FacetURI::FromCanonicalSpec(kTestAndroidFacetURIGamma),
-      StrategyOnCacheMiss::FAIL);
+  mock_affiliation_service()
+      ->ExpectCallToGetAffiliationsAndBrandingAndEmulateFailure(
+          FacetURI::FromCanonicalSpec(kTestAndroidFacetURIGamma),
+          StrategyOnCacheMiss::FAIL);
 
   PasswordStore::FormDigest digest =
       GetTestObservedWebForm(kTestWebRealmBeta1, nullptr);
@@ -524,8 +536,9 @@ TEST_F(AffiliatedMatchHelperTest, IsValidAndroidCredential) {
 
 // Verifies that affiliations for Android applications with pre-existing
 // credentials on start-up are prefetched.
-TEST_F(AffiliatedMatchHelperTest,
-       PrefetchAffiliationsForPreexistingAndroidCredentialsOnStartup) {
+TEST_F(
+    AffiliatedMatchHelperTest,
+    PrefetchAffiliationsAndBrandingForPreexistingAndroidCredentialsOnStartup) {
   AddAndroidAndNonAndroidTestLogins();
 
   match_helper()->Initialize();
@@ -561,7 +574,7 @@ TEST_F(AffiliatedMatchHelperTest,
 }
 
 TEST_F(AffiliatedMatchHelperTest,
-       CancelPrefetchingAffiliationsForRemovedAndroidCredentials) {
+       CancelPrefetchingAffiliationsAndBrandingForRemovedAndroidCredentials) {
   AddAndroidAndNonAndroidTestLogins();
   match_helper()->Initialize();
   ExpectPrefetchForAndroidTestLogins();

components/password_manager/core/browser/android_affiliation/affiliation_backend.cc

@@ -56,7 +56,7 @@ void AffiliationBackend::Initialize(const base::FilePath& db_path) {
   cache_->Init(db_path);
 }
 
-void AffiliationBackend::GetAffiliations(
+void AffiliationBackend::GetAffiliationsAndBranding(
     const FacetURI& facet_uri,
     StrategyOnCacheMiss cache_miss_strategy,
     const AffiliationService::ResultCallback& callback,
@@ -65,8 +65,8 @@ void AffiliationBackend::GetAffiliations(
 
   FacetManager* facet_manager = GetOrCreateFacetManager(facet_uri);
   DCHECK(facet_manager);
-  facet_manager->GetAffiliations(cache_miss_strategy, callback,
-                                 callback_task_runner);
+  facet_manager->GetAffiliationsAndBranding(cache_miss_strategy, callback,
+                                            callback_task_runner);
 
   if (facet_manager->CanBeDiscarded())
     facet_managers_.erase(facet_uri);
@@ -101,7 +101,7 @@ void AffiliationBackend::TrimCacheForFacetURI(const FacetURI& facet_uri) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   AffiliatedFacetsWithUpdateTime affiliation;
-  if (cache_->GetAffiliationsForFacetURI(facet_uri, &affiliation))
+  if (cache_->GetAffiliationsAndBrandingForFacetURI(facet_uri, &affiliation))
     DiscardCachedDataIfNoLongerNeeded(affiliation.facets);
 }
 
@@ -135,7 +135,7 @@ void AffiliationBackend::DiscardCachedDataIfNoLongerNeeded(
   }
 
   CHECK(!affiliated_facets.empty());
-  cache_->DeleteAffiliationsForFacetURI(affiliated_facets[0].uri);
+  cache_->DeleteAffiliationsAndBrandingForFacetURI(affiliated_facets[0].uri);
 }
 
 void AffiliationBackend::OnSendNotification(const FacetURI& facet_uri) {
@@ -150,10 +150,10 @@ void AffiliationBackend::OnSendNotification(const FacetURI& facet_uri) {
     facet_managers_.erase(facet_uri);
 }
 
-bool AffiliationBackend::ReadAffiliationsFromDatabase(
+bool AffiliationBackend::ReadAffiliationsAndBrandingFromDatabase(
     const FacetURI& facet_uri,
     AffiliatedFacetsWithUpdateTime* affiliations) {
-  return cache_->GetAffiliationsForFacetURI(facet_uri, affiliations);
+  return cache_->GetAffiliationsAndBrandingForFacetURI(facet_uri, affiliations);
 }
 
 void AffiliationBackend::SignalNeedNetworkRequest() {
@@ -208,8 +208,9 @@ void AffiliationBackend::OnFetchSucceeded(
     }
   }
 
-  // A subsequent fetch may be needed if any additional GetAffiliations()
-  // requests came in while the current fetch was in flight.
+  // A subsequent fetch may be needed if any additional
+  // GetAffiliationsAndBranding() requests came in while the current fetch was
+  // in flight.
   for (const auto& facet_manager_pair : facet_managers_) {
     if (facet_manager_pair.second->DoesRequireFetch()) {
       throttler_->SignalNetworkRequestNeeded();

components/password_manager/core/browser/android_affiliation/affiliation_backend.h

@@ -8,6 +8,7 @@
 #include <stddef.h>
 
 #include <map>
+#include <memory>
 #include <unordered_map>
 #include <vector>
 
@@ -73,7 +74,7 @@ class AffiliationBackend : public FacetManagerHost,
 
   // Implementations for methods of the same name in AffiliationService. They
   // are not documented here again. See affiliation_service.h for details:
-  void GetAffiliations(
+  void GetAffiliationsAndBranding(
       const FacetURI& facet_uri,
       StrategyOnCacheMiss cache_miss_strategy,
       const AffiliationService::ResultCallback& callback,
@@ -107,7 +108,7 @@ class AffiliationBackend : public FacetManagerHost,
   void OnSendNotification(const FacetURI& facet_uri);
 
   // FacetManagerHost:
-  bool ReadAffiliationsFromDatabase(
+  bool ReadAffiliationsAndBrandingFromDatabase(
       const FacetURI& facet_uri,
       AffiliatedFacetsWithUpdateTime* affiliations) override;
   void SignalNeedNetworkRequest() override;

components/password_manager/core/browser/android_affiliation/affiliation_database.cc

@@ -89,7 +89,7 @@ bool AffiliationDatabase::Init(const base::FilePath& path) {
   return true;
 }
 
-bool AffiliationDatabase::GetAffiliationsForFacetURI(
+bool AffiliationDatabase::GetAffiliationsAndBrandingForFacetURI(
     const FacetURI& facet_uri,
     AffiliatedFacetsWithUpdateTime* result) const {
   DCHECK(result);
@@ -116,7 +116,7 @@ bool AffiliationDatabase::GetAffiliationsForFacetURI(
   return !result->facets.empty();
 }
 
-void AffiliationDatabase::GetAllAffiliations(
+void AffiliationDatabase::GetAllAffiliationsAndBranding(
     std::vector<AffiliatedFacetsWithUpdateTime>* results) const {
   DCHECK(results);
   results->clear();
@@ -146,7 +146,7 @@ void AffiliationDatabase::GetAllAffiliations(
   }
 }
 
-void AffiliationDatabase::DeleteAffiliationsForFacetURI(
+void AffiliationDatabase::DeleteAffiliationsAndBrandingForFacetURI(
     const FacetURI& facet_uri) {
   sql::Transaction transaction(sql_connection_.get());
   if (!transaction.Begin())
@@ -174,7 +174,7 @@ void AffiliationDatabase::DeleteAffiliationsForFacetURI(
   transaction.Commit();
 }
 
-void AffiliationDatabase::DeleteAffiliationsOlderThan(
+void AffiliationDatabase::DeleteAffiliationsAndBrandingOlderThan(
     const base::Time& cutoff_threshold) {
   // Children will get deleted due to 'ON DELETE CASCADE'.
   sql::Statement statement_parent(sql_connection_->GetCachedStatement(
@@ -185,7 +185,7 @@ void AffiliationDatabase::DeleteAffiliationsOlderThan(
   statement_parent.Run();
 }
 
-void AffiliationDatabase::DeleteAllAffiliations() {
+void AffiliationDatabase::DeleteAllAffiliationsAndBranding() {
   // Children will get deleted due to 'ON DELETE CASCADE'.
   sql::Statement statement_parent(
       sql_connection_->GetUniqueStatement("DELETE FROM eq_classes"));
@@ -242,12 +242,12 @@ void AffiliationDatabase::StoreAndRemoveConflicting(
 
   for (const Facet& facet : affiliation.facets) {
     AffiliatedFacetsWithUpdateTime old_affiliation;
-    if (GetAffiliationsForFacetURI(facet.uri, &old_affiliation)) {
+    if (GetAffiliationsAndBrandingForFacetURI(facet.uri, &old_affiliation)) {
       if (!AreEquivalenceClassesEqual(old_affiliation.facets,
                                       affiliation.facets)) {
         removed_affiliations->push_back(old_affiliation);
       }
-      DeleteAffiliationsForFacetURI(facet.uri);
+      DeleteAffiliationsAndBrandingForFacetURI(facet.uri);
     }
   }
 

components/password_manager/core/browser/android_affiliation/affiliation_database.h

@@ -25,8 +25,9 @@ class Statement;
 namespace password_manager {
 
 // Stores equivalence classes of facets, i.e., facets that are affiliated with
-// each other, in an SQLite database. See affiliation_utils.h for a more
-// detailed definition of what this means.
+// each other, in an SQLite database. In addition, relevant branding information
+// is stored. See affiliation_utils.h for a more detailed definition of what
+// this means.
 //
 // Under the assumption that there is most likely not much the caller can do in
 // case of database errors, most methods silently ignore them. Nevertheless, the
@@ -42,33 +43,39 @@ class AffiliationDatabase {
   bool Init(const base::FilePath& path);
 
   // Looks up the equivalence class containing |facet_uri|, and returns true if
-  // such a class is found, in which case it is also stored into |result|.
-  bool GetAffiliationsForFacetURI(const FacetURI& facet_uri,
-                                  AffiliatedFacetsWithUpdateTime* result) const;
-
-  // Retrieves all stored equivalence classes.
-  void GetAllAffiliations(
+  // such a class is found, in which case it is also stored into |result|
+  // together with branding information, if applicable.
+  bool GetAffiliationsAndBrandingForFacetURI(
+      const FacetURI& facet_uri,
+      AffiliatedFacetsWithUpdateTime* result) const;
+
+  // Retrieves all stored equivalence classes and branding information.
+  void GetAllAffiliationsAndBranding(
       std::vector<AffiliatedFacetsWithUpdateTime>* results) const;
 
-  // Removes the stored equivalence class, if any, containing |facet_uri|.
-  void DeleteAffiliationsForFacetURI(const FacetURI& facet_uri);
+  // Removes the stored equivalence class and branding information, if any,
+  // containing |facet_uri|.
+  void DeleteAffiliationsAndBrandingForFacetURI(const FacetURI& facet_uri);
 
-  // Removes stored equivalence classes that were last updated before the
-  // |cutoff_threshold|.
-  void DeleteAffiliationsOlderThan(const base::Time& cutoff_threshold);
+  // Removes stored equivalence classes and branding information that were last
+  // updated before the |cutoff_threshold|.
+  void DeleteAffiliationsAndBrandingOlderThan(
+      const base::Time& cutoff_threshold);
 
   // Removes all records from all tables of the database.
-  void DeleteAllAffiliations();
+  void DeleteAllAffiliationsAndBranding();
 
-  // Stores the equivalence class defined by |affiliated_facets| to the DB and
-  // returns true unless it has a non-empty subset with a preexisting class, in
-  // which case no changes are made and the function returns false.
+  // Stores the equivalence class and branding information defined by
+  // |affiliated_facets| to the DB and returns true unless it has a non-empty
+  // subset with a preexisting class, in which case no changes are made and the
+  // function returns false.
   bool Store(const AffiliatedFacetsWithUpdateTime& affiliated_facets);
 
-  // Stores the equivalence class defined by |affiliated_facets| to the DB,
-  // database, and removes any other equivalence classes that are in conflict
-  // with |affiliated_facets|, i.e. those that are neither equal nor disjoint to
-  // it. Removed equivalence classes are stored into |removed_affiliations|.
+  // Stores the equivalence class and branding information defined by
+  // |affiliated_facets| to the database, and removes any other equivalence
+  // classes that are in conflict with |affiliated_facets|, i.e. those that are
+  // neither equal nor disjoint to it. Removed equivalence classes are stored
+  // into |removed_affiliations|.
   void StoreAndRemoveConflicting(
       const AffiliatedFacetsWithUpdateTime& affiliated_facets,
       std::vector<AffiliatedFacetsWithUpdateTime>* removed_affiliations);

components/password_manager/core/browser/android_affiliation/affiliation_database_unittest.cc

@@ -144,17 +144,17 @@ TEST_F(AffiliationDatabaseTest, Store) {
   }
 }
 
-TEST_F(AffiliationDatabaseTest, GetAllAffiliations) {
+TEST_F(AffiliationDatabaseTest, GetAllAffiliationsAndBranding) {
   std::vector<AffiliatedFacetsWithUpdateTime> affiliations;
 
   // Empty database should not return any equivalence classes.
-  db().GetAllAffiliations(&affiliations);
+  db().GetAllAffiliationsAndBranding(&affiliations);
   EXPECT_EQ(0u, affiliations.size());
 
   ASSERT_NO_FATAL_FAILURE(StoreInitialTestData());
 
   // The test data should be returned in order.
-  db().GetAllAffiliations(&affiliations);
+  db().GetAllAffiliationsAndBranding(&affiliations);
   ASSERT_EQ(3u, affiliations.size());
   ExpectEquivalenceClassesIncludingBrandingInfoAreEqual(TestEquivalenceClass1(),
                                                         affiliations[0]);
@@ -171,7 +171,8 @@ TEST_F(AffiliationDatabaseTest, GetAffiliationForFacet) {
   // class.
   for (const auto& facet : TestEquivalenceClass1().facets) {
     AffiliatedFacetsWithUpdateTime affiliation;
-    EXPECT_TRUE(db().GetAffiliationsForFacetURI(facet.uri, &affiliation));
+    EXPECT_TRUE(
+        db().GetAffiliationsAndBrandingForFacetURI(facet.uri, &affiliation));
     ExpectEquivalenceClassesIncludingBrandingInfoAreEqual(
         TestEquivalenceClass1(), affiliation);
   }
@@ -180,7 +181,7 @@ TEST_F(AffiliationDatabaseTest, GetAffiliationForFacet) {
   // that class.
   {
     AffiliatedFacetsWithUpdateTime affiliation;
-    EXPECT_TRUE(db().GetAffiliationsForFacetURI(
+    EXPECT_TRUE(db().GetAffiliationsAndBrandingForFacetURI(
         FacetURI::FromCanonicalSpec(kTestAndroidFacetURI), &affiliation));
     ExpectEquivalenceClassesIncludingBrandingInfoAreEqual(
         TestEquivalenceClass3(), affiliation);
@@ -189,7 +190,7 @@ TEST_F(AffiliationDatabaseTest, GetAffiliationForFacet) {
   // Verify that querying a facet not in the database yields no result.
   {
     AffiliatedFacetsWithUpdateTime affiliation;
-    EXPECT_FALSE(db().GetAffiliationsForFacetURI(
+    EXPECT_FALSE(db().GetAffiliationsAndBrandingForFacetURI(
         FacetURI::FromCanonicalSpec(kTestFacetURI6), &affiliation));
     ExpectEquivalenceClassesIncludingBrandingInfoAreEqual(
         AffiliatedFacetsWithUpdateTime(), affiliation);
@@ -210,7 +211,7 @@ TEST_F(AffiliationDatabaseTest, StoreAndRemoveConflicting) {
     EXPECT_EQ(0u, removed.size());
 
     AffiliatedFacetsWithUpdateTime affiliation;
-    EXPECT_TRUE(db().GetAffiliationsForFacetURI(
+    EXPECT_TRUE(db().GetAffiliationsAndBrandingForFacetURI(
         FacetURI::FromCanonicalSpec(kTestFacetURI1), &affiliation));
     ExpectEquivalenceClassesIncludingBrandingInfoAreEqual(updated, affiliation);
   }
@@ -233,7 +234,7 @@ TEST_F(AffiliationDatabaseTest, StoreAndRemoveConflicting) {
         TestEquivalenceClass2(), removed[1]);
 
     std::vector<AffiliatedFacetsWithUpdateTime> affiliations;
-    db().GetAllAffiliations(&affiliations);
+    db().GetAllAffiliationsAndBranding(&affiliations);
     ASSERT_EQ(2u, affiliations.size());
     ExpectEquivalenceClassesIncludingBrandingInfoAreEqual(
         TestEquivalenceClass3(), affiliations[0]);
@@ -242,36 +243,37 @@ TEST_F(AffiliationDatabaseTest, StoreAndRemoveConflicting) {
   }
 }
 
-TEST_F(AffiliationDatabaseTest, DeleteAllAffiliations) {
-  db().DeleteAllAffiliations();
+TEST_F(AffiliationDatabaseTest, DeleteAllAffiliationsAndBranding) {
+  db().DeleteAllAffiliationsAndBranding();
 
   ASSERT_NO_FATAL_FAILURE(StoreInitialTestData());
 
-  db().DeleteAllAffiliations();
+  db().DeleteAllAffiliationsAndBranding();
 
   std::vector<AffiliatedFacetsWithUpdateTime> affiliations;
-  db().GetAllAffiliations(&affiliations);
+  db().GetAllAffiliationsAndBranding(&affiliations);
   ASSERT_EQ(0u, affiliations.size());
 }
 
-TEST_F(AffiliationDatabaseTest, DeleteAffiliationsOlderThan) {
-  db().DeleteAffiliationsOlderThan(base::Time::FromInternalValue(0));
+TEST_F(AffiliationDatabaseTest, DeleteAffiliationsAndBrandingOlderThan) {
+  db().DeleteAffiliationsAndBrandingOlderThan(base::Time::FromInternalValue(0));
 
   ASSERT_NO_FATAL_FAILURE(StoreInitialTestData());
 
-  db().DeleteAffiliationsOlderThan(base::Time::FromInternalValue(kTestTimeUs2));
+  db().DeleteAffiliationsAndBrandingOlderThan(
+      base::Time::FromInternalValue(kTestTimeUs2));
 
   std::vector<AffiliatedFacetsWithUpdateTime> affiliations;
-  db().GetAllAffiliations(&affiliations);
+  db().GetAllAffiliationsAndBranding(&affiliations);
   ASSERT_EQ(2u, affiliations.size());
   ExpectEquivalenceClassesIncludingBrandingInfoAreEqual(TestEquivalenceClass2(),
                                                         affiliations[0]);
   ExpectEquivalenceClassesIncludingBrandingInfoAreEqual(TestEquivalenceClass3(),
                                                         affiliations[1]);
 
-  db().DeleteAffiliationsOlderThan(base::Time::Max());
+  db().DeleteAffiliationsAndBrandingOlderThan(base::Time::Max());
 
-  db().GetAllAffiliations(&affiliations);
+  db().GetAllAffiliationsAndBranding(&affiliations);
   ASSERT_EQ(0u, affiliations.size());
 }
 
@@ -284,7 +286,7 @@ TEST_F(AffiliationDatabaseTest, DBRetainsDataAfterReopening) {
 
   // The test data should be returned in order.
   std::vector<AffiliatedFacetsWithUpdateTime> affiliations;
-  db().GetAllAffiliations(&affiliations);
+  db().GetAllAffiliationsAndBranding(&affiliations);
   ASSERT_EQ(3u, affiliations.size());
   ExpectEquivalenceClassesIncludingBrandingInfoAreEqual(TestEquivalenceClass1(),
                                                         affiliations[0]);
@@ -304,11 +306,11 @@ TEST_F(AffiliationDatabaseTest, CorruptDBIsRazedThenOpened) {
   ASSERT_NO_FATAL_FAILURE(OpenDatabase());
 
   std::vector<AffiliatedFacetsWithUpdateTime> affiliations;
-  db().GetAllAffiliations(&affiliations);
+  db().GetAllAffiliationsAndBranding(&affiliations);
   EXPECT_EQ(0u, affiliations.size());
 
   ASSERT_NO_FATAL_FAILURE(StoreInitialTestData());
-  db().GetAllAffiliations(&affiliations);
+  db().GetAllAffiliationsAndBranding(&affiliations);
   EXPECT_EQ(3u, affiliations.size());
 }
 
@@ -321,7 +323,7 @@ TEST_F(AffiliationDatabaseTest, CorruptDBGetsPoisoned) {
 
   EXPECT_FALSE(db().Store(TestEquivalenceClass2()));
   std::vector<AffiliatedFacetsWithUpdateTime> affiliations;
-  db().GetAllAffiliations(&affiliations);
+  db().GetAllAffiliationsAndBranding(&affiliations);
   EXPECT_EQ(0u, affiliations.size());
 }
 
@@ -354,7 +356,7 @@ TEST_F(AffiliationDatabaseTest, MigrateFromVersion1) {
   // Check that migration was successful and existing data was untouched.
   EXPECT_EQ(2, db().GetDatabaseVersionForTesting());
   std::vector<AffiliatedFacetsWithUpdateTime> affiliations;
-  db().GetAllAffiliations(&affiliations);
+  db().GetAllAffiliationsAndBranding(&affiliations);
   ASSERT_EQ(3u, affiliations.size());
 
   // There was no branding information in version 1, thus we expect it to be
@@ -392,7 +394,7 @@ TEST_F(AffiliationDatabaseTest, InitializeFromVersion2) {
   // Expect the migration to be a no-op that does not modify the existing data.
   OpenDatabase();
   std::vector<AffiliatedFacetsWithUpdateTime> affiliations;
-  db().GetAllAffiliations(&affiliations);
+  db().GetAllAffiliationsAndBranding(&affiliations);
   ASSERT_EQ(3u, affiliations.size());
   ExpectEquivalenceClassesIncludingBrandingInfoAreEqual(TestEquivalenceClass1(),
                                                         affiliations[0]);

components/password_manager/core/browser/android_affiliation/affiliation_service.cc

@@ -4,6 +4,8 @@
 
 #include "components/password_manager/core/browser/android_affiliation/affiliation_service.h"
 
+#include <memory>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
@@ -48,7 +50,7 @@ void AffiliationService::Initialize(
                             base::Unretained(backend_), db_path));
 }
 
-void AffiliationService::GetAffiliations(
+void AffiliationService::GetAffiliationsAndBranding(
     const FacetURI& facet_uri,
     StrategyOnCacheMiss cache_miss_strategy,
     const ResultCallback& result_callback) {
@@ -56,7 +58,7 @@ void AffiliationService::GetAffiliations(
   DCHECK(backend_);
   backend_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&AffiliationBackend::GetAffiliations,
+      base::Bind(&AffiliationBackend::GetAffiliationsAndBranding,
                  base::Unretained(backend_), facet_uri, cache_miss_strategy,
                  result_callback, base::SequencedTaskRunnerHandle::Get()));
 }

components/password_manager/core/browser/android_affiliation/affiliation_service.h

@@ -40,7 +40,8 @@ class AffiliationBackend;
 //       network request to the Affiliation API containing the URI of facet X
 //       is acceptable from the privacy and/or performance perspective.
 //
-//       This mode of operation is achieved by invoking GetAffiliations() with
+//       This mode of operation is achieved by invoking
+//       GetAffiliationsAndBranding() with
 //       StrategyOnCacheMiss::FETCH_OVER_NETWORK.
 //
 //   2.) Proactive fetching: For the compound query that is concerned with
@@ -69,7 +70,7 @@ class AffiliationBackend;
 //         ~ExampleAffiliatedCredentialFiller() { cancel_handle_.Run(); }
 //
 //         void ShouldFillInto(const FacetURI& wi, FillDelegate* delegate) {
-//           service_->GetAffiliations(wi, StrategyOnCacheMiss::FAIL,
+//           service_->GetAffiliationsAndBranding(wi, StrategyOnCacheMiss::FAIL,
 //               base::Bind(
 //                   &ExampleAffiliatedCredentialFiller::OnAffiliationResult,
 //                   AsWeakPtr(),
@@ -107,18 +108,19 @@ class AffiliationService : public KeyedService {
   void Initialize(net::URLRequestContextGetter* request_context_getter,
                   const base::FilePath& db_path);
 
-  // Looks up facets affiliated with the facet identified by |facet_uri|, and
-  // invokes |result_callback| with the results. It is guaranteed that the
-  // results will contain one facet with URI equal to |facet_uri| when
-  // |result_callback| is invoked with success set to true.
+  // Looks up facets affiliated with the facet identified by |facet_uri| and
+  // branding information, and invokes |result_callback| with the results. It is
+  // guaranteed that the results will contain one facet with URI equal to
+  // |facet_uri| when |result_callback| is invoked with success set to true.
   //
-  // If the local cache contains fresh affiliation information for |facet_uri|,
-  // the request will be served from cache. Otherwise, |cache_miss_policy|
-  // controls whether to issue an on-demand network request, or to fail the
-  // request without fetching.
-  virtual void GetAffiliations(const FacetURI& facet_uri,
-                               StrategyOnCacheMiss cache_miss_strategy,
-                               const ResultCallback& result_callback);
+  // If the local cache contains fresh affiliation and branding information for
+  // |facet_uri|, the request will be served from cache. Otherwise,
+  // |cache_miss_policy| controls whether to issue an on-demand network request,
+  // or to fail the request without fetching.
+  virtual void GetAffiliationsAndBranding(
+      const FacetURI& facet_uri,
+      StrategyOnCacheMiss cache_miss_strategy,
+      const ResultCallback& result_callback);
 
   // Prefetches affiliation information for the facet identified by |facet_uri|,
   // and keeps the information fresh by periodic re-fetches (as needed) until

components/password_manager/core/browser/android_affiliation/affiliation_service_unittest.cc

@@ -101,12 +101,13 @@ class AffiliationServiceTest : public testing::Test {
   DISALLOW_COPY_AND_ASSIGN(AffiliationServiceTest);
 };
 
-TEST_F(AffiliationServiceTest, GetAffiliations) {
+TEST_F(AffiliationServiceTest, GetAffiliationsAndBranding) {
   // The first request allows on-demand fetching, and should trigger a fetch.
   // Then, it should succeed after the fetch is complete.
-  service()->GetAffiliations(FacetURI::FromCanonicalSpec(kTestFacetURIAlpha1),
-                             StrategyOnCacheMiss::FETCH_OVER_NETWORK,
-                             mock_consumer()->GetResultCallback());
+  service()->GetAffiliationsAndBranding(
+      FacetURI::FromCanonicalSpec(kTestFacetURIAlpha1),
+      StrategyOnCacheMiss::FETCH_OVER_NETWORK,
+      mock_consumer()->GetResultCallback());
 
   background_task_runner()->RunUntilIdle();
   ASSERT_TRUE(fake_affiliation_api()->HasPendingRequest());
@@ -123,9 +124,9 @@ TEST_F(AffiliationServiceTest, GetAffiliations) {
   testing::Mock::VerifyAndClearExpectations(mock_consumer());
 
   // The second request should be (and can be) served from cache.
-  service()->GetAffiliations(FacetURI::FromCanonicalSpec(kTestFacetURIAlpha1),
-                             StrategyOnCacheMiss::FAIL,
-                             mock_consumer()->GetResultCallback());
+  service()->GetAffiliationsAndBranding(
+      FacetURI::FromCanonicalSpec(kTestFacetURIAlpha1),
+      StrategyOnCacheMiss::FAIL, mock_consumer()->GetResultCallback());
 
   background_task_runner()->RunUntilIdle();
   ASSERT_FALSE(fake_affiliation_api()->HasPendingRequest());
@@ -136,9 +137,9 @@ TEST_F(AffiliationServiceTest, GetAffiliations) {
 
   // The third request is also restricted to the cache, but cannot be served
   // from cache, thus it should fail.
-  service()->GetAffiliations(FacetURI::FromCanonicalSpec(kTestFacetURIBeta1),
-                             StrategyOnCacheMiss::FAIL,
-                             mock_consumer()->GetResultCallback());
+  service()->GetAffiliationsAndBranding(
+      FacetURI::FromCanonicalSpec(kTestFacetURIBeta1),
+      StrategyOnCacheMiss::FAIL, mock_consumer()->GetResultCallback());
 
   background_task_runner()->RunUntilIdle();
   ASSERT_FALSE(fake_affiliation_api()->HasPendingRequest());
@@ -149,9 +150,10 @@ TEST_F(AffiliationServiceTest, GetAffiliations) {
 }
 
 TEST_F(AffiliationServiceTest, ShutdownWhileTasksArePosted) {
-  service()->GetAffiliations(FacetURI::FromCanonicalSpec(kTestFacetURIAlpha1),
-                             StrategyOnCacheMiss::FETCH_OVER_NETWORK,
-                             mock_consumer()->GetResultCallback());
+  service()->GetAffiliationsAndBranding(
+      FacetURI::FromCanonicalSpec(kTestFacetURIAlpha1),
+      StrategyOnCacheMiss::FETCH_OVER_NETWORK,
+      mock_consumer()->GetResultCallback());
   EXPECT_TRUE(background_task_runner()->HasPendingTask());
 
   DestroyService();

components/password_manager/core/browser/android_affiliation/facet_manager.cc

@@ -7,10 +7,10 @@
 //
 // On-demand fetching strategy
 //
-// A GetAffiliations() request concerning facet X will be served from the cache
-// as long as the cache contains fresh affiliation information for facet X, that
-// is, if there is an equivalence class in the cache that contains X and has
-// been fetched less than |kCacheHardExpiryInHours| hours ago.
+// A GetAffiliationsAndBranding() request concerning facet X will be served from
+// the cache as long as the cache contains fresh affiliation information for
+// facet X, that is, if there is an equivalence class in the cache that contains
+// X and has been fetched less than |kCacheHardExpiryInHours| hours ago.
 //
 // Otherwise, a network request is issued against the Affiliation API as soon as
 // possible, that is, immediately if there is no fetch in flight, or right after
@@ -87,7 +87,7 @@ static_assert(
         FacetManager::kCacheHardExpiryInHours,
     "Soft expiry period must be longer than half of the hard expiry period.");
 
-// Encapsulates the details of a pending GetAffiliations() request.
+// Encapsulates the details of a pending GetAffiliationsAndBranding() request.
 struct FacetManager::RequestInfo {
   AffiliationService::ResultCallback callback;
   scoped_refptr<base::TaskRunner> callback_task_runner;
@@ -98,7 +98,8 @@ FacetManager::FacetManager(const FacetURI& facet_uri,
                            base::Clock* clock)
     : facet_uri_(facet_uri), backend_(backend), clock_(clock) {
   AffiliatedFacetsWithUpdateTime affiliations;
-  if (backend_->ReadAffiliationsFromDatabase(facet_uri_, &affiliations))
+  if (backend_->ReadAffiliationsAndBrandingFromDatabase(facet_uri_,
+                                                        &affiliations))
     last_update_time_ = affiliations.last_update_time;
 }
 
@@ -109,7 +110,7 @@ FacetManager::~FacetManager() {
     ServeRequestWithFailure(request_info);
 }
 
-void FacetManager::GetAffiliations(
+void FacetManager::GetAffiliationsAndBranding(
     StrategyOnCacheMiss cache_miss_strategy,
     const AffiliationService::ResultCallback& callback,
     const scoped_refptr<base::TaskRunner>& callback_task_runner) {
@@ -118,7 +119,8 @@ void FacetManager::GetAffiliations(
   request_info.callback_task_runner = callback_task_runner;
   if (IsCachedDataFresh()) {
     AffiliatedFacetsWithUpdateTime affiliation;
-    if (!backend_->ReadAffiliationsFromDatabase(facet_uri_, &affiliation)) {
+    if (!backend_->ReadAffiliationsAndBrandingFromDatabase(facet_uri_,
+                                                           &affiliation)) {
       ServeRequestWithFailure(request_info);
       return;
     }

components/password_manager/core/browser/android_affiliation/facet_manager.h

@@ -39,7 +39,7 @@ class FacetManager {
 
   // Facet-specific implementations for methods in AffiliationService of the
   // same name. See documentation in affiliation_service.h for details:
-  void GetAffiliations(
+  void GetAffiliationsAndBranding(
       StrategyOnCacheMiss cache_miss_strategy,
       const AffiliationService::ResultCallback& callback,
       const scoped_refptr<base::TaskRunner>& callback_task_runner);
@@ -116,8 +116,8 @@ class FacetManager {
   // in the database should match this value; it is stored to reduce disk I/O.
   base::Time last_update_time_;
 
-  // Contains information about the GetAffiliations() requests that are waiting
-  // for the result of looking up this facet.
+  // Contains information about the GetAffiliationsAndBranding() requests that
+  // are waiting for the result of looking up this facet.
   std::vector<RequestInfo> pending_requests_;
 
   // Keeps track of |keep_fresh_until| thresholds corresponding to Prefetch()

components/password_manager/core/browser/android_affiliation/facet_manager_host.h

@@ -18,7 +18,7 @@ class FacetManagerHost {
 
   // Reads the equivalence class containing |facet_uri| from the database and
   // returns true if found; returns false otherwise.
-  virtual bool ReadAffiliationsFromDatabase(
+  virtual bool ReadAffiliationsAndBrandingFromDatabase(
       const FacetURI& facet_uri,
       AffiliatedFacetsWithUpdateTime* affiliations) = 0;
 

components/password_manager/core/browser/android_affiliation/facet_manager_unittest.cc

@@ -98,7 +98,8 @@ class MockFacetManagerHost : public FacetManagerHost {
   const FacetURI& expected_facet_uri() const { return expected_facet_uri_; }
 
   // Sets up fake |database_content| as the canned response to be returned to
-  // the FacetManager every time it calls ReadAffiliationsFromDatabase().
+  // the FacetManager every time it calls
+  // ReadAffiliationsAndBrandingFromDatabase().
   void set_fake_database_content(
       const AffiliatedFacetsWithUpdateTime& database_content) {
     fake_database_content_ = database_content;
@@ -117,7 +118,7 @@ class MockFacetManagerHost : public FacetManagerHost {
 
  private:
   // FacetManagerHost:
-  bool ReadAffiliationsFromDatabase(
+  bool ReadAffiliationsAndBrandingFromDatabase(
       const FacetURI& facet_uri,
       AffiliatedFacetsWithUpdateTime* affiliations) override {
     EXPECT_EQ(expected_facet_uri_, facet_uri);
@@ -262,10 +263,10 @@ class FacetManagerTest : public testing::Test {
   // Returns the elapsed time since CreateFacetManager() was last called.
   base::TimeDelta DeltaNow() { return Now() - facet_manager_creation_; }
 
-  void GetAffiliations(StrategyOnCacheMiss cache_miss_strategy) {
-    facet_manager()->GetAffiliations(cache_miss_strategy,
-                                     mock_consumer()->GetResultCallback(),
-                                     consumer_task_runner());
+  void GetAffiliationsAndBranding(StrategyOnCacheMiss cache_miss_strategy) {
+    facet_manager()->GetAffiliationsAndBranding(
+        cache_miss_strategy, mock_consumer()->GetResultCallback(),
+        consumer_task_runner());
   }
 
   void Prefetch(base::Time until) { facet_manager()->Prefetch(until); }
@@ -376,7 +377,7 @@ class FacetManagerTest : public testing::Test {
 
   void ExpectRequestsServedFromCache() {
     EXPECT_TRUE(facet_manager()->IsCachedDataFresh());
-    GetAffiliations(StrategyOnCacheMiss::FAIL);
+    GetAffiliationsAndBranding(StrategyOnCacheMiss::FAIL);
     ExpectConsumerSuccessCallback();
   }
 
@@ -433,9 +434,10 @@ TEST_F(FacetManagerTest, NewInstanceCanBeDiscarded) {
   EXPECT_FALSE(main_task_runner()->HasPendingTask());
 }
 
-// Both cached-only and on-demand GetAffiliations() requests should be served
-// from cache if it contains fresh data. Nothing should happen on cache expiry.
-TEST_F(FacetManagerTest, GetAffiliationsServedFromCache) {
+// Both cached-only and on-demand GetAffiliationsAndBranding() requests should
+// be served from cache if it contains fresh data. Nothing should happen on
+// cache expiry.
+TEST_F(FacetManagerTest, GetAffiliationsAndBrandingServedFromCache) {
   fake_facet_manager_host()->set_fake_database_content(
       GetTestEquivalenceClassWithUpdateTime(Now()));
   AdvanceTime(GetCacheHardExpiryPeriod() - Epsilon());
@@ -443,12 +445,12 @@ TEST_F(FacetManagerTest, GetAffiliationsServedFromCache) {
   CreateFacetManager();
   EXPECT_TRUE(facet_manager()->IsCachedDataFresh());
 
-  GetAffiliations(StrategyOnCacheMiss::FAIL);
+  GetAffiliationsAndBranding(StrategyOnCacheMiss::FAIL);
   ExpectConsumerSuccessCallback();
   EXPECT_TRUE(facet_manager()->CanBeDiscarded());
   ASSERT_NO_FATAL_FAILURE(ExpectNoFetchNeeded());
 
-  GetAffiliations(StrategyOnCacheMiss::FETCH_OVER_NETWORK);
+  GetAffiliationsAndBranding(StrategyOnCacheMiss::FETCH_OVER_NETWORK);
   ExpectConsumerSuccessCallback();
   EXPECT_TRUE(facet_manager()->CanBeDiscarded());
   ASSERT_NO_FATAL_FAILURE(ExpectNoFetchNeeded());
@@ -461,10 +463,11 @@ TEST_F(FacetManagerTest, GetAffiliationsServedFromCache) {
   EXPECT_FALSE(main_task_runner()->HasPendingTask());
 }
 
-// On-demand GetAffiliations() requests should trigger a fetch if the cache has
-// already stale data, or no corresponding data whatsoever. Nothing should
-// happen once the newly fetched data expires.
-TEST_F(FacetManagerTest, OnDemandGetAffiliationsRequestTriggersFetch) {
+// On-demand GetAffiliationsAndBranding() requests should trigger a fetch if the
+// cache has already stale data, or no corresponding data whatsoever. Nothing
+// should happen once the newly fetched data expires.
+TEST_F(FacetManagerTest,
+       OnDemandGetAffiliationsAndBrandingRequestTriggersFetch) {
   for (const bool cache_initially_has_stale_data : kFalseTrue) {
     SCOPED_TRACE(cache_initially_has_stale_data);
 
@@ -479,7 +482,7 @@ TEST_F(FacetManagerTest, OnDemandGetAffiliationsRequestTriggersFetch) {
     CreateFacetManager();
     EXPECT_FALSE(facet_manager()->IsCachedDataFresh());
 
-    GetAffiliations(StrategyOnCacheMiss::FETCH_OVER_NETWORK);
+    GetAffiliationsAndBranding(StrategyOnCacheMiss::FETCH_OVER_NETWORK);
     ASSERT_NO_FATAL_FAILURE(ExpectFetchNeeded());
     EXPECT_FALSE(facet_manager()->CanBeDiscarded());
     ASSERT_NO_FATAL_FAILURE(CompleteFetch());
@@ -488,12 +491,12 @@ TEST_F(FacetManagerTest, OnDemandGetAffiliationsRequestTriggersFetch) {
     AdvanceTime(GetCacheHardExpiryPeriod() - Epsilon());
     EXPECT_TRUE(facet_manager()->IsCachedDataFresh());
 
-    GetAffiliations(StrategyOnCacheMiss::FAIL);
+    GetAffiliationsAndBranding(StrategyOnCacheMiss::FAIL);
     ExpectConsumerSuccessCallback();
     EXPECT_TRUE(facet_manager()->CanBeDiscarded());
     ASSERT_NO_FATAL_FAILURE(ExpectNoFetchNeeded());
 
-    GetAffiliations(StrategyOnCacheMiss::FETCH_OVER_NETWORK);
+    GetAffiliationsAndBranding(StrategyOnCacheMiss::FETCH_OVER_NETWORK);
     ExpectConsumerSuccessCallback();
     EXPECT_TRUE(facet_manager()->CanBeDiscarded());
     ASSERT_NO_FATAL_FAILURE(ExpectNoFetchNeeded());
@@ -507,22 +510,24 @@ TEST_F(FacetManagerTest, OnDemandGetAffiliationsRequestTriggersFetch) {
   }
 }
 
-TEST_F(FacetManagerTest, CachedOnlyGetAffiliationsFailsDueToStaleCache) {
+TEST_F(FacetManagerTest,
+       CachedOnlyGetAffiliationsAndBrandingFailsDueToStaleCache) {
   CreateFacetManager();
   EXPECT_FALSE(facet_manager()->IsCachedDataFresh());
 
-  GetAffiliations(StrategyOnCacheMiss::FAIL);
+  GetAffiliationsAndBranding(StrategyOnCacheMiss::FAIL);
   ExpectConsumerFailureCallback();
   ASSERT_NO_FATAL_FAILURE(ExpectNoFetchNeeded());
   EXPECT_TRUE(facet_manager()->CanBeDiscarded());
   EXPECT_FALSE(main_task_runner()->HasPendingTask());
 }
 
-TEST_F(FacetManagerTest, GetAffiliationsFailureCallbackInvokedOnDestruction) {
+TEST_F(FacetManagerTest,
+       GetAffiliationsAndBrandingFailureCallbackInvokedOnDestruction) {
   CreateFacetManager();
   EXPECT_FALSE(facet_manager()->IsCachedDataFresh());
 
-  GetAffiliations(StrategyOnCacheMiss::FETCH_OVER_NETWORK);
+  GetAffiliationsAndBranding(StrategyOnCacheMiss::FETCH_OVER_NETWORK);
   ASSERT_NO_FATAL_FAILURE(ExpectFetchNeeded());
   EXPECT_FALSE(facet_manager()->CanBeDiscarded());
 
@@ -1452,7 +1457,7 @@ TEST_F(FacetManagerTest, StaleCachedDataBeCanDiscardedWhilePendingFetch) {
   CreateFacetManager();
   ASSERT_FALSE(facet_manager()->IsCachedDataFresh());
 
-  GetAffiliations(StrategyOnCacheMiss::FETCH_OVER_NETWORK);
+  GetAffiliationsAndBranding(StrategyOnCacheMiss::FETCH_OVER_NETWORK);
   ASSERT_NO_FATAL_FAILURE(ExpectFetchNeeded());
   EXPECT_FALSE(facet_manager()->CanBeDiscarded());
   EXPECT_TRUE(facet_manager()->CanCachedDataBeDiscarded());
@@ -1464,7 +1469,7 @@ TEST_F(FacetManagerTest, CachedDataBeCanDiscardedAfterOnDemandGetAffiliatons) {
   CreateFacetManager();
   ASSERT_FALSE(facet_manager()->IsCachedDataFresh());
 
-  GetAffiliations(StrategyOnCacheMiss::FETCH_OVER_NETWORK);
+  GetAffiliationsAndBranding(StrategyOnCacheMiss::FETCH_OVER_NETWORK);
   ASSERT_NO_FATAL_FAILURE(ExpectFetchNeeded());
   ASSERT_NO_FATAL_FAILURE(CompleteFetch());
   ExpectConsumerSuccessCallback();

components/password_manager/core/browser/android_affiliation/mock_affiliation_consumer.h

@@ -12,7 +12,7 @@
 
 namespace password_manager {
 
-// A mock consumer of AffiliationService::GetAffiliations().
+// A mock consumer of AffiliationService::GetAffiliationsAndBranding().
 class MockAffiliationConsumer {
  public:
   MockAffiliationConsumer();