OLD | NEW |
---|---|
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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 "base/macros.h" | 5 #include "base/macros.h" |
6 #include "base/run_loop.h" | 6 #include "base/run_loop.h" |
7 #include "base/strings/utf_string_conversions.h" | 7 #include "base/strings/utf_string_conversions.h" |
8 #include "build/build_config.h" | 8 #include "build/build_config.h" |
9 #include "chrome/browser/extensions/extension_browsertest.h" | 9 #include "chrome/browser/extensions/extension_browsertest.h" |
10 #include "chrome/browser/prefs/session_startup_pref.h" | 10 #include "chrome/browser/prefs/session_startup_pref.h" |
11 #include "chrome/browser/profiles/profile.h" | 11 #include "chrome/browser/profiles/profile.h" |
12 #include "chrome/browser/search/search.h" | |
12 #include "chrome/browser/search_engines/template_url_service_factory.h" | 13 #include "chrome/browser/search_engines/template_url_service_factory.h" |
14 #include "chrome/browser/search_engines/ui_thread_search_terms_data.h" | |
13 #include "chrome/common/pref_names.h" | 15 #include "chrome/common/pref_names.h" |
16 #include "chrome/test/base/search_test_utils.h" | |
14 #include "components/prefs/pref_service.h" | 17 #include "components/prefs/pref_service.h" |
18 #include "components/search_engines/default_search_manager.h" | |
19 #include "components/search_engines/search_engines_test_util.h" | |
15 #include "components/search_engines/template_url.h" | 20 #include "components/search_engines/template_url.h" |
21 #include "components/search_engines/template_url_prepopulate_data.h" | |
16 #include "components/search_engines/template_url_service.h" | 22 #include "components/search_engines/template_url_service.h" |
17 #include "components/version_info/version_info.h" | 23 #include "components/version_info/version_info.h" |
18 #include "extensions/common/features/feature_channel.h" | 24 #include "extensions/common/features/feature_channel.h" |
19 | 25 |
20 namespace { | 26 namespace { |
21 | 27 #if defined(OS_WIN) || defined(OS_MACOSX) |
22 class TemplateURLServiceObserver { | 28 // Prepopulated id hardcoded in test_extension. |
23 public: | 29 const int kTestExtensionPrepopulatedId = 1; |
24 TemplateURLServiceObserver(TemplateURLService* service, | 30 // TemplateURLData with search engines settings from test extension manifest. |
25 base::RunLoop* loop) | 31 // chrome/test/data/extensions/settings_override/manifest.json |
26 : runner_(loop) { | 32 std::unique_ptr<TemplateURLData> TestExtensionSearchEngine(PrefService* prefs) { |
27 DCHECK(loop); | 33 auto result = base::MakeUnique<TemplateURLData>(); |
28 template_url_sub_ = service->RegisterOnLoadedCallback( | 34 result->SetShortName(base::ASCIIToUTF16("name.de")); |
29 base::Bind(&TemplateURLServiceObserver::StopLoop, | 35 result->SetKeyword(base::ASCIIToUTF16("keyword.de")); |
30 base::Unretained(this))); | 36 result->SetURL("http://www.foo.de/s?q={searchTerms}&id=10"); |
31 service->Load(); | 37 result->favicon_url = GURL("http://www.foo.de/favicon.ico?id=10"); |
32 } | 38 result->suggestions_url = "http://www.foo.de/suggest?q={searchTerms}&id=10"; |
33 ~TemplateURLServiceObserver() {} | 39 result->instant_url = "http://www.foo.de/instant?q={searchTerms}&id=10"; |
34 | 40 result->image_url = "http://www.foo.de/image?q={searchTerms}&id=10"; |
35 private: | 41 result->search_url_post_params = "search_lang=de"; |
36 void StopLoop() { | 42 result->suggestions_url_post_params = "suggest_lang=de"; |
37 runner_->Quit(); | 43 result->instant_url_post_params = "instant_lang=de"; |
38 } | 44 result->image_url_post_params = "image_lang=de"; |
39 base::RunLoop* runner_; | 45 result->alternate_urls.push_back("http://www.moo.de/s?q={searchTerms}&id=10"); |
40 std::unique_ptr<TemplateURLService::Subscription> template_url_sub_; | 46 result->alternate_urls.push_back("http://www.noo.de/s?q={searchTerms}&id=10"); |
41 | 47 result->input_encodings.push_back("UTF-8"); |
42 DISALLOW_COPY_AND_ASSIGN(TemplateURLServiceObserver); | 48 |
43 }; | 49 std::unique_ptr<TemplateURLData> prepopulated = |
50 TemplateURLPrepopulateData::GetPrepopulatedEngine( | |
51 prefs, kTestExtensionPrepopulatedId); | |
52 // Values below do not exist in extension manifest and are taken from | |
53 // prepopulated engine with prepopulated_id set in extension manifest. | |
54 result->search_terms_replacement_key = | |
55 prepopulated->search_terms_replacement_key; | |
56 result->contextual_search_url = prepopulated->contextual_search_url; | |
57 result->new_tab_url = prepopulated->new_tab_url; | |
58 return result; | |
59 } | |
44 | 60 |
45 testing::AssertionResult VerifyTemplateURLServiceLoad( | 61 testing::AssertionResult VerifyTemplateURLServiceLoad( |
46 TemplateURLService* service) { | 62 TemplateURLService* service) { |
47 if (service->loaded()) | 63 if (service->loaded()) |
48 return testing::AssertionSuccess(); | 64 return testing::AssertionSuccess(); |
49 base::RunLoop runner; | 65 search_test_utils::WaitForTemplateURLServiceToLoad(service); |
50 TemplateURLServiceObserver observer(service, &runner); | |
51 runner.Run(); | |
52 if (service->loaded()) | 66 if (service->loaded()) |
53 return testing::AssertionSuccess(); | 67 return testing::AssertionSuccess(); |
54 return testing::AssertionFailure() << "TemplateURLService isn't loaded"; | 68 return testing::AssertionFailure() << "TemplateURLService isn't loaded"; |
55 } | 69 } |
56 | 70 |
57 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, OverrideSettings) { | 71 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, OverrideHomePageSettings) { |
58 PrefService* prefs = profile()->GetPrefs(); | 72 PrefService* prefs = profile()->GetPrefs(); |
59 ASSERT_TRUE(prefs); | 73 ASSERT_TRUE(prefs); |
60 prefs->SetString(prefs::kHomePage, "http://google.com/"); | 74 prefs->SetString(prefs::kHomePage, "http://google.com/"); |
61 prefs->SetBoolean(prefs::kHomePageIsNewTabPage, true); | 75 prefs->SetBoolean(prefs::kHomePageIsNewTabPage, true); |
76 | |
77 const extensions::Extension* extension = LoadExtensionWithInstallParam( | |
78 test_data_dir_.AppendASCII("settings_override"), kFlagEnableFileAccess, | |
79 "10"); | |
80 ASSERT_TRUE(extension); | |
81 EXPECT_EQ("http://www.homepage.de/?param=10", | |
82 prefs->GetString(prefs::kHomePage)); | |
83 EXPECT_FALSE(prefs->GetBoolean(prefs::kHomePageIsNewTabPage)); | |
84 UnloadExtension(extension->id()); | |
85 EXPECT_EQ("http://google.com/", prefs->GetString(prefs::kHomePage)); | |
86 EXPECT_TRUE(prefs->GetBoolean(prefs::kHomePageIsNewTabPage)); | |
87 } | |
88 | |
89 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, OverrideStartupPagesSettings) { | |
90 PrefService* prefs = profile()->GetPrefs(); | |
91 ASSERT_TRUE(prefs); | |
62 const GURL urls[] = {GURL("http://foo"), GURL("http://bar")}; | 92 const GURL urls[] = {GURL("http://foo"), GURL("http://bar")}; |
63 SessionStartupPref startup_pref(SessionStartupPref::LAST); | 93 SessionStartupPref startup_pref(SessionStartupPref::LAST); |
64 startup_pref.urls.assign(urls, urls + arraysize(urls)); | 94 startup_pref.urls.assign(urls, urls + arraysize(urls)); |
65 SessionStartupPref::SetStartupPref(prefs, startup_pref); | 95 SessionStartupPref::SetStartupPref(prefs, startup_pref); |
66 TemplateURLService* url_service = | 96 |
67 TemplateURLServiceFactory::GetForProfile(profile()); | |
68 ASSERT_TRUE(url_service); | |
69 EXPECT_TRUE(VerifyTemplateURLServiceLoad(url_service)); | |
70 TemplateURL* default_provider = url_service->GetDefaultSearchProvider(); | |
71 ASSERT_TRUE(default_provider); | |
72 EXPECT_EQ(TemplateURL::NORMAL, default_provider->type()); | |
73 | |
74 #if defined(OS_MACOSX) | |
75 // On Mac, this API is limited to trunk. | |
76 extensions::ScopedCurrentChannel scoped_channel( | |
77 version_info::Channel::UNKNOWN); | |
78 #endif // OS_MACOSX | |
79 | |
80 #if defined(OS_WIN) || defined(OS_MACOSX) | |
81 const extensions::Extension* extension = LoadExtensionWithInstallParam( | 97 const extensions::Extension* extension = LoadExtensionWithInstallParam( |
82 test_data_dir_.AppendASCII("settings_override"), | 98 test_data_dir_.AppendASCII("settings_override"), |
83 kFlagEnableFileAccess, | 99 kFlagEnableFileAccess, |
84 "10"); | 100 "10"); |
85 ASSERT_TRUE(extension); | 101 ASSERT_TRUE(extension); |
86 EXPECT_EQ("http://www.homepage.de/?param=10", | |
87 prefs->GetString(prefs::kHomePage)); | |
88 EXPECT_FALSE(prefs->GetBoolean(prefs::kHomePageIsNewTabPage)); | |
89 startup_pref = SessionStartupPref::GetStartupPref(prefs); | 102 startup_pref = SessionStartupPref::GetStartupPref(prefs); |
90 EXPECT_EQ(SessionStartupPref::URLS, startup_pref.type); | 103 EXPECT_EQ(SessionStartupPref::URLS, startup_pref.type); |
91 EXPECT_EQ(std::vector<GURL>(1, GURL("http://www.startup.de/?param=10")), | 104 EXPECT_EQ(std::vector<GURL>(1, GURL("http://www.startup.de/?param=10")), |
92 startup_pref.urls); | 105 startup_pref.urls); |
93 TemplateURL* extension_provider = url_service->GetDefaultSearchProvider(); | 106 UnloadExtension(extension->id()); |
94 EXPECT_EQ(TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION, | |
95 extension_provider->type()); | |
96 EXPECT_EQ(base::ASCIIToUTF16("name.de"), extension_provider->short_name()); | |
97 EXPECT_EQ(base::ASCIIToUTF16("keyword.de"), extension_provider->keyword()); | |
98 EXPECT_EQ("http://www.foo.de/s?q={searchTerms}&id=10", | |
99 extension_provider->url()); | |
100 EXPECT_EQ(GURL("http://www.foo.de/favicon.ico?id=10"), | |
101 extension_provider->favicon_url()); | |
102 EXPECT_EQ("http://www.foo.de/suggest?q={searchTerms}&id=10", | |
103 extension_provider->suggestions_url()); | |
104 EXPECT_EQ("http://www.foo.de/instant?q={searchTerms}&id=10", | |
105 extension_provider->instant_url()); | |
106 EXPECT_EQ("http://www.foo.de/image?q={searchTerms}&id=10", | |
107 extension_provider->image_url()); | |
108 EXPECT_EQ("search_lang=de", extension_provider->search_url_post_params()); | |
109 EXPECT_EQ("suggest_lang=de", | |
110 extension_provider->suggestions_url_post_params()); | |
111 EXPECT_EQ("instant_lang=de", extension_provider->instant_url_post_params()); | |
112 EXPECT_EQ("image_lang=de", extension_provider->image_url_post_params()); | |
113 const std::string alternate_urls[] = { | |
114 "http://www.moo.de/s?q={searchTerms}&id=10", | |
115 "http://www.noo.de/s?q={searchTerms}&id=10"}; | |
116 EXPECT_EQ(std::vector<std::string>( | |
117 alternate_urls, alternate_urls + arraysize(alternate_urls)), | |
118 extension_provider->alternate_urls()); | |
119 EXPECT_EQ(std::vector<std::string>(1, "UTF-8"), | |
120 extension_provider->input_encodings()); | |
121 EXPECT_EQ(default_provider->new_tab_url(), extension_provider->new_tab_url()); | |
122 | |
123 UnloadExtension(extension->id()); | |
124 EXPECT_EQ("http://google.com/", prefs->GetString(prefs::kHomePage)); | |
125 EXPECT_TRUE(prefs->GetBoolean(prefs::kHomePageIsNewTabPage)); | |
126 startup_pref = SessionStartupPref::GetStartupPref(prefs); | 107 startup_pref = SessionStartupPref::GetStartupPref(prefs); |
127 EXPECT_EQ(SessionStartupPref::LAST, startup_pref.type); | 108 EXPECT_EQ(SessionStartupPref::LAST, startup_pref.type); |
128 EXPECT_EQ(std::vector<GURL>(urls, urls + arraysize(urls)), startup_pref.urls); | 109 EXPECT_EQ(std::vector<GURL>(urls, urls + arraysize(urls)), startup_pref.urls); |
110 } | |
111 | |
112 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, OverrideDSE) { | |
113 PrefService* prefs = profile()->GetPrefs(); | |
114 ASSERT_TRUE(prefs); | |
115 TemplateURLService* url_service = | |
116 TemplateURLServiceFactory::GetForProfile(profile()); | |
117 ASSERT_TRUE(url_service); | |
118 EXPECT_TRUE(VerifyTemplateURLServiceLoad(url_service)); | |
119 TemplateURL* default_provider = url_service->GetDefaultSearchProvider(); | |
120 ASSERT_TRUE(default_provider); | |
121 EXPECT_EQ(TemplateURL::NORMAL, default_provider->type()); | |
122 | |
123 const extensions::Extension* extension = LoadExtensionWithInstallParam( | |
124 test_data_dir_.AppendASCII("settings_override"), kFlagEnableFileAccess, | |
125 "10"); | |
126 ASSERT_TRUE(extension); | |
127 TemplateURL* current_dse = url_service->GetDefaultSearchProvider(); | |
128 EXPECT_EQ(TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION, current_dse->type()); | |
129 | |
130 std::unique_ptr<TemplateURLData> extension_dse = | |
131 TestExtensionSearchEngine(prefs); | |
132 ExpectSimilar(extension_dse.get(), ¤t_dse->data()); | |
133 | |
134 UnloadExtension(extension->id()); | |
129 EXPECT_EQ(default_provider, url_service->GetDefaultSearchProvider()); | 135 EXPECT_EQ(default_provider, url_service->GetDefaultSearchProvider()); |
136 } | |
137 | |
138 // Install and load extension into test profile. | |
139 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, PRE_OverridenDSEPersists) { | |
140 PrefService* prefs = profile()->GetPrefs(); | |
141 ASSERT_TRUE(prefs); | |
142 TemplateURLService* url_service = | |
143 TemplateURLServiceFactory::GetForProfile(profile()); | |
144 ASSERT_TRUE(url_service); | |
145 EXPECT_TRUE(VerifyTemplateURLServiceLoad(url_service)); | |
146 TemplateURL* default_provider = url_service->GetDefaultSearchProvider(); | |
147 ASSERT_TRUE(default_provider); | |
148 // Check that default provider is normal before extension is | |
149 // installed and loaded. | |
150 EXPECT_EQ(TemplateURL::NORMAL, default_provider->type()); | |
151 EXPECT_NE(base::ASCIIToUTF16("name.de"), default_provider->short_name()); | |
152 EXPECT_NE(base::ASCIIToUTF16("keyword.de"), default_provider->keyword()); | |
153 | |
154 // Install extension that overrides DSE. | |
155 const extensions::Extension* extension = LoadExtensionWithInstallParam( | |
156 test_data_dir_.AppendASCII("settings_override"), kFlagEnableFileAccess, | |
157 "10"); | |
158 ASSERT_TRUE(extension); | |
159 } | |
160 | |
161 // PRE_OverridenDSEPersists already installed extension with overriden DSE into | |
162 // profile. Current test checks that after extension is installed, | |
163 // default_search_manager correctly determines extension overriden DSE | |
164 // from profile. | |
165 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, OverridenDSEPersists) { | |
166 Profile* profile = browser()->profile(); | |
167 DefaultSearchManager default_manager( | |
168 profile->GetPrefs(), DefaultSearchManager::ObserverCallback()); | |
169 | |
170 DefaultSearchManager::Source source; | |
171 const TemplateURLData* current_dse = | |
172 default_manager.GetDefaultSearchEngine(&source); | |
173 | |
174 ASSERT_TRUE(current_dse); | |
175 std::unique_ptr<TemplateURLData> extension_dse = | |
176 TestExtensionSearchEngine(profile->GetPrefs()); | |
177 ExpectSimilar(extension_dse.get(), current_dse); | |
178 EXPECT_EQ(DefaultSearchManager::FROM_EXTENSION, source); | |
179 | |
180 // Check that new tab url is correctly overriden by extension. | |
181 TemplateURL ext_turl(*extension_dse, | |
182 TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION); | |
183 | |
184 std::string new_tab_url_ext = ext_turl.new_tab_url_ref().ReplaceSearchTerms( | |
185 TemplateURLRef::SearchTermsArgs(base::string16()), | |
186 UIThreadSearchTermsData(profile)); | |
187 | |
188 EXPECT_EQ(new_tab_url_ext, search::GetNewTabPageURL(profile).spec()); | |
189 | |
190 // Check that after template url service is loaded, extension dse persists. | |
191 TemplateURLService* url_service = | |
192 TemplateURLServiceFactory::GetForProfile(profile); | |
193 ASSERT_TRUE(url_service); | |
194 EXPECT_TRUE(VerifyTemplateURLServiceLoad(url_service)); | |
195 EXPECT_TRUE(url_service->IsExtensionControlledDefaultSearch()); | |
196 TemplateURL* default_provider = url_service->GetDefaultSearchProvider(); | |
197 ASSERT_TRUE(default_provider); | |
198 ExpectSimilar(extension_dse.get(), &default_provider->data()); | |
199 | |
200 UninstallExtension( | |
201 default_provider->GetExtensionInfoForTesting()->extension_id); | |
202 } | |
203 | |
204 // This tests checks that extension overriding default search can be correctly | |
205 // loaded before TemplateURLService is loaded. | |
206 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, BeforeTemplateUrlServiceLoad) { | |
207 PrefService* prefs = profile()->GetPrefs(); | |
208 ASSERT_TRUE(prefs); | |
209 TemplateURLService* url_service = | |
210 TemplateURLServiceFactory::GetForProfile(profile()); | |
211 ASSERT_TRUE(url_service); | |
212 EXPECT_TRUE(VerifyTemplateURLServiceLoad(url_service)); | |
vasilii
2017/02/27 15:20:35
What's going on here? Why you load the service in
Alexander Yashkin
2017/02/27 19:36:03
I decided to ensure that TemplateURLService is loa
vasilii
2017/02/28 14:59:41
It's a browser test and what happens here should m
Alexander Yashkin
2017/02/28 19:30:29
Removed explicit TemplateURLService load and set_l
| |
213 // Set TemplateURLService unloaded for testing purpose. | |
214 url_service->set_loaded(false); | |
vasilii
2017/02/27 15:20:35
I don't think it's applicable here in the browser
Alexander Yashkin
2017/02/27 19:36:03
Why not applicable? I think set_loaded() function
vasilii
2017/02/28 14:59:42
TemplateURLService::Load is called explicitly. If
Alexander Yashkin
2017/02/28 19:30:29
Removed TemplateURLService load.
| |
215 | |
216 EXPECT_FALSE(url_service->IsExtensionControlledDefaultSearch()); | |
217 const extensions::Extension* extension = LoadExtensionWithInstallParam( | |
218 test_data_dir_.AppendASCII("settings_override"), kFlagEnableFileAccess, | |
219 "10"); | |
220 ASSERT_TRUE(extension); | |
221 TemplateURL* current_dse = url_service->GetDefaultSearchProvider(); | |
222 EXPECT_EQ(TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION, current_dse->type()); | |
223 EXPECT_TRUE(url_service->IsExtensionControlledDefaultSearch()); | |
224 | |
225 std::unique_ptr<TemplateURLData> extension_dse = | |
226 TestExtensionSearchEngine(prefs); | |
227 ExpectSimilar(extension_dse.get(), ¤t_dse->data()); | |
228 | |
229 UnloadExtension(extension->id()); | |
230 EXPECT_NE(TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION, | |
231 url_service->GetDefaultSearchProvider()->type()); | |
232 EXPECT_FALSE(url_service->IsExtensionControlledDefaultSearch()); | |
233 } | |
234 | |
130 #else | 235 #else |
236 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, SettingsOverridesDisallowed) { | |
131 const extensions::Extension* extension = | 237 const extensions::Extension* extension = |
132 LoadExtensionWithFlags(test_data_dir_.AppendASCII("settings_override"), | 238 LoadExtensionWithFlags(test_data_dir_.AppendASCII("settings_override"), |
133 kFlagIgnoreManifestWarnings); | 239 kFlagIgnoreManifestWarnings); |
134 ASSERT_TRUE(extension); | 240 ASSERT_TRUE(extension); |
135 ASSERT_EQ(1u, extension->install_warnings().size()); | 241 ASSERT_EQ(1u, extension->install_warnings().size()); |
136 EXPECT_EQ(std::string( | 242 EXPECT_EQ(std::string("'chrome_settings_overrides' " |
137 "'chrome_settings_overrides' " | 243 "is not allowed for specified platform."), |
138 "is not allowed for specified platform."), | |
139 extension->install_warnings().front().message); | 244 extension->install_warnings().front().message); |
245 } | |
140 #endif | 246 #endif |
141 } | |
142 | 247 |
143 } // namespace | 248 } // namespace |
OLD | NEW |