chrome/browser/lacros/account_manager/account_profile_mapper.cc

// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chrome/browser/lacros/account_manager/account_profile_mapper.h"

#include <vector>

#include "base/check.h"
#include "base/containers/contains.h"
#include "base/containers/flat_map.h"
#include "base/containers/flat_set.h"
#include "base/containers/unique_ptr_adapters.h"
#include "base/debug/dump_without_crashing.h"
#include "base/functional/bind.h"
#include "base/functional/callback.h"
#include "base/functional/callback_helpers.h"
#include "base/logging.h"
#include "base/notreached.h"
#include "base/ranges/algorithm.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/lacros/account_manager/add_account_helper.h"
#include "chrome/browser/profiles/delete_profile_helper.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/profiles/profile_attributes_entry.h"
#include "chrome/browser/profiles/profile_attributes_storage.h"
#include "chrome/browser/profiles/profile_manager.h"
#include "chrome/browser/profiles/profile_metrics.h"
#include "components/account_manager_core/account.h"
#include "components/account_manager_core/chromeos/account_manager_facade_factory.h"
#include "components/signin/public/identity_manager/account_info.h"
#include "google_apis/gaia/oauth2_access_token_fetcher.h"
#include "google_apis/gaia/oauth2_access_token_fetcher_immediate_error.h"

AccountProfileMapper::AccountProfileMapper(
    account_manager::AccountManagerFacade* facade,
    ProfileAttributesStorage* storage,
    PrefService* local_state)
    : account_manager_facade_(facade),
      profile_attributes_storage_(storage),
      account_cache_(local_state) {
  DCHECK(profile_attributes_storage_);

  // This must be done before OnGetAccountsCompleted() is called, to avoid
  // unnecessary profile deletion.
  MigrateOldProfiles();

  account_manager_facade_observation_.Observe(account_manager_facade_.get());
  profile_attributes_storage_observation_.Observe(
      profile_attributes_storage_.get());
  account_manager_facade_->GetAccounts(
      base::BindOnce(&AccountProfileMapper::OnGetAccountsCompleted,
                     weak_factory_.GetWeakPtr()));
}

AccountProfileMapper::~AccountProfileMapper() = default;

void AccountProfileMapper::AddObserver(Observer* observer) {
  observers_.AddObserver(observer);
}

void AccountProfileMapper::RemoveObserver(Observer* observer) {
  observers_.RemoveObserver(observer);
}

void AccountProfileMapper::GetAccounts(const base::FilePath& profile_path,
                                       ListAccountsCallback callback) {
  if (!initialized_) {
    initialization_callbacks_.push_back(base::BindOnce(
        &AccountProfileMapper::GetAccounts, weak_factory_.GetWeakPtr(),
        profile_path, std::move(callback)));
    return;
  }
  std::vector<account_manager::Account> accounts;
  const ProfileAttributesEntry* entry =
      profile_attributes_storage_->GetProfileAttributesWithPath(profile_path);
  // `entry` may be null during profile deletion, as it is destroyed before the
  // profile.
  if (entry) {
    for (const std::string& gaia_id : entry->GetGaiaIds()) {
      const account_manager::Account* account =
          account_cache_.FindAccountByGaiaId(gaia_id);
      if (!account) {
        NOTREACHED_IN_MIGRATION() << "Account " << gaia_id << " missing.";
        continue;
      }
      accounts.push_back(*account);
    }
  }
  std::move(callback).Run(accounts);
}

void AccountProfileMapper::GetPersistentErrorForAccount(
    const base::FilePath& profile_path,
    const account_manager::AccountKey& account,
    base::OnceCallback<void(const GoogleServiceAuthError&)> callback) {
  if (!initialized_) {
    initialization_callbacks_.push_back(
        base::BindOnce(&AccountProfileMapper::GetPersistentErrorForAccount,
                       weak_factory_.GetWeakPtr(), profile_path, account,
                       std::move(callback)));
    return;
  }
  if (!ProfileContainsAccount(profile_path, account)) {
    std::move(callback).Run(
        GoogleServiceAuthError(GoogleServiceAuthError::USER_NOT_SIGNED_UP));
    return;
  }
  account_manager_facade_->GetPersistentErrorForAccount(account,
                                                        std::move(callback));
}

std::unique_ptr<OAuth2AccessTokenFetcher>
AccountProfileMapper::CreateAccessTokenFetcher(
    const base::FilePath& profile_path,
    const account_manager::AccountKey& account,
    OAuth2AccessTokenConsumer* consumer) {
  // TODO(crbug.com/40188699): Create a fetcher that can wait on
  // initialization of the class.
  if (!ProfileContainsAccount(profile_path, account)) {
    return std::make_unique<OAuth2AccessTokenFetcherImmediateError>(
        consumer,
        GoogleServiceAuthError(GoogleServiceAuthError::USER_NOT_SIGNED_UP));
  }

  return account_manager_facade_->CreateAccessTokenFetcher(account, consumer);
}

void AccountProfileMapper::ReportAuthError(
    const base::FilePath& profile_path,
    const account_manager::AccountKey& account,
    const GoogleServiceAuthError& error) {
  if (!initialized_) {
    initialization_callbacks_.push_back(base::BindOnce(
        &AccountProfileMapper::ReportAuthError, weak_factory_.GetWeakPtr(),
        profile_path, account, error));
    return;
  }

  if (!ProfileContainsAccount(profile_path, account))
    return;

  account_manager_facade_->ReportAuthError(account, error);
}

void AccountProfileMapper::GetAccountsMap(MapAccountsCallback callback) {
  if (!initialized_) {
    initialization_callbacks_.push_back(
        base::BindOnce(&AccountProfileMapper::GetAccountsMap,
                       weak_factory_.GetWeakPtr(), std::move(callback)));
    return;
  }

  std::map<base::FilePath, std::vector<account_manager::Account>> accounts_map;
  AccountCache::AccountByGaiaIdMap unassigned_accounts =
      account_cache_.GetAccountsCopy();
  for (ProfileAttributesEntry* entry :
       profile_attributes_storage_->GetAllProfilesAttributes()) {
    const base::FilePath path = entry->GetPath();
    for (const std::string& gaia_id : entry->GetGaiaIds()) {
      const account_manager::Account* account =
          account_cache_.FindAccountByGaiaId(gaia_id);
      if (!account) {
        NOTREACHED_IN_MIGRATION() << "Account " << gaia_id << " missing.";
        continue;
      }
      accounts_map[path].push_back(*account);
      unassigned_accounts.erase(gaia_id);
    }
  }
  for (const auto& [gaia_id, account] : unassigned_accounts)
    accounts_map[base::FilePath()].push_back(account);
  std::move(callback).Run(accounts_map);
}

void AccountProfileMapper::ShowAddAccountDialog(
    const base::FilePath& profile_path,
    account_manager::AccountManagerFacade::AccountAdditionSource source,
    AddAccountCallback callback) {
  DCHECK(!profile_path.empty())
      << "For a new profile use ShowAddAccountDialogAndCreateNewProfile()";
  AddAccountInternal(profile_path, source, std::move(callback));
}

void AccountProfileMapper::AddAccount(
    const base::FilePath& profile_path,
    const account_manager::AccountKey& account,
    AddAccountCallback callback) {
  DCHECK(!profile_path.empty())
      << "For a new profile use CreateNewProfileWithAccount()";
  AddAccountInternal(profile_path, account, std::move(callback));
}

void AccountProfileMapper::ShowAddAccountDialogAndCreateNewProfile(
    account_manager::AccountManagerFacade::AccountAdditionSource source,
    AddAccountCallback callback) {
  AddAccountInternal(base::FilePath(), source, std::move(callback));
}

void AccountProfileMapper::CreateNewProfileWithAccount(
    const account_manager::AccountKey& account,
    AddAccountCallback callback) {
  AddAccountInternal(base::FilePath(), account, std::move(callback));
}

void AccountProfileMapper::RemoveAllAccounts(
    const base::FilePath& profile_path) {
  if (!initialized_) {
    initialization_callbacks_.push_back(
        base::BindOnce(&AccountProfileMapper::RemoveAllAccounts,
                       weak_factory_.GetWeakPtr(), profile_path));
    return;
  }

  ProfileAttributesEntry* entry =
      profile_attributes_storage_->GetProfileAttributesWithPath(profile_path);

  if (!entry) {
    DLOG(ERROR) << "Profile with profile path: " << profile_path
                << " does not exist";
    return;
  }

  base::flat_set<std::string> gaia_ids = entry->GetGaiaIds();
  if (!gaia_ids.empty())
    RemoveAccountsInternal(profile_path, gaia_ids);
}

void AccountProfileMapper::RemoveAccount(
    const base::FilePath& profile_path,
    const account_manager::AccountKey& account_key) {
  if (!initialized_) {
    initialization_callbacks_.push_back(
        base::BindOnce(&AccountProfileMapper::RemoveAccount,
                       weak_factory_.GetWeakPtr(), profile_path, account_key));
    return;
  }

  if (account_key.account_type() != account_manager::AccountType::kGaia)
    return;

  RemoveAccountsInternal(profile_path, {account_key.id()});
}

void AccountProfileMapper::OnAccountUpserted(
    const account_manager::Account& account) {
  if (account.key.account_type() != account_manager::AccountType::kGaia)
    return;

  if (!initialized_) {
    initialization_callbacks_.push_back(
        base::BindOnce(&AccountProfileMapper::OnAccountUpserted,
                       weak_factory_.GetWeakPtr(), account));
    return;
  }

  if (account_cache_.FindAccountByGaiaId(account.key.id())) {
    // The account is already known. This is an account update. Propagate the
    // update to all profiles that have this account.
    std::vector<ProfileAttributesEntry*> entries =
        profile_attributes_storage_->GetAllProfilesAttributes();
    std::vector<base::FilePath> profiles_with_updated_account;
    for (const ProfileAttributesEntry* entry : entries) {
      if (entry->GetGaiaIds().contains(account.key.id()))
        profiles_with_updated_account.push_back(entry->GetPath());
    }

    // Send a notification with empty path if `account` is unassigned.
    if (profiles_with_updated_account.empty())
      profiles_with_updated_account.push_back(base::FilePath());

    for (const base::FilePath& profile_path : profiles_with_updated_account) {
      for (auto& obs : observers_)
        obs.OnAccountUpserted(profile_path, account);
    }

    // Do not return early to update the list of accounts below.
    // `account_cache_` might be stale here. There is a small chance that
    // `account` has been already removed and re-added and that we took re-add
    // operation for an update.
  }

  account_manager_facade_->GetAccounts(
      base::BindOnce(&AccountProfileMapper::OnGetAccountsCompleted,
                     weak_factory_.GetWeakPtr()));
}

void AccountProfileMapper::OnAccountRemoved(
    const account_manager::Account& account) {
  if (account.key.account_type() != account_manager::AccountType::kGaia)
    return;

  account_manager_facade_->GetAccounts(
      base::BindOnce(&AccountProfileMapper::OnGetAccountsCompleted,
                     weak_factory_.GetWeakPtr()));
}

void AccountProfileMapper::OnAuthErrorChanged(
    const account_manager::AccountKey& account,
    const GoogleServiceAuthError& error) {
  if (!initialized_) {
    initialization_callbacks_.push_back(
        base::BindOnce(&AccountProfileMapper::OnAuthErrorChanged,
                       weak_factory_.GetWeakPtr(), account, error));
    return;
  }

  DCHECK_EQ(account.account_type(), account_manager::AccountType::kGaia);
  if (!account_cache_.FindAccountByGaiaId(account.id())) {
    LOG(ERROR) << "Ignoring account error update for unknown account";
    return;
  }

  std::vector<ProfileAttributesEntry*> entries =
      profile_attributes_storage_->GetAllProfilesAttributes();
  for (const ProfileAttributesEntry* entry : entries) {
    if (!entry->GetGaiaIds().contains(account.id())) {
      continue;
    }

    for (auto& observer : observers_) {
      observer.OnAuthErrorChanged(entry->GetPath(), account, error);
    }
  }
}

void AccountProfileMapper::OnProfileWillBeRemoved(
    const base::FilePath& profile_path) {
  ProfileAttributesEntry* entry_to_be_removed =
      profile_attributes_storage_->GetProfileAttributesWithPath(profile_path);
  DCHECK(entry_to_be_removed);

  // Compute a set of accounts that are assigned to at least one profile.
  base::flat_set<std::string> assigned_account_ids;
  for (ProfileAttributesEntry* entry :
       profile_attributes_storage_->GetAllProfilesAttributes()) {
    if (entry == entry_to_be_removed)
      continue;
    base::flat_set<std::string> profile_account_ids = entry->GetGaiaIds();
    assigned_account_ids.insert(profile_account_ids.begin(),
                                profile_account_ids.end());
  }

  // Compute a list of accounts that will become unassigned after a profile at
  // `profile_path` is removed.
  base::flat_set<std::string> freed_account_ids =
      entry_to_be_removed->GetGaiaIds();
  std::vector<std::string> unassigned_account_ids;
  base::ranges::set_difference(freed_account_ids, assigned_account_ids,
                               std::back_inserter(unassigned_account_ids));

  // Notify observers about accounts that became unassigned.
  for (const std::string& unassigned_account_id : unassigned_account_ids) {
    const account_manager::Account* account =
        account_cache_.FindAccountByGaiaId(unassigned_account_id);
    // `account_cache_` might be outdated.
    if (!account)
      continue;

    for (auto& obs : observers_)
      obs.OnAccountRemoved(profile_path, *account);
  }
}

void AccountProfileMapper::UpsertAccountForTesting(
    const base::FilePath& profile_path,
    const account_manager::Account& account,
    const std::string& token_value) {
  if (!initialized_) {
    initialization_callbacks_.push_back(base::BindOnce(
        &AccountProfileMapper::UpsertAccountForTesting,
        weak_factory_.GetWeakPtr(), profile_path, account, token_value));
    return;
  }

  add_account_helpers_.push_back(std::make_unique<AddAccountHelper>(
      base::BindRepeating(
          &AccountProfileMapper::IsAccountInCache,
          // `this` owns the helper, so base::Unretained() is fine.
          base::Unretained(this)),
      account_manager_facade_, profile_attributes_storage_));
  AddAccountHelper* helper = add_account_helpers_.back().get();

  helper->UpsertAccountForTesting(  // IN-TEST
      profile_path, account, token_value,
      base::BindOnce(&AccountProfileMapper::OnAddAccountCompleted,
                     weak_factory_.GetWeakPtr(), helper, base::DoNothing()));
}

void AccountProfileMapper::RemoveAccountForTesting(
    const base::FilePath& profile_path,
    const account_manager::AccountKey& account_key) {
  if (!initialized_) {
    initialization_callbacks_.push_back(
        base::BindOnce(&AccountProfileMapper::RemoveAccountForTesting,
                       weak_factory_.GetWeakPtr(), profile_path, account_key));
    return;
  }
  account_manager_facade_->RemoveAccountForTesting(account_key);  // IN-TEST
}

bool AccountProfileMapper::IsAccountInCache(
    const account_manager::Account& account) {
  return account.key.account_type() == account_manager::AccountType::kGaia &&
         account_cache_.FindAccountByGaiaId(account.key.id());
}

void AccountProfileMapper::AddAccountInternal(
    const base::FilePath& profile_path,
    const absl::variant<
        account_manager::AccountManagerFacade::AccountAdditionSource,
        account_manager::AccountKey>& source_or_accountkey,
    AddAccountCallback callback) {
  if (!initialized_) {
    initialization_callbacks_.push_back(base::BindOnce(
        &AccountProfileMapper::AddAccountInternal, weak_factory_.GetWeakPtr(),
        profile_path, source_or_accountkey, std::move(callback)));
    return;
  }

  absl::variant<account_manager::AccountManagerFacade::AccountAdditionSource,
                account_manager::Account>
      source_or_account;
  // If an account is provided, check that it exists in the facade.
  if (const account_manager::AccountKey* account_key =
          absl::get_if<account_manager::AccountKey>(&source_or_accountkey)) {
    if (account_key->account_type() != account_manager::AccountType::kGaia) {
      if (callback)
        std::move(callback).Run(std::nullopt);
      return;
    }
    const account_manager::Account* account =
        account_cache_.FindAccountByGaiaId(account_key->id());
    if (!account) {
      if (callback)
        std::move(callback).Run(std::nullopt);
      return;
    } else {
      source_or_account = *account;
    }
  } else {
    source_or_account =
        absl::get<account_manager::AccountManagerFacade::AccountAdditionSource>(
            source_or_accountkey);
  }

  add_account_helpers_.push_back(std::make_unique<AddAccountHelper>(
      base::BindRepeating(
          &AccountProfileMapper::IsAccountInCache,
          // `this` owns the helper, so base::Unretained() is fine.
          base::Unretained(this)),
      account_manager_facade_, profile_attributes_storage_));
  AddAccountHelper* helper = add_account_helpers_.back().get();
  helper->Start(
      profile_path, source_or_account,
      base::BindOnce(&AccountProfileMapper::OnAddAccountCompleted,
                     weak_factory_.GetWeakPtr(), helper, std::move(callback)));
}

void AccountProfileMapper::OnAddAccountCompleted(
    AddAccountHelper* helper,
    AddAccountCallback callback,
    const std::optional<AddAccountResult>& result) {
  // Note: the new account may or may not be in `account_cache_`. There is a
  // small possibility that an account was already removed from the OS. As a
  // result, this function does not use `account_cache_` at all.
  // Exclude unassigned accounts because `OnGetAccountsCompleted()` will notify
  // observers about them.
  if (result && !result->profile_path.empty()) {
    for (auto& obs : observers_)
      obs.OnAccountUpserted(result->profile_path, result->account);
  }

  if (callback)
    std::move(callback).Run(result);

  size_t erased_count =
      std::erase_if(add_account_helpers_, base::MatchesUniquePtr(helper));
  DCHECK_EQ(erased_count, 1u);
  if (add_account_helpers_.empty()) {
    account_manager_facade_->GetAccounts(
        base::BindOnce(&AccountProfileMapper::OnGetAccountsCompleted,
                       weak_factory_.GetWeakPtr()));
  }
}

std::vector<std::pair<base::FilePath, std::string>>
AccountProfileMapper::RemoveStaleAccounts() {
  std::vector<std::pair<base::FilePath, std::string>> removed_ids;
  std::vector<ProfileAttributesEntry*> entries =
      profile_attributes_storage_->GetAllProfilesAttributes();
  // For each profile.
  for (ProfileAttributesEntry* entry : entries) {
    base::flat_set<std::string> entry_ids = entry->GetGaiaIds();
    bool entry_needs_update = false;
    // For each account in the profile.
    auto it = entry_ids.begin();
    while (it != entry_ids.end()) {
      if (account_cache_.FindAccountByGaiaId(*it)) {
        ++it;
      } else {
        // An account in the profile is no longer in the system.
        entry_needs_update = true;
        removed_ids.push_back(std::make_pair(entry->GetPath(), *it));
        it = entry_ids.erase(it);
      }
    }
    if (entry_needs_update)
      entry->SetGaiaIds(entry_ids);
    if (ShouldDeleteProfile(entry)) {
      // Pass an empty callback because this should never delete the last
      // profile.
      // TODO(crbug.com/40200752): ensure that the user cannot cancel the
      // profile deletion.
      g_browser_process->profile_manager()
          ->GetDeleteProfileHelper()
          .MaybeScheduleProfileForDeletion(
              entry->GetPath(), base::DoNothing(),
              ProfileMetrics::DELETE_PROFILE_PRIMARY_ACCOUNT_REMOVED_LACROS);
    }
  }
  return removed_ids;
}

std::vector<const account_manager::Account*>
AccountProfileMapper::AddNewGaiaAccounts(
    const std::vector<account_manager::Account>& system_accounts,
    AccountCache::AccountIdSet lacros_account_ids,
    ProfileAttributesEntry* entry_for_new_accounts) {
  // Add the set of Gaia IDs in the profiles to `lacros_account_ids`. This is
  // important because accounts created by Chrome are initially added to
  // ProfileAttributesStorage first, but not to account cache. Otherwise, we'd
  // treat these new accounts as new unassigned accounts.
  std::vector<ProfileAttributesEntry*> entries =
      profile_attributes_storage_->GetAllProfilesAttributes();
  for (ProfileAttributesEntry* entry : entries) {
    base::flat_set<std::string> entry_ids = entry->GetGaiaIds();
    lacros_account_ids.insert(entry_ids.begin(), entry_ids.end());
  }

  // Diff computed set against system accounts.
  std::vector<const account_manager::Account*> added_accounts;
  for (const account_manager::Account& account : system_accounts) {
    if (account.key.account_type() == account_manager::AccountType::kGaia &&
        !lacros_account_ids.contains(account.key.id())) {
      added_accounts.push_back(&account);
    }
  }
  // Update the `ProfileAttributesEntry`.
  if (entry_for_new_accounts) {
    base::flat_set<std::string> gaia_ids = entry_for_new_accounts->GetGaiaIds();
    for (const account_manager::Account* account : added_accounts)
      gaia_ids.insert(account->key.id());
    entry_for_new_accounts->SetGaiaIds(gaia_ids);
  }
  return added_accounts;
}

void AccountProfileMapper::OnGetAccountsCompleted(
    const std::vector<account_manager::Account>& system_accounts) {
  account_cache_.UpdateAccounts(system_accounts);

  // `AccountManagerFacade` may call `OnAccountUpserted()` before the
  // `ShowAddAccountDialog()` callback, which may result in this function being
  // called during the account addition. In this case, notify helpers and
  // return immediately now, to avoid incorrectly assigning accounts to the main
  // profile. Another call will be triggered at the end of the account addition
  // to sort things up.
  if (!add_account_helpers_.empty()) {
    // Create a local copy of `add_account_helpers_` because
    // `OnAccountCacheUpdated()` may delete a helper in the middle of the
    // iteration.
    std::vector<AddAccountHelper*> local_add_account_helpers;
    local_add_account_helpers.reserve(add_account_helpers_.size());
    for (const auto& add_account_helper : add_account_helpers_)
      local_add_account_helpers.push_back(add_account_helper.get());

    for (auto* add_account_helper : local_add_account_helpers)
      add_account_helper->OnAccountCacheUpdated();
    return;
  }

  // Accounts that were removed.
  std::vector<std::pair<base::FilePath, std::string>> removed_ids =
      RemoveStaleAccounts();
  ProfileAttributesEntry* entry_for_new_accounts =
      MaybeGetProfileForNewAccounts();

  if (initialized_) {
    DCHECK(initialization_callbacks_.empty());

    AccountCache::AccountByGaiaIdMap old_cache =
        account_cache_.UpdateSnapshot();
    AccountCache::AccountIdSet old_account_ids = base::MakeFlatSet<std::string>(
        old_cache, {},
        [](const auto& mapped_pair) { return mapped_pair.first; });
    // Accounts that were added.
    std::vector<const account_manager::Account*> added_accounts =
        AddNewGaiaAccounts(system_accounts, std::move(old_account_ids),
                           entry_for_new_accounts);

    // Call observers once all entries are updated.
    base::FilePath path_for_new_accounts;
    if (entry_for_new_accounts)
      path_for_new_accounts = entry_for_new_accounts->GetPath();
    // Accounts added (either to a profile or unassigned).
    for (const auto* account : added_accounts) {
      DCHECK_EQ(account->key.account_type(),
                account_manager::AccountType::kGaia);
      for (auto& obs : observers_)
        obs.OnAccountUpserted(path_for_new_accounts, *account);
    }
    // Accounts removed that were assigned to a profile: pass the profile path.
    base::flat_set<std::string> removed_accounts_notified;
    for (const auto& [profile_path, gaia_id] : removed_ids) {
      auto it = old_cache.find(gaia_id);
      if (it == old_cache.cend()) {
        NOTREACHED_IN_MIGRATION() << "Account " << gaia_id << " missing.";
        continue;
      }
      removed_accounts_notified.insert(gaia_id);
      for (auto& obs : observers_)
        obs.OnAccountRemoved(profile_path, it->second);
    }
    // Unassigned accounts removed: pass the empty path.
    for (const auto& [gaia_id, account] : old_cache) {
      if (!base::Contains(system_accounts, account) &&
          !removed_accounts_notified.contains(account.key.id())) {
        for (auto& obs : observers_)
          obs.OnAccountRemoved(base::FilePath(), account);
      }
    }
  } else {
    AccountCache::AccountIdSet old_account_ids =
        account_cache_.CreateSnapshot();
    AddNewGaiaAccounts(system_accounts, std::move(old_account_ids),
                       entry_for_new_accounts);
    initialized_ = true;
    for (auto& callback : initialization_callbacks_)
      std::move(callback).Run();
    initialization_callbacks_.clear();
  }
}

bool AccountProfileMapper::ProfileContainsAccount(
    const base::FilePath& profile_path,
    const account_manager::AccountKey& account) const {
  const ProfileAttributesEntry* entry =
      profile_attributes_storage_->GetProfileAttributesWithPath(profile_path);
  if (!entry)
    return false;
  return entry->GetGaiaIds().contains(account.id());
}

ProfileAttributesEntry* AccountProfileMapper::MaybeGetProfileForNewAccounts()
    const {
  std::vector<ProfileAttributesEntry*> entries =
      profile_attributes_storage_->GetAllProfilesAttributes();
  // Ignore omitted profiles.
  std::erase_if(entries,
                [](const auto* entry) -> bool { return entry->IsOmitted(); });
  if (entries.empty())
    return nullptr;  // Happens in tests.
  // If there are multiple profiles, leave new accounts unassigned.
  if (entries.size() > 1)
    return nullptr;
  // Otherwise auto-assign new accounts to the main profile.
  DCHECK(Profile::IsMainProfilePath(entries[0]->GetPath()));
  return entries[0];
}

bool AccountProfileMapper::ShouldDeleteProfile(
    ProfileAttributesEntry* entry) const {
  // Delete profile if its primary account has been removed.
  const std::string& primary_gaia_id = entry->GetGAIAId();
  bool primary_account_deleted =
      !primary_gaia_id.empty() &&
      !account_cache_.FindAccountByGaiaId(primary_gaia_id);

  if (Profile::IsMainProfilePath(entry->GetPath())) {
    // Never delete the main profile.
    if (primary_account_deleted && !MaybeGetAshAccountManagerForTests()) {
      // Primary account of the main profile must never be deleted. A CHECK here
      // can possibly put a device in a crash loop, so upload a crash report
      // silently instead.
      // Do not emit these in tests, as some tests don't have an account in the
      // main profile, in particular if they are shared with desktop platforms.
      DLOG(ERROR) << "Primary account has been removed from the main profile";
      base::debug::DumpWithoutCrashing();
    }
    return false;
  }

  // If non syncing profiles enabled, only delete syncing managed profile.
  // For non managed profiles, the SigninManager will signout the profile if
  // there is no refresh token for the primary account as soon as the profile is
  // loaded. The profile may not signout if the account has been re-added to the
  // OS and `MigrateOldProfiles` re-inserted the Gaia Id before the profile is
  // loaded.
  return primary_account_deleted && entry->IsAuthenticated() &&
         AccountInfo::IsManaged(entry->GetHostedDomain());
}

void AccountProfileMapper::MigrateOldProfiles() {
  for (ProfileAttributesEntry* entry :
       profile_attributes_storage_->GetAllProfilesAttributes()) {
    // Populate missing Gaia Ids.
    // Note: this code might re-insert the Gaia id of a profile that has not
    // been loaded since its primary account removal from the OS (AuthInfo did
    // not re-set). The account will be removed later if it does not exist in
    // the OS in `RemoveStaleAccounts`.
    std::string primary_gaia_id = entry->GetGAIAId();
    if (!primary_gaia_id.empty()) {
      base::flat_set<std::string> gaia_ids = entry->GetGaiaIds();
      auto inserted_result = gaia_ids.insert(primary_gaia_id);
      if (inserted_result.second)
        entry->SetGaiaIds(gaia_ids);
    }
  }
}

void AccountProfileMapper::RemoveAccountsInternal(
    const base::FilePath& profile_path,
    const base::flat_set<std::string>& gaia_ids) {
  // Note: On initialization 'RemoveAllAccounts' may run before or after
  // `ProfileOAuth2TokenServiceDelegateChromeOS::OnGetAccounts()` which will
  // influence the order of `OnRefreshTokenRevoked()` and
  // `OnRefreshTokensLoaded()`. The'ProfileOAuth2TokenServiceDelegateChromeOS'
  // ensures the integrity of accounts with refresh tokens through
  // 'pending_accounts_'.
  DCHECK(!profile_path.empty());
  DCHECK(initialized_);
  DCHECK(!gaia_ids.empty());

  // Profile might be deleted during initialization.
  ProfileAttributesEntry* entry =
      profile_attributes_storage_->GetProfileAttributesWithPath(profile_path);

  if (!entry) {
    DLOG(ERROR) << "Profile with profile path: " << profile_path
                << " does not exist";
    return;
  }

  if (Profile::IsMainProfilePath(profile_path) &&
      gaia_ids.contains(entry->GetGAIAId())) {
    DLOG(ERROR)
        << "The primary account should not be removed from the main profile";
    return;
  }

  std::vector<account_manager::Account> removed_accounts;
  base::flat_set<std::string> profile_accounts = entry->GetGaiaIds();
  for (const auto& gaia_id : gaia_ids) {
    if (profile_accounts.contains(gaia_id)) {
      profile_accounts.erase(gaia_id);
      const account_manager::Account* account =
          account_cache_.FindAccountByGaiaId(gaia_id);
      if (account)
        removed_accounts.push_back(*account);
      else
        DLOG(ERROR) << "Account " << gaia_id << " missing.";
    }
  }
  entry->SetGaiaIds(profile_accounts);

  for (auto& obs : observers_) {
    for (const account_manager::Account& account : removed_accounts) {
      obs.OnAccountRemoved(profile_path, account);
    }
  }
}