src/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/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
  21 void ReleaseBrowserProcessModule() {
  22   g_browser_process->ReleaseModule();
  23 }
  24
  25 }  // namespace
  26
  27 class ExtensionPreferenceApiTest : public ExtensionApiTest {
  28  protected:
  29   ExtensionPreferenceApiTest() : profile_(NULL) {}
  30
  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
  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
  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
  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
  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,
 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
 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
 156 IN_PROC_BROWSER_TEST_F(ExtensionPreferenceApiTest, DISABLED_IncognitoDisabled) {
 157   EXPECT_FALSE(RunExtensionTest("preference/persistent_incognito"));
 158 }
 159
 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
 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
 196 IN_PROC_BROWSER_TEST_F(ExtensionPreferenceApiTest, OnChange) {
 197   EXPECT_TRUE(RunExtensionTestIncognito("preference/onchange")) <<
 198       message_;
 199 }
 200
 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 }