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 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
63 | 63 |
64 std::unique_ptr<TemplateURL> CreateKeywordWithDate( | 64 std::unique_ptr<TemplateURL> CreateKeywordWithDate( |
65 TemplateURLService* model, | 65 TemplateURLService* model, |
66 const std::string& short_name, | 66 const std::string& short_name, |
67 const std::string& keyword, | 67 const std::string& keyword, |
68 const std::string& url, | 68 const std::string& url, |
69 const std::string& suggest_url, | 69 const std::string& suggest_url, |
70 const std::string& alternate_url, | 70 const std::string& alternate_url, |
71 const std::string& favicon_url, | 71 const std::string& favicon_url, |
72 bool safe_for_autoreplace, | 72 bool safe_for_autoreplace, |
73 bool show_in_default_list, | 73 int prepopulate_id, |
74 const std::string& encodings, | 74 const std::string& encodings, |
75 Time date_created, | 75 Time date_created, |
76 Time last_modified, | 76 Time last_modified, |
77 TemplateURL::Type type = TemplateURL::NORMAL) { | 77 TemplateURL::Type type = TemplateURL::NORMAL) { |
78 TemplateURLData data; | 78 TemplateURLData data; |
79 data.SetShortName(base::UTF8ToUTF16(short_name)); | 79 data.SetShortName(base::UTF8ToUTF16(short_name)); |
80 data.SetKeyword(base::UTF8ToUTF16(keyword)); | 80 data.SetKeyword(base::UTF8ToUTF16(keyword)); |
81 data.SetURL(url); | 81 data.SetURL(url); |
82 data.suggestions_url = suggest_url; | 82 data.suggestions_url = suggest_url; |
83 if (!alternate_url.empty()) | 83 if (!alternate_url.empty()) |
84 data.alternate_urls.push_back(alternate_url); | 84 data.alternate_urls.push_back(alternate_url); |
85 data.favicon_url = GURL(favicon_url); | 85 data.favicon_url = GURL(favicon_url); |
86 data.safe_for_autoreplace = safe_for_autoreplace; | 86 data.safe_for_autoreplace = safe_for_autoreplace; |
87 data.show_in_default_list = show_in_default_list; | 87 data.prepopulate_id = prepopulate_id; |
88 data.input_encodings = base::SplitString( | 88 data.input_encodings = base::SplitString( |
89 encodings, ";", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL); | 89 encodings, ";", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL); |
90 data.date_created = date_created; | 90 data.date_created = date_created; |
91 data.last_modified = last_modified; | 91 data.last_modified = last_modified; |
92 return base::MakeUnique<TemplateURL>(data, type); | 92 return base::MakeUnique<TemplateURL>(data, type); |
93 } | 93 } |
94 | 94 |
95 TemplateURL* AddKeywordWithDate( | 95 TemplateURL* AddKeywordWithDate( |
96 TemplateURLService* model, | 96 TemplateURLService* model, |
97 const std::string& short_name, | 97 const std::string& short_name, |
98 const std::string& keyword, | 98 const std::string& keyword, |
99 const std::string& url, | 99 const std::string& url, |
100 const std::string& suggest_url, | 100 const std::string& suggest_url, |
101 const std::string& alternate_url, | 101 const std::string& alternate_url, |
102 const std::string& favicon_url, | 102 const std::string& favicon_url, |
103 bool safe_for_autoreplace, | 103 bool safe_for_autoreplace, |
104 const std::string& encodings, | 104 const std::string& encodings, |
105 Time date_created, | 105 Time date_created, |
106 Time last_modified) { | 106 Time last_modified) { |
107 TemplateURL* t_url = model->Add(CreateKeywordWithDate( | 107 TemplateURL* t_url = model->Add(CreateKeywordWithDate( |
108 model, short_name, keyword, url, suggest_url, alternate_url, favicon_url, | 108 model, short_name, keyword, url, suggest_url, alternate_url, favicon_url, |
109 safe_for_autoreplace, false, encodings, date_created, last_modified)); | 109 safe_for_autoreplace, 0, encodings, date_created, last_modified)); |
110 EXPECT_NE(0, t_url->id()); | 110 EXPECT_NE(0, t_url->id()); |
111 return t_url; | 111 return t_url; |
112 } | 112 } |
113 | 113 |
114 // Checks that the two TemplateURLs are similar. It does not check the id, the | 114 // Checks that the two TemplateURLs are similar. It does not check the id, the |
115 // date_created or the last_modified time. Neither pointer should be NULL. | 115 // date_created or the last_modified time. Neither pointer should be NULL. |
116 void ExpectSimilar(const TemplateURL* expected, const TemplateURL* actual) { | 116 void ExpectSimilar(const TemplateURL* expected, const TemplateURL* actual) { |
117 ASSERT_TRUE(expected != NULL); | 117 ASSERT_TRUE(expected != NULL); |
118 ASSERT_TRUE(actual != NULL); | 118 ASSERT_TRUE(actual != NULL); |
119 EXPECT_EQ(expected->short_name(), actual->short_name()); | 119 EXPECT_EQ(expected->short_name(), actual->short_name()); |
120 EXPECT_EQ(expected->keyword(), actual->keyword()); | 120 EXPECT_EQ(expected->keyword(), actual->keyword()); |
121 EXPECT_EQ(expected->url(), actual->url()); | 121 EXPECT_EQ(expected->url(), actual->url()); |
122 EXPECT_EQ(expected->suggestions_url(), actual->suggestions_url()); | 122 EXPECT_EQ(expected->suggestions_url(), actual->suggestions_url()); |
123 EXPECT_EQ(expected->favicon_url(), actual->favicon_url()); | 123 EXPECT_EQ(expected->favicon_url(), actual->favicon_url()); |
124 EXPECT_EQ(expected->alternate_urls(), actual->alternate_urls()); | 124 EXPECT_EQ(expected->alternate_urls(), actual->alternate_urls()); |
125 EXPECT_EQ(expected->show_in_default_list(), actual->show_in_default_list()); | |
126 EXPECT_EQ(expected->safe_for_autoreplace(), actual->safe_for_autoreplace()); | 125 EXPECT_EQ(expected->safe_for_autoreplace(), actual->safe_for_autoreplace()); |
127 EXPECT_EQ(expected->input_encodings(), actual->input_encodings()); | 126 EXPECT_EQ(expected->input_encodings(), actual->input_encodings()); |
128 EXPECT_EQ(expected->search_terms_replacement_key(), | 127 EXPECT_EQ(expected->search_terms_replacement_key(), |
129 actual->search_terms_replacement_key()); | 128 actual->search_terms_replacement_key()); |
130 } | 129 } |
131 | 130 |
132 } // namespace | 131 } // namespace |
133 | 132 |
134 | 133 |
135 // TemplateURLServiceTest ----------------------------------------------------- | 134 // TemplateURLServiceTest ----------------------------------------------------- |
(...skipping 90 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
226 } | 225 } |
227 | 226 |
228 void TemplateURLServiceTest::AssertEquals(const TemplateURL& expected, | 227 void TemplateURLServiceTest::AssertEquals(const TemplateURL& expected, |
229 const TemplateURL& actual) { | 228 const TemplateURL& actual) { |
230 ASSERT_EQ(expected.short_name(), actual.short_name()); | 229 ASSERT_EQ(expected.short_name(), actual.short_name()); |
231 ASSERT_EQ(expected.keyword(), actual.keyword()); | 230 ASSERT_EQ(expected.keyword(), actual.keyword()); |
232 ASSERT_EQ(expected.url(), actual.url()); | 231 ASSERT_EQ(expected.url(), actual.url()); |
233 ASSERT_EQ(expected.suggestions_url(), actual.suggestions_url()); | 232 ASSERT_EQ(expected.suggestions_url(), actual.suggestions_url()); |
234 ASSERT_EQ(expected.favicon_url(), actual.favicon_url()); | 233 ASSERT_EQ(expected.favicon_url(), actual.favicon_url()); |
235 ASSERT_EQ(expected.alternate_urls(), actual.alternate_urls()); | 234 ASSERT_EQ(expected.alternate_urls(), actual.alternate_urls()); |
236 ASSERT_EQ(expected.show_in_default_list(), actual.show_in_default_list()); | 235 ASSERT_EQ(expected.prepopulate_id(), actual.prepopulate_id()); |
237 ASSERT_EQ(expected.safe_for_autoreplace(), actual.safe_for_autoreplace()); | 236 ASSERT_EQ(expected.safe_for_autoreplace(), actual.safe_for_autoreplace()); |
238 ASSERT_EQ(expected.input_encodings(), actual.input_encodings()); | 237 ASSERT_EQ(expected.input_encodings(), actual.input_encodings()); |
239 ASSERT_EQ(expected.id(), actual.id()); | 238 ASSERT_EQ(expected.id(), actual.id()); |
240 ASSERT_EQ(expected.date_created(), actual.date_created()); | 239 ASSERT_EQ(expected.date_created(), actual.date_created()); |
241 AssertTimesEqual(expected.last_modified(), actual.last_modified()); | 240 AssertTimesEqual(expected.last_modified(), actual.last_modified()); |
242 ASSERT_EQ(expected.sync_guid(), actual.sync_guid()); | 241 ASSERT_EQ(expected.sync_guid(), actual.sync_guid()); |
243 ASSERT_EQ(expected.search_terms_replacement_key(), | 242 ASSERT_EQ(expected.search_terms_replacement_key(), |
244 actual.search_terms_replacement_key()); | 243 actual.search_terms_replacement_key()); |
245 } | 244 } |
246 | 245 |
247 void TemplateURLServiceTest::AssertTimesEqual(const base::Time& expected, | 246 void TemplateURLServiceTest::AssertTimesEqual(const base::Time& expected, |
248 const base::Time& actual) { | 247 const base::Time& actual) { |
249 // Because times are stored with a granularity of one second, there is a loss | 248 // Because times are stored with a granularity of one second, there is a loss |
250 // of precision when serializing and deserializing the timestamps. Hence, only | 249 // of precision when serializing and deserializing the timestamps. Hence, only |
251 // expect timestamps to be equal to within one second of one another. | 250 // expect timestamps to be equal to within one second of one another. |
252 ASSERT_LT((expected - actual).magnitude(), base::TimeDelta::FromSeconds(1)); | 251 ASSERT_LT((expected - actual).magnitude(), base::TimeDelta::FromSeconds(1)); |
253 } | 252 } |
254 | 253 |
255 std::unique_ptr<TemplateURL> TemplateURLServiceTest::CreatePreloadedTemplateURL( | 254 std::unique_ptr<TemplateURL> TemplateURLServiceTest::CreatePreloadedTemplateURL( |
256 bool safe_for_autoreplace, | 255 bool safe_for_autoreplace, |
257 int prepopulate_id) { | 256 int prepopulate_id) { |
258 TemplateURLData data; | 257 TemplateURLData data; |
259 data.SetShortName(ASCIIToUTF16("unittest")); | 258 data.SetShortName(ASCIIToUTF16("unittest")); |
260 data.SetKeyword(ASCIIToUTF16("unittest")); | 259 data.SetKeyword(ASCIIToUTF16("unittest")); |
261 data.SetURL("http://www.unittest.com/{searchTerms}"); | 260 data.SetURL("http://www.unittest.com/{searchTerms}"); |
262 data.favicon_url = GURL("http://favicon.url"); | 261 data.favicon_url = GURL("http://favicon.url"); |
263 data.show_in_default_list = true; | |
264 data.safe_for_autoreplace = safe_for_autoreplace; | 262 data.safe_for_autoreplace = safe_for_autoreplace; |
265 data.input_encodings.push_back("UTF-8"); | 263 data.input_encodings.push_back("UTF-8"); |
266 data.date_created = Time::FromTimeT(100); | 264 data.date_created = Time::FromTimeT(100); |
267 data.last_modified = Time::FromTimeT(100); | 265 data.last_modified = Time::FromTimeT(100); |
268 data.prepopulate_id = prepopulate_id; | 266 data.prepopulate_id = prepopulate_id; |
269 return base::MakeUnique<TemplateURL>(data); | 267 return base::MakeUnique<TemplateURL>(data); |
270 } | 268 } |
271 | 269 |
272 void TemplateURLServiceTest::VerifyObserverCount(int expected_changed_count) { | 270 void TemplateURLServiceTest::VerifyObserverCount(int expected_changed_count) { |
273 EXPECT_EQ(expected_changed_count, test_util_->GetObserverCount()); | 271 EXPECT_EQ(expected_changed_count, test_util_->GetObserverCount()); |
(...skipping 405 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
679 test_util()->VerifyLoad(); | 677 test_util()->VerifyLoad(); |
680 const size_t initial_count = model()->GetTemplateURLs().size(); | 678 const size_t initial_count = model()->GetTemplateURLs().size(); |
681 TemplateURL* t_url = AddKeywordWithDate( | 679 TemplateURL* t_url = AddKeywordWithDate( |
682 "name1", "key1", "http://foo1/{searchTerms}", "http://sugg1", | 680 "name1", "key1", "http://foo1/{searchTerms}", "http://sugg1", |
683 std::string(), "http://icon1", true, "UTF-8;UTF-16", Time(), Time()); | 681 std::string(), "http://icon1", true, "UTF-8;UTF-16", Time(), Time()); |
684 test_util()->ResetObserverCount(); | 682 test_util()->ResetObserverCount(); |
685 | 683 |
686 model()->SetUserSelectedDefaultSearchProvider(t_url); | 684 model()->SetUserSelectedDefaultSearchProvider(t_url); |
687 ASSERT_EQ(t_url, model()->GetDefaultSearchProvider()); | 685 ASSERT_EQ(t_url, model()->GetDefaultSearchProvider()); |
688 ASSERT_TRUE(t_url->safe_for_autoreplace()); | 686 ASSERT_TRUE(t_url->safe_for_autoreplace()); |
689 ASSERT_TRUE(t_url->show_in_default_list()); | 687 ASSERT_TRUE(model()->ShowInDefaultList(t_url)); |
690 | 688 |
691 // Setting the default search provider should have caused notification. | 689 // Setting the default search provider should have caused notification. |
692 VerifyObserverCount(1); | 690 VerifyObserverCount(1); |
693 base::RunLoop().RunUntilIdle(); | 691 base::RunLoop().RunUntilIdle(); |
694 | 692 |
695 std::unique_ptr<TemplateURL> cloned_url( | 693 std::unique_ptr<TemplateURL> cloned_url( |
696 base::MakeUnique<TemplateURL>(t_url->data())); | 694 base::MakeUnique<TemplateURL>(t_url->data())); |
697 | 695 |
698 // Make sure when we reload we get a default search provider. | 696 // Make sure when we reload we get a default search provider. |
699 test_util()->ResetModel(true); | 697 test_util()->ResetModel(true); |
(...skipping 159 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
859 kIconURL, kEncodings, | 857 kIconURL, kEncodings, |
860 kAlternateURL, | 858 kAlternateURL, |
861 kSearchTermsReplacementKey); | 859 kSearchTermsReplacementKey); |
862 test_util()->VerifyLoad(); | 860 test_util()->VerifyLoad(); |
863 // Verify that the default manager we are getting is the managed one. | 861 // Verify that the default manager we are getting is the managed one. |
864 TemplateURLData data; | 862 TemplateURLData data; |
865 data.SetShortName(ASCIIToUTF16(kName)); | 863 data.SetShortName(ASCIIToUTF16(kName)); |
866 data.SetKeyword(ASCIIToUTF16(kKeyword)); | 864 data.SetKeyword(ASCIIToUTF16(kKeyword)); |
867 data.SetURL(kSearchURL); | 865 data.SetURL(kSearchURL); |
868 data.favicon_url = GURL(kIconURL); | 866 data.favicon_url = GURL(kIconURL); |
869 data.show_in_default_list = true; | 867 data.prepopulate_id = 999999; |
Peter Kasting
2016/11/10 06:41:06
Nit: Define a constant for this somewhere (kPrepop
ltian
2016/11/11 03:52:13
kNotPrepopulatedId might not be necessary because
| |
870 data.input_encodings = base::SplitString( | 868 data.input_encodings = base::SplitString( |
871 kEncodings, ";", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL); | 869 kEncodings, ";", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL); |
872 data.alternate_urls.push_back(kAlternateURL); | 870 data.alternate_urls.push_back(kAlternateURL); |
873 data.search_terms_replacement_key = kSearchTermsReplacementKey; | 871 data.search_terms_replacement_key = kSearchTermsReplacementKey; |
874 std::unique_ptr<TemplateURL> expected_managed_default(new TemplateURL(data)); | 872 std::unique_ptr<TemplateURL> expected_managed_default(new TemplateURL(data)); |
875 EXPECT_TRUE(model()->is_default_search_managed()); | 873 EXPECT_TRUE(model()->is_default_search_managed()); |
876 const TemplateURL* actual_managed_default = | 874 const TemplateURL* actual_managed_default = |
877 model()->GetDefaultSearchProvider(); | 875 model()->GetDefaultSearchProvider(); |
878 ExpectSimilar(expected_managed_default.get(), actual_managed_default); | 876 ExpectSimilar(expected_managed_default.get(), actual_managed_default); |
879 | 877 |
(...skipping 359 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1239 VerifyObserverFired(); | 1237 VerifyObserverFired(); |
1240 EXPECT_TRUE(model()->is_default_search_managed()); | 1238 EXPECT_TRUE(model()->is_default_search_managed()); |
1241 EXPECT_EQ(initial_count + 2, model()->GetTemplateURLs().size()); | 1239 EXPECT_EQ(initial_count + 2, model()->GetTemplateURLs().size()); |
1242 | 1240 |
1243 // Verify that the default manager we are getting is the managed one. | 1241 // Verify that the default manager we are getting is the managed one. |
1244 TemplateURLData data; | 1242 TemplateURLData data; |
1245 data.SetShortName(ASCIIToUTF16(kName)); | 1243 data.SetShortName(ASCIIToUTF16(kName)); |
1246 data.SetKeyword(ASCIIToUTF16(kKeyword)); | 1244 data.SetKeyword(ASCIIToUTF16(kKeyword)); |
1247 data.SetURL(kSearchURL); | 1245 data.SetURL(kSearchURL); |
1248 data.favicon_url = GURL(kIconURL); | 1246 data.favicon_url = GURL(kIconURL); |
1249 data.show_in_default_list = true; | 1247 data.prepopulate_id = 999999; |
1250 data.input_encodings = base::SplitString( | 1248 data.input_encodings = base::SplitString( |
1251 kEncodings, ";", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL); | 1249 kEncodings, ";", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL); |
1252 data.alternate_urls.push_back(kAlternateURL); | 1250 data.alternate_urls.push_back(kAlternateURL); |
1253 data.search_terms_replacement_key = kSearchTermsReplacementKey; | 1251 data.search_terms_replacement_key = kSearchTermsReplacementKey; |
1254 std::unique_ptr<TemplateURL> expected_managed_default1(new TemplateURL(data)); | 1252 std::unique_ptr<TemplateURL> expected_managed_default1(new TemplateURL(data)); |
1255 const TemplateURL* actual_managed_default = | 1253 const TemplateURL* actual_managed_default = |
1256 model()->GetDefaultSearchProvider(); | 1254 model()->GetDefaultSearchProvider(); |
1257 ExpectSimilar(expected_managed_default1.get(), actual_managed_default); | 1255 ExpectSimilar(expected_managed_default1.get(), actual_managed_default); |
1258 EXPECT_TRUE(actual_managed_default->show_in_default_list()); | 1256 EXPECT_TRUE(model()->ShowInDefaultList(actual_managed_default)); |
1259 | 1257 |
1260 // Update the managed preference and check that the model has changed. | 1258 // Update the managed preference and check that the model has changed. |
1261 const char kNewName[] = "test2"; | 1259 const char kNewName[] = "test2"; |
1262 const char kNewKeyword[] = "other.com"; | 1260 const char kNewKeyword[] = "other.com"; |
1263 const char kNewSearchURL[] = "http://other.com/search?t={searchTerms}"; | 1261 const char kNewSearchURL[] = "http://other.com/search?t={searchTerms}"; |
1264 const char kNewSuggestURL[] = "http://other.com/suggest?t={searchTerms}"; | 1262 const char kNewSuggestURL[] = "http://other.com/suggest?t={searchTerms}"; |
1265 test_util()->SetManagedDefaultSearchPreferences(true, kNewName, kNewKeyword, | 1263 test_util()->SetManagedDefaultSearchPreferences(true, kNewName, kNewKeyword, |
1266 kNewSearchURL, kNewSuggestURL, std::string(), std::string(), | 1264 kNewSearchURL, kNewSuggestURL, std::string(), std::string(), |
1267 std::string(), std::string()); | 1265 std::string(), std::string()); |
1268 VerifyObserverFired(); | 1266 VerifyObserverFired(); |
1269 EXPECT_TRUE(model()->is_default_search_managed()); | 1267 EXPECT_TRUE(model()->is_default_search_managed()); |
1270 EXPECT_EQ(initial_count + 2, model()->GetTemplateURLs().size()); | 1268 EXPECT_EQ(initial_count + 2, model()->GetTemplateURLs().size()); |
1271 | 1269 |
1272 // Verify that the default manager we are now getting is the correct one. | 1270 // Verify that the default manager we are now getting is the correct one. |
1273 TemplateURLData data2; | 1271 TemplateURLData data2; |
1274 data2.SetShortName(ASCIIToUTF16(kNewName)); | 1272 data2.SetShortName(ASCIIToUTF16(kNewName)); |
1275 data2.SetKeyword(ASCIIToUTF16(kNewKeyword)); | 1273 data2.SetKeyword(ASCIIToUTF16(kNewKeyword)); |
1276 data2.SetURL(kNewSearchURL); | 1274 data2.SetURL(kNewSearchURL); |
1277 data2.suggestions_url = kNewSuggestURL; | 1275 data2.suggestions_url = kNewSuggestURL; |
1278 data2.show_in_default_list = true; | 1276 data2.prepopulate_id = 999999; |
1279 std::unique_ptr<TemplateURL> expected_managed_default2( | 1277 std::unique_ptr<TemplateURL> expected_managed_default2( |
1280 new TemplateURL(data2)); | 1278 new TemplateURL(data2)); |
1281 actual_managed_default = model()->GetDefaultSearchProvider(); | 1279 actual_managed_default = model()->GetDefaultSearchProvider(); |
1282 ExpectSimilar(expected_managed_default2.get(), actual_managed_default); | 1280 ExpectSimilar(expected_managed_default2.get(), actual_managed_default); |
1283 EXPECT_EQ(actual_managed_default->show_in_default_list(), true); | 1281 EXPECT_EQ(model()->ShowInDefaultList(actual_managed_default), true); |
1284 | 1282 |
1285 // Remove all the managed prefs and check that we are no longer managed. | 1283 // Remove all the managed prefs and check that we are no longer managed. |
1286 test_util()->RemoveManagedDefaultSearchPreferences(); | 1284 test_util()->RemoveManagedDefaultSearchPreferences(); |
1287 VerifyObserverFired(); | 1285 VerifyObserverFired(); |
1288 EXPECT_FALSE(model()->is_default_search_managed()); | 1286 EXPECT_FALSE(model()->is_default_search_managed()); |
1289 EXPECT_EQ(initial_count + 1, model()->GetTemplateURLs().size()); | 1287 EXPECT_EQ(initial_count + 1, model()->GetTemplateURLs().size()); |
1290 | 1288 |
1291 // The default should now be the user preference. | 1289 // The default should now be the user preference. |
1292 const TemplateURL* actual_final_managed_default = | 1290 const TemplateURL* actual_final_managed_default = |
1293 model()->GetDefaultSearchProvider(); | 1291 model()->GetDefaultSearchProvider(); |
1294 ExpectSimilar(regular_default, actual_final_managed_default); | 1292 ExpectSimilar(regular_default, actual_final_managed_default); |
1295 EXPECT_EQ(actual_final_managed_default->show_in_default_list(), true); | 1293 EXPECT_EQ(model()->ShowInDefaultList(actual_final_managed_default), true); |
1296 | 1294 |
1297 // Disable the default search provider through policy. | 1295 // Disable the default search provider through policy. |
1298 test_util()->SetManagedDefaultSearchPreferences(false, std::string(), | 1296 test_util()->SetManagedDefaultSearchPreferences(false, std::string(), |
1299 std::string(), std::string(), std::string(), std::string(), | 1297 std::string(), std::string(), std::string(), std::string(), |
1300 std::string(), std::string(), std::string()); | 1298 std::string(), std::string(), std::string()); |
1301 VerifyObserverFired(); | 1299 VerifyObserverFired(); |
1302 EXPECT_TRUE(model()->is_default_search_managed()); | 1300 EXPECT_TRUE(model()->is_default_search_managed()); |
1303 EXPECT_TRUE(NULL == model()->GetDefaultSearchProvider()); | 1301 EXPECT_TRUE(NULL == model()->GetDefaultSearchProvider()); |
1304 EXPECT_EQ(initial_count + 1, model()->GetTemplateURLs().size()); | 1302 EXPECT_EQ(initial_count + 1, model()->GetTemplateURLs().size()); |
1305 | 1303 |
1306 // Re-enable it. | 1304 // Re-enable it. |
1307 test_util()->SetManagedDefaultSearchPreferences(true, kName, kKeyword, | 1305 test_util()->SetManagedDefaultSearchPreferences(true, kName, kKeyword, |
1308 kSearchURL, std::string(), kIconURL, kEncodings, kAlternateURL, | 1306 kSearchURL, std::string(), kIconURL, kEncodings, kAlternateURL, |
1309 kSearchTermsReplacementKey); | 1307 kSearchTermsReplacementKey); |
1310 VerifyObserverFired(); | 1308 VerifyObserverFired(); |
1311 EXPECT_TRUE(model()->is_default_search_managed()); | 1309 EXPECT_TRUE(model()->is_default_search_managed()); |
1312 EXPECT_EQ(initial_count + 2, model()->GetTemplateURLs().size()); | 1310 EXPECT_EQ(initial_count + 2, model()->GetTemplateURLs().size()); |
1313 | 1311 |
1314 // Verify that the default manager we are getting is the managed one. | 1312 // Verify that the default manager we are getting is the managed one. |
1315 actual_managed_default = model()->GetDefaultSearchProvider(); | 1313 actual_managed_default = model()->GetDefaultSearchProvider(); |
1316 ExpectSimilar(expected_managed_default1.get(), actual_managed_default); | 1314 ExpectSimilar(expected_managed_default1.get(), actual_managed_default); |
1317 EXPECT_EQ(actual_managed_default->show_in_default_list(), true); | 1315 EXPECT_EQ(model()->ShowInDefaultList(actual_managed_default), true); |
1318 | 1316 |
1319 // Clear the model and disable the default search provider through policy. | 1317 // Clear the model and disable the default search provider through policy. |
1320 // Verify that there is no default search provider after loading the model. | 1318 // Verify that there is no default search provider after loading the model. |
1321 // This checks against regressions of http://crbug.com/67180 | 1319 // This checks against regressions of http://crbug.com/67180 |
1322 | 1320 |
1323 // First, remove the preferences, reset the model, and set a default. | 1321 // First, remove the preferences, reset the model, and set a default. |
1324 test_util()->RemoveManagedDefaultSearchPreferences(); | 1322 test_util()->RemoveManagedDefaultSearchPreferences(); |
1325 test_util()->ResetModel(true); | 1323 test_util()->ResetModel(true); |
1326 TemplateURL* new_default = | 1324 TemplateURL* new_default = |
1327 model()->GetTemplateURLForKeyword(ASCIIToUTF16("key1")); | 1325 model()->GetTemplateURLForKeyword(ASCIIToUTF16("key1")); |
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1411 // Add third-party default search engine. | 1409 // Add third-party default search engine. |
1412 TemplateURL* user_dse = AddKeywordWithDate( | 1410 TemplateURL* user_dse = AddKeywordWithDate( |
1413 "user", "user", "http://www.goo.com/s?q={searchTerms}", | 1411 "user", "user", "http://www.goo.com/s?q={searchTerms}", |
1414 std::string(), std::string(), std::string(), | 1412 std::string(), std::string(), std::string(), |
1415 true, "UTF-8", Time(), Time()); | 1413 true, "UTF-8", Time(), Time()); |
1416 model()->SetUserSelectedDefaultSearchProvider(user_dse); | 1414 model()->SetUserSelectedDefaultSearchProvider(user_dse); |
1417 EXPECT_EQ(user_dse, model()->GetDefaultSearchProvider()); | 1415 EXPECT_EQ(user_dse, model()->GetDefaultSearchProvider()); |
1418 | 1416 |
1419 std::unique_ptr<TemplateURL> ext_dse = CreateKeywordWithDate( | 1417 std::unique_ptr<TemplateURL> ext_dse = CreateKeywordWithDate( |
1420 model(), "ext", "ext", "http://www.search.com/s?q={searchTerms}", | 1418 model(), "ext", "ext", "http://www.search.com/s?q={searchTerms}", |
1421 std::string(), std::string(), std::string(), true, true, "UTF-8", Time(), | 1419 std::string(), std::string(), std::string(), true, 999999, "UTF-8", |
1422 Time(), TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION); | 1420 Time(), Time(), TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION); |
1423 std::unique_ptr<TemplateURL::AssociatedExtensionInfo> extension_info( | 1421 std::unique_ptr<TemplateURL::AssociatedExtensionInfo> extension_info( |
1424 new TemplateURL::AssociatedExtensionInfo("ext")); | 1422 new TemplateURL::AssociatedExtensionInfo("ext")); |
1425 extension_info->wants_to_be_default_engine = true; | 1423 extension_info->wants_to_be_default_engine = true; |
1426 TemplateURL* ext_dse_ptr = model()->AddExtensionControlledTURL( | 1424 TemplateURL* ext_dse_ptr = model()->AddExtensionControlledTURL( |
1427 std::move(ext_dse), std::move(extension_info)); | 1425 std::move(ext_dse), std::move(extension_info)); |
1428 EXPECT_EQ(ext_dse_ptr, model()->GetDefaultSearchProvider()); | 1426 EXPECT_EQ(ext_dse_ptr, model()->GetDefaultSearchProvider()); |
1429 | 1427 |
1430 model()->RemoveExtensionControlledTURL( | 1428 model()->RemoveExtensionControlledTURL( |
1431 "ext", TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION); | 1429 "ext", TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION); |
1432 ExpectSimilar(user_dse, model()->GetDefaultSearchProvider()); | 1430 ExpectSimilar(user_dse, model()->GetDefaultSearchProvider()); |
1433 } | 1431 } |
1434 | 1432 |
1435 TEST_F(TemplateURLServiceTest, ExtensionEnginesNotPersist) { | 1433 TEST_F(TemplateURLServiceTest, ExtensionEnginesNotPersist) { |
1436 test_util()->VerifyLoad(); | 1434 test_util()->VerifyLoad(); |
1437 // Add third-party default search engine. | 1435 // Add third-party default search engine. |
1438 TemplateURL* user_dse = AddKeywordWithDate( | 1436 TemplateURL* user_dse = AddKeywordWithDate( |
1439 "user", "user", "http://www.goo.com/s?q={searchTerms}", | 1437 "user", "user", "http://www.goo.com/s?q={searchTerms}", |
1440 std::string(), std::string(), std::string(), | 1438 std::string(), std::string(), std::string(), |
1441 true, "UTF-8", Time(), Time()); | 1439 true, "UTF-8", Time(), Time()); |
1442 model()->SetUserSelectedDefaultSearchProvider(user_dse); | 1440 model()->SetUserSelectedDefaultSearchProvider(user_dse); |
1443 EXPECT_EQ(user_dse, model()->GetDefaultSearchProvider()); | 1441 EXPECT_EQ(user_dse, model()->GetDefaultSearchProvider()); |
1444 | 1442 |
1445 std::unique_ptr<TemplateURL> ext_dse = CreateKeywordWithDate( | 1443 std::unique_ptr<TemplateURL> ext_dse = CreateKeywordWithDate( |
1446 model(), "ext1", "ext1", "http://www.ext1.com/s?q={searchTerms}", | 1444 model(), "ext1", "ext1", "http://www.ext1.com/s?q={searchTerms}", |
1447 std::string(), std::string(), std::string(), true, false, "UTF-8", Time(), | 1445 std::string(), std::string(), std::string(), true, 0, "UTF-8", Time(), |
1448 Time(), TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION); | 1446 Time(), TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION); |
1449 std::unique_ptr<TemplateURL::AssociatedExtensionInfo> extension_info( | 1447 std::unique_ptr<TemplateURL::AssociatedExtensionInfo> extension_info( |
1450 new TemplateURL::AssociatedExtensionInfo("ext1")); | 1448 new TemplateURL::AssociatedExtensionInfo("ext1")); |
1451 extension_info->wants_to_be_default_engine = false; | 1449 extension_info->wants_to_be_default_engine = false; |
1452 model()->AddExtensionControlledTURL(std::move(ext_dse), | 1450 model()->AddExtensionControlledTURL(std::move(ext_dse), |
1453 std::move(extension_info)); | 1451 std::move(extension_info)); |
1454 EXPECT_EQ(user_dse, model()->GetDefaultSearchProvider()); | 1452 EXPECT_EQ(user_dse, model()->GetDefaultSearchProvider()); |
1455 | 1453 |
1456 ext_dse = CreateKeywordWithDate( | 1454 ext_dse = CreateKeywordWithDate( |
1457 model(), "ext2", "ext2", "http://www.ext2.com/s?q={searchTerms}", | 1455 model(), "ext2", "ext2", "http://www.ext2.com/s?q={searchTerms}", |
1458 std::string(), std::string(), std::string(), true, true, "UTF-8", Time(), | 1456 std::string(), std::string(), std::string(), true, 999999, "UTF-8", |
1459 Time(), TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION); | 1457 Time(), Time(), TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION); |
1460 extension_info.reset(new TemplateURL::AssociatedExtensionInfo("ext2")); | 1458 extension_info.reset(new TemplateURL::AssociatedExtensionInfo("ext2")); |
1461 extension_info->wants_to_be_default_engine = true; | 1459 extension_info->wants_to_be_default_engine = true; |
1462 TemplateURL* ext_dse_ptr = model()->AddExtensionControlledTURL( | 1460 TemplateURL* ext_dse_ptr = model()->AddExtensionControlledTURL( |
1463 std::move(ext_dse), std::move(extension_info)); | 1461 std::move(ext_dse), std::move(extension_info)); |
1464 EXPECT_EQ(ext_dse_ptr, model()->GetDefaultSearchProvider()); | 1462 EXPECT_EQ(ext_dse_ptr, model()->GetDefaultSearchProvider()); |
1465 | 1463 |
1466 test_util()->ResetModel(true); | 1464 test_util()->ResetModel(true); |
1467 user_dse = model()->GetTemplateURLForKeyword(ASCIIToUTF16("user")); | 1465 user_dse = model()->GetTemplateURLForKeyword(ASCIIToUTF16("user")); |
1468 ExpectSimilar(user_dse, model()->GetDefaultSearchProvider()); | 1466 ExpectSimilar(user_dse, model()->GetDefaultSearchProvider()); |
1469 EXPECT_FALSE(model()->GetTemplateURLForKeyword(ASCIIToUTF16("ext1"))); | 1467 EXPECT_FALSE(model()->GetTemplateURLForKeyword(ASCIIToUTF16("ext1"))); |
(...skipping 12 matching lines...) Expand all Loading... | |
1482 test_util()->SetManagedDefaultSearchPreferences( | 1480 test_util()->SetManagedDefaultSearchPreferences( |
1483 true, kName, kKeyword, kSearchURL, std::string(), kIconURL, kEncodings, | 1481 true, kName, kKeyword, kSearchURL, std::string(), kIconURL, kEncodings, |
1484 kAlternateURL, kSearchTermsReplacementKey); | 1482 kAlternateURL, kSearchTermsReplacementKey); |
1485 test_util()->VerifyLoad(); | 1483 test_util()->VerifyLoad(); |
1486 // Verify that the default manager we are getting is the managed one. | 1484 // Verify that the default manager we are getting is the managed one. |
1487 TemplateURLData data; | 1485 TemplateURLData data; |
1488 data.SetShortName(ASCIIToUTF16(kName)); | 1486 data.SetShortName(ASCIIToUTF16(kName)); |
1489 data.SetKeyword(ASCIIToUTF16(kKeyword)); | 1487 data.SetKeyword(ASCIIToUTF16(kKeyword)); |
1490 data.SetURL(kSearchURL); | 1488 data.SetURL(kSearchURL); |
1491 data.favicon_url = GURL(kIconURL); | 1489 data.favicon_url = GURL(kIconURL); |
1492 data.show_in_default_list = true; | |
1493 data.input_encodings = base::SplitString( | 1490 data.input_encodings = base::SplitString( |
1494 kEncodings, ";", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL); | 1491 kEncodings, ";", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL); |
1495 data.alternate_urls.push_back(kAlternateURL); | 1492 data.alternate_urls.push_back(kAlternateURL); |
1496 data.search_terms_replacement_key = kSearchTermsReplacementKey; | 1493 data.search_terms_replacement_key = kSearchTermsReplacementKey; |
1497 std::unique_ptr<TemplateURL> expected_managed_default(new TemplateURL(data)); | 1494 std::unique_ptr<TemplateURL> expected_managed_default(new TemplateURL(data)); |
1498 EXPECT_TRUE(model()->is_default_search_managed()); | 1495 EXPECT_TRUE(model()->is_default_search_managed()); |
1499 const TemplateURL* actual_managed_default = | 1496 const TemplateURL* actual_managed_default = |
1500 model()->GetDefaultSearchProvider(); | 1497 model()->GetDefaultSearchProvider(); |
1501 ExpectSimilar(expected_managed_default.get(), actual_managed_default); | 1498 ExpectSimilar(expected_managed_default.get(), actual_managed_default); |
1502 | 1499 |
1503 std::unique_ptr<TemplateURL> ext_dse = CreateKeywordWithDate( | 1500 std::unique_ptr<TemplateURL> ext_dse = CreateKeywordWithDate( |
1504 model(), "ext1", "ext1", "http://www.ext1.com/s?q={searchTerms}", | 1501 model(), "ext1", "ext1", "http://www.ext1.com/s?q={searchTerms}", |
1505 std::string(), std::string(), std::string(), true, true, "UTF-8", Time(), | 1502 std::string(), std::string(), std::string(), true, 999999, "UTF-8", |
1506 Time(), TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION); | 1503 Time(), Time(), TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION); |
1507 std::unique_ptr<TemplateURL::AssociatedExtensionInfo> extension_info( | 1504 std::unique_ptr<TemplateURL::AssociatedExtensionInfo> extension_info( |
1508 new TemplateURL::AssociatedExtensionInfo("ext1")); | 1505 new TemplateURL::AssociatedExtensionInfo("ext1")); |
1509 extension_info->wants_to_be_default_engine = true; | 1506 extension_info->wants_to_be_default_engine = true; |
1510 TemplateURL* ext_dse_ptr = model()->AddExtensionControlledTURL( | 1507 TemplateURL* ext_dse_ptr = model()->AddExtensionControlledTURL( |
1511 std::move(ext_dse), std::move(extension_info)); | 1508 std::move(ext_dse), std::move(extension_info)); |
1512 EXPECT_EQ(ext_dse_ptr, | 1509 EXPECT_EQ(ext_dse_ptr, |
1513 model()->GetTemplateURLForKeyword(ASCIIToUTF16("ext1"))); | 1510 model()->GetTemplateURLForKeyword(ASCIIToUTF16("ext1"))); |
1514 EXPECT_TRUE(model()->is_default_search_managed()); | 1511 EXPECT_TRUE(model()->is_default_search_managed()); |
1515 actual_managed_default = model()->GetDefaultSearchProvider(); | 1512 actual_managed_default = model()->GetDefaultSearchProvider(); |
1516 ExpectSimilar(expected_managed_default.get(), actual_managed_default); | 1513 ExpectSimilar(expected_managed_default.get(), actual_managed_default); |
1517 } | 1514 } |
OLD | NEW |