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
3 // found in the LICENSE file.
4
5 #include "base/prefs/pref_service.h"
6 #include "base/strings/utf_string_conversions.h"
7 #include "chrome/browser/browser_process.h"
8 #include "chrome/browser/chrome_notification_types.h"
9 #include "chrome/browser/extensions/extension_apitest.h"
10 #include "chrome/browser/extensions/extension_test_message_listener.h"
11 #include "chrome/browser/profiles/profile.h"
12 #include "chrome/browser/ui/browser.h"
13 #include "chrome/common/chrome_switches.h"
14 #include "chrome/common/pref_names.h"
15 #include "chrome/test/base/ui_test_utils.h"
16 #include "components/translate/core/common/translate_pref_names.h"
17 #include "content/public/browser/notification_service.h"
18
19 namespace {
20
ReleaseBrowserProcessModule()21 void ReleaseBrowserProcessModule() {
22 g_browser_process->ReleaseModule();
23 }
24
25 } // namespace
26
27 class ExtensionPreferenceApiTest : public ExtensionApiTest {
28 protected:
ExtensionPreferenceApiTest()29 ExtensionPreferenceApiTest() : profile_(NULL) {}
30
CheckPreferencesSet()31 void CheckPreferencesSet() {
32 PrefService* prefs = profile_->GetPrefs();
33 const PrefService::Preference* pref = prefs->FindPreference(
34 prefs::kBlockThirdPartyCookies);
35 ASSERT_TRUE(pref);
36 EXPECT_TRUE(pref->IsExtensionControlled());
37 EXPECT_TRUE(prefs->GetBoolean(prefs::kAlternateErrorPagesEnabled));
38 EXPECT_TRUE(prefs->GetBoolean(autofill::prefs::kAutofillEnabled));
39 EXPECT_FALSE(prefs->GetBoolean(prefs::kBlockThirdPartyCookies));
40 EXPECT_TRUE(prefs->GetBoolean(prefs::kEnableHyperlinkAuditing));
41 EXPECT_TRUE(prefs->GetBoolean(prefs::kEnableReferrers));
42 EXPECT_TRUE(prefs->GetBoolean(prefs::kEnableTranslate));
43 EXPECT_TRUE(prefs->GetBoolean(prefs::kNetworkPredictionEnabled));
44 EXPECT_TRUE(prefs->GetBoolean(prefs::kSafeBrowsingEnabled));
45 EXPECT_TRUE(prefs->GetBoolean(prefs::kSearchSuggestEnabled));
46 }
47
CheckPreferencesCleared()48 void CheckPreferencesCleared() {
49 PrefService* prefs = profile_->GetPrefs();
50 const PrefService::Preference* pref = prefs->FindPreference(
51 prefs::kBlockThirdPartyCookies);
52 ASSERT_TRUE(pref);
53 EXPECT_FALSE(pref->IsExtensionControlled());
54 EXPECT_FALSE(prefs->GetBoolean(prefs::kAlternateErrorPagesEnabled));
55 EXPECT_FALSE(prefs->GetBoolean(autofill::prefs::kAutofillEnabled));
56 EXPECT_TRUE(prefs->GetBoolean(prefs::kBlockThirdPartyCookies));
57 EXPECT_FALSE(prefs->GetBoolean(prefs::kEnableHyperlinkAuditing));
58 EXPECT_FALSE(prefs->GetBoolean(prefs::kEnableReferrers));
59 EXPECT_FALSE(prefs->GetBoolean(prefs::kEnableTranslate));
60 EXPECT_FALSE(prefs->GetBoolean(prefs::kNetworkPredictionEnabled));
61 EXPECT_FALSE(prefs->GetBoolean(prefs::kSafeBrowsingEnabled));
62 EXPECT_FALSE(prefs->GetBoolean(prefs::kSearchSuggestEnabled));
63 }
64
SetUpOnMainThread()65 virtual void SetUpOnMainThread() OVERRIDE {
66 ExtensionApiTest::SetUpOnMainThread();
67
68 // The browser might get closed later (and therefore be destroyed), so we
69 // save the profile.
70 profile_ = browser()->profile();
71
72 // Closing the last browser window also releases a module reference. Make
73 // sure it's not the last one, so the message loop doesn't quit
74 // unexpectedly.
75 g_browser_process->AddRefModule();
76 }
77
CleanUpOnMainThread()78 virtual void CleanUpOnMainThread() OVERRIDE {
79 // ReleaseBrowserProcessModule() needs to be called in a message loop, so we
80 // post a task to do it, then run the message loop.
81 base::MessageLoop::current()->PostTask(
82 FROM_HERE, base::Bind(&ReleaseBrowserProcessModule));
83 content::RunAllPendingInMessageLoop();
84
85 ExtensionApiTest::CleanUpOnMainThread();
86 }
87
88 Profile* profile_;
89 };
90
91 // http://crbug.com/177163
92 #if defined(OS_WIN) && !defined(NDEBUG)
93 #define MAYBE_Standard DISABLED_Standard
94 #else
95 #define MAYBE_Standard Standard
96 #endif
IN_PROC_BROWSER_TEST_F(ExtensionPreferenceApiTest,MAYBE_Standard)97 IN_PROC_BROWSER_TEST_F(ExtensionPreferenceApiTest, MAYBE_Standard) {
98 PrefService* prefs = profile_->GetPrefs();
99 prefs->SetBoolean(prefs::kAlternateErrorPagesEnabled, false);
100 prefs->SetBoolean(autofill::prefs::kAutofillEnabled, false);
101 prefs->SetBoolean(prefs::kBlockThirdPartyCookies, true);
102 prefs->SetBoolean(prefs::kEnableHyperlinkAuditing, false);
103 prefs->SetBoolean(prefs::kEnableReferrers, false);
104 prefs->SetBoolean(prefs::kEnableTranslate, false);
105 prefs->SetBoolean(prefs::kNetworkPredictionEnabled, false);
106 prefs->SetBoolean(prefs::kSafeBrowsingEnabled, false);
107 prefs->SetBoolean(prefs::kSearchSuggestEnabled, false);
108
109 const char kExtensionPath[] = "preference/standard";
110
111 EXPECT_TRUE(RunExtensionSubtest(kExtensionPath, "test.html")) << message_;
112 CheckPreferencesSet();
113
114 // The settings should not be reset when the extension is reloaded.
115 ReloadExtension(last_loaded_extension_id());
116 CheckPreferencesSet();
117
118 // Uninstalling and installing the extension (without running the test that
119 // calls the extension API) should clear the settings.
120 content::WindowedNotificationObserver observer(
121 chrome::NOTIFICATION_EXTENSION_UNINSTALLED_DEPRECATED,
122 content::NotificationService::AllSources());
123 UninstallExtension(last_loaded_extension_id());
124 observer.Wait();
125 CheckPreferencesCleared();
126
127 LoadExtension(test_data_dir_.AppendASCII(kExtensionPath));
128 CheckPreferencesCleared();
129 }
130
IN_PROC_BROWSER_TEST_F(ExtensionPreferenceApiTest,PersistentIncognito)131 IN_PROC_BROWSER_TEST_F(ExtensionPreferenceApiTest, PersistentIncognito) {
132 PrefService* prefs = profile_->GetPrefs();
133 prefs->SetBoolean(prefs::kBlockThirdPartyCookies, false);
134
135 EXPECT_TRUE(
136 RunExtensionTestIncognito("preference/persistent_incognito")) <<
137 message_;
138
139 // Setting an incognito preference should not create an incognito profile.
140 EXPECT_FALSE(profile_->HasOffTheRecordProfile());
141
142 PrefService* otr_prefs = profile_->GetOffTheRecordProfile()->GetPrefs();
143 const PrefService::Preference* pref =
144 otr_prefs->FindPreference(prefs::kBlockThirdPartyCookies);
145 ASSERT_TRUE(pref);
146 EXPECT_TRUE(pref->IsExtensionControlled());
147 EXPECT_TRUE(otr_prefs->GetBoolean(prefs::kBlockThirdPartyCookies));
148
149 pref = prefs->FindPreference(prefs::kBlockThirdPartyCookies);
150 ASSERT_TRUE(pref);
151 EXPECT_FALSE(pref->IsExtensionControlled());
152 EXPECT_FALSE(prefs->GetBoolean(prefs::kBlockThirdPartyCookies));
153 }
154
155 // Flakily times out: http://crbug.com/106144
IN_PROC_BROWSER_TEST_F(ExtensionPreferenceApiTest,DISABLED_IncognitoDisabled)156 IN_PROC_BROWSER_TEST_F(ExtensionPreferenceApiTest, DISABLED_IncognitoDisabled) {
157 EXPECT_FALSE(RunExtensionTest("preference/persistent_incognito"));
158 }
159
IN_PROC_BROWSER_TEST_F(ExtensionPreferenceApiTest,SessionOnlyIncognito)160 IN_PROC_BROWSER_TEST_F(ExtensionPreferenceApiTest, SessionOnlyIncognito) {
161 PrefService* prefs = profile_->GetPrefs();
162 prefs->SetBoolean(prefs::kBlockThirdPartyCookies, false);
163
164 EXPECT_TRUE(
165 RunExtensionTestIncognito("preference/session_only_incognito")) <<
166 message_;
167
168 EXPECT_TRUE(profile_->HasOffTheRecordProfile());
169
170 PrefService* otr_prefs = profile_->GetOffTheRecordProfile()->GetPrefs();
171 const PrefService::Preference* pref =
172 otr_prefs->FindPreference(prefs::kBlockThirdPartyCookies);
173 ASSERT_TRUE(pref);
174 EXPECT_TRUE(pref->IsExtensionControlled());
175 EXPECT_FALSE(otr_prefs->GetBoolean(prefs::kBlockThirdPartyCookies));
176
177 pref = prefs->FindPreference(prefs::kBlockThirdPartyCookies);
178 ASSERT_TRUE(pref);
179 EXPECT_FALSE(pref->IsExtensionControlled());
180 EXPECT_FALSE(prefs->GetBoolean(prefs::kBlockThirdPartyCookies));
181 }
182
IN_PROC_BROWSER_TEST_F(ExtensionPreferenceApiTest,Clear)183 IN_PROC_BROWSER_TEST_F(ExtensionPreferenceApiTest, Clear) {
184 PrefService* prefs = profile_->GetPrefs();
185 prefs->SetBoolean(prefs::kBlockThirdPartyCookies, true);
186
187 EXPECT_TRUE(RunExtensionTest("preference/clear")) << message_;
188
189 const PrefService::Preference* pref = prefs->FindPreference(
190 prefs::kBlockThirdPartyCookies);
191 ASSERT_TRUE(pref);
192 EXPECT_FALSE(pref->IsExtensionControlled());
193 EXPECT_EQ(true, prefs->GetBoolean(prefs::kBlockThirdPartyCookies));
194 }
195
IN_PROC_BROWSER_TEST_F(ExtensionPreferenceApiTest,OnChange)196 IN_PROC_BROWSER_TEST_F(ExtensionPreferenceApiTest, OnChange) {
197 EXPECT_TRUE(RunExtensionTestIncognito("preference/onchange")) <<
198 message_;
199 }
200
IN_PROC_BROWSER_TEST_F(ExtensionPreferenceApiTest,OnChangeSplit)201 IN_PROC_BROWSER_TEST_F(ExtensionPreferenceApiTest, OnChangeSplit) {
202 ResultCatcher catcher;
203 catcher.RestrictToProfile(profile_);
204 ResultCatcher catcher_incognito;
205 catcher_incognito.RestrictToProfile(profile_->GetOffTheRecordProfile());
206
207 // Open an incognito window.
208 ui_test_utils::OpenURLOffTheRecord(profile_, GURL("chrome://newtab/"));
209
210 // changeDefault listeners.
211 ExtensionTestMessageListener listener1("changeDefault regular ready", true);
212 ExtensionTestMessageListener listener_incognito1(
213 "changeDefault incognito ready", true);
214
215 // changeIncognitoOnly listeners.
216 ExtensionTestMessageListener listener2(
217 "changeIncognitoOnly regular ready", true);
218 ExtensionTestMessageListener listener_incognito2(
219 "changeIncognitoOnly incognito ready", true);
220 ExtensionTestMessageListener listener3(
221 "changeIncognitoOnly regular listening", true);
222 ExtensionTestMessageListener listener_incognito3(
223 "changeIncognitoOnly incognito pref set", false);
224
225 // changeDefaultOnly listeners.
226 ExtensionTestMessageListener listener4(
227 "changeDefaultOnly regular ready", true);
228 ExtensionTestMessageListener listener_incognito4(
229 "changeDefaultOnly incognito ready", true);
230 ExtensionTestMessageListener listener5(
231 "changeDefaultOnly regular pref set", false);
232 ExtensionTestMessageListener listener_incognito5(
233 "changeDefaultOnly incognito listening", true);
234
235 // changeIncognitoOnlyBack listeners.
236 ExtensionTestMessageListener listener6(
237 "changeIncognitoOnlyBack regular ready", true);
238 ExtensionTestMessageListener listener_incognito6(
239 "changeIncognitoOnlyBack incognito ready", true);
240 ExtensionTestMessageListener listener7(
241 "changeIncognitoOnlyBack regular listening", true);
242 ExtensionTestMessageListener listener_incognito7(
243 "changeIncognitoOnlyBack incognito pref set", false);
244
245 // clearIncognito listeners.
246 ExtensionTestMessageListener listener8(
247 "clearIncognito regular ready", true);
248 ExtensionTestMessageListener listener_incognito8(
249 "clearIncognito incognito ready", true);
250 ExtensionTestMessageListener listener9(
251 "clearIncognito regular listening", true);
252 ExtensionTestMessageListener listener_incognito9(
253 "clearIncognito incognito pref cleared", false);
254
255 // clearDefault listeners.
256 ExtensionTestMessageListener listener10(
257 "clearDefault regular ready", true);
258 ExtensionTestMessageListener listener_incognito10(
259 "clearDefault incognito ready", true);
260
261 base::FilePath extension_data_dir =
262 test_data_dir_.AppendASCII("preference").AppendASCII("onchange_split");
263 ASSERT_TRUE(LoadExtensionIncognito(extension_data_dir));
264
265 // Test 1 - changeDefault
266 EXPECT_TRUE(listener1.WaitUntilSatisfied()); // Regular ready
267 EXPECT_TRUE(listener_incognito1.WaitUntilSatisfied()); // Incognito ready
268 listener1.Reply("ok");
269 listener_incognito1.Reply("ok");
270
271 // Test 2 - changeIncognitoOnly
272 EXPECT_TRUE(listener2.WaitUntilSatisfied()); // Regular ready
273 EXPECT_TRUE(listener_incognito2.WaitUntilSatisfied()); // Incognito ready
274 EXPECT_TRUE(listener3.WaitUntilSatisfied()); // Regular listening
275 listener2.Reply("ok");
276 listener_incognito2.Reply("ok");
277 // Incognito preference set -- notify the regular listener
278 EXPECT_TRUE(listener_incognito3.WaitUntilSatisfied());
279 listener3.Reply("ok");
280
281 // Test 3 - changeDefaultOnly
282 EXPECT_TRUE(listener4.WaitUntilSatisfied()); // Regular ready
283 EXPECT_TRUE(listener_incognito4.WaitUntilSatisfied()); // Incognito ready
284 EXPECT_TRUE(listener_incognito5.WaitUntilSatisfied()); // Incognito listening
285 listener4.Reply("ok");
286 listener_incognito4.Reply("ok");
287 // Regular preference set - notify the incognito listener
288 EXPECT_TRUE(listener5.WaitUntilSatisfied());
289 listener_incognito5.Reply("ok");
290
291 // Test 4 - changeIncognitoOnlyBack
292 EXPECT_TRUE(listener6.WaitUntilSatisfied()); // Regular ready
293 EXPECT_TRUE(listener_incognito6.WaitUntilSatisfied()); // Incognito ready
294 EXPECT_TRUE(listener7.WaitUntilSatisfied()); // Regular listening
295 listener6.Reply("ok");
296 listener_incognito6.Reply("ok");
297 // Incognito preference set -- notify the regular listener
298 EXPECT_TRUE(listener_incognito7.WaitUntilSatisfied());
299 listener7.Reply("ok");
300
301 // Test 5 - clearIncognito
302 EXPECT_TRUE(listener8.WaitUntilSatisfied()); // Regular ready
303 EXPECT_TRUE(listener_incognito8.WaitUntilSatisfied()); // Incognito ready
304 EXPECT_TRUE(listener9.WaitUntilSatisfied()); // Regular listening
305 listener8.Reply("ok");
306 listener_incognito8.Reply("ok");
307 // Incognito preference cleared -- notify the regular listener
308 EXPECT_TRUE(listener_incognito9.WaitUntilSatisfied());
309 listener9.Reply("ok");
310
311 // Test 6 - clearDefault
312 EXPECT_TRUE(listener10.WaitUntilSatisfied()); // Regular ready
313 EXPECT_TRUE(listener_incognito10.WaitUntilSatisfied()); // Incognito ready
314 listener10.Reply("ok");
315 listener_incognito10.Reply("ok");
316
317 EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
318 EXPECT_TRUE(catcher_incognito.GetNextResult()) << catcher.message();
319 }
320