OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "components/search_engines/template_url_service.h" | 5 #include "components/search_engines/template_url_service.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <memory> | 9 #include <memory> |
10 #include <utility> | 10 #include <utility> |
(...skipping 23 matching lines...) Expand all Loading... |
34 #include "components/search_engines/template_url_prepopulate_data.h" | 34 #include "components/search_engines/template_url_prepopulate_data.h" |
35 #include "content/public/test/test_browser_thread_bundle.h" | 35 #include "content/public/test/test_browser_thread_bundle.h" |
36 #include "testing/gtest/include/gtest/gtest.h" | 36 #include "testing/gtest/include/gtest/gtest.h" |
37 | 37 |
38 using base::ASCIIToUTF16; | 38 using base::ASCIIToUTF16; |
39 using base::Time; | 39 using base::Time; |
40 using base::TimeDelta; | 40 using base::TimeDelta; |
41 | 41 |
42 namespace { | 42 namespace { |
43 | 43 |
| 44 // A prepopulated ID to set for engines we want to show in the default list. |
| 45 // This must simply be greater than 0. |
| 46 static constexpr int kPrepopulatedId = 999999; |
| 47 |
44 // QueryHistoryCallbackImpl --------------------------------------------------- | 48 // QueryHistoryCallbackImpl --------------------------------------------------- |
45 | 49 |
46 struct QueryHistoryCallbackImpl { | 50 struct QueryHistoryCallbackImpl { |
47 QueryHistoryCallbackImpl() : success(false) {} | 51 QueryHistoryCallbackImpl() : success(false) {} |
48 | 52 |
49 void Callback(bool success, | 53 void Callback(bool success, |
50 const history::URLRow& row, | 54 const history::URLRow& row, |
51 const history::VisitVector& visits) { | 55 const history::VisitVector& visits) { |
52 this->success = success; | 56 this->success = success; |
53 if (success) { | 57 if (success) { |
(...skipping 67 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
121 EXPECT_EQ(expected->url(), actual->url()); | 125 EXPECT_EQ(expected->url(), actual->url()); |
122 EXPECT_EQ(expected->suggestions_url(), actual->suggestions_url()); | 126 EXPECT_EQ(expected->suggestions_url(), actual->suggestions_url()); |
123 EXPECT_EQ(expected->favicon_url(), actual->favicon_url()); | 127 EXPECT_EQ(expected->favicon_url(), actual->favicon_url()); |
124 EXPECT_EQ(expected->alternate_urls(), actual->alternate_urls()); | 128 EXPECT_EQ(expected->alternate_urls(), actual->alternate_urls()); |
125 EXPECT_EQ(expected->safe_for_autoreplace(), actual->safe_for_autoreplace()); | 129 EXPECT_EQ(expected->safe_for_autoreplace(), actual->safe_for_autoreplace()); |
126 EXPECT_EQ(expected->input_encodings(), actual->input_encodings()); | 130 EXPECT_EQ(expected->input_encodings(), actual->input_encodings()); |
127 EXPECT_EQ(expected->search_terms_replacement_key(), | 131 EXPECT_EQ(expected->search_terms_replacement_key(), |
128 actual->search_terms_replacement_key()); | 132 actual->search_terms_replacement_key()); |
129 } | 133 } |
130 | 134 |
| 135 std::unique_ptr<TemplateURLData> CreateTestSearchEngine() { |
| 136 auto result = base::MakeUnique<TemplateURLData>(); |
| 137 result->SetShortName(ASCIIToUTF16("test1")); |
| 138 result->SetKeyword(ASCIIToUTF16("test.com")); |
| 139 result->SetURL("http://test.com/search?t={searchTerms}"); |
| 140 result->favicon_url = GURL("http://test.com/icon.jpg"); |
| 141 result->prepopulate_id = kPrepopulatedId; |
| 142 result->input_encodings = {"UTF-16", "UTF-32"}; |
| 143 result->alternate_urls = {"http://test.com/search#t={searchTerms}"}; |
| 144 result->search_terms_replacement_key = "espv"; |
| 145 return result; |
| 146 } |
| 147 |
131 } // namespace | 148 } // namespace |
132 | 149 |
133 | 150 |
134 // TemplateURLServiceTest ----------------------------------------------------- | 151 // TemplateURLServiceTest ----------------------------------------------------- |
135 | 152 |
136 class TemplateURLServiceTest : public testing::Test { | 153 class TemplateURLServiceTest : public testing::Test { |
137 public: | 154 public: |
138 TemplateURLServiceTest(); | 155 TemplateURLServiceTest(); |
139 | 156 |
140 // A prepopulated ID to set for engines we want to show in the default list. | |
141 // This must simply be greater than 0. | |
142 static constexpr int kPrepopulatedId = 999999; | |
143 | |
144 // testing::Test: | 157 // testing::Test: |
145 void SetUp() override; | 158 void SetUp() override; |
146 void TearDown() override; | 159 void TearDown() override; |
147 | 160 |
148 TemplateURL* AddKeywordWithDate(const std::string& short_name, | 161 TemplateURL* AddKeywordWithDate(const std::string& short_name, |
149 const std::string& keyword, | 162 const std::string& keyword, |
150 const std::string& url, | 163 const std::string& url, |
151 const std::string& suggest_url, | 164 const std::string& suggest_url, |
152 const std::string& alternate_url, | 165 const std::string& alternate_url, |
153 const std::string& favicon_url, | 166 const std::string& favicon_url, |
(...skipping 688 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
842 ASSERT_TRUE(bing); | 855 ASSERT_TRUE(bing); |
843 EXPECT_EQ(TemplateURL::NORMAL, bing->type()); | 856 EXPECT_EQ(TemplateURL::NORMAL, bing->type()); |
844 | 857 |
845 // User search engine is preserved. | 858 // User search engine is preserved. |
846 EXPECT_EQ(user_dse, model()->GetTemplateURLForHost("www.goo.com")); | 859 EXPECT_EQ(user_dse, model()->GetTemplateURLForHost("www.goo.com")); |
847 EXPECT_EQ(ASCIIToUTF16("google.com"), user_dse->keyword()); | 860 EXPECT_EQ(ASCIIToUTF16("google.com"), user_dse->keyword()); |
848 } | 861 } |
849 | 862 |
850 TEST_F(TemplateURLServiceTest, RepairSearchEnginesWithManagedDefault) { | 863 TEST_F(TemplateURLServiceTest, RepairSearchEnginesWithManagedDefault) { |
851 // Set a managed preference that establishes a default search provider. | 864 // Set a managed preference that establishes a default search provider. |
852 const char kName[] = "test1"; | 865 std::unique_ptr<TemplateURLData> managed = CreateTestSearchEngine(); |
853 const char kKeyword[] = "test.com"; | 866 SetManagedDefaultSearchPreferences(*managed, true, test_util()->profile()); |
854 const char kSearchURL[] = "http://test.com/search?t={searchTerms}"; | |
855 const char kIconURL[] = "http://test.com/icon.jpg"; | |
856 const char kEncodings[] = "UTF-16;UTF-32"; | |
857 const char kAlternateURL[] = "http://test.com/search#t={searchTerms}"; | |
858 const char kSearchTermsReplacementKey[] = "espv"; | |
859 test_util()->SetManagedDefaultSearchPreferences(true, kName, kKeyword, | |
860 kSearchURL, std::string(), | |
861 kIconURL, kEncodings, | |
862 kAlternateURL, | |
863 kSearchTermsReplacementKey); | |
864 test_util()->VerifyLoad(); | 867 test_util()->VerifyLoad(); |
| 868 |
865 // Verify that the default manager we are getting is the managed one. | 869 // Verify that the default manager we are getting is the managed one. |
866 TemplateURLData data; | 870 auto expected_managed_default = base::MakeUnique<TemplateURL>(*managed); |
867 data.SetShortName(ASCIIToUTF16(kName)); | |
868 data.SetKeyword(ASCIIToUTF16(kKeyword)); | |
869 data.SetURL(kSearchURL); | |
870 data.favicon_url = GURL(kIconURL); | |
871 data.prepopulate_id = kPrepopulatedId; | |
872 data.input_encodings = base::SplitString( | |
873 kEncodings, ";", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL); | |
874 data.alternate_urls.push_back(kAlternateURL); | |
875 data.search_terms_replacement_key = kSearchTermsReplacementKey; | |
876 std::unique_ptr<TemplateURL> expected_managed_default(new TemplateURL(data)); | |
877 EXPECT_TRUE(model()->is_default_search_managed()); | 871 EXPECT_TRUE(model()->is_default_search_managed()); |
878 const TemplateURL* actual_managed_default = | 872 const TemplateURL* actual_managed_default = |
879 model()->GetDefaultSearchProvider(); | 873 model()->GetDefaultSearchProvider(); |
880 ExpectSimilar(expected_managed_default.get(), actual_managed_default); | 874 ExpectSimilar(expected_managed_default.get(), actual_managed_default); |
881 | 875 |
882 // The following call has no effect on the managed search engine. | 876 // The following call has no effect on the managed search engine. |
883 model()->RepairPrepopulatedSearchEngines(); | 877 model()->RepairPrepopulatedSearchEngines(); |
884 | 878 |
885 EXPECT_TRUE(model()->is_default_search_managed()); | 879 EXPECT_TRUE(model()->is_default_search_managed()); |
886 actual_managed_default = model()->GetDefaultSearchProvider(); | 880 actual_managed_default = model()->GetDefaultSearchProvider(); |
(...skipping 336 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1223 std::string(), "http://icon1", true, "UTF-8;UTF-16", Time(), Time()); | 1217 std::string(), "http://icon1", true, "UTF-8;UTF-16", Time(), Time()); |
1224 VerifyObserverCount(1); | 1218 VerifyObserverCount(1); |
1225 model()->SetUserSelectedDefaultSearchProvider(regular_default); | 1219 model()->SetUserSelectedDefaultSearchProvider(regular_default); |
1226 // Adding the URL and setting the default search provider should have caused | 1220 // Adding the URL and setting the default search provider should have caused |
1227 // notifications. | 1221 // notifications. |
1228 VerifyObserverCount(1); | 1222 VerifyObserverCount(1); |
1229 EXPECT_FALSE(model()->is_default_search_managed()); | 1223 EXPECT_FALSE(model()->is_default_search_managed()); |
1230 EXPECT_EQ(initial_count + 1, model()->GetTemplateURLs().size()); | 1224 EXPECT_EQ(initial_count + 1, model()->GetTemplateURLs().size()); |
1231 | 1225 |
1232 // Set a managed preference that establishes a default search provider. | 1226 // Set a managed preference that establishes a default search provider. |
1233 const char kName[] = "test1"; | 1227 std::unique_ptr<TemplateURLData> managed = CreateTestSearchEngine(); |
1234 const char kKeyword[] = "test.com"; | 1228 SetManagedDefaultSearchPreferences(*managed, true, test_util()->profile()); |
1235 const char kSearchURL[] = "http://test.com/search?t={searchTerms}"; | |
1236 const char kIconURL[] = "http://test.com/icon.jpg"; | |
1237 const char kEncodings[] = "UTF-16;UTF-32"; | |
1238 const char kAlternateURL[] = "http://test.com/search#t={searchTerms}"; | |
1239 const char kSearchTermsReplacementKey[] = "espv"; | |
1240 test_util()->SetManagedDefaultSearchPreferences(true, kName, kKeyword, | |
1241 kSearchURL, std::string(), kIconURL, kEncodings, kAlternateURL, | |
1242 kSearchTermsReplacementKey); | |
1243 VerifyObserverFired(); | 1229 VerifyObserverFired(); |
1244 EXPECT_TRUE(model()->is_default_search_managed()); | 1230 EXPECT_TRUE(model()->is_default_search_managed()); |
1245 EXPECT_EQ(initial_count + 2, model()->GetTemplateURLs().size()); | 1231 EXPECT_EQ(initial_count + 2, model()->GetTemplateURLs().size()); |
1246 | 1232 |
1247 // Verify that the default manager we are getting is the managed one. | 1233 // Verify that the default manager we are getting is the managed one. |
1248 TemplateURLData data; | 1234 auto expected_managed_default1 = base::MakeUnique<TemplateURL>(*managed); |
1249 data.SetShortName(ASCIIToUTF16(kName)); | |
1250 data.SetKeyword(ASCIIToUTF16(kKeyword)); | |
1251 data.SetURL(kSearchURL); | |
1252 data.favicon_url = GURL(kIconURL); | |
1253 data.prepopulate_id = kPrepopulatedId; | |
1254 data.input_encodings = base::SplitString( | |
1255 kEncodings, ";", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL); | |
1256 data.alternate_urls.push_back(kAlternateURL); | |
1257 data.search_terms_replacement_key = kSearchTermsReplacementKey; | |
1258 std::unique_ptr<TemplateURL> expected_managed_default1(new TemplateURL(data)); | |
1259 const TemplateURL* actual_managed_default = | 1235 const TemplateURL* actual_managed_default = |
1260 model()->GetDefaultSearchProvider(); | 1236 model()->GetDefaultSearchProvider(); |
1261 ExpectSimilar(expected_managed_default1.get(), actual_managed_default); | 1237 ExpectSimilar(expected_managed_default1.get(), actual_managed_default); |
1262 EXPECT_TRUE(model()->ShowInDefaultList(actual_managed_default)); | 1238 EXPECT_TRUE(model()->ShowInDefaultList(actual_managed_default)); |
1263 | 1239 |
1264 // Update the managed preference and check that the model has changed. | 1240 // Update the managed preference and check that the model has changed. |
1265 const char kNewName[] = "test2"; | 1241 TemplateURLData managed2; |
1266 const char kNewKeyword[] = "other.com"; | 1242 managed2.SetShortName(ASCIIToUTF16("test2")); |
1267 const char kNewSearchURL[] = "http://other.com/search?t={searchTerms}"; | 1243 managed2.SetKeyword(ASCIIToUTF16("other.com")); |
1268 const char kNewSuggestURL[] = "http://other.com/suggest?t={searchTerms}"; | 1244 managed2.SetURL("http://other.com/search?t={searchTerms}"); |
1269 test_util()->SetManagedDefaultSearchPreferences(true, kNewName, kNewKeyword, | 1245 managed2.suggestions_url = "http://other.com/suggest?t={searchTerms}"; |
1270 kNewSearchURL, kNewSuggestURL, std::string(), std::string(), | 1246 SetManagedDefaultSearchPreferences(managed2, true, test_util()->profile()); |
1271 std::string(), std::string()); | |
1272 VerifyObserverFired(); | 1247 VerifyObserverFired(); |
1273 EXPECT_TRUE(model()->is_default_search_managed()); | 1248 EXPECT_TRUE(model()->is_default_search_managed()); |
1274 EXPECT_EQ(initial_count + 2, model()->GetTemplateURLs().size()); | 1249 EXPECT_EQ(initial_count + 2, model()->GetTemplateURLs().size()); |
1275 | 1250 |
1276 // Verify that the default manager we are now getting is the correct one. | 1251 // Verify that the default manager we are now getting is the correct one. |
1277 TemplateURLData data2; | 1252 auto expected_managed_default2 = base::MakeUnique<TemplateURL>(managed2); |
1278 data2.SetShortName(ASCIIToUTF16(kNewName)); | |
1279 data2.SetKeyword(ASCIIToUTF16(kNewKeyword)); | |
1280 data2.SetURL(kNewSearchURL); | |
1281 data2.suggestions_url = kNewSuggestURL; | |
1282 data2.prepopulate_id = kPrepopulatedId; | |
1283 std::unique_ptr<TemplateURL> expected_managed_default2( | |
1284 new TemplateURL(data2)); | |
1285 actual_managed_default = model()->GetDefaultSearchProvider(); | 1253 actual_managed_default = model()->GetDefaultSearchProvider(); |
1286 ExpectSimilar(expected_managed_default2.get(), actual_managed_default); | 1254 ExpectSimilar(expected_managed_default2.get(), actual_managed_default); |
1287 EXPECT_EQ(model()->ShowInDefaultList(actual_managed_default), true); | 1255 EXPECT_EQ(model()->ShowInDefaultList(actual_managed_default), true); |
1288 | 1256 |
1289 // Remove all the managed prefs and check that we are no longer managed. | 1257 // Remove all the managed prefs and check that we are no longer managed. |
1290 test_util()->RemoveManagedDefaultSearchPreferences(); | 1258 RemoveManagedDefaultSearchPreferences(test_util()->profile()); |
1291 VerifyObserverFired(); | 1259 VerifyObserverFired(); |
1292 EXPECT_FALSE(model()->is_default_search_managed()); | 1260 EXPECT_FALSE(model()->is_default_search_managed()); |
1293 EXPECT_EQ(initial_count + 1, model()->GetTemplateURLs().size()); | 1261 EXPECT_EQ(initial_count + 1, model()->GetTemplateURLs().size()); |
1294 | 1262 |
1295 // The default should now be the user preference. | 1263 // The default should now be the user preference. |
1296 const TemplateURL* actual_final_managed_default = | 1264 const TemplateURL* actual_final_managed_default = |
1297 model()->GetDefaultSearchProvider(); | 1265 model()->GetDefaultSearchProvider(); |
1298 ExpectSimilar(regular_default, actual_final_managed_default); | 1266 ExpectSimilar(regular_default, actual_final_managed_default); |
1299 EXPECT_EQ(model()->ShowInDefaultList(actual_final_managed_default), true); | 1267 EXPECT_EQ(model()->ShowInDefaultList(actual_final_managed_default), true); |
1300 | 1268 |
1301 // Disable the default search provider through policy. | 1269 // Disable the default search provider through policy. |
1302 test_util()->SetManagedDefaultSearchPreferences(false, std::string(), | 1270 SetManagedDefaultSearchPreferences(managed2, false, test_util()->profile()); |
1303 std::string(), std::string(), std::string(), std::string(), | |
1304 std::string(), std::string(), std::string()); | |
1305 VerifyObserverFired(); | 1271 VerifyObserverFired(); |
1306 EXPECT_TRUE(model()->is_default_search_managed()); | 1272 EXPECT_TRUE(model()->is_default_search_managed()); |
1307 EXPECT_TRUE(NULL == model()->GetDefaultSearchProvider()); | 1273 EXPECT_TRUE(NULL == model()->GetDefaultSearchProvider()); |
1308 EXPECT_EQ(initial_count + 1, model()->GetTemplateURLs().size()); | 1274 EXPECT_EQ(initial_count + 1, model()->GetTemplateURLs().size()); |
1309 | 1275 |
1310 // Re-enable it. | 1276 // Re-enable it. |
1311 test_util()->SetManagedDefaultSearchPreferences(true, kName, kKeyword, | 1277 SetManagedDefaultSearchPreferences(*managed, true, test_util()->profile()); |
1312 kSearchURL, std::string(), kIconURL, kEncodings, kAlternateURL, | |
1313 kSearchTermsReplacementKey); | |
1314 VerifyObserverFired(); | 1278 VerifyObserverFired(); |
1315 EXPECT_TRUE(model()->is_default_search_managed()); | 1279 EXPECT_TRUE(model()->is_default_search_managed()); |
1316 EXPECT_EQ(initial_count + 2, model()->GetTemplateURLs().size()); | 1280 EXPECT_EQ(initial_count + 2, model()->GetTemplateURLs().size()); |
1317 | 1281 |
1318 // Verify that the default manager we are getting is the managed one. | 1282 // Verify that the default manager we are getting is the managed one. |
1319 actual_managed_default = model()->GetDefaultSearchProvider(); | 1283 actual_managed_default = model()->GetDefaultSearchProvider(); |
1320 ExpectSimilar(expected_managed_default1.get(), actual_managed_default); | 1284 ExpectSimilar(expected_managed_default1.get(), actual_managed_default); |
1321 EXPECT_EQ(model()->ShowInDefaultList(actual_managed_default), true); | 1285 EXPECT_EQ(model()->ShowInDefaultList(actual_managed_default), true); |
1322 | 1286 |
1323 // Clear the model and disable the default search provider through policy. | 1287 // Clear the model and disable the default search provider through policy. |
1324 // Verify that there is no default search provider after loading the model. | 1288 // Verify that there is no default search provider after loading the model. |
1325 // This checks against regressions of http://crbug.com/67180 | 1289 // This checks against regressions of http://crbug.com/67180 |
1326 | 1290 |
1327 // First, remove the preferences, reset the model, and set a default. | 1291 // First, remove the preferences, reset the model, and set a default. |
1328 test_util()->RemoveManagedDefaultSearchPreferences(); | 1292 RemoveManagedDefaultSearchPreferences(test_util()->profile()); |
1329 test_util()->ResetModel(true); | 1293 test_util()->ResetModel(true); |
1330 TemplateURL* new_default = | 1294 TemplateURL* new_default = |
1331 model()->GetTemplateURLForKeyword(ASCIIToUTF16("key1")); | 1295 model()->GetTemplateURLForKeyword(ASCIIToUTF16("key1")); |
1332 ASSERT_FALSE(new_default == NULL); | 1296 ASSERT_FALSE(new_default == NULL); |
1333 model()->SetUserSelectedDefaultSearchProvider(new_default); | 1297 model()->SetUserSelectedDefaultSearchProvider(new_default); |
1334 EXPECT_EQ(new_default, model()->GetDefaultSearchProvider()); | 1298 EXPECT_EQ(new_default, model()->GetDefaultSearchProvider()); |
1335 | 1299 |
1336 // Now reset the model again but load it after setting the preferences. | 1300 // Now reset the model again but load it after setting the preferences. |
1337 test_util()->ResetModel(false); | 1301 test_util()->ResetModel(false); |
1338 test_util()->SetManagedDefaultSearchPreferences(false, std::string(), | 1302 SetManagedDefaultSearchPreferences(*managed, false, test_util()->profile()); |
1339 std::string(), std::string(), std::string(), std::string(), | |
1340 std::string(), std::string(), std::string()); | |
1341 test_util()->VerifyLoad(); | 1303 test_util()->VerifyLoad(); |
1342 EXPECT_TRUE(model()->is_default_search_managed()); | 1304 EXPECT_TRUE(model()->is_default_search_managed()); |
1343 EXPECT_TRUE(model()->GetDefaultSearchProvider() == NULL); | 1305 EXPECT_TRUE(model()->GetDefaultSearchProvider() == NULL); |
1344 } | 1306 } |
1345 | 1307 |
1346 // Test that if we load a TemplateURL with an empty GUID, the load process | 1308 // Test that if we load a TemplateURL with an empty GUID, the load process |
1347 // assigns it a newly generated GUID. | 1309 // assigns it a newly generated GUID. |
1348 TEST_F(TemplateURLServiceTest, PatchEmptySyncGUID) { | 1310 TEST_F(TemplateURLServiceTest, PatchEmptySyncGUID) { |
1349 // Add a new TemplateURL. | 1311 // Add a new TemplateURL. |
1350 test_util()->VerifyLoad(); | 1312 test_util()->VerifyLoad(); |
(...skipping 118 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1469 | 1431 |
1470 test_util()->ResetModel(true); | 1432 test_util()->ResetModel(true); |
1471 user_dse = model()->GetTemplateURLForKeyword(ASCIIToUTF16("user")); | 1433 user_dse = model()->GetTemplateURLForKeyword(ASCIIToUTF16("user")); |
1472 ExpectSimilar(user_dse, model()->GetDefaultSearchProvider()); | 1434 ExpectSimilar(user_dse, model()->GetDefaultSearchProvider()); |
1473 EXPECT_FALSE(model()->GetTemplateURLForKeyword(ASCIIToUTF16("ext1"))); | 1435 EXPECT_FALSE(model()->GetTemplateURLForKeyword(ASCIIToUTF16("ext1"))); |
1474 EXPECT_FALSE(model()->GetTemplateURLForKeyword(ASCIIToUTF16("ext2"))); | 1436 EXPECT_FALSE(model()->GetTemplateURLForKeyword(ASCIIToUTF16("ext2"))); |
1475 } | 1437 } |
1476 | 1438 |
1477 TEST_F(TemplateURLServiceTest, ExtensionEngineVsPolicy) { | 1439 TEST_F(TemplateURLServiceTest, ExtensionEngineVsPolicy) { |
1478 // Set a managed preference that establishes a default search provider. | 1440 // Set a managed preference that establishes a default search provider. |
1479 const char kName[] = "test"; | 1441 std::unique_ptr<TemplateURLData> managed = CreateTestSearchEngine(); |
1480 const char kKeyword[] = "test.com"; | 1442 SetManagedDefaultSearchPreferences(*managed, true, test_util()->profile()); |
1481 const char kSearchURL[] = "http://test.com/search?t={searchTerms}"; | |
1482 const char kIconURL[] = "http://test.com/icon.jpg"; | |
1483 const char kEncodings[] = "UTF-16;UTF-32"; | |
1484 const char kAlternateURL[] = "http://test.com/search#t={searchTerms}"; | |
1485 const char kSearchTermsReplacementKey[] = "espv"; | |
1486 test_util()->SetManagedDefaultSearchPreferences( | |
1487 true, kName, kKeyword, kSearchURL, std::string(), kIconURL, kEncodings, | |
1488 kAlternateURL, kSearchTermsReplacementKey); | |
1489 test_util()->VerifyLoad(); | 1443 test_util()->VerifyLoad(); |
1490 // Verify that the default manager we are getting is the managed one. | 1444 // Verify that the default manager we are getting is the managed one. |
1491 TemplateURLData data; | 1445 auto expected_managed_default = base::MakeUnique<TemplateURL>(*managed); |
1492 data.SetShortName(ASCIIToUTF16(kName)); | |
1493 data.SetKeyword(ASCIIToUTF16(kKeyword)); | |
1494 data.SetURL(kSearchURL); | |
1495 data.favicon_url = GURL(kIconURL); | |
1496 data.input_encodings = base::SplitString( | |
1497 kEncodings, ";", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL); | |
1498 data.alternate_urls.push_back(kAlternateURL); | |
1499 data.search_terms_replacement_key = kSearchTermsReplacementKey; | |
1500 std::unique_ptr<TemplateURL> expected_managed_default(new TemplateURL(data)); | |
1501 EXPECT_TRUE(model()->is_default_search_managed()); | 1446 EXPECT_TRUE(model()->is_default_search_managed()); |
1502 const TemplateURL* actual_managed_default = | 1447 const TemplateURL* actual_managed_default = |
1503 model()->GetDefaultSearchProvider(); | 1448 model()->GetDefaultSearchProvider(); |
1504 ExpectSimilar(expected_managed_default.get(), actual_managed_default); | 1449 ExpectSimilar(expected_managed_default.get(), actual_managed_default); |
1505 | 1450 |
1506 std::unique_ptr<TemplateURL> ext_dse = CreateKeywordWithDate( | 1451 std::unique_ptr<TemplateURL> ext_dse = CreateKeywordWithDate( |
1507 model(), "ext1", "ext1", "http://www.ext1.com/s?q={searchTerms}", | 1452 model(), "ext1", "ext1", "http://www.ext1.com/s?q={searchTerms}", |
1508 std::string(), std::string(), std::string(), true, kPrepopulatedId, | 1453 std::string(), std::string(), std::string(), true, kPrepopulatedId, |
1509 "UTF-8", Time(), Time(), TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION); | 1454 "UTF-8", Time(), Time(), TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION); |
1510 std::unique_ptr<TemplateURL::AssociatedExtensionInfo> extension_info( | 1455 auto extension_info = |
1511 new TemplateURL::AssociatedExtensionInfo("ext1")); | 1456 base::MakeUnique<TemplateURL::AssociatedExtensionInfo>("ext1"); |
1512 extension_info->wants_to_be_default_engine = true; | 1457 extension_info->wants_to_be_default_engine = true; |
1513 TemplateURL* ext_dse_ptr = model()->AddExtensionControlledTURL( | 1458 TemplateURL* ext_dse_ptr = model()->AddExtensionControlledTURL( |
1514 std::move(ext_dse), std::move(extension_info)); | 1459 std::move(ext_dse), std::move(extension_info)); |
1515 EXPECT_EQ(ext_dse_ptr, | 1460 EXPECT_EQ(ext_dse_ptr, |
1516 model()->GetTemplateURLForKeyword(ASCIIToUTF16("ext1"))); | 1461 model()->GetTemplateURLForKeyword(ASCIIToUTF16("ext1"))); |
1517 EXPECT_TRUE(model()->is_default_search_managed()); | 1462 EXPECT_TRUE(model()->is_default_search_managed()); |
1518 actual_managed_default = model()->GetDefaultSearchProvider(); | 1463 actual_managed_default = model()->GetDefaultSearchProvider(); |
1519 ExpectSimilar(expected_managed_default.get(), actual_managed_default); | 1464 ExpectSimilar(expected_managed_default.get(), actual_managed_default); |
1520 } | 1465 } |
OLD | NEW |