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_engines/template_url_service_factory.h" | 12 #include "chrome/browser/search_engines/template_url_service_factory.h" |
13 #include "chrome/common/pref_names.h" | 13 #include "chrome/common/pref_names.h" |
14 #include "chrome/test/base/search_test_utils.h" | |
14 #include "components/prefs/pref_service.h" | 15 #include "components/prefs/pref_service.h" |
16 #include "components/search_engines/default_search_manager.h" | |
17 #include "components/search_engines/search_engines_test_util.h" | |
15 #include "components/search_engines/template_url.h" | 18 #include "components/search_engines/template_url.h" |
19 #include "components/search_engines/template_url_prepopulate_data.h" | |
16 #include "components/search_engines/template_url_service.h" | 20 #include "components/search_engines/template_url_service.h" |
17 #include "components/version_info/version_info.h" | 21 #include "components/version_info/version_info.h" |
18 #include "extensions/common/features/feature_channel.h" | 22 #include "extensions/common/features/feature_channel.h" |
19 | 23 |
20 namespace { | 24 namespace { |
25 // TemplateURLData with search engines settings from test extension manifest. | |
26 std::unique_ptr<TemplateURLData> TestExtensionSearchEngine(PrefService* prefs) { | |
27 auto result = base::MakeUnique<TemplateURLData>(); | |
28 result->SetShortName(base::ASCIIToUTF16("name.de")); | |
29 result->SetKeyword(base::ASCIIToUTF16("keyword.de")); | |
30 result->SetURL("http://www.foo.de/s?q={searchTerms}&id=10"); | |
31 result->favicon_url = GURL("http://www.foo.de/favicon.ico?id=10"); | |
32 result->suggestions_url = "http://www.foo.de/suggest?q={searchTerms}&id=10"; | |
33 result->instant_url = "http://www.foo.de/instant?q={searchTerms}&id=10"; | |
34 result->image_url = "http://www.foo.de/image?q={searchTerms}&id=10"; | |
35 result->search_url_post_params = "search_lang=de"; | |
36 result->suggestions_url_post_params = "suggest_lang=de"; | |
37 result->instant_url_post_params = "instant_lang=de"; | |
38 result->image_url_post_params = "image_lang=de"; | |
39 result->alternate_urls.push_back("http://www.moo.de/s?q={searchTerms}&id=10"); | |
40 result->alternate_urls.push_back("http://www.noo.de/s?q={searchTerms}&id=10"); | |
41 result->input_encodings.push_back("UTF-8"); | |
21 | 42 |
22 class TemplateURLServiceObserver { | 43 std::unique_ptr<TemplateURLData> google_engine( |
23 public: | 44 TemplateURLPrepopulateData::GetPrepopulatedEngine(prefs, 1)); |
vasilii
2016/11/30 14:00:02
prepopulated_id should come from the manifest inst
Alexander Yashkin
2016/12/05 18:16:48
Added extraction of prepopulated_id from manifest.
| |
24 TemplateURLServiceObserver(TemplateURLService* service, | 45 // Values below are taken for Google engine settings, because extension |
25 base::RunLoop* loop) | 46 // manifest has prepopulate_id 1, which is Google. |
26 : runner_(loop) { | 47 result->search_terms_replacement_key = |
27 DCHECK(loop); | 48 google_engine->search_terms_replacement_key; |
28 template_url_sub_ = service->RegisterOnLoadedCallback( | 49 result->contextual_search_url = google_engine->contextual_search_url; |
vasilii
2016/11/30 14:00:02
contextual_search_url and search_terms_replacement
Alexander Yashkin
2016/12/05 18:16:48
I don't think that someone would want to override
vasilii
2016/12/06 19:16:42
No, that's fine.
| |
29 base::Bind(&TemplateURLServiceObserver::StopLoop, | 50 result->new_tab_url = google_engine->new_tab_url; |
30 base::Unretained(this))); | 51 return result; |
31 service->Load(); | |
32 } | 52 } |
33 ~TemplateURLServiceObserver() {} | |
34 | |
35 private: | |
36 void StopLoop() { | |
37 runner_->Quit(); | |
38 } | |
39 base::RunLoop* runner_; | |
40 std::unique_ptr<TemplateURLService::Subscription> template_url_sub_; | |
41 | |
42 DISALLOW_COPY_AND_ASSIGN(TemplateURLServiceObserver); | |
43 }; | |
44 | 53 |
45 testing::AssertionResult VerifyTemplateURLServiceLoad( | 54 testing::AssertionResult VerifyTemplateURLServiceLoad( |
46 TemplateURLService* service) { | 55 TemplateURLService* service) { |
47 if (service->loaded()) | 56 if (service->loaded()) |
48 return testing::AssertionSuccess(); | 57 return testing::AssertionSuccess(); |
49 base::RunLoop runner; | 58 search_test_utils::WaitForTemplateURLServiceToLoad(service); |
50 TemplateURLServiceObserver observer(service, &runner); | |
51 runner.Run(); | |
52 if (service->loaded()) | 59 if (service->loaded()) |
53 return testing::AssertionSuccess(); | 60 return testing::AssertionSuccess(); |
54 return testing::AssertionFailure() << "TemplateURLService isn't loaded"; | 61 return testing::AssertionFailure() << "TemplateURLService isn't loaded"; |
55 } | 62 } |
63 } // namespace | |
vasilii
2016/11/30 14:00:02
Why do you move the namespace?
Alexander Yashkin
2016/12/05 18:16:48
Reverted, did not even noticed in hacking rage :)
| |
56 | 64 |
57 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, OverrideSettings) { | 65 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, OverrideHomePageSettings) { |
vasilii
2016/11/30 14:00:02
If you decided to split the tests then one should
Alexander Yashkin
2016/12/05 18:16:48
Ok, splitted home page and startup pages tests.
| |
58 PrefService* prefs = profile()->GetPrefs(); | 66 PrefService* prefs = profile()->GetPrefs(); |
59 ASSERT_TRUE(prefs); | 67 ASSERT_TRUE(prefs); |
60 prefs->SetString(prefs::kHomePage, "http://google.com/"); | 68 prefs->SetString(prefs::kHomePage, "http://google.com/"); |
61 prefs->SetBoolean(prefs::kHomePageIsNewTabPage, true); | 69 prefs->SetBoolean(prefs::kHomePageIsNewTabPage, true); |
62 const GURL urls[] = {GURL("http://foo"), GURL("http://bar")}; | 70 const GURL urls[] = {GURL("http://foo"), GURL("http://bar")}; |
63 SessionStartupPref startup_pref(SessionStartupPref::LAST); | 71 SessionStartupPref startup_pref(SessionStartupPref::LAST); |
64 startup_pref.urls.assign(urls, urls + arraysize(urls)); | 72 startup_pref.urls.assign(urls, urls + arraysize(urls)); |
65 SessionStartupPref::SetStartupPref(prefs, startup_pref); | 73 SessionStartupPref::SetStartupPref(prefs, startup_pref); |
66 TemplateURLService* url_service = | |
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 |
74 #if defined(OS_MACOSX) | 75 #if defined(OS_MACOSX) |
75 // On Mac, this API is limited to trunk. | 76 // On Mac, this API is limited to trunk. |
vasilii
2016/11/30 14:00:02
I think it's not true anymore.
Alexander Yashkin
2016/12/05 18:16:48
Deleted.
| |
76 extensions::ScopedCurrentChannel scoped_channel( | 77 extensions::ScopedCurrentChannel scoped_channel( |
77 version_info::Channel::UNKNOWN); | 78 version_info::Channel::UNKNOWN); |
78 #endif // OS_MACOSX | 79 #endif // OS_MACOSX |
79 | 80 |
80 #if defined(OS_WIN) || defined(OS_MACOSX) | 81 #if defined(OS_WIN) || defined(OS_MACOSX) |
81 const extensions::Extension* extension = LoadExtensionWithInstallParam( | 82 const extensions::Extension* extension = LoadExtensionWithInstallParam( |
82 test_data_dir_.AppendASCII("settings_override"), | 83 test_data_dir_.AppendASCII("settings_override"), |
83 kFlagEnableFileAccess, | 84 kFlagEnableFileAccess, |
84 "10"); | 85 "10"); |
85 ASSERT_TRUE(extension); | 86 ASSERT_TRUE(extension); |
86 EXPECT_EQ("http://www.homepage.de/?param=10", | 87 EXPECT_EQ("http://www.homepage.de/?param=10", |
87 prefs->GetString(prefs::kHomePage)); | 88 prefs->GetString(prefs::kHomePage)); |
88 EXPECT_FALSE(prefs->GetBoolean(prefs::kHomePageIsNewTabPage)); | 89 EXPECT_FALSE(prefs->GetBoolean(prefs::kHomePageIsNewTabPage)); |
89 startup_pref = SessionStartupPref::GetStartupPref(prefs); | 90 startup_pref = SessionStartupPref::GetStartupPref(prefs); |
90 EXPECT_EQ(SessionStartupPref::URLS, startup_pref.type); | 91 EXPECT_EQ(SessionStartupPref::URLS, startup_pref.type); |
91 EXPECT_EQ(std::vector<GURL>(1, GURL("http://www.startup.de/?param=10")), | 92 EXPECT_EQ(std::vector<GURL>(1, GURL("http://www.startup.de/?param=10")), |
92 startup_pref.urls); | 93 startup_pref.urls); |
93 TemplateURL* extension_provider = url_service->GetDefaultSearchProvider(); | |
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()); | 94 UnloadExtension(extension->id()); |
124 EXPECT_EQ("http://google.com/", prefs->GetString(prefs::kHomePage)); | 95 EXPECT_EQ("http://google.com/", prefs->GetString(prefs::kHomePage)); |
125 EXPECT_TRUE(prefs->GetBoolean(prefs::kHomePageIsNewTabPage)); | 96 EXPECT_TRUE(prefs->GetBoolean(prefs::kHomePageIsNewTabPage)); |
126 startup_pref = SessionStartupPref::GetStartupPref(prefs); | 97 startup_pref = SessionStartupPref::GetStartupPref(prefs); |
127 EXPECT_EQ(SessionStartupPref::LAST, startup_pref.type); | 98 EXPECT_EQ(SessionStartupPref::LAST, startup_pref.type); |
128 EXPECT_EQ(std::vector<GURL>(urls, urls + arraysize(urls)), startup_pref.urls); | 99 EXPECT_EQ(std::vector<GURL>(urls, urls + arraysize(urls)), startup_pref.urls); |
100 #else | |
101 const extensions::Extension* extension = | |
102 LoadExtensionWithFlags(test_data_dir_.AppendASCII("settings_override"), | |
103 kFlagIgnoreManifestWarnings); | |
104 ASSERT_TRUE(extension); | |
105 ASSERT_EQ(1u, extension->install_warnings().size()); | |
106 EXPECT_EQ(std::string("'chrome_settings_overrides' " | |
107 "is not allowed for specified platform."), | |
108 extension->install_warnings().front().message); | |
109 #endif | |
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 #if defined(OS_MACOSX) | |
124 // On Mac, this API is limited to trunk. | |
125 extensions::ScopedCurrentChannel scoped_channel( | |
126 version_info::Channel::UNKNOWN); | |
127 #endif // OS_MACOSX | |
128 | |
129 #if defined(OS_WIN) || defined(OS_MACOSX) | |
130 const extensions::Extension* extension = LoadExtensionWithInstallParam( | |
131 test_data_dir_.AppendASCII("settings_override"), kFlagEnableFileAccess, | |
132 "10"); | |
133 ASSERT_TRUE(extension); | |
134 TemplateURL* extension_provider = url_service->GetDefaultSearchProvider(); | |
135 EXPECT_EQ(TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION, | |
136 extension_provider->type()); | |
137 | |
138 auto extension_dse = TestExtensionSearchEngine(prefs); | |
139 ExpectSimilar(&extension_provider->data(), extension_dse.get()); | |
140 | |
141 UnloadExtension(extension->id()); | |
129 EXPECT_EQ(default_provider, url_service->GetDefaultSearchProvider()); | 142 EXPECT_EQ(default_provider, url_service->GetDefaultSearchProvider()); |
130 #else | 143 #else |
131 const extensions::Extension* extension = | 144 const extensions::Extension* extension = |
132 LoadExtensionWithFlags(test_data_dir_.AppendASCII("settings_override"), | 145 LoadExtensionWithFlags(test_data_dir_.AppendASCII("settings_override"), |
133 kFlagIgnoreManifestWarnings); | 146 kFlagIgnoreManifestWarnings); |
134 ASSERT_TRUE(extension); | 147 ASSERT_TRUE(extension); |
135 ASSERT_EQ(1u, extension->install_warnings().size()); | 148 ASSERT_EQ(1u, extension->install_warnings().size()); |
136 EXPECT_EQ(std::string( | 149 EXPECT_EQ(std::string( |
137 "'chrome_settings_overrides' " | 150 "'chrome_settings_overrides' " |
138 "is not allowed for specified platform."), | 151 "is not allowed for specified platform."), |
139 extension->install_warnings().front().message); | 152 extension->install_warnings().front().message); |
140 #endif | 153 #endif |
141 } | 154 } |
142 | 155 |
143 } // namespace | 156 #if defined(OS_WIN) || defined(OS_MACOSX) |
157 // Install and load extension into test profile. | |
158 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, PRE_OverridenDSEPersists) { | |
vasilii
2016/11/30 14:00:02
The test should load an extension that overwrites
Alexander Yashkin
2016/12/05 18:16:48
new_tab page from extension overriden engine not a
vasilii
2016/12/06 19:16:42
I think you can reuse the extension.
You can make
| |
159 PrefService* prefs = profile()->GetPrefs(); | |
160 ASSERT_TRUE(prefs); | |
161 TemplateURLService* url_service = | |
162 TemplateURLServiceFactory::GetForProfile(profile()); | |
163 ASSERT_TRUE(url_service); | |
164 EXPECT_TRUE(VerifyTemplateURLServiceLoad(url_service)); | |
165 TemplateURL* default_provider = url_service->GetDefaultSearchProvider(); | |
166 ASSERT_TRUE(default_provider); | |
167 // Check that default provider is normal before extension is | |
168 // installed and loaded. | |
169 EXPECT_EQ(TemplateURL::NORMAL, default_provider->type()); | |
170 EXPECT_NE(base::ASCIIToUTF16("name.de"), default_provider->short_name()); | |
171 EXPECT_NE(base::ASCIIToUTF16("keyword.de"), default_provider->keyword()); | |
172 | |
173 #if defined(OS_MACOSX) | |
174 // On Mac, this API is limited to trunk. | |
175 extensions::ScopedCurrentChannel scoped_channel( | |
176 version_info::Channel::UNKNOWN); | |
177 #endif // OS_MACOSX | |
178 // Install extension that overrides DSE. | |
179 const extensions::Extension* extension = LoadExtensionWithInstallParam( | |
180 test_data_dir_.AppendASCII("settings_override"), kFlagEnableFileAccess, | |
181 "10"); | |
182 ASSERT_TRUE(extension); | |
183 } | |
184 | |
185 // PRE_OverridenDSEPersists already installed extension with overriden DSE into | |
186 // profile. Current test checks that after extension is installed, | |
187 // default_search_manager correctly determines extension overriden DSE | |
188 // from profile. | |
189 IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, OverridenDSEPersists) { | |
190 Profile* profile = browser()->profile(); | |
191 DefaultSearchManager default_manager( | |
192 profile->GetPrefs(), DefaultSearchManager::ObserverCallback()); | |
193 | |
194 DefaultSearchManager::Source source; | |
195 TemplateURLData* dse = default_manager.GetDefaultSearchEngine(&source); | |
196 | |
197 ASSERT_TRUE(dse); | |
198 auto extension_dse = TestExtensionSearchEngine(profile->GetPrefs()); | |
199 ExpectSimilar(dse, extension_dse.get()); | |
200 EXPECT_EQ(DefaultSearchManager::FROM_EXTENSION, source); | |
201 } | |
202 #endif | |
OLD | NEW |