// Copyright 2020 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/account_manager_core/account_manager_facade_impl.h"
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>
#include "base/check.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/logging.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/weak_ptr.h"
#include "base/metrics/histogram_functions.h"
#include "base/notreached.h"
#include "base/strings/stringprintf.h"
#include "chromeos/crosapi/mojom/account_manager.mojom.h"
#include "components/account_manager_core/account.h"
#include "components/account_manager_core/account_manager_util.h"
#include "components/account_manager_core/account_upsertion_result.h"
#include "components/account_manager_core/chromeos/account_manager.h"
#include "google_apis/gaia/google_service_auth_error.h"
#include "google_apis/gaia/oauth2_access_token_consumer.h"
#include "google_apis/gaia/oauth2_access_token_fetcher.h"
#include "google_apis/gaia/oauth2_access_token_fetcher_immediate_error.h"
namespace account_manager {
namespace {
using RemoteMinVersions = crosapi::mojom::AccountManager::MethodMinVersions;
// UMA histogram names.
const char kAccountUpsertionResultStatus[] =
"AccountManager.AccountUpsertionResultStatus";
const char kGetAccountsMojoStatus[] =
"AccountManager.FacadeGetAccountsMojoStatus";
const char kMojoDisconnectionsAccountManagerRemote[] =
"AccountManager.MojoDisconnections.AccountManagerRemote";
const char kMojoDisconnectionsAccountManagerObserverReceiver[] =
"AccountManager.MojoDisconnections.AccountManagerObserverReceiver";
const char kMojoDisconnectionsAccountManagerAccessTokenFetcherRemote[] =
"AccountManager.MojoDisconnections.AccessTokenFetcherRemote";
void UnmarshalAccounts(
base::OnceCallback<void(const std::vector<Account>&)> callback,
std::vector<crosapi::mojom::AccountPtr> mojo_accounts) {
std::vector<Account> accounts;
for (const auto& mojo_account : mojo_accounts) {
std::optional<Account> maybe_account = FromMojoAccount(mojo_account);
if (!maybe_account) {
// Skip accounts we couldn't unmarshal. No logging, as it would produce
// a lot of noise.
continue;
}
accounts.emplace_back(std::move(maybe_account.value()));
}
std::move(callback).Run(std::move(accounts));
}
void UnmarshalPersistentError(
base::OnceCallback<void(const GoogleServiceAuthError&)> callback,
crosapi::mojom::GoogleServiceAuthErrorPtr mojo_error) {
std::optional<GoogleServiceAuthError> maybe_error =
FromMojoGoogleServiceAuthError(mojo_error);
if (!maybe_error) {
// Couldn't unmarshal GoogleServiceAuthError, report the account as not
// having an error. This is safe to do, as GetPersistentErrorForAccount is
// best-effort (there's no way to know that the token was revoked on the
// server).
std::move(callback).Run(GoogleServiceAuthError::AuthErrorNone());
return;
}
std::move(callback).Run(maybe_error.value());
}
// Returns whether an account should be available in ARC after it's added
// in-session.
bool GetIsAvailableInArcBySource(
AccountManagerFacade::AccountAdditionSource source) {
switch (source) {
// Accounts added from Ash should be available in ARC.
case AccountManagerFacade::AccountAdditionSource::kSettingsAddAccountButton:
case AccountManagerFacade::AccountAdditionSource::
kAccountManagerMigrationWelcomeScreen:
case AccountManagerFacade::AccountAdditionSource::kArc:
case AccountManagerFacade::AccountAdditionSource::kOnboarding:
return true;
// Accounts added from the browser should not be available in ARC.
case AccountManagerFacade::AccountAdditionSource::kChromeProfileCreation:
case AccountManagerFacade::AccountAdditionSource::kOgbAddAccount:
case AccountManagerFacade::AccountAdditionSource::
kAvatarBubbleTurnOnSyncAddAccount:
case AccountManagerFacade::AccountAdditionSource::
kChromeExtensionAddAccount:
case AccountManagerFacade::AccountAdditionSource::
kChromeSyncPromoAddAccount:
case AccountManagerFacade::AccountAdditionSource::
kChromeSettingsTurnOnSyncButton:
case AccountManagerFacade::AccountAdditionSource::kChromeMenuTurnOnSync:
case AccountManagerFacade::AccountAdditionSource::
kChromeSigninPromoAddAccount:
return false;
// These are reauthentication cases. ARC visibility shouldn't change for
// reauthentication.
case AccountManagerFacade::AccountAdditionSource::kContentAreaReauth:
case AccountManagerFacade::AccountAdditionSource::
kSettingsReauthAccountButton:
case AccountManagerFacade::AccountAdditionSource::
kAvatarBubbleReauthAccountButton:
case AccountManagerFacade::AccountAdditionSource::kChromeExtensionReauth:
case AccountManagerFacade::AccountAdditionSource::kChromeSyncPromoReauth:
case AccountManagerFacade::AccountAdditionSource::
kChromeOSProjectorAppReauth:
case AccountManagerFacade::AccountAdditionSource::
kChromeSettingsReauthAccountButton:
NOTREACHED_IN_MIGRATION();
return false;
// Unused enums that cannot be deleted.
case AccountManagerFacade::AccountAdditionSource::kPrintPreviewDialogUnused:
NOTREACHED_IN_MIGRATION();
return false;
}
}
// Error logs the Mojo connection stats when `event` occurs.
void LogMojoConnectionStats(const std::string& event,
int num_remote_disconnections,
int num_receiver_disconnections) {
LOG(ERROR) << base::StringPrintf(
"%s. Number of remote disconnections: %d, "
"number of receiver disconnections: %d",
event.c_str(), num_remote_disconnections, num_receiver_disconnections);
}
} // namespace
// Fetches access tokens over the Mojo remote to `AccountManager`.
class AccountManagerFacadeImpl::AccessTokenFetcher
: public OAuth2AccessTokenFetcher {
public:
AccessTokenFetcher(AccountManagerFacadeImpl* account_manager_facade_impl,
const account_manager::AccountKey& account_key,
OAuth2AccessTokenConsumer* consumer)
: OAuth2AccessTokenFetcher(consumer),
account_manager_facade_impl_(account_manager_facade_impl),
account_key_(account_key),
oauth_consumer_name_(consumer->GetConsumerName()) {}
AccessTokenFetcher(const AccessTokenFetcher&) = delete;
AccessTokenFetcher& operator=(const AccessTokenFetcher&) = delete;
~AccessTokenFetcher() override {
base::UmaHistogramCounts100(
kMojoDisconnectionsAccountManagerAccessTokenFetcherRemote,
num_remote_disconnections_);
}
// Returns a closure, which marks `this` instance as ready for use. This
// happens when `AccountManagerFacadeImpl`'s initialization sequence is
// complete.
base::OnceClosure UnblockTokenRequest() {
return base::BindOnce(&AccessTokenFetcher::UnblockTokenRequestInternal,
weak_factory_.GetWeakPtr());
}
// Returns a closure which handles Mojo connection errors tied to Account
// Manager remote.
base::OnceClosure AccountManagerRemoteDisconnectionClosure() {
return base::BindOnce(
&AccessTokenFetcher::OnAccountManagerRemoteDisconnection,
weak_factory_.GetWeakPtr());
}
// OAuth2AccessTokenFetcher override:
// Note: This implementation ignores `client_id` and `client_secret` because
// AccountManager's Mojo API does not support overriding OAuth client id and
// secret.
void Start(const std::string& client_id,
const std::string& client_secret,
const std::vector<std::string>& scopes) override {
DCHECK(!is_request_pending_);
is_request_pending_ = true;
scopes_ = scopes;
if (!are_token_requests_allowed_) {
return;
}
StartInternal();
}
// OAuth2AccessTokenFetcher override:
void CancelRequest() override {
access_token_fetcher_.reset();
is_request_pending_ = false;
}
private:
void UnblockTokenRequestInternal() {
are_token_requests_allowed_ = true;
if (is_request_pending_) {
StartInternal();
}
}
void StartInternal() {
DCHECK(are_token_requests_allowed_);
bool is_remote_connected =
account_manager_facade_impl_->CreateAccessTokenFetcher(
account_manager::ToMojoAccountKey(account_key_),
oauth_consumer_name_,
base::BindOnce(&AccessTokenFetcher::FetchAccessToken,
weak_factory_.GetWeakPtr()));
if (!is_remote_connected) {
OnAccountManagerRemoteDisconnection();
}
}
void FetchAccessToken(
mojo::PendingRemote<crosapi::mojom::AccessTokenFetcher> pending_remote) {
access_token_fetcher_.Bind(std::move(pending_remote));
access_token_fetcher_.set_disconnect_handler(base::BindOnce(
&AccessTokenFetcher::OnAccessTokenFetcherRemoteDisconnection,
weak_factory_.GetWeakPtr()));
access_token_fetcher_->Start(
scopes_, base::BindOnce(&AccessTokenFetcher::OnAccessTokenFetchComplete,
weak_factory_.GetWeakPtr()));
}
void OnAccessTokenFetchComplete(crosapi::mojom::AccessTokenResultPtr result) {
DCHECK(is_request_pending_);
is_request_pending_ = false;
if (result->is_error()) {
std::optional<GoogleServiceAuthError> maybe_error =
account_manager::FromMojoGoogleServiceAuthError(result->get_error());
if (!maybe_error.has_value()) {
LOG(ERROR) << "Unable to parse error result of access token fetch: "
<< result->get_error()->state;
FireOnGetTokenFailure(
GoogleServiceAuthError::FromUnexpectedServiceResponse(
"Error parsing Mojo error result of access token fetch"));
} else {
FireOnGetTokenFailure(maybe_error.value());
}
return;
}
FireOnGetTokenSuccess(
OAuth2AccessTokenConsumer::TokenResponse::Builder()
.WithAccessToken(result->get_access_token_info()->access_token)
.WithExpirationTime(
result->get_access_token_info()->expiration_time)
.WithIdToken(result->get_access_token_info()->id_token)
.build());
}
void OnAccountManagerRemoteDisconnection() {
FailPendingRequestWithServiceError("Mojo pipe disconnected");
}
void OnAccessTokenFetcherRemoteDisconnection() {
num_remote_disconnections_++;
LOG(ERROR) << "Access token fetcher remote disconnected";
FailPendingRequestWithServiceError("Access token Mojo pipe disconnected");
}
void FailPendingRequestWithServiceError(const std::string& message) {
if (!is_request_pending_)
return;
CancelRequest();
FireOnGetTokenFailure(GoogleServiceAuthError::FromServiceError(message));
}
const raw_ptr<AccountManagerFacadeImpl> account_manager_facade_impl_;
const account_manager::AccountKey account_key_;
const std::string oauth_consumer_name_;
bool are_token_requests_allowed_ = false;
bool is_request_pending_ = false;
// Number of Mojo pipe disconnections seen by `access_token_fetcher_`.
int num_remote_disconnections_ = 0;
std::vector<std::string> scopes_;
mojo::Remote<crosapi::mojom::AccessTokenFetcher> access_token_fetcher_;
base::WeakPtrFactory<AccessTokenFetcher> weak_factory_{this};
};
AccountManagerFacadeImpl::AccountManagerFacadeImpl(
mojo::Remote<crosapi::mojom::AccountManager> account_manager_remote,
uint32_t remote_version,
base::WeakPtr<AccountManager> account_manager_for_tests,
base::OnceClosure init_finished)
: remote_version_(remote_version),
account_manager_remote_(std::move(account_manager_remote)),
account_manager_for_tests_(std::move(account_manager_for_tests)) {
DCHECK(init_finished);
initialization_callbacks_.emplace_back(std::move(init_finished));
if (!account_manager_remote_ ||
remote_version_ < RemoteMinVersions::kGetAccountsMinVersion) {
LOG(WARNING) << "Found remote at: " << remote_version_
<< ", expected: " << RemoteMinVersions::kGetAccountsMinVersion
<< ". Account consistency will be disabled";
FinishInitSequenceIfNotAlreadyFinished();
return;
}
account_manager_remote_.set_disconnect_handler(base::BindOnce(
&AccountManagerFacadeImpl::OnAccountManagerRemoteDisconnected,
weak_factory_.GetWeakPtr()));
account_manager_remote_->AddObserver(
base::BindOnce(&AccountManagerFacadeImpl::OnReceiverReceived,
weak_factory_.GetWeakPtr()));
}
AccountManagerFacadeImpl::~AccountManagerFacadeImpl() {
base::UmaHistogramCounts100(kMojoDisconnectionsAccountManagerRemote,
num_remote_disconnections_);
base::UmaHistogramCounts100(kMojoDisconnectionsAccountManagerObserverReceiver,
num_receiver_disconnections_);
}
void AccountManagerFacadeImpl::AddObserver(Observer* observer) {
observer_list_.AddObserver(observer);
}
void AccountManagerFacadeImpl::RemoveObserver(Observer* observer) {
observer_list_.RemoveObserver(observer);
}
void AccountManagerFacadeImpl::GetAccounts(
base::OnceCallback<void(const std::vector<Account>&)> callback) {
// Record the status of the mojo connection, to get more information about
// https://crbug.com/1287297
FacadeMojoStatus mojo_status = FacadeMojoStatus::kOk;
if (!account_manager_remote_)
mojo_status = FacadeMojoStatus::kNoRemote;
else if (remote_version_ < RemoteMinVersions::kGetAccountsMinVersion)
mojo_status = FacadeMojoStatus::kVersionMismatch;
else if (!is_initialized_)
mojo_status = FacadeMojoStatus::kUninitialized;
base::UmaHistogramEnumeration(kGetAccountsMojoStatus, mojo_status);
if (!account_manager_remote_ ||
remote_version_ < RemoteMinVersions::kGetAccountsMinVersion) {
// Remote side is disconnected or doesn't support GetAccounts. Do not return
// an empty list as that may cause Lacros to delete user profiles.
// TODO(crbug.com/40211181): Try to reconnect, or return an error.
return;
}
RunAfterInitializationSequence(
base::BindOnce(&AccountManagerFacadeImpl::GetAccountsInternal,
weak_factory_.GetWeakPtr(), std::move(callback)));
}
void AccountManagerFacadeImpl::GetPersistentErrorForAccount(
const AccountKey& account,
base::OnceCallback<void(const GoogleServiceAuthError&)> callback) {
if (!account_manager_remote_ ||
remote_version_ <
RemoteMinVersions::kGetPersistentErrorForAccountMinVersion) {
// Remote side doesn't support GetPersistentErrorForAccount.
std::move(callback).Run(GoogleServiceAuthError::AuthErrorNone());
return;
}
RunAfterInitializationSequence(
base::BindOnce(&AccountManagerFacadeImpl::GetPersistentErrorInternal,
weak_factory_.GetWeakPtr(), account, std::move(callback)));
}
void AccountManagerFacadeImpl::ShowAddAccountDialog(
AccountAdditionSource source) {
ShowAddAccountDialog(source, base::DoNothing());
}
void AccountManagerFacadeImpl::ShowAddAccountDialog(
AccountAdditionSource source,
base::OnceCallback<
void(const account_manager::AccountUpsertionResult& result)> callback) {
if (!account_manager_remote_) {
LOG(WARNING) << "Account Manager remote disconnected";
FinishUpsertAccount(
std::move(callback),
AccountUpsertionResult::FromStatus(
AccountUpsertionResult::Status::kMojoRemoteDisconnected));
return;
}
if (remote_version_ < RemoteMinVersions::kShowAddAccountDialogMinVersion) {
LOG(WARNING) << "Found remote at: " << remote_version_ << ", expected: "
<< RemoteMinVersions::kShowAddAccountDialogMinVersion
<< " for ShowAddAccountDialog.";
FinishUpsertAccount(
std::move(callback),
AccountUpsertionResult::FromStatus(
AccountUpsertionResult::Status::kIncompatibleMojoVersions));
return;
}
base::UmaHistogramEnumeration(kAccountAdditionSource, source);
crosapi::mojom::AccountAdditionOptionsPtr options =
crosapi::mojom::AccountAdditionOptions::New();
options->is_available_in_arc = GetIsAvailableInArcBySource(source);
options->show_arc_availability_picker =
(source == AccountManagerFacade::AccountAdditionSource::kArc);
account_manager_remote_->ShowAddAccountDialog(
std::move(options),
base::BindOnce(&AccountManagerFacadeImpl::OnSigninDialogActionFinished,
weak_factory_.GetWeakPtr(), std::move(callback)));
}
void AccountManagerFacadeImpl::ShowReauthAccountDialog(
AccountAdditionSource source,
const std::string& email,
base::OnceCallback<
void(const account_manager::AccountUpsertionResult& result)> callback) {
if (!account_manager_remote_) {
LOG(WARNING) << "Account Manager remote disconnected";
FinishUpsertAccount(
std::move(callback),
AccountUpsertionResult::FromStatus(
AccountUpsertionResult::Status::kMojoRemoteDisconnected));
return;
}
if (remote_version_ < RemoteMinVersions::kShowReauthAccountDialogMinVersion) {
LOG(WARNING) << "Found remote at: " << remote_version_ << ", expected: "
<< RemoteMinVersions::kShowReauthAccountDialogMinVersion
<< " for ShowReauthAccountDialog.";
FinishUpsertAccount(
std::move(callback),
AccountUpsertionResult::FromStatus(
AccountUpsertionResult::Status::kIncompatibleMojoVersions));
return;
}
base::UmaHistogramEnumeration(kAccountAdditionSource, source);
account_manager_remote_->ShowReauthAccountDialog(
email,
base::BindOnce(&AccountManagerFacadeImpl::OnSigninDialogActionFinished,
weak_factory_.GetWeakPtr(), std::move(callback)));
}
void AccountManagerFacadeImpl::ShowManageAccountsSettings() {
if (!account_manager_remote_ ||
remote_version_ <
RemoteMinVersions::kShowManageAccountsSettingsMinVersion) {
LOG(WARNING) << "Found remote at: " << remote_version_ << ", expected: "
<< RemoteMinVersions::kShowManageAccountsSettingsMinVersion
<< " for ShowManageAccountsSettings.";
return;
}
account_manager_remote_->ShowManageAccountsSettings();
}
std::unique_ptr<OAuth2AccessTokenFetcher>
AccountManagerFacadeImpl::CreateAccessTokenFetcher(
const AccountKey& account,
OAuth2AccessTokenConsumer* consumer) {
if (!account_manager_remote_ ||
remote_version_ <
RemoteMinVersions::kCreateAccessTokenFetcherMinVersion) {
VLOG(1) << "Found remote at: " << remote_version_ << ", expected: "
<< RemoteMinVersions::kCreateAccessTokenFetcherMinVersion
<< " for CreateAccessTokenFetcher";
return std::make_unique<OAuth2AccessTokenFetcherImmediateError>(
consumer,
GoogleServiceAuthError::FromServiceError("Mojo pipe disconnected"));
}
auto access_token_fetcher = std::make_unique<AccessTokenFetcher>(
/*account_manager_facade_impl=*/this, account, consumer);
RunAfterInitializationSequence(access_token_fetcher->UnblockTokenRequest());
RunOnAccountManagerRemoteDisconnection(
access_token_fetcher->AccountManagerRemoteDisconnectionClosure());
return std::move(access_token_fetcher);
}
void AccountManagerFacadeImpl::ReportAuthError(
const account_manager::AccountKey& account,
const GoogleServiceAuthError& error) {
if (!account_manager_remote_ ||
remote_version_ < RemoteMinVersions::kReportAuthErrorMinVersion) {
LOG(WARNING) << "Found remote at: " << remote_version_ << ", expected: "
<< RemoteMinVersions::kReportAuthErrorMinVersion
<< " for ReportAuthError.";
return;
}
account_manager_remote_->ReportAuthError(ToMojoAccountKey(account),
ToMojoGoogleServiceAuthError(error));
}
void AccountManagerFacadeImpl::UpsertAccountForTesting(
const Account& account,
const std::string& token_value) {
CHECK(account_manager_for_tests_);
account_manager_for_tests_->UpsertAccount(account.key, account.raw_email,
token_value);
}
void AccountManagerFacadeImpl::RemoveAccountForTesting(
const AccountKey& account) {
CHECK(account_manager_for_tests_);
account_manager_for_tests_->RemoveAccount(account);
}
// static
std::string AccountManagerFacadeImpl::
GetAccountUpsertionResultStatusHistogramNameForTesting() {
return kAccountUpsertionResultStatus;
}
// static
std::string
AccountManagerFacadeImpl::GetAccountsMojoStatusHistogramNameForTesting() {
return kGetAccountsMojoStatus;
}
void AccountManagerFacadeImpl::OnReceiverReceived(
mojo::PendingReceiver<AccountManagerObserver> receiver) {
receiver_ =
std::make_unique<mojo::Receiver<crosapi::mojom::AccountManagerObserver>>(
this, std::move(receiver));
// At this point (`receiver_` exists), we are subscribed to Account Manager.
receiver_->set_disconnect_handler(base::BindOnce(
&AccountManagerFacadeImpl::OnAccountManagerObserverReceiverDisconnected,
weak_factory_.GetWeakPtr()));
FinishInitSequenceIfNotAlreadyFinished();
}
void AccountManagerFacadeImpl::OnSigninDialogActionFinished(
base::OnceCallback<
void(const account_manager::AccountUpsertionResult& result)> callback,
crosapi::mojom::AccountUpsertionResultPtr mojo_result) {
std::optional<account_manager::AccountUpsertionResult> result =
account_manager::FromMojoAccountUpsertionResult(mojo_result);
if (!result.has_value()) {
FinishUpsertAccount(
std::move(callback),
AccountUpsertionResult::FromStatus(
AccountUpsertionResult::Status::kUnexpectedResponse));
return;
}
FinishUpsertAccount(std::move(callback), result.value());
}
void AccountManagerFacadeImpl::FinishUpsertAccount(
base::OnceCallback<
void(const account_manager::AccountUpsertionResult& result)> callback,
const account_manager::AccountUpsertionResult& result) {
base::UmaHistogramEnumeration(kAccountUpsertionResultStatus, result.status());
std::move(callback).Run(result);
}
void AccountManagerFacadeImpl::OnTokenUpserted(
crosapi::mojom::AccountPtr account) {
std::optional<Account> maybe_account = FromMojoAccount(account);
if (!maybe_account) {
LOG(WARNING) << "Can't unmarshal account of type: "
<< account->key->account_type;
return;
}
for (auto& observer : observer_list_) {
observer.OnAccountUpserted(maybe_account.value());
}
}
void AccountManagerFacadeImpl::OnAccountRemoved(
crosapi::mojom::AccountPtr account) {
std::optional<Account> maybe_account = FromMojoAccount(account);
if (!maybe_account) {
LOG(WARNING) << "Can't unmarshal account of type: "
<< account->key->account_type;
return;
}
for (auto& observer : observer_list_) {
observer.OnAccountRemoved(maybe_account.value());
}
}
void AccountManagerFacadeImpl::OnAuthErrorChanged(
crosapi::mojom::AccountKeyPtr account,
crosapi::mojom::GoogleServiceAuthErrorPtr error) {
std::optional<AccountKey> maybe_account_key = FromMojoAccountKey(account);
if (!maybe_account_key) {
LOG(WARNING) << "Can't unmarshal account key of type: "
<< account->account_type;
return;
}
std::optional<GoogleServiceAuthError> maybe_error =
FromMojoGoogleServiceAuthError(error);
if (!maybe_error) {
LOG(WARNING) << "Can't unmarshal error with state: " << error->state;
return;
}
for (auto& observer : observer_list_) {
observer.OnAuthErrorChanged(maybe_account_key.value(), maybe_error.value());
}
}
void AccountManagerFacadeImpl::OnSigninDialogClosed() {
for (auto& observer : observer_list_) {
observer.OnSigninDialogClosed();
}
}
void AccountManagerFacadeImpl::GetAccountsInternal(
base::OnceCallback<void(const std::vector<Account>&)> callback) {
account_manager_remote_->GetAccounts(
base::BindOnce(&UnmarshalAccounts, std::move(callback)));
}
void AccountManagerFacadeImpl::GetPersistentErrorInternal(
const AccountKey& account,
base::OnceCallback<void(const GoogleServiceAuthError&)> callback) {
account_manager_remote_->GetPersistentErrorForAccount(
ToMojoAccountKey(account),
base::BindOnce(&UnmarshalPersistentError, std::move(callback)));
}
bool AccountManagerFacadeImpl::CreateAccessTokenFetcher(
crosapi::mojom::AccountKeyPtr account_key,
const std::string& oauth_consumer_name,
crosapi::mojom::AccountManager::CreateAccessTokenFetcherCallback callback) {
if (!account_manager_remote_) {
return false;
}
account_manager_remote_->CreateAccessTokenFetcher(
std::move(account_key), oauth_consumer_name, std::move(callback));
return true;
}
void AccountManagerFacadeImpl::FinishInitSequenceIfNotAlreadyFinished() {
if (is_initialized_) {
return;
}
is_initialized_ = true;
for (auto& cb : initialization_callbacks_) {
std::move(cb).Run();
}
initialization_callbacks_.clear();
}
void AccountManagerFacadeImpl::RunAfterInitializationSequence(
base::OnceClosure closure) {
if (!is_initialized_) {
initialization_callbacks_.emplace_back(std::move(closure));
} else {
std::move(closure).Run();
}
}
void AccountManagerFacadeImpl::RunOnAccountManagerRemoteDisconnection(
base::OnceClosure closure) {
if (!account_manager_remote_) {
std::move(closure).Run();
return;
}
account_manager_remote_disconnection_handlers_.emplace_back(
std::move(closure));
}
void AccountManagerFacadeImpl::OnAccountManagerRemoteDisconnected() {
num_remote_disconnections_++;
LogMojoConnectionStats("Account Manager disconnected",
num_remote_disconnections_,
num_receiver_disconnections_);
for (auto& cb : account_manager_remote_disconnection_handlers_) {
std::move(cb).Run();
}
account_manager_remote_disconnection_handlers_.clear();
account_manager_remote_.reset();
}
void AccountManagerFacadeImpl::OnAccountManagerObserverReceiverDisconnected() {
num_receiver_disconnections_++;
LogMojoConnectionStats("Account Manager Observer disconnected",
num_remote_disconnections_,
num_receiver_disconnections_);
}
bool AccountManagerFacadeImpl::IsInitialized() {
return is_initialized_;
}
void AccountManagerFacadeImpl::FlushMojoForTesting() {
if (!account_manager_remote_) {
return;
}
account_manager_remote_.FlushForTesting();
}
} // namespace account_manager
Codebase Browser
chromium