Skip to content

Commit

Permalink
Update search engine defaults for DE / AU / NZ / IE
Browse files Browse the repository at this point in the history 
Fixes brave/brave-browser#6187
  • Loading branch information
@bsclifton
bsclifton committed Oct 3, 2019
1 parent d17efcf commit 60e3672
Show file tree
Hide file tree
Showing 5 changed files with 202 additions and 95 deletions.
60 changes: 48 additions & 12 deletions chromium_src/components/search_engines/brave_template_url_prepopulate_data_unittest.cc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -139,28 +139,64 @@ TEST_F(BraveTemplateURLPrepopulateDataTest, ProvidersFromPrepopulated) {
}

// Verifies default search provider for locale
TEST_F(BraveTemplateURLPrepopulateDataTest, DefaultSearchProvidersForLocale) {
// Use United States.
TEST_F(BraveTemplateURLPrepopulateDataTest, DefaultSearchProvidersForUSA) {
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());
}

t_urls.clear();

// Use Germany.
TEST_F(BraveTemplateURLPrepopulateDataTest, DefaultSearchProvidersForGermany) {
prefs_.SetInteger(kCountryIDAtInstall, 'D' << 8 | 'E');
t_urls = TemplateURLPrepopulateData::GetPrepopulatedEngines(&prefs_,
&default_index);
EXPECT_EQ(ASCIIToUTF16("Qwant"), t_urls[default_index]->short_name());
size_t default_index;

t_urls.clear();
std::vector<std::unique_ptr<TemplateURLData>> t_urls =
TemplateURLPrepopulateData::GetPrepopulatedEngines(&prefs_,
&default_index);
EXPECT_EQ(ASCIIToUTF16("DuckDuckGo"), t_urls[default_index]->short_name());
}

// Use France.
TEST_F(BraveTemplateURLPrepopulateDataTest, DefaultSearchProvidersForFrance) {
prefs_.SetInteger(kCountryIDAtInstall, 'F' << 8 | 'R');
t_urls = TemplateURLPrepopulateData::GetPrepopulatedEngines(&prefs_,
&default_index);
size_t default_index;

std::vector<std::unique_ptr<TemplateURLData>> t_urls =
TemplateURLPrepopulateData::GetPrepopulatedEngines(&prefs_,
&default_index);
EXPECT_EQ(ASCIIToUTF16("Qwant"), t_urls[default_index]->short_name());
}

TEST_F(BraveTemplateURLPrepopulateDataTest,
DefaultSearchProvidersForAustralia) {
prefs_.SetInteger(kCountryIDAtInstall, 'A' << 8 | 'U');
size_t default_index;

std::vector<std::unique_ptr<TemplateURLData>> t_urls =
TemplateURLPrepopulateData::GetPrepopulatedEngines(&prefs_,
&default_index);
EXPECT_EQ(ASCIIToUTF16("DuckDuckGo"), t_urls[default_index]->short_name());
}

TEST_F(BraveTemplateURLPrepopulateDataTest,
DefaultSearchProvidersForNewZealand) {
prefs_.SetInteger(kCountryIDAtInstall, 'N' << 8 | 'Z');
size_t default_index;

std::vector<std::unique_ptr<TemplateURLData>> t_urls =
TemplateURLPrepopulateData::GetPrepopulatedEngines(&prefs_,
&default_index);
EXPECT_EQ(ASCIIToUTF16("DuckDuckGo"), t_urls[default_index]->short_name());
}

TEST_F(BraveTemplateURLPrepopulateDataTest,
DefaultSearchProvidersForIreland) {
prefs_.SetInteger(kCountryIDAtInstall, 'I' << 8 | 'E');
size_t default_index;

std::vector<std::unique_ptr<TemplateURLData>> t_urls =
TemplateURLPrepopulateData::GetPrepopulatedEngines(&prefs_,
&default_index);
EXPECT_EQ(ASCIIToUTF16("DuckDuckGo"), t_urls[default_index]->short_name());
}
100 changes: 63 additions & 37 deletions chromium_src/components/search_engines/brave_template_url_service_util_unittest.cc
View file
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(TemplateURL::OwnedTemplateURLVector& template_urls,
std::vector<std::string> keywords) {
EXPECT_EQ(template_urls.size(), keywords.size());

for (int i = 0; i < (int)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 GetKeywordResult(
sync_preferences::TestingPrefServiceSyncable* prefs,
std::vector<TemplateURLData> local_turls) {
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,
GetKeywordResult(&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,
GetKeywordResult(&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
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,
std::vector<BravePrepopulatedEngineID> engine_ids,
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

0 comments on commit 60e3672

Please sign in to comment.