src/chrome/browser/content_settings/tab_specific_content_settings_unittest.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/strings/string16.h"
   6 #include "base/strings/utf_string_conversions.h"
   7 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
   8 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
   9 #include "chrome/test/base/testing_profile.h"
  10 #include "content/public/test/test_browser_thread.h"
  11 #include "net/cookies/canonical_cookie.h"
  12 #include "net/cookies/cookie_options.h"
  13 #include "net/cookies/parsed_cookie.h"
  14 #include "testing/gmock/include/gmock/gmock.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16
  17 using content::BrowserThread;
  18
  19 namespace {
  20
  21 class MockSiteDataObserver
  22     : public TabSpecificContentSettings::SiteDataObserver {
  23  public:
  24   explicit MockSiteDataObserver(
  25       TabSpecificContentSettings* tab_specific_content_settings)
  26       : SiteDataObserver(tab_specific_content_settings) {
  27   }
  28
  29   virtual ~MockSiteDataObserver() {}
  30
  31   MOCK_METHOD0(OnSiteDataAccessed, void());
  32
  33  private:
  34   DISALLOW_COPY_AND_ASSIGN(MockSiteDataObserver);
  35 };
  36
  37 }  // namespace
  38
  39 class TabSpecificContentSettingsTest : public ChromeRenderViewHostTestHarness {
  40  public:
  41   virtual void SetUp() OVERRIDE {
  42     ChromeRenderViewHostTestHarness::SetUp();
  43     TabSpecificContentSettings::CreateForWebContents(web_contents());
  44   }
  45 };
  46
  47 TEST_F(TabSpecificContentSettingsTest, BlockedContent) {
  48   TabSpecificContentSettings* content_settings =
  49       TabSpecificContentSettings::FromWebContents(web_contents());
  50   net::CookieOptions options;
  51
  52   // Check that after initializing, nothing is blocked.
  53   EXPECT_FALSE(
  54       content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_IMAGES));
  55   EXPECT_FALSE(
  56       content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_JAVASCRIPT));
  57   EXPECT_FALSE(
  58       content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_PLUGINS));
  59   EXPECT_FALSE(
  60       content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES));
  61   EXPECT_FALSE(
  62       content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_POPUPS));
  63   EXPECT_FALSE(content_settings->IsContentBlocked(
  64       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
  65   EXPECT_FALSE(content_settings->IsContentBlocked(
  66       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
  67
  68   // Set a cookie, block access to images, block mediastream access and block a
  69   // popup.
  70   content_settings->OnCookieChanged(GURL("http://google.com"),
  71                                     GURL("http://google.com"),
  72                                     "A=B",
  73                                     options,
  74                                     false);
  75   content_settings->OnContentBlocked(CONTENT_SETTINGS_TYPE_IMAGES,
  76                                      std::string());
  77   content_settings->SetPopupsBlocked(true);
  78   content_settings->OnContentBlocked(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
  79                                      std::string());
  80   content_settings->OnContentBlocked(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
  81                                      std::string());
  82
  83   // Check that only the respective content types are affected.
  84   EXPECT_TRUE(content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_IMAGES));
  85   EXPECT_FALSE(
  86       content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_JAVASCRIPT));
  87   EXPECT_FALSE(
  88       content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_PLUGINS));
  89   EXPECT_FALSE(
  90       content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES));
  91   EXPECT_TRUE(content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_POPUPS));
  92   EXPECT_TRUE(content_settings->IsContentBlocked(
  93       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
  94   EXPECT_TRUE(content_settings->IsContentBlocked(
  95       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
  96   content_settings->OnCookieChanged(GURL("http://google.com"),
  97                                     GURL("http://google.com"),
  98                                     "A=B",
  99                                     options,
 100                                     false);
 101
 102   // Block a cookie.
 103   content_settings->OnCookieChanged(GURL("http://google.com"),
 104                                     GURL("http://google.com"),
 105                                     "C=D",
 106                                     options,
 107                                     true);
 108   EXPECT_TRUE(
 109       content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES));
 110
 111   // Reset blocked content settings.
 112   content_settings->ClearBlockedContentSettingsExceptForCookies();
 113   EXPECT_FALSE(
 114       content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_IMAGES));
 115   EXPECT_FALSE(
 116       content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_JAVASCRIPT));
 117   EXPECT_FALSE(
 118       content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_PLUGINS));
 119   EXPECT_TRUE(
 120       content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES));
 121   EXPECT_FALSE(
 122       content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_POPUPS));
 123   EXPECT_FALSE(content_settings->IsContentBlocked(
 124       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
 125   EXPECT_FALSE(content_settings->IsContentBlocked(
 126       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
 127
 128   content_settings->ClearCookieSpecificContentSettings();
 129   EXPECT_FALSE(
 130       content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_IMAGES));
 131   EXPECT_FALSE(
 132       content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_JAVASCRIPT));
 133   EXPECT_FALSE(
 134       content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_PLUGINS));
 135   EXPECT_FALSE(
 136       content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES));
 137   EXPECT_FALSE(
 138       content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_POPUPS));
 139   EXPECT_FALSE(content_settings->IsContentBlocked(
 140       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
 141   EXPECT_FALSE(content_settings->IsContentBlocked(
 142       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
 143 }
 144
 145 TEST_F(TabSpecificContentSettingsTest, BlockedFileSystems) {
 146   TabSpecificContentSettings* content_settings =
 147       TabSpecificContentSettings::FromWebContents(web_contents());
 148
 149   // Access a file system.
 150   content_settings->OnFileSystemAccessed(GURL("http://google.com"), false);
 151   EXPECT_FALSE(
 152       content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES));
 153
 154   // Block access to a file system.
 155   content_settings->OnFileSystemAccessed(GURL("http://google.com"), true);
 156   EXPECT_TRUE(
 157       content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES));
 158 }
 159
 160 TEST_F(TabSpecificContentSettingsTest, AllowedContent) {
 161   TabSpecificContentSettings* content_settings =
 162       TabSpecificContentSettings::FromWebContents(web_contents());
 163   net::CookieOptions options;
 164
 165   // Test default settings.
 166   ASSERT_FALSE(
 167       content_settings->IsContentAllowed(CONTENT_SETTINGS_TYPE_IMAGES));
 168   ASSERT_FALSE(
 169       content_settings->IsContentAllowed(CONTENT_SETTINGS_TYPE_COOKIES));
 170   ASSERT_FALSE(
 171       content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES));
 172   ASSERT_FALSE(content_settings->IsContentAllowed(
 173       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
 174   ASSERT_FALSE(content_settings->IsContentAllowed(
 175       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
 176
 177   // Record a cookie.
 178   content_settings->OnCookieChanged(GURL("http://google.com"),
 179                                     GURL("http://google.com"),
 180                                     "A=B",
 181                                     options,
 182                                     false);
 183   ASSERT_TRUE(
 184       content_settings->IsContentAllowed(CONTENT_SETTINGS_TYPE_COOKIES));
 185   ASSERT_FALSE(
 186       content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES));
 187
 188   // Record a blocked cookie.
 189   content_settings->OnCookieChanged(GURL("http://google.com"),
 190                                     GURL("http://google.com"),
 191                                     "C=D",
 192                                     options,
 193                                     true);
 194   ASSERT_TRUE(
 195       content_settings->IsContentAllowed(CONTENT_SETTINGS_TYPE_COOKIES));
 196   ASSERT_TRUE(
 197       content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES));
 198 }
 199
 200 TEST_F(TabSpecificContentSettingsTest, AllowedBlockedMediaContent) {
 201   TabSpecificContentSettings* content_settings =
 202       TabSpecificContentSettings::FromWebContents(web_contents());
 203
 204   ASSERT_EQ(TabSpecificContentSettings::MICROPHONE_CAMERA_NOT_ACCESSED,
 205             content_settings->GetMicrophoneCameraState());
 206
 207   // Request and allow microphone access.
 208   GURL security_origin("http://google.com");
 209   MediaStreamDevicesController::MediaStreamTypeSettingsMap
 210       request_permissions;
 211   request_permissions[content::MEDIA_DEVICE_AUDIO_CAPTURE].permission =
 212       MediaStreamDevicesController::MEDIA_ALLOWED;
 213   content_settings->OnMediaStreamPermissionSet(security_origin,
 214                                                request_permissions);
 215   ASSERT_TRUE(content_settings->IsContentAllowed(
 216       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
 217   ASSERT_FALSE(content_settings->IsContentBlocked(
 218       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
 219   ASSERT_EQ(TabSpecificContentSettings::MICROPHONE_ACCESSED,
 220             content_settings->GetMicrophoneCameraState());
 221
 222   // Request and allow camera access.
 223   request_permissions.clear();
 224   request_permissions[content::MEDIA_DEVICE_VIDEO_CAPTURE].permission =
 225       MediaStreamDevicesController::MEDIA_ALLOWED;
 226   content_settings->OnMediaStreamPermissionSet(security_origin,
 227                                                request_permissions);
 228   ASSERT_TRUE(content_settings->IsContentAllowed(
 229       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
 230   ASSERT_FALSE(content_settings->IsContentBlocked(
 231       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
 232   ASSERT_EQ(TabSpecificContentSettings::MICROPHONE_CAMERA_ACCESSED,
 233             content_settings->GetMicrophoneCameraState());
 234
 235   // Request and block microphone access.
 236   request_permissions.clear();
 237   request_permissions[content::MEDIA_DEVICE_AUDIO_CAPTURE].permission =
 238       MediaStreamDevicesController::MEDIA_BLOCKED_BY_USER;
 239   content_settings->OnMediaStreamPermissionSet(security_origin,
 240                                                request_permissions);
 241   ASSERT_FALSE(content_settings->IsContentAllowed(
 242       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
 243   ASSERT_TRUE(content_settings->IsContentBlocked(
 244       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
 245   ASSERT_EQ(TabSpecificContentSettings::CAMERA_ACCESSED,
 246             content_settings->GetMicrophoneCameraState());
 247
 248   // Request and block camera access.
 249   request_permissions.clear();
 250   request_permissions[content::MEDIA_DEVICE_VIDEO_CAPTURE].permission =
 251       MediaStreamDevicesController::MEDIA_BLOCKED_BY_USER;
 252   content_settings->OnMediaStreamPermissionSet(security_origin,
 253                                                request_permissions);
 254   ASSERT_FALSE(content_settings->IsContentAllowed(
 255       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
 256   ASSERT_TRUE(content_settings->IsContentBlocked(
 257       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
 258   ASSERT_EQ(TabSpecificContentSettings::MICROPHONE_CAMERA_BLOCKED,
 259             content_settings->GetMicrophoneCameraState());
 260
 261   // Request and allow microphone and camera access.
 262   request_permissions[content::MEDIA_DEVICE_AUDIO_CAPTURE].permission =
 263       MediaStreamDevicesController::MEDIA_ALLOWED;
 264   request_permissions[content::MEDIA_DEVICE_VIDEO_CAPTURE].permission =
 265       MediaStreamDevicesController::MEDIA_ALLOWED;
 266   content_settings->OnMediaStreamPermissionSet(security_origin,
 267                                                request_permissions);
 268   ASSERT_TRUE(content_settings->IsContentAllowed(
 269       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
 270   ASSERT_FALSE(content_settings->IsContentBlocked(
 271       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
 272   ASSERT_TRUE(content_settings->IsContentAllowed(
 273       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
 274   ASSERT_FALSE(content_settings->IsContentBlocked(
 275       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
 276   ASSERT_EQ(TabSpecificContentSettings::MICROPHONE_CAMERA_ACCESSED,
 277             content_settings->GetMicrophoneCameraState());
 278
 279   // Request and block microphone and camera access.
 280   request_permissions[content::MEDIA_DEVICE_AUDIO_CAPTURE].permission =
 281       MediaStreamDevicesController::MEDIA_BLOCKED_BY_USER;
 282   request_permissions[content::MEDIA_DEVICE_VIDEO_CAPTURE].permission =
 283       MediaStreamDevicesController::MEDIA_BLOCKED_BY_USER;
 284   content_settings->OnMediaStreamPermissionSet(security_origin,
 285                                                request_permissions);
 286   ASSERT_FALSE(content_settings->IsContentAllowed(
 287       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
 288   ASSERT_TRUE(content_settings->IsContentBlocked(
 289       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
 290   ASSERT_FALSE(content_settings->IsContentAllowed(
 291       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
 292   ASSERT_TRUE(content_settings->IsContentBlocked(
 293       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
 294   ASSERT_EQ(TabSpecificContentSettings::MICROPHONE_CAMERA_BLOCKED,
 295             content_settings->GetMicrophoneCameraState());
 296
 297   // Request microphone and camera access. Allow microphone, block camera.
 298   request_permissions[content::MEDIA_DEVICE_AUDIO_CAPTURE].permission =
 299       MediaStreamDevicesController::MEDIA_ALLOWED;
 300   content_settings->OnMediaStreamPermissionSet(security_origin,
 301                                                request_permissions);
 302   ASSERT_TRUE(content_settings->IsContentAllowed(
 303       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
 304   ASSERT_FALSE(content_settings->IsContentBlocked(
 305       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
 306   ASSERT_FALSE(content_settings->IsContentAllowed(
 307       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
 308   ASSERT_TRUE(content_settings->IsContentBlocked(
 309       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
 310   ASSERT_EQ(TabSpecificContentSettings::MICROPHONE_ACCESSED,
 311             content_settings->GetMicrophoneCameraState());
 312
 313   // Request microphone and camera access. Block microphone, allow camera.
 314   request_permissions[content::MEDIA_DEVICE_AUDIO_CAPTURE].permission =
 315       MediaStreamDevicesController::MEDIA_BLOCKED_BY_USER;
 316   request_permissions[content::MEDIA_DEVICE_VIDEO_CAPTURE].permission =
 317       MediaStreamDevicesController::MEDIA_ALLOWED;
 318   content_settings->OnMediaStreamPermissionSet(security_origin,
 319                                                request_permissions);
 320   ASSERT_FALSE(content_settings->IsContentAllowed(
 321       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
 322   ASSERT_TRUE(content_settings->IsContentBlocked(
 323       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC));
 324   ASSERT_TRUE(content_settings->IsContentAllowed(
 325       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
 326   ASSERT_FALSE(content_settings->IsContentBlocked(
 327       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA));
 328   ASSERT_EQ(TabSpecificContentSettings::CAMERA_ACCESSED,
 329             content_settings->GetMicrophoneCameraState());
 330 }
 331
 332 TEST_F(TabSpecificContentSettingsTest, EmptyCookieList) {
 333   TabSpecificContentSettings* content_settings =
 334       TabSpecificContentSettings::FromWebContents(web_contents());
 335
 336   ASSERT_FALSE(
 337       content_settings->IsContentAllowed(CONTENT_SETTINGS_TYPE_COOKIES));
 338   ASSERT_FALSE(
 339       content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES));
 340   content_settings->OnCookiesRead(GURL("http://google.com"),
 341                                   GURL("http://google.com"),
 342                                   net::CookieList(),
 343                                   true);
 344   ASSERT_FALSE(
 345       content_settings->IsContentAllowed(CONTENT_SETTINGS_TYPE_COOKIES));
 346   ASSERT_FALSE(
 347       content_settings->IsContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES));
 348 }
 349
 350 TEST_F(TabSpecificContentSettingsTest, SiteDataObserver) {
 351   TabSpecificContentSettings* content_settings =
 352       TabSpecificContentSettings::FromWebContents(web_contents());
 353   MockSiteDataObserver mock_observer(content_settings);
 354   EXPECT_CALL(mock_observer, OnSiteDataAccessed()).Times(6);
 355
 356   bool blocked_by_policy = false;
 357   content_settings->OnCookieChanged(GURL("http://google.com"),
 358                                     GURL("http://google.com"),
 359                                     "A=B",
 360                                     net::CookieOptions(),
 361                                     blocked_by_policy);
 362   net::CookieList cookie_list;
 363   scoped_ptr<net::CanonicalCookie> cookie(
 364       net::CanonicalCookie::Create(GURL("http://google.com"),
 365                                    "CookieName=CookieValue",
 366                                    base::Time::Now(), net::CookieOptions()));
 367
 368   cookie_list.push_back(*cookie);
 369   content_settings->OnCookiesRead(GURL("http://google.com"),
 370                                   GURL("http://google.com"),
 371                                   cookie_list,
 372                                   blocked_by_policy);
 373   content_settings->OnFileSystemAccessed(GURL("http://google.com"),
 374                                               blocked_by_policy);
 375   content_settings->OnIndexedDBAccessed(GURL("http://google.com"),
 376                                         UTF8ToUTF16("text"),
 377                                         blocked_by_policy);
 378   content_settings->OnLocalStorageAccessed(GURL("http://google.com"),
 379                                            true,
 380                                            blocked_by_policy);
 381   content_settings->OnWebDatabaseAccessed(GURL("http://google.com"),
 382                                           UTF8ToUTF16("name"),
 383                                           UTF8ToUTF16("display_name"),
 384                                           blocked_by_policy);
 385 }