Home | History | Annotate | Download | only in preference
      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/extensions/extension_apitest.h"
      8 #include "chrome/browser/extensions/extension_test_message_listener.h"
      9 #include "chrome/browser/profiles/profile.h"
     10 #include "chrome/browser/ui/browser.h"
     11 #include "chrome/common/chrome_switches.h"
     12 #include "chrome/common/pref_names.h"
     13 #include "chrome/test/base/ui_test_utils.h"
     14 
     15 IN_PROC_BROWSER_TEST_F(ExtensionApiTest, PreferenceApi) {
     16   PrefService* pref_service = browser()->profile()->GetPrefs();
     17   pref_service->SetBoolean(prefs::kAlternateErrorPagesEnabled, false);
     18   pref_service->SetBoolean(autofill::prefs::kAutofillEnabled, false);
     19   pref_service->SetBoolean(prefs::kBlockThirdPartyCookies, true);
     20   pref_service->SetBoolean(prefs::kEnableHyperlinkAuditing, false);
     21   pref_service->SetBoolean(prefs::kEnableReferrers, false);
     22   pref_service->SetBoolean(prefs::kEnableTranslate, false);
     23   pref_service->SetBoolean(prefs::kNetworkPredictionEnabled, false);
     24   pref_service->SetBoolean(prefs::kSafeBrowsingEnabled, false);
     25   pref_service->SetBoolean(prefs::kSearchSuggestEnabled, false);
     26 
     27   EXPECT_TRUE(RunExtensionTest("preference/standard")) << message_;
     28 
     29   const PrefService::Preference* pref = pref_service->FindPreference(
     30       prefs::kBlockThirdPartyCookies);
     31   ASSERT_TRUE(pref);
     32   EXPECT_TRUE(pref->IsExtensionControlled());
     33   EXPECT_TRUE(pref_service->GetBoolean(prefs::kAlternateErrorPagesEnabled));
     34   EXPECT_TRUE(pref_service->GetBoolean(autofill::prefs::kAutofillEnabled));
     35   EXPECT_FALSE(pref_service->GetBoolean(prefs::kBlockThirdPartyCookies));
     36   EXPECT_TRUE(pref_service->GetBoolean(prefs::kEnableHyperlinkAuditing));
     37   EXPECT_TRUE(pref_service->GetBoolean(prefs::kEnableReferrers));
     38   EXPECT_TRUE(pref_service->GetBoolean(prefs::kEnableTranslate));
     39   EXPECT_TRUE(pref_service->GetBoolean(prefs::kNetworkPredictionEnabled));
     40   EXPECT_TRUE(pref_service->GetBoolean(prefs::kSafeBrowsingEnabled));
     41   EXPECT_TRUE(pref_service->GetBoolean(prefs::kSearchSuggestEnabled));
     42 }
     43 
     44 IN_PROC_BROWSER_TEST_F(ExtensionApiTest, PreferencePersistentIncognito) {
     45   PrefService* prefs = browser()->profile()->GetPrefs();
     46   prefs->SetBoolean(prefs::kBlockThirdPartyCookies, false);
     47 
     48   EXPECT_TRUE(
     49       RunExtensionTestIncognito("preference/persistent_incognito")) <<
     50       message_;
     51 
     52   // Setting an incognito preference should not create an incognito profile.
     53   EXPECT_FALSE(browser()->profile()->HasOffTheRecordProfile());
     54 
     55   PrefService* otr_prefs =
     56       browser()->profile()->GetOffTheRecordProfile()->GetPrefs();
     57   const PrefService::Preference* pref =
     58       otr_prefs->FindPreference(prefs::kBlockThirdPartyCookies);
     59   ASSERT_TRUE(pref);
     60   EXPECT_TRUE(pref->IsExtensionControlled());
     61   EXPECT_TRUE(otr_prefs->GetBoolean(prefs::kBlockThirdPartyCookies));
     62 
     63   pref = prefs->FindPreference(prefs::kBlockThirdPartyCookies);
     64   ASSERT_TRUE(pref);
     65   EXPECT_FALSE(pref->IsExtensionControlled());
     66   EXPECT_FALSE(prefs->GetBoolean(prefs::kBlockThirdPartyCookies));
     67 }
     68 
     69 // Flakily times out: http://crbug.com/106144
     70 IN_PROC_BROWSER_TEST_F(ExtensionApiTest, DISABLED_PreferenceIncognitoDisabled) {
     71   EXPECT_FALSE(RunExtensionTest("preference/persistent_incognito"));
     72 }
     73 
     74 IN_PROC_BROWSER_TEST_F(ExtensionApiTest, PreferenceSessionOnlyIncognito) {
     75   PrefService* prefs = browser()->profile()->GetPrefs();
     76   prefs->SetBoolean(prefs::kBlockThirdPartyCookies, false);
     77 
     78   EXPECT_TRUE(
     79       RunExtensionTestIncognito("preference/session_only_incognito")) <<
     80       message_;
     81 
     82   EXPECT_TRUE(browser()->profile()->HasOffTheRecordProfile());
     83 
     84   PrefService* otr_prefs =
     85       browser()->profile()->GetOffTheRecordProfile()->GetPrefs();
     86   const PrefService::Preference* pref =
     87       otr_prefs->FindPreference(prefs::kBlockThirdPartyCookies);
     88   ASSERT_TRUE(pref);
     89   EXPECT_TRUE(pref->IsExtensionControlled());
     90   EXPECT_FALSE(otr_prefs->GetBoolean(prefs::kBlockThirdPartyCookies));
     91 
     92   pref = prefs->FindPreference(prefs::kBlockThirdPartyCookies);
     93   ASSERT_TRUE(pref);
     94   EXPECT_FALSE(pref->IsExtensionControlled());
     95   EXPECT_FALSE(prefs->GetBoolean(prefs::kBlockThirdPartyCookies));
     96 }
     97 
     98 IN_PROC_BROWSER_TEST_F(ExtensionApiTest, PreferenceClear) {
     99   PrefService* pref_service = browser()->profile()->GetPrefs();
    100   pref_service->SetBoolean(prefs::kBlockThirdPartyCookies, true);
    101 
    102   EXPECT_TRUE(RunExtensionTest("preference/clear")) << message_;
    103 
    104   const PrefService::Preference* pref = pref_service->FindPreference(
    105       prefs::kBlockThirdPartyCookies);
    106   ASSERT_TRUE(pref);
    107   EXPECT_FALSE(pref->IsExtensionControlled());
    108   EXPECT_EQ(true, pref_service->GetBoolean(prefs::kBlockThirdPartyCookies));
    109 }
    110 
    111 IN_PROC_BROWSER_TEST_F(ExtensionApiTest, PreferenceOnChange) {
    112   EXPECT_TRUE(RunExtensionTestIncognito("preference/onchange")) <<
    113       message_;
    114 }
    115 
    116 IN_PROC_BROWSER_TEST_F(ExtensionApiTest, PreferenceOnChangeSplit) {
    117   ResultCatcher catcher;
    118   catcher.RestrictToProfile(browser()->profile());
    119   ResultCatcher catcher_incognito;
    120   catcher_incognito.RestrictToProfile(
    121       browser()->profile()->GetOffTheRecordProfile());
    122 
    123   // Open an incognito window.
    124   ui_test_utils::OpenURLOffTheRecord(browser()->profile(),
    125                                      GURL("chrome://newtab/"));
    126 
    127   // changeDefault listeners.
    128   ExtensionTestMessageListener listener1("changeDefault regular ready", true);
    129   ExtensionTestMessageListener listener_incognito1(
    130       "changeDefault incognito ready", true);
    131 
    132   // changeIncognitoOnly listeners.
    133   ExtensionTestMessageListener listener2(
    134       "changeIncognitoOnly regular ready", true);
    135   ExtensionTestMessageListener listener_incognito2(
    136       "changeIncognitoOnly incognito ready", true);
    137   ExtensionTestMessageListener listener3(
    138       "changeIncognitoOnly regular listening", true);
    139   ExtensionTestMessageListener listener_incognito3(
    140       "changeIncognitoOnly incognito pref set", false);
    141 
    142   // changeDefaultOnly listeners.
    143   ExtensionTestMessageListener listener4(
    144       "changeDefaultOnly regular ready", true);
    145   ExtensionTestMessageListener listener_incognito4(
    146       "changeDefaultOnly incognito ready", true);
    147   ExtensionTestMessageListener listener5(
    148       "changeDefaultOnly regular pref set", false);
    149   ExtensionTestMessageListener listener_incognito5(
    150       "changeDefaultOnly incognito listening", true);
    151 
    152   // changeIncognitoOnlyBack listeners.
    153   ExtensionTestMessageListener listener6(
    154       "changeIncognitoOnlyBack regular ready", true);
    155   ExtensionTestMessageListener listener_incognito6(
    156       "changeIncognitoOnlyBack incognito ready", true);
    157   ExtensionTestMessageListener listener7(
    158       "changeIncognitoOnlyBack regular listening", true);
    159   ExtensionTestMessageListener listener_incognito7(
    160       "changeIncognitoOnlyBack incognito pref set", false);
    161 
    162   // clearIncognito listeners.
    163   ExtensionTestMessageListener listener8(
    164       "clearIncognito regular ready", true);
    165   ExtensionTestMessageListener listener_incognito8(
    166       "clearIncognito incognito ready", true);
    167   ExtensionTestMessageListener listener9(
    168       "clearIncognito regular listening", true);
    169   ExtensionTestMessageListener listener_incognito9(
    170       "clearIncognito incognito pref cleared", false);
    171 
    172   // clearDefault listeners.
    173   ExtensionTestMessageListener listener10(
    174       "clearDefault regular ready", true);
    175   ExtensionTestMessageListener listener_incognito10(
    176       "clearDefault incognito ready", true);
    177 
    178   base::FilePath extension_data_dir =
    179       test_data_dir_.AppendASCII("preference").AppendASCII("onchange_split");
    180   ASSERT_TRUE(LoadExtensionIncognito(extension_data_dir));
    181 
    182   // Test 1 - changeDefault
    183   EXPECT_TRUE(listener1.WaitUntilSatisfied()); // Regular ready
    184   EXPECT_TRUE(listener_incognito1.WaitUntilSatisfied()); // Incognito ready
    185   listener1.Reply("ok");
    186   listener_incognito1.Reply("ok");
    187 
    188   // Test 2 - changeIncognitoOnly
    189   EXPECT_TRUE(listener2.WaitUntilSatisfied()); // Regular ready
    190   EXPECT_TRUE(listener_incognito2.WaitUntilSatisfied()); // Incognito ready
    191   EXPECT_TRUE(listener3.WaitUntilSatisfied()); // Regular listening
    192   listener2.Reply("ok");
    193   listener_incognito2.Reply("ok");
    194   // Incognito preference set -- notify the regular listener
    195   EXPECT_TRUE(listener_incognito3.WaitUntilSatisfied());
    196   listener3.Reply("ok");
    197 
    198   // Test 3 - changeDefaultOnly
    199   EXPECT_TRUE(listener4.WaitUntilSatisfied()); // Regular ready
    200   EXPECT_TRUE(listener_incognito4.WaitUntilSatisfied()); // Incognito ready
    201   EXPECT_TRUE(listener_incognito5.WaitUntilSatisfied()); // Incognito listening
    202   listener4.Reply("ok");
    203   listener_incognito4.Reply("ok");
    204   // Regular preference set - notify the incognito listener
    205   EXPECT_TRUE(listener5.WaitUntilSatisfied());
    206   listener_incognito5.Reply("ok");
    207 
    208   // Test 4 - changeIncognitoOnlyBack
    209   EXPECT_TRUE(listener6.WaitUntilSatisfied()); // Regular ready
    210   EXPECT_TRUE(listener_incognito6.WaitUntilSatisfied()); // Incognito ready
    211   EXPECT_TRUE(listener7.WaitUntilSatisfied()); // Regular listening
    212   listener6.Reply("ok");
    213   listener_incognito6.Reply("ok");
    214   // Incognito preference set -- notify the regular listener
    215   EXPECT_TRUE(listener_incognito7.WaitUntilSatisfied());
    216   listener7.Reply("ok");
    217 
    218   // Test 5 - clearIncognito
    219   EXPECT_TRUE(listener8.WaitUntilSatisfied()); // Regular ready
    220   EXPECT_TRUE(listener_incognito8.WaitUntilSatisfied()); // Incognito ready
    221   EXPECT_TRUE(listener9.WaitUntilSatisfied()); // Regular listening
    222   listener8.Reply("ok");
    223   listener_incognito8.Reply("ok");
    224   // Incognito preference cleared -- notify the regular listener
    225   EXPECT_TRUE(listener_incognito9.WaitUntilSatisfied());
    226   listener9.Reply("ok");
    227 
    228   // Test 6 - clearDefault
    229   EXPECT_TRUE(listener10.WaitUntilSatisfied()); // Regular ready
    230   EXPECT_TRUE(listener_incognito10.WaitUntilSatisfied()); // Incognito ready
    231   listener10.Reply("ok");
    232   listener_incognito10.Reply("ok");
    233 
    234   EXPECT_TRUE(catcher.GetNextResult()) << catcher.message();
    235   EXPECT_TRUE(catcher_incognito.GetNextResult()) << catcher.message();
    236 }
    237