src/chrome/browser/content_settings/content_settings_policy_provider_unittest.cc

   1 // Copyright (c) 2011 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 "chrome/browser/content_settings/content_settings_policy_provider.h"
   6
   7 #include <string>
   8
   9 #include "base/auto_reset.h"
  10 #include "base/command_line.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/message_loop/message_loop.h"
  13 #include "base/prefs/pref_service.h"
  14 #include "chrome/browser/content_settings/content_settings_mock_observer.h"
  15 #include "chrome/browser/content_settings/content_settings_rule.h"
  16 #include "chrome/browser/content_settings/content_settings_utils.h"
  17 #include "chrome/common/chrome_switches.h"
  18 #include "chrome/common/pref_names.h"
  19 #include "chrome/common/url_constants.h"
  20 #include "chrome/test/base/testing_pref_service_syncable.h"
  21 #include "chrome/test/base/testing_profile.h"
  22 #include "content/public/test/test_browser_thread.h"
  23 #include "testing/gtest/include/gtest/gtest.h"
  24 #include "url/gurl.h"
  25
  26 using ::testing::_;
  27 using content::BrowserThread;
  28
  29 namespace content_settings {
  30
  31 typedef std::vector<Rule> Rules;
  32
  33 class PolicyProviderTest : public testing::Test {
  34  public:
  35   PolicyProviderTest()
  36       : ui_thread_(BrowserThread::UI, &message_loop_) {
  37   }
  38
  39  protected:
  40   // TODO(markusheintz): Check if it's possible to derive the provider class
  41   // from NonThreadSafe and to use native thread identifiers instead of
  42   // BrowserThread IDs. Then we could get rid of the message_loop and ui_thread
  43   // fields.
  44   base::MessageLoop message_loop_;
  45   content::TestBrowserThread ui_thread_;
  46 };
  47
  48 TEST_F(PolicyProviderTest, DefaultGeolocationContentSetting) {
  49   TestingProfile profile;
  50   TestingPrefServiceSyncable* prefs = profile.GetTestingPrefService();
  51   PolicyProvider provider(prefs);
  52
  53   Rules rules;
  54
  55   scoped_ptr<RuleIterator> rule_iterator(
  56       provider.GetRuleIterator(
  57           CONTENT_SETTINGS_TYPE_GEOLOCATION,
  58           std::string(),
  59           false));
  60   EXPECT_FALSE(rule_iterator->HasNext());
  61
  62   // Change the managed value of the default geolocation setting
  63   prefs->SetManagedPref(prefs::kManagedDefaultGeolocationSetting,
  64                         new base::FundamentalValue(CONTENT_SETTING_BLOCK));
  65
  66   rule_iterator.reset(
  67       provider.GetRuleIterator(
  68           CONTENT_SETTINGS_TYPE_GEOLOCATION,
  69           std::string(),
  70           false));
  71   EXPECT_TRUE(rule_iterator->HasNext());
  72   Rule rule = rule_iterator->Next();
  73   EXPECT_FALSE(rule_iterator->HasNext());
  74
  75   EXPECT_EQ(ContentSettingsPattern::Wildcard(), rule.primary_pattern);
  76   EXPECT_EQ(ContentSettingsPattern::Wildcard(), rule.secondary_pattern);
  77   EXPECT_EQ(CONTENT_SETTING_BLOCK, ValueToContentSetting(rule.value.get()));
  78
  79   provider.ShutdownOnUIThread();
  80 }
  81
  82 TEST_F(PolicyProviderTest, ManagedDefaultContentSettings) {
  83   TestingProfile profile;
  84   TestingPrefServiceSyncable* prefs = profile.GetTestingPrefService();
  85   PolicyProvider provider(prefs);
  86
  87   prefs->SetManagedPref(prefs::kManagedDefaultPluginsSetting,
  88                         new base::FundamentalValue(CONTENT_SETTING_BLOCK));
  89
  90   scoped_ptr<RuleIterator> rule_iterator(
  91       provider.GetRuleIterator(
  92           CONTENT_SETTINGS_TYPE_PLUGINS,
  93           std::string(),
  94           false));
  95   EXPECT_TRUE(rule_iterator->HasNext());
  96   Rule rule = rule_iterator->Next();
  97   EXPECT_FALSE(rule_iterator->HasNext());
  98
  99   EXPECT_EQ(ContentSettingsPattern::Wildcard(), rule.primary_pattern);
 100   EXPECT_EQ(ContentSettingsPattern::Wildcard(), rule.secondary_pattern);
 101   EXPECT_EQ(CONTENT_SETTING_BLOCK, ValueToContentSetting(rule.value.get()));
 102
 103   provider.ShutdownOnUIThread();
 104 }
 105
 106 // When a default-content-setting is set to a managed setting a
 107 // CONTENT_SETTINGS_CHANGED notification should be fired. The same should happen
 108 // if the managed setting is removed.
 109 TEST_F(PolicyProviderTest, ObserveManagedSettingsChange) {
 110   TestingProfile profile;
 111   TestingPrefServiceSyncable* prefs = profile.GetTestingPrefService();
 112   PolicyProvider provider(prefs);
 113
 114   MockObserver mock_observer;
 115   EXPECT_CALL(mock_observer,
 116               OnContentSettingChanged(_,
 117                                       _,
 118                                       CONTENT_SETTINGS_TYPE_DEFAULT,
 119                                       ""));
 120   provider.AddObserver(&mock_observer);
 121
 122   // Set the managed default-content-setting.
 123   prefs->SetManagedPref(prefs::kManagedDefaultImagesSetting,
 124                         new base::FundamentalValue(CONTENT_SETTING_BLOCK));
 125   ::testing::Mock::VerifyAndClearExpectations(&mock_observer);
 126   EXPECT_CALL(mock_observer,
 127               OnContentSettingChanged(_,
 128                                       _,
 129                                       CONTENT_SETTINGS_TYPE_DEFAULT,
 130                                       ""));
 131   // Remove the managed default-content-setting.
 132   prefs->RemoveManagedPref(prefs::kManagedDefaultImagesSetting);
 133   provider.ShutdownOnUIThread();
 134 }
 135
 136 TEST_F(PolicyProviderTest, GettingManagedContentSettings) {
 137   TestingProfile profile;
 138   TestingPrefServiceSyncable* prefs = profile.GetTestingPrefService();
 139
 140   base::ListValue* value = new base::ListValue();
 141   value->Append(new base::StringValue("[*.]google.com"));
 142   prefs->SetManagedPref(prefs::kManagedImagesBlockedForUrls,
 143                         value);
 144
 145   PolicyProvider provider(prefs);
 146
 147   ContentSettingsPattern yt_url_pattern =
 148       ContentSettingsPattern::FromString("www.youtube.com");
 149   GURL youtube_url("http://www.youtube.com");
 150   GURL google_url("http://mail.google.com");
 151
 152   EXPECT_EQ(CONTENT_SETTING_DEFAULT,
 153             GetContentSetting(&provider,
 154                               youtube_url,
 155                               youtube_url,
 156                               CONTENT_SETTINGS_TYPE_COOKIES,
 157                               std::string(),
 158                               false));
 159   EXPECT_EQ(NULL,
 160             GetContentSettingValue(&provider,
 161                                    youtube_url,
 162                                    youtube_url,
 163                                    CONTENT_SETTINGS_TYPE_COOKIES,
 164                                    std::string(),
 165                                    false));
 166
 167   EXPECT_EQ(CONTENT_SETTING_BLOCK,
 168             GetContentSetting(&provider,
 169                               google_url,
 170                               google_url,
 171                               CONTENT_SETTINGS_TYPE_IMAGES,
 172                               std::string(),
 173                               false));
 174   scoped_ptr<base::Value> value_ptr(
 175       GetContentSettingValue(&provider,
 176                              google_url,
 177                              google_url,
 178                              CONTENT_SETTINGS_TYPE_IMAGES,
 179                              std::string(),
 180                              false));
 181
 182   int int_value = -1;
 183   value_ptr->GetAsInteger(&int_value);
 184   EXPECT_EQ(CONTENT_SETTING_BLOCK, IntToContentSetting(int_value));
 185
 186   // The PolicyProvider does not allow setting content settings as they are
 187   // enforced via policies and not set by the user or extension. So a call to
 188   // SetWebsiteSetting does nothing.
 189   scoped_ptr<base::Value> value_block(
 190       new base::FundamentalValue(CONTENT_SETTING_BLOCK));
 191   bool owned = provider.SetWebsiteSetting(yt_url_pattern,
 192                                           yt_url_pattern,
 193                                           CONTENT_SETTINGS_TYPE_COOKIES,
 194                                           std::string(),
 195                                           value_block.get());
 196   EXPECT_FALSE(owned);
 197   EXPECT_EQ(CONTENT_SETTING_DEFAULT,
 198             GetContentSetting(&provider,
 199                               youtube_url,
 200                               youtube_url,
 201                               CONTENT_SETTINGS_TYPE_COOKIES,
 202                               std::string(),
 203                               false));
 204
 205   provider.ShutdownOnUIThread();
 206 }
 207
 208 TEST_F(PolicyProviderTest, ResourceIdentifier) {
 209   TestingProfile profile;
 210   TestingPrefServiceSyncable* prefs = profile.GetTestingPrefService();
 211
 212   base::ListValue* value = new base::ListValue();
 213   value->Append(new base::StringValue("[*.]google.com"));
 214   prefs->SetManagedPref(prefs::kManagedPluginsAllowedForUrls,
 215                         value);
 216
 217   PolicyProvider provider(prefs);
 218
 219   GURL youtube_url("http://www.youtube.com");
 220   GURL google_url("http://mail.google.com");
 221
 222   EXPECT_EQ(CONTENT_SETTING_DEFAULT,
 223             GetContentSetting(
 224                 &provider, youtube_url, youtube_url,
 225                 CONTENT_SETTINGS_TYPE_PLUGINS, "someplugin", false));
 226
 227   // There is currently no policy support for resource content settings.
 228   // Resource identifiers are simply ignored by the PolicyProvider.
 229   EXPECT_EQ(CONTENT_SETTING_ALLOW,
 230             GetContentSetting(&provider,
 231                               google_url,
 232                               google_url,
 233                               CONTENT_SETTINGS_TYPE_PLUGINS,
 234                               std::string(),
 235                               false));
 236
 237   EXPECT_EQ(CONTENT_SETTING_DEFAULT,
 238             GetContentSetting(
 239                 &provider, google_url, google_url,
 240                 CONTENT_SETTINGS_TYPE_PLUGINS, "someplugin", false));
 241
 242   provider.ShutdownOnUIThread();
 243 }
 244
 245 TEST_F(PolicyProviderTest, AutoSelectCertificateList) {
 246   TestingProfile profile;
 247   TestingPrefServiceSyncable* prefs = profile.GetTestingPrefService();
 248
 249   PolicyProvider provider(prefs);
 250   GURL google_url("https://mail.google.com");
 251   // Tests the default setting for auto selecting certificates
 252   EXPECT_EQ(
 253       NULL,
 254       GetContentSettingValue(&provider,
 255                              google_url,
 256                              google_url,
 257                              CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE,
 258                              std::string(),
 259                              false));
 260
 261   // Set the content settings pattern list for origins to auto select
 262   // certificates.
 263   std::string pattern_str("\"pattern\":\"[*.]google.com\"");
 264   std::string filter_str("\"filter\":{\"ISSUER\":{\"CN\":\"issuer name\"}}");
 265   base::ListValue* value = new base::ListValue();
 266   value->Append(
 267       new base::StringValue("{" + pattern_str + "," + filter_str + "}"));
 268   prefs->SetManagedPref(prefs::kManagedAutoSelectCertificateForUrls,
 269                         value);
 270   GURL youtube_url("https://www.youtube.com");
 271   EXPECT_EQ(
 272       NULL,
 273       GetContentSettingValue(&provider,
 274                              youtube_url,
 275                              youtube_url,
 276                              CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE,
 277                              std::string(),
 278                              false));
 279   scoped_ptr<base::Value> cert_filter(
 280       GetContentSettingValue(&provider,
 281                              google_url,
 282                              google_url,
 283                              CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE,
 284                              std::string(),
 285                              false));
 286
 287   ASSERT_EQ(base::Value::TYPE_DICTIONARY, cert_filter->GetType());
 288   base::DictionaryValue* dict_value =
 289       static_cast<base::DictionaryValue*>(cert_filter.get());
 290   std::string actual_common_name;
 291   ASSERT_TRUE(dict_value->GetString("ISSUER.CN", &actual_common_name));
 292   EXPECT_EQ("issuer name", actual_common_name);
 293   provider.ShutdownOnUIThread();
 294 }
 295
 296 }  // namespace content_settings