Skip to content

Commit

Permalink
Merge pull request #3626 from brave/search-default-0.71.x
Browse files Browse the repository at this point in the history 
Update search engine defaults for DE / AU / NZ / IE (uplift to 0.71.x)
  • Loading branch information
@bsclifton
bsclifton authored Oct 8, 2019
2 parents 1c908fa + 684560a commit 3f58d27
Show file tree
Hide file tree
Showing 5 changed files with 182 additions and 103 deletions.
50 changes: 30 additions & 20 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 @@ -63,6 +63,15 @@ class BraveTemplateURLPrepopulateDataTest : public testing::Test {
TemplateURLPrepopulateData::RegisterProfilePrefs(prefs_.registry());
}

void CheckForCountry(char digit1, char digit2, const std::string& expected) {
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,
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
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,
const std::vector<std::string>& keywords) {
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,
const 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,
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"});
}
89 changes: 44 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,75 +32,82 @@ 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},
{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,
PREPOPULATED_ENGINE_ID_QWANT,
PREPOPULATED_ENGINE_ID_BING,
PREPOPULATED_ENGINE_ID_STARTPAGE,
};

// Germany - Qwant appears on top.
const BravePrepopulatedEngineID brave_engines_DE[] = {
// Germany - DDG appears on top.
std::vector<BravePrepopulatedEngineID> brave_engines_DE = {
PREPOPULATED_ENGINE_ID_DUCKDUCKGO_DE,
PREPOPULATED_ENGINE_ID_QWANT,
PREPOPULATED_ENGINE_ID_GOOGLE,
PREPOPULATED_ENGINE_ID_DUCKDUCKGO,
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,
PREPOPULATED_ENGINE_ID_BING,
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,
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,
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) {
const PrepopulatedEngine* engine = brave_engines_map.at(engine_ids[i]);
for (size_t i = 0; i < engine_ids.size(); ++i) {
const PrepopulatedEngine* engine = brave_engines_map.at(engine_ids.at(i));
DCHECK(engine);
if (engine) {
engines.push_back(engine);
if (default_search_provider_index && default_engine_id == engine_ids[i])
if (default_search_provider_index &&
default_engine_id == engine_ids.at(i))
*default_search_provider_index = i;
}
}
Expand Down Expand Up @@ -128,34 +135,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 3f58d27

Please sign in to comment.