blob: 9b912a5555eb3622aeb940f79f8e2355dc2f583b [file] [log] [blame]
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/autofill/core/browser/test_personal_data_manager.h"
#include "components/autofill/core/browser/personal_data_manager_observer.h"
namespace autofill {
TestPersonalDataManager::TestPersonalDataManager()
: PersonalDataManager("en-US") {}
TestPersonalDataManager::~TestPersonalDataManager() {}
void TestPersonalDataManager::RecordUseOf(const AutofillDataModel& data_model) {
CreditCard* credit_card = GetCreditCardWithGUID(data_model.guid().c_str());
if (credit_card)
credit_card->RecordAndLogUse();
AutofillProfile* profile = GetProfileWithGUID(data_model.guid().c_str());
if (profile)
profile->RecordAndLogUse();
}
std::string TestPersonalDataManager::SaveImportedProfile(
const AutofillProfile& imported_profile) {
num_times_save_imported_profile_called_++;
return PersonalDataManager::SaveImportedProfile(imported_profile);
}
std::string TestPersonalDataManager::SaveImportedCreditCard(
const CreditCard& imported_credit_card) {
num_times_save_imported_credit_card_called_++;
AddCreditCard(imported_credit_card);
return imported_credit_card.guid();
}
void TestPersonalDataManager::AddProfile(const AutofillProfile& profile) {
std::unique_ptr<AutofillProfile> profile_ptr =
std::make_unique<AutofillProfile>(profile);
web_profiles_.push_back(std::move(profile_ptr));
NotifyPersonalDataChanged();
}
void TestPersonalDataManager::UpdateProfile(const AutofillProfile& profile) {
AutofillProfile* existing_profile =
GetProfileWithGUID(profile.guid().c_str());
if (existing_profile) {
RemoveByGUID(existing_profile->guid());
AddProfile(profile);
}
}
void TestPersonalDataManager::RemoveByGUID(const std::string& guid) {
CreditCard* credit_card = GetCreditCardWithGUID(guid.c_str());
if (credit_card) {
local_credit_cards_.erase(
std::find_if(local_credit_cards_.begin(), local_credit_cards_.end(),
[credit_card](const std::unique_ptr<CreditCard>& ptr) {
return ptr.get() == credit_card;
}));
}
AutofillProfile* profile = GetProfileWithGUID(guid.c_str());
if (profile) {
web_profiles_.erase(
std::find_if(web_profiles_.begin(), web_profiles_.end(),
[profile](const std::unique_ptr<AutofillProfile>& ptr) {
return ptr.get() == profile;
}));
}
}
void TestPersonalDataManager::AddCreditCard(const CreditCard& credit_card) {
std::unique_ptr<CreditCard> local_credit_card =
std::make_unique<CreditCard>(credit_card);
local_credit_cards_.push_back(std::move(local_credit_card));
NotifyPersonalDataChanged();
}
void TestPersonalDataManager::UpdateCreditCard(const CreditCard& credit_card) {
CreditCard* existing_credit_card =
GetCreditCardWithGUID(credit_card.guid().c_str());
if (existing_credit_card) {
RemoveByGUID(existing_credit_card->guid());
AddCreditCard(credit_card);
}
}
void TestPersonalDataManager::AddFullServerCreditCard(
const CreditCard& credit_card) {
// Though the name is AddFullServerCreditCard, this test class treats masked
// and full server cards equally, relying on their preset RecordType to
// differentiate them.
AddServerCreditCard(credit_card);
}
std::vector<AutofillProfile*> TestPersonalDataManager::GetProfiles() const {
std::vector<AutofillProfile*> result;
result.reserve(web_profiles_.size());
for (const auto& profile : web_profiles_)
result.push_back(profile.get());
return result;
}
const std::string& TestPersonalDataManager::GetDefaultCountryCodeForNewAddress()
const {
if (default_country_code_.empty())
return PersonalDataManager::GetDefaultCountryCodeForNewAddress();
return default_country_code_;
}
void TestPersonalDataManager::SetProfiles(
std::vector<AutofillProfile>* profiles) {
// Copy all the profiles. Called by functions like
// PersonalDataManager::SaveImportedProfile, which impact metrics.
ClearProfiles();
for (const auto& profile : *profiles)
AddProfile(profile);
}
void TestPersonalDataManager::LoadProfiles() {
// Overridden to avoid a trip to the database. This should be a no-op except
// for the side-effect of logging the profile count.
pending_profiles_query_ = 123;
pending_server_profiles_query_ = 124;
{
std::vector<std::unique_ptr<AutofillProfile>> profiles;
web_profiles_.swap(profiles);
std::unique_ptr<WDTypedResult> result = std::make_unique<
WDResult<std::vector<std::unique_ptr<AutofillProfile>>>>(
AUTOFILL_PROFILES_RESULT, std::move(profiles));
OnWebDataServiceRequestDone(pending_profiles_query_, std::move(result));
}
{
std::vector<std::unique_ptr<AutofillProfile>> profiles;
server_profiles_.swap(profiles);
std::unique_ptr<WDTypedResult> result = std::make_unique<
WDResult<std::vector<std::unique_ptr<AutofillProfile>>>>(
AUTOFILL_PROFILES_RESULT, std::move(profiles));
OnWebDataServiceRequestDone(pending_server_profiles_query_,
std::move(result));
}
}
void TestPersonalDataManager::LoadCreditCards() {
// Overridden to avoid a trip to the database.
pending_creditcards_query_ = 125;
pending_server_creditcards_query_ = 126;
{
std::vector<std::unique_ptr<CreditCard>> credit_cards;
local_credit_cards_.swap(credit_cards);
std::unique_ptr<WDTypedResult> result =
std::make_unique<WDResult<std::vector<std::unique_ptr<CreditCard>>>>(
AUTOFILL_CREDITCARDS_RESULT, std::move(credit_cards));
OnWebDataServiceRequestDone(pending_creditcards_query_, std::move(result));
}
{
std::vector<std::unique_ptr<CreditCard>> credit_cards;
server_credit_cards_.swap(credit_cards);
std::unique_ptr<WDTypedResult> result =
std::make_unique<WDResult<std::vector<std::unique_ptr<CreditCard>>>>(
AUTOFILL_CREDITCARDS_RESULT, std::move(credit_cards));
OnWebDataServiceRequestDone(pending_server_creditcards_query_,
std::move(result));
}
}
bool TestPersonalDataManager::IsAutofillEnabled() const {
// Return the value of autofill_enabled_ if it has been set, otherwise fall
// back to the normal behavior of checking the pref_service.
if (autofill_enabled_.has_value())
return autofill_enabled_.value();
return PersonalDataManager::IsAutofillEnabled();
}
bool TestPersonalDataManager::IsAutofillProfileEnabled() const {
// Return the value of autofill_profile_enabled_ if it has been set,
// otherwise fall back to the normal behavior of checking the pref_service.
if (autofill_profile_enabled_.has_value())
return autofill_profile_enabled_.value();
return PersonalDataManager::IsAutofillProfileEnabled();
}
bool TestPersonalDataManager::IsAutofillCreditCardEnabled() const {
// Return the value of autofill_credit_card_enabled_ if it has been set,
// otherwise fall back to the normal behavior of checking the pref_service.
if (autofill_credit_card_enabled_.has_value())
return autofill_credit_card_enabled_.value();
return PersonalDataManager::IsAutofillCreditCardEnabled();
}
bool TestPersonalDataManager::IsAutofillWalletImportEnabled() const {
// Return the value of autofill_wallet_import_enabled_ if it has been set,
// otherwise fall back to the normal behavior of checking the pref_service.
if (autofill_wallet_import_enabled_.has_value())
return autofill_wallet_import_enabled_.value();
return PersonalDataManager::IsAutofillWalletImportEnabled();
}
bool TestPersonalDataManager::ShouldSuggestServerCards() const {
return IsAutofillCreditCardEnabled() && IsAutofillWalletImportEnabled();
}
std::string TestPersonalDataManager::CountryCodeForCurrentTimezone()
const {
return timezone_country_code_;
}
bool TestPersonalDataManager::IsDataLoaded() const {
return true;
}
void TestPersonalDataManager::ClearProfiles() {
web_profiles_.clear();
}
void TestPersonalDataManager::ClearCreditCards() {
local_credit_cards_.clear();
server_credit_cards_.clear();
}
AutofillProfile* TestPersonalDataManager::GetProfileWithGUID(const char* guid) {
for (AutofillProfile* profile : GetProfiles()) {
if (!profile->guid().compare(guid))
return profile;
}
return nullptr;
}
CreditCard* TestPersonalDataManager::GetCreditCardWithGUID(const char* guid) {
for (CreditCard* card : GetCreditCards()) {
if (!card->guid().compare(guid))
return card;
}
return nullptr;
}
void TestPersonalDataManager::AddServerCreditCard(
const CreditCard& credit_card) {
std::unique_ptr<CreditCard> server_credit_card =
std::make_unique<CreditCard>(credit_card);
server_credit_cards_.push_back(std::move(server_credit_card));
NotifyPersonalDataChanged();
}
} // namespace autofill