Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Update search engine defaults for DE / AU / NZ / IE #3591

Merged
merged 4 commits into from
Oct 4, 2019
Merged

Update search engine defaults for DE / AU / NZ / IE #3591

Show file tree
Hide file tree
Changes from 2 commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
60e3672
Update search engine defaults for DE / AU / NZ / IE
bsclifton Sep 26, 2019
9be289f
Test cleanup
bsclifton Oct 3, 2019
201436c
Fixes
bsclifton Oct 4, 2019
3c2807c
lint fix
bsclifton Oct 4, 2019
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
50 changes: 30 additions & 20 deletions chromium_src/components/search_engines/brave_template_url_prepopulate_data_unittest.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -63,6 +63,15 @@ class BraveTemplateURLPrepopulateDataTest : public testing::Test {
TemplateURLPrepopulateData::RegisterProfilePrefs(prefs_.registry());
}

void CheckForCountry(char digit1, char digit2, std::string expected) {
bsclifton marked this conversation as resolved.
Show resolved Hide resolved
prefs_.SetInteger(kCountryIDAtInstall, digit1 << 8 | digit2);
size_t default_index;
std::vector<std::unique_ptr<TemplateURLData>> t_urls =
TemplateURLPrepopulateData::GetPrepopulatedEngines(&prefs_,
&default_index);
EXPECT_EQ(ASCIIToUTF16(expected), t_urls[default_index]->short_name());
}

protected:
sync_preferences::TestingPrefServiceSyncable prefs_;
};
Expand Down Expand Up @@ -139,28 +148,29 @@ TEST_F(BraveTemplateURLPrepopulateDataTest, ProvidersFromPrepopulated) {
}

// Verifies default search provider for locale
TEST_F(BraveTemplateURLPrepopulateDataTest, DefaultSearchProvidersForLocale) {
// Use United States.
prefs_.SetInteger(kCountryIDAtInstall, 'U' << 8 | 'S');
size_t default_index;
std::vector<std::unique_ptr<TemplateURLData>> t_urls =
TemplateURLPrepopulateData::GetPrepopulatedEngines(&prefs_,
&default_index);
EXPECT_EQ(ASCIIToUTF16("Google"), t_urls[default_index]->short_name());
TEST_F(BraveTemplateURLPrepopulateDataTest, DefaultSearchProvidersForUSA) {
CheckForCountry('U', 'S', "Google");
}

TEST_F(BraveTemplateURLPrepopulateDataTest, DefaultSearchProvidersForGermany) {
CheckForCountry('D', 'E', "DuckDuckGo");
}

t_urls.clear();
TEST_F(BraveTemplateURLPrepopulateDataTest, DefaultSearchProvidersForFrance) {
CheckForCountry('F', 'R', "Qwant");
}

// Use Germany.
prefs_.SetInteger(kCountryIDAtInstall, 'D' << 8 | 'E');
t_urls = TemplateURLPrepopulateData::GetPrepopulatedEngines(&prefs_,
&default_index);
EXPECT_EQ(ASCIIToUTF16("Qwant"), t_urls[default_index]->short_name());
TEST_F(BraveTemplateURLPrepopulateDataTest,
bsclifton marked this conversation as resolved.
Show resolved Hide resolved
DefaultSearchProvidersForAustralia) {
CheckForCountry('A', 'U', "DuckDuckGo");
}

t_urls.clear();
TEST_F(BraveTemplateURLPrepopulateDataTest,
DefaultSearchProvidersForNewZealand) {
CheckForCountry('N', 'Z', "DuckDuckGo");
}

// Use France.
prefs_.SetInteger(kCountryIDAtInstall, 'F' << 8 | 'R');
t_urls = TemplateURLPrepopulateData::GetPrepopulatedEngines(&prefs_,
&default_index);
EXPECT_EQ(ASCIIToUTF16("Qwant"), t_urls[default_index]->short_name());
TEST_F(BraveTemplateURLPrepopulateDataTest,
DefaultSearchProvidersForIreland) {
CheckForCountry('I', 'E', "DuckDuckGo");
}
100 changes: 63 additions & 37 deletions chromium_src/components/search_engines/brave_template_url_service_util_unittest.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -9,6 +9,7 @@

#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "brave/components/search_engines/brave_prepopulated_engines.h"
#include "components/search_engines/search_engines_pref_names.h"
#include "components/search_engines/search_terms_data.h"
#include "components/search_engines/template_url.h"
Expand Down Expand Up @@ -45,15 +46,47 @@ class BraveTemplateURLServiceUtilTest : public testing::Test {
sync_preferences::TestingPrefServiceSyncable prefs_;
};

TEST_F(BraveTemplateURLServiceUtilTest, GetSearchProvidersUsingKeywordResult) {
void TestDefaultOrder(const TemplateURL::OwnedTemplateURLVector& template_urls,
std::vector<std::string> keywords) {
bsclifton marked this conversation as resolved.
Show resolved Hide resolved
EXPECT_EQ(template_urls.size(), keywords.size());

for (size_t i = 0; i < template_urls.size(); i++) {
EXPECT_EQ(template_urls[i]->keyword(), base::ASCIIToUTF16(keywords[i]));
}
}

std::vector<TemplateURLData> GetSampleTemplateData() {
std::vector<TemplateURLData> local_turls;

// Create a sets of TURLs in order different from prepopulated TURLs.
local_turls.push_back(*CreatePrepopulateTemplateURLData(511, ":sp", 1));
local_turls.push_back(*CreatePrepopulateTemplateURLData(
TemplateURLPrepopulateData::PREPOPULATED_ENGINE_ID_STARTPAGE, ":sp", 1));
local_turls.push_back(*CreatePrepopulateTemplateURLData(15, ":ya", 2));
local_turls.push_back(*CreatePrepopulateTemplateURLData(3, ":b", 3));
local_turls.push_back(*CreatePrepopulateTemplateURLData(507, ":q", 4));
local_turls.push_back(*CreatePrepopulateTemplateURLData(501, ":d", 5));
local_turls.push_back(*CreatePrepopulateTemplateURLData(1, ":g", 6));
local_turls.push_back(*CreatePrepopulateTemplateURLData(
TemplateURLPrepopulateData::PREPOPULATED_ENGINE_ID_BING, ":b", 3));
local_turls.push_back(*CreatePrepopulateTemplateURLData(
TemplateURLPrepopulateData::PREPOPULATED_ENGINE_ID_QWANT, ":q", 4));
local_turls.push_back(*CreatePrepopulateTemplateURLData(
TemplateURLPrepopulateData::PREPOPULATED_ENGINE_ID_DUCKDUCKGO, ":d", 5));
local_turls.push_back(*CreatePrepopulateTemplateURLData(
TemplateURLPrepopulateData::PREPOPULATED_ENGINE_ID_GOOGLE, ":g", 6));

return local_turls;
}

WDKeywordsResult InitKeywordResult(
sync_preferences::TestingPrefServiceSyncable* prefs,
std::vector<TemplateURLData> local_turls) {
bsclifton marked this conversation as resolved.
Show resolved Hide resolved
WDKeywordsResult kwResult;
kwResult.builtin_keyword_version =
TemplateURLPrepopulateData::GetDataVersion(prefs);
kwResult.default_search_provider_id = 2;
kwResult.keywords = local_turls;
return kwResult;
}

TEST_F(BraveTemplateURLServiceUtilTest, GetSearchProvidersUsingKeywordResult) {
std::vector<TemplateURLData> local_turls = GetSampleTemplateData();
std::unique_ptr<TemplateURL> default_turl =
std::make_unique<TemplateURL>(local_turls.back());

Expand All @@ -62,12 +95,8 @@ TEST_F(BraveTemplateURLServiceUtilTest, GetSearchProvidersUsingKeywordResult) {
local_turls.push_back(*CreatePrepopulateTemplateURLData(1004, "random2", 8));

// Prepare call arguments
WDKeywordsResult kwResult;
kwResult.builtin_keyword_version =
TemplateURLPrepopulateData::GetDataVersion(&prefs_);
kwResult.default_search_provider_id = 2;
kwResult.keywords = local_turls;
WDResult<WDKeywordsResult> result(KEYWORDS_RESULT, kwResult);
WDResult<WDKeywordsResult> result(KEYWORDS_RESULT,
InitKeywordResult(&prefs_, local_turls));

TemplateURL::OwnedTemplateURLVector template_urls;
int new_resource_keyword_version = 0;
Expand All @@ -76,38 +105,35 @@ TEST_F(BraveTemplateURLServiceUtilTest, GetSearchProvidersUsingKeywordResult) {
default_turl.get(), SearchTermsData(),
&new_resource_keyword_version, nullptr);

// Verify count.
// Verify count and order.
EXPECT_EQ(local_turls.size(), template_urls.size());
// Verify order.
EXPECT_EQ(template_urls[0]->keyword(), base::ASCIIToUTF16(":g"));
EXPECT_EQ(template_urls[1]->keyword(), base::ASCIIToUTF16(":d"));
EXPECT_EQ(template_urls[2]->keyword(), base::ASCIIToUTF16(":q"));
EXPECT_EQ(template_urls[3]->keyword(), base::ASCIIToUTF16(":b"));
EXPECT_EQ(template_urls[4]->keyword(), base::ASCIIToUTF16(":sp"));
EXPECT_EQ(template_urls[5]->keyword(), base::ASCIIToUTF16(":ya"));
EXPECT_EQ(template_urls[6]->keyword(), base::ASCIIToUTF16("random1"));
EXPECT_EQ(template_urls[7]->keyword(), base::ASCIIToUTF16("random2"));

// Reset
template_urls.clear();
new_resource_keyword_version = 0;
TestDefaultOrder(template_urls, {":g", ":d", ":q", ":b", ":sp", ":ya",
"random1", "random2"});
}

TEST_F(BraveTemplateURLServiceUtilTest,
GetSearchProvidersUsingKeywordResultGermany) {
std::vector<TemplateURLData> local_turls = GetSampleTemplateData();
std::unique_ptr<TemplateURL> default_turl =
std::make_unique<TemplateURL>(local_turls.back());

// Germany specific query param
local_turls[4].prepopulate_id =
TemplateURLPrepopulateData::PREPOPULATED_ENGINE_ID_DUCKDUCKGO_DE;

// Prepare call arguments
WDResult<WDKeywordsResult> result(KEYWORDS_RESULT,
InitKeywordResult(&prefs_, local_turls));
TemplateURL::OwnedTemplateURLVector template_urls;
int new_resource_keyword_version = 0;

// Check Germany.
prefs_.SetInteger(kCountryIDAtInstall, 'D' << 8 | 'E');

GetSearchProvidersUsingKeywordResult(result, nullptr, &prefs_, &template_urls,
default_turl.get(), SearchTermsData(),
&new_resource_keyword_version, nullptr);

// Verify count.
// Verify count and order.
EXPECT_EQ(local_turls.size(), template_urls.size());
// Verify order.
EXPECT_EQ(template_urls[0]->keyword(), base::ASCIIToUTF16(":q"));
EXPECT_EQ(template_urls[1]->keyword(), base::ASCIIToUTF16(":g"));
EXPECT_EQ(template_urls[2]->keyword(), base::ASCIIToUTF16(":d"));
EXPECT_EQ(template_urls[3]->keyword(), base::ASCIIToUTF16(":b"));
EXPECT_EQ(template_urls[4]->keyword(), base::ASCIIToUTF16(":sp"));
EXPECT_EQ(template_urls[5]->keyword(), base::ASCIIToUTF16(":ya"));
EXPECT_EQ(template_urls[6]->keyword(), base::ASCIIToUTF16("random1"));
EXPECT_EQ(template_urls[7]->keyword(), base::ASCIIToUTF16("random2"));
TestDefaultOrder(template_urls, {":d", ":q", ":g", ":b", ":sp", ":ya"});
}
91 changes: 46 additions & 45 deletions chromium_src/components/search_engines/template_url_prepopulate_data.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -32,35 +32,23 @@ namespace TemplateURLPrepopulateData {

namespace {

// Maps Brave engine id to PrepopulatedEngine.
// Maps BravePrepopulatedEngineID to Chromium's PrepopulatedEngine.
const std::map<BravePrepopulatedEngineID, const PrepopulatedEngine*>
brave_engines_map = {
{PREPOPULATED_ENGINE_ID_GOOGLE, &google},
{PREPOPULATED_ENGINE_ID_BING, &bing},
{PREPOPULATED_ENGINE_ID_DUCKDUCKGO, &duckduckgo},
{PREPOPULATED_ENGINE_ID_DUCKDUCKGO_DE, &duckduckgo_de},
{PREPOPULATED_ENGINE_ID_DUCKDUCKGO_AU_NZ_IE, &duckduckgo_au_nz_ie},
#if defined(OS_ANDROID)
{PREPOPULATED_ENGINE_ID_DUCKDUCKGO_LITE, &duckduckgo_lite},
#endif
{PREPOPULATED_ENGINE_ID_QWANT, &qwant},
{PREPOPULATED_ENGINE_ID_STARTPAGE, &startpage},
};

// Engine ID to use as the default engine.
const BravePrepopulatedEngineID kDefaultEngineID =
PREPOPULATED_ENGINE_ID_GOOGLE;

// A map to keep track of default engines for countries that don't use the
// regular default engine.
const std::map<int, BravePrepopulatedEngineID>
default_engine_by_country_id_map = {
{country_codes::CountryCharsToCountryID('D', 'E'),
PREPOPULATED_ENGINE_ID_QWANT},
{country_codes::CountryCharsToCountryID('F', 'R'),
PREPOPULATED_ENGINE_ID_QWANT}
};

// Default order in which engines will appear in the UI.
const BravePrepopulatedEngineID brave_engines_default[] = {
std::vector<BravePrepopulatedEngineID> brave_engines_default = {
PREPOPULATED_ENGINE_ID_GOOGLE,
PREPOPULATED_ENGINE_ID_DUCKDUCKGO,
#if defined(OS_ANDROID)
Expand All @@ -71,20 +59,20 @@ const BravePrepopulatedEngineID brave_engines_default[] = {
PREPOPULATED_ENGINE_ID_STARTPAGE,
};

// Germany - Qwant appears on top.
const BravePrepopulatedEngineID brave_engines_DE[] = {
PREPOPULATED_ENGINE_ID_QWANT,
PREPOPULATED_ENGINE_ID_GOOGLE,
PREPOPULATED_ENGINE_ID_DUCKDUCKGO,
// Germany - DDG appears on top.
std::vector<BravePrepopulatedEngineID> brave_engines_DE = {
PREPOPULATED_ENGINE_ID_DUCKDUCKGO_DE,
#if defined(OS_ANDROID)
PREPOPULATED_ENGINE_ID_DUCKDUCKGO_LITE,
#endif
PREPOPULATED_ENGINE_ID_QWANT,
PREPOPULATED_ENGINE_ID_GOOGLE,
PREPOPULATED_ENGINE_ID_BING,
PREPOPULATED_ENGINE_ID_STARTPAGE,
};

// France - Qwant appears on top.
const BravePrepopulatedEngineID brave_engines_FR[] = {
std::vector<BravePrepopulatedEngineID> brave_engines_FR = {
PREPOPULATED_ENGINE_ID_QWANT,
PREPOPULATED_ENGINE_ID_GOOGLE,
PREPOPULATED_ENGINE_ID_DUCKDUCKGO,
Expand All @@ -95,19 +83,40 @@ const BravePrepopulatedEngineID brave_engines_FR[] = {
PREPOPULATED_ENGINE_ID_STARTPAGE,
};

// Australia / NZ / IE - DDG appears on top.
std::vector<BravePrepopulatedEngineID> brave_engines_AU_NZ_IE = {
PREPOPULATED_ENGINE_ID_DUCKDUCKGO_AU_NZ_IE,
#if defined(OS_ANDROID)
PREPOPULATED_ENGINE_ID_DUCKDUCKGO_LITE,
#endif
PREPOPULATED_ENGINE_ID_GOOGLE,
PREPOPULATED_ENGINE_ID_QWANT,
PREPOPULATED_ENGINE_ID_BING,
PREPOPULATED_ENGINE_ID_STARTPAGE};

// A map to keep track of default engines for countries that don't use the
// regular default engine.
const std::map<int, std::vector<BravePrepopulatedEngineID>>
default_engines_by_country_id_map = {
{country_codes::CountryCharsToCountryID('D', 'E'), brave_engines_DE},
{country_codes::CountryCharsToCountryID('F', 'R'), brave_engines_FR},
{country_codes::CountryCharsToCountryID('A', 'U'),
brave_engines_AU_NZ_IE},
{country_codes::CountryCharsToCountryID('N', 'Z'),
brave_engines_AU_NZ_IE},
{country_codes::CountryCharsToCountryID('I', 'E'),
brave_engines_AU_NZ_IE}};

// Builds a vector of PrepulatedEngine objects from the given array of
// |engine_ids|. Fills in the default engine index for the given |country_id|,
// if asked.
std::vector<const PrepopulatedEngine*> GetEnginesFromEngineIDs(
const BravePrepopulatedEngineID engine_ids[],
size_t num_ids,
const std::vector<BravePrepopulatedEngineID> engine_ids,
bsclifton marked this conversation as resolved.
Show resolved Hide resolved
int country_id,
BravePrepopulatedEngineID default_engine_id,
size_t* default_search_provider_index = nullptr) {
DCHECK(engine_ids);
DCHECK(num_ids);
std::vector<const PrepopulatedEngine*> engines;
for (size_t i = 0; i < num_ids; ++i) {
for (size_t i = 0; i < engine_ids.size(); ++i) {
const PrepopulatedEngine* engine = brave_engines_map.at(engine_ids[i]);
DCHECK(engine);
if (engine) {
Expand Down Expand Up @@ -140,34 +149,26 @@ std::vector<std::unique_ptr<TemplateURLData>>
GetBravePrepopulatedEnginesForCountryID(
int country_id,
size_t* default_search_provider_index = nullptr) {
const BravePrepopulatedEngineID* brave_engines;
size_t num_brave_engines;
std::vector<BravePrepopulatedEngineID> brave_engines;

// Check for exceptions from the default list of engines
if (country_codes::CountryCharsToCountryID('D', 'E') == country_id) {
brave_engines = brave_engines_DE;
num_brave_engines = base::size(brave_engines_DE);
} else if (country_codes::CountryCharsToCountryID('F', 'R') == country_id) {
brave_engines = brave_engines_FR;
num_brave_engines = base::size(brave_engines_FR);
const auto& it = default_engines_by_country_id_map.find(country_id);
if (it != default_engines_by_country_id_map.end()) {
brave_engines = it->second;
} else {
brave_engines = brave_engines_default;
num_brave_engines = base::size(brave_engines_default);
}
DCHECK(brave_engines);
DCHECK(num_brave_engines);
DCHECK_GT(brave_engines.size(), 0);

// Check for an exception to the default engine
BravePrepopulatedEngineID default_id = kDefaultEngineID;
const auto& it = default_engine_by_country_id_map.find(country_id);
if (it != default_engine_by_country_id_map.end())
default_id = it->second;
// Default engine is the first in the list
BravePrepopulatedEngineID default_id = brave_engines.front();

// Build a vector PrepopulatedEngines from BravePrepopulatedEngineIDs and
// also get the default engine index
std::vector<const PrepopulatedEngine*> engines =
GetEnginesFromEngineIDs(brave_engines, num_brave_engines, country_id,
GetEnginesFromEngineIDs(brave_engines, country_id,
default_id, default_search_provider_index);
DCHECK(engines.size() == num_brave_engines);
DCHECK(engines.size() == brave_engines.size());

std::vector<std::unique_ptr<TemplateURLData>> t_urls;
for (const PrepopulatedEngine* engine : engines) {
Expand Down
Loading