chrome/browser/extensions/api/preference/preference_apitest.cc

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