chrome/browser/ui/website_settings/website_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 "chrome/browser/ui/website_settings/website_settings.h"
   6
   7 #include "base/at_exit.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "base/strings/string16.h"
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "chrome/browser/infobars/infobar_service.h"
  12 #include "chrome/browser/ui/website_settings/website_settings_ui.h"
  13 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
  14 #include "chrome/test/base/testing_profile.h"
  15 #include "components/content_settings/core/browser/host_content_settings_map.h"
  16 #include "components/content_settings/core/common/content_settings.h"
  17 #include "components/content_settings/core/common/content_settings_types.h"
  18 #include "components/infobars/core/infobar.h"
  19 #include "content/public/browser/cert_store.h"
  20 #include "content/public/common/ssl_status.h"
  21 #include "net/cert/cert_status_flags.h"
  22 #include "net/cert/x509_certificate.h"
  23 #include "net/ssl/ssl_connection_status_flags.h"
  24 #include "net/test/test_certificate_data.h"
  25 #include "testing/gmock/include/gmock/gmock.h"
  26 #include "testing/gtest/include/gtest/gtest.h"
  27
  28 using content::SSLStatus;
  29 using testing::_;
  30 using testing::AnyNumber;
  31 using testing::Return;
  32 using testing::SetArgPointee;
  33
  34 namespace {
  35
  36 // SSL cipher suite like specified in RFC5246 Appendix A.5. "The Cipher Suite".
  37 // Without the CR_ prefix, this clashes with the OS X 10.8 headers.
  38 int CR_TLS_RSA_WITH_AES_256_CBC_SHA256 = 0x3D;
  39
  40 int SetSSLVersion(int connection_status, int version) {
  41   // Clear SSL version bits (Bits 20, 21 and 22).
  42   connection_status &=
  43       ~(net::SSL_CONNECTION_VERSION_MASK << net::SSL_CONNECTION_VERSION_SHIFT);
  44   int bitmask = version << net::SSL_CONNECTION_VERSION_SHIFT;
  45   return bitmask | connection_status;
  46 }
  47
  48 int SetSSLCipherSuite(int connection_status, int cipher_suite) {
  49   // Clear cipher suite bits (the 16 lowest bits).
  50   connection_status &= ~net::SSL_CONNECTION_CIPHERSUITE_MASK;
  51   return cipher_suite | connection_status;
  52 }
  53
  54 class MockCertStore : public content::CertStore {
  55  public:
  56   virtual ~MockCertStore() {}
  57   MOCK_METHOD2(StoreCert, int(net::X509Certificate*, int));
  58   MOCK_METHOD2(RetrieveCert, bool(int, scoped_refptr<net::X509Certificate>*));
  59 };
  60
  61 class MockWebsiteSettingsUI : public WebsiteSettingsUI {
  62  public:
  63   virtual ~MockWebsiteSettingsUI() {}
  64   MOCK_METHOD1(SetCookieInfo, void(const CookieInfoList& cookie_info_list));
  65   MOCK_METHOD1(SetPermissionInfo,
  66                void(const PermissionInfoList& permission_info_list));
  67   MOCK_METHOD1(SetIdentityInfo, void(const IdentityInfo& identity_info));
  68   MOCK_METHOD1(SetFirstVisit, void(const base::string16& first_visit));
  69   MOCK_METHOD1(SetSelectedTab, void(TabId tab_id));
  70 };
  71
  72 class WebsiteSettingsTest : public ChromeRenderViewHostTestHarness {
  73  public:
  74   WebsiteSettingsTest() : cert_id_(0), url_("http://www.example.com") {}
  75
  76   ~WebsiteSettingsTest() override {}
  77
  78   void SetUp() override {
  79     ChromeRenderViewHostTestHarness::SetUp();
  80     // Setup stub SSLStatus.
  81     ssl_.security_style = content::SECURITY_STYLE_UNAUTHENTICATED;
  82
  83     // Create the certificate.
  84     cert_id_ = 1;
  85     base::Time start_date = base::Time::Now();
  86     base::Time expiration_date = base::Time::FromInternalValue(
  87         start_date.ToInternalValue() + base::Time::kMicrosecondsPerWeek);
  88     cert_ = new net::X509Certificate("subject",
  89                                      "issuer",
  90                                      start_date,
  91                                      expiration_date);
  92
  93     TabSpecificContentSettings::CreateForWebContents(web_contents());
  94     InfoBarService::CreateForWebContents(web_contents());
  95
  96     // Setup the mock cert store.
  97     EXPECT_CALL(cert_store_, RetrieveCert(cert_id_, _) )
  98         .Times(AnyNumber())
  99         .WillRepeatedly(DoAll(SetArgPointee<1>(cert_), Return(true)));
 100
 101     // Setup mock ui.
 102     mock_ui_.reset(new MockWebsiteSettingsUI());
 103   }
 104
 105   void TearDown() override {
 106     ASSERT_TRUE(website_settings_.get())
 107         << "No WebsiteSettings instance created.";
 108     RenderViewHostTestHarness::TearDown();
 109     website_settings_.reset();
 110   }
 111
 112   void SetDefaultUIExpectations(MockWebsiteSettingsUI* mock_ui) {
 113     // During creation |WebsiteSettings| makes the following calls to the ui.
 114     EXPECT_CALL(*mock_ui, SetPermissionInfo(_));
 115     EXPECT_CALL(*mock_ui, SetIdentityInfo(_));
 116     EXPECT_CALL(*mock_ui, SetCookieInfo(_));
 117     EXPECT_CALL(*mock_ui, SetFirstVisit(base::string16()));
 118   }
 119
 120   void SetURL(std::string url) { url_ = GURL(url); }
 121
 122   const GURL& url() const { return url_; }
 123   MockCertStore* cert_store() { return &cert_store_; }
 124   int cert_id() { return cert_id_; }
 125   MockWebsiteSettingsUI* mock_ui() { return mock_ui_.get(); }
 126   const SSLStatus& ssl() { return ssl_; }
 127   TabSpecificContentSettings* tab_specific_content_settings() {
 128     return TabSpecificContentSettings::FromWebContents(web_contents());
 129   }
 130   InfoBarService* infobar_service() {
 131     return InfoBarService::FromWebContents(web_contents());
 132   }
 133
 134   WebsiteSettings* website_settings() {
 135     if (!website_settings_.get()) {
 136       website_settings_.reset(new WebsiteSettings(
 137           mock_ui(), profile(), tab_specific_content_settings(),
 138           infobar_service(), url(), ssl(), cert_store()));
 139     }
 140     return website_settings_.get();
 141   }
 142
 143   SSLStatus ssl_;
 144
 145  private:
 146   scoped_ptr<WebsiteSettings> website_settings_;
 147   scoped_ptr<MockWebsiteSettingsUI> mock_ui_;
 148   int cert_id_;
 149   scoped_refptr<net::X509Certificate> cert_;
 150   MockCertStore cert_store_;
 151   GURL url_;
 152 };
 153
 154 }  // namespace
 155
 156 TEST_F(WebsiteSettingsTest, OnPermissionsChanged) {
 157   // Setup site permissions.
 158   HostContentSettingsMap* content_settings =
 159       profile()->GetHostContentSettingsMap();
 160   ContentSetting setting = content_settings->GetContentSetting(
 161       url(), url(), CONTENT_SETTINGS_TYPE_POPUPS, std::string());
 162   EXPECT_EQ(setting, CONTENT_SETTING_BLOCK);
 163   setting = content_settings->GetContentSetting(
 164       url(), url(), CONTENT_SETTINGS_TYPE_PLUGINS, std::string());
 165   EXPECT_EQ(setting, CONTENT_SETTING_ALLOW);
 166   setting = content_settings->GetContentSetting(
 167       url(), url(), CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string());
 168   EXPECT_EQ(setting, CONTENT_SETTING_ASK);
 169   setting = content_settings->GetContentSetting(
 170       url(), url(), CONTENT_SETTINGS_TYPE_NOTIFICATIONS, std::string());
 171   EXPECT_EQ(setting, CONTENT_SETTING_ASK);
 172   setting = content_settings->GetContentSetting(
 173       url(), url(), CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, std::string());
 174   EXPECT_EQ(setting, CONTENT_SETTING_ASK);
 175   setting = content_settings->GetContentSetting(
 176       url(), url(), CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, std::string());
 177   EXPECT_EQ(setting, CONTENT_SETTING_ASK);
 178
 179   EXPECT_CALL(*mock_ui(), SetIdentityInfo(_));
 180   EXPECT_CALL(*mock_ui(), SetCookieInfo(_));
 181   EXPECT_CALL(*mock_ui(), SetFirstVisit(base::string16()));
 182
 183   // SetPermissionInfo() is called once initially, and then again every time
 184   // OnSitePermissionChanged() is called.
 185 // TODO(markusheintz): This is a temporary hack to fix issue: http://crbug.com/144203.
 186 #if defined(OS_MACOSX)
 187   EXPECT_CALL(*mock_ui(), SetPermissionInfo(_)).Times(7);
 188 #else
 189   EXPECT_CALL(*mock_ui(), SetPermissionInfo(_)).Times(1);
 190 #endif
 191   EXPECT_CALL(*mock_ui(), SetSelectedTab(
 192       WebsiteSettingsUI::TAB_ID_PERMISSIONS));
 193
 194   // Execute code under tests.
 195   website_settings()->OnSitePermissionChanged(CONTENT_SETTINGS_TYPE_POPUPS,
 196                                               CONTENT_SETTING_ALLOW);
 197   website_settings()->OnSitePermissionChanged(CONTENT_SETTINGS_TYPE_PLUGINS,
 198                                               CONTENT_SETTING_BLOCK);
 199   website_settings()->OnSitePermissionChanged(CONTENT_SETTINGS_TYPE_GEOLOCATION,
 200                                               CONTENT_SETTING_ALLOW);
 201   website_settings()->OnSitePermissionChanged(
 202       CONTENT_SETTINGS_TYPE_NOTIFICATIONS, CONTENT_SETTING_ALLOW);
 203   website_settings()->OnSitePermissionChanged(
 204       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, CONTENT_SETTING_ALLOW);
 205   website_settings()->OnSitePermissionChanged(
 206       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, CONTENT_SETTING_ALLOW);
 207
 208   // Verify that the site permissions were changed correctly.
 209   setting = content_settings->GetContentSetting(
 210       url(), url(), CONTENT_SETTINGS_TYPE_POPUPS, std::string());
 211   EXPECT_EQ(setting, CONTENT_SETTING_ALLOW);
 212   setting = content_settings->GetContentSetting(
 213       url(), url(), CONTENT_SETTINGS_TYPE_PLUGINS, std::string());
 214   EXPECT_EQ(setting, CONTENT_SETTING_BLOCK);
 215   setting = content_settings->GetContentSetting(
 216       url(), url(), CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string());
 217   EXPECT_EQ(setting, CONTENT_SETTING_ALLOW);
 218   setting = content_settings->GetContentSetting(
 219       url(), url(), CONTENT_SETTINGS_TYPE_NOTIFICATIONS, std::string());
 220   EXPECT_EQ(setting, CONTENT_SETTING_ALLOW);
 221   setting = content_settings->GetContentSetting(
 222       url(), url(), CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, std::string());
 223   EXPECT_EQ(setting, CONTENT_SETTING_ALLOW);
 224   setting = content_settings->GetContentSetting(
 225       url(), url(), CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, std::string());
 226   EXPECT_EQ(setting, CONTENT_SETTING_ALLOW);
 227 }
 228
 229 TEST_F(WebsiteSettingsTest, OnSiteDataAccessed) {
 230   EXPECT_CALL(*mock_ui(), SetPermissionInfo(_));
 231   EXPECT_CALL(*mock_ui(), SetIdentityInfo(_));
 232   EXPECT_CALL(*mock_ui(), SetFirstVisit(base::string16()));
 233   EXPECT_CALL(*mock_ui(), SetCookieInfo(_)).Times(2);
 234   EXPECT_CALL(*mock_ui(), SetSelectedTab(
 235       WebsiteSettingsUI::TAB_ID_PERMISSIONS));
 236
 237   website_settings()->OnSiteDataAccessed();
 238 }
 239
 240 TEST_F(WebsiteSettingsTest, HTTPConnection) {
 241   SetDefaultUIExpectations(mock_ui());
 242   EXPECT_CALL(*mock_ui(), SetSelectedTab(
 243       WebsiteSettingsUI::TAB_ID_PERMISSIONS));
 244   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_UNENCRYPTED,
 245             website_settings()->site_connection_status());
 246   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_NO_CERT,
 247             website_settings()->site_identity_status());
 248   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 249 }
 250
 251 TEST_F(WebsiteSettingsTest, HTTPSConnection) {
 252   ssl_.security_style = content::SECURITY_STYLE_AUTHENTICATED;
 253   ssl_.cert_id = cert_id();
 254   ssl_.cert_status = 0;
 255   ssl_.security_bits = 81;  // No error if > 80.
 256   int status = 0;
 257   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
 258   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
 259   ssl_.connection_status = status;
 260
 261   SetDefaultUIExpectations(mock_ui());
 262   EXPECT_CALL(*mock_ui(), SetSelectedTab(
 263       WebsiteSettingsUI::TAB_ID_PERMISSIONS));
 264
 265   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_ENCRYPTED,
 266             website_settings()->site_connection_status());
 267   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_CERT,
 268             website_settings()->site_identity_status());
 269   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 270 }
 271
 272 TEST_F(WebsiteSettingsTest, HTTPSMixedContent) {
 273   ssl_.security_style = content::SECURITY_STYLE_AUTHENTICATED;
 274   ssl_.cert_id = cert_id();
 275   ssl_.cert_status = 0;
 276   ssl_.security_bits = 81;  // No error if > 80.
 277   ssl_.content_status = SSLStatus::DISPLAYED_INSECURE_CONTENT;
 278   int status = 0;
 279   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
 280   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
 281   ssl_.connection_status = status;
 282
 283   SetDefaultUIExpectations(mock_ui());
 284   EXPECT_CALL(*mock_ui(), SetSelectedTab(WebsiteSettingsUI::TAB_ID_CONNECTION));
 285
 286   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_MIXED_CONTENT,
 287             website_settings()->site_connection_status());
 288   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_CERT,
 289             website_settings()->site_identity_status());
 290   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 291 }
 292
 293 TEST_F(WebsiteSettingsTest, HTTPSEVCert) {
 294   scoped_refptr<net::X509Certificate> ev_cert =
 295       net::X509Certificate::CreateFromBytes(
 296           reinterpret_cast<const char*>(google_der),
 297           sizeof(google_der));
 298   int ev_cert_id = 1;
 299   EXPECT_CALL(*cert_store(), RetrieveCert(ev_cert_id, _)).WillRepeatedly(
 300       DoAll(SetArgPointee<1>(ev_cert), Return(true)));
 301
 302   ssl_.security_style = content::SECURITY_STYLE_AUTHENTICATED;
 303   ssl_.cert_id = ev_cert_id;
 304   ssl_.cert_status = net::CERT_STATUS_IS_EV;
 305   ssl_.security_bits = 81;  // No error if > 80.
 306   ssl_.content_status = SSLStatus::DISPLAYED_INSECURE_CONTENT;
 307   int status = 0;
 308   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
 309   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
 310   ssl_.connection_status = status;
 311
 312   SetDefaultUIExpectations(mock_ui());
 313   EXPECT_CALL(*mock_ui(), SetSelectedTab(WebsiteSettingsUI::TAB_ID_CONNECTION));
 314
 315   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_MIXED_CONTENT,
 316             website_settings()->site_connection_status());
 317   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_EV_CERT,
 318             website_settings()->site_identity_status());
 319   EXPECT_EQ(base::UTF8ToUTF16("Google Inc"),
 320             website_settings()->organization_name());
 321 }
 322
 323 TEST_F(WebsiteSettingsTest, HTTPSRevocationError) {
 324   ssl_.security_style = content::SECURITY_STYLE_AUTHENTICATED;
 325   ssl_.cert_id = cert_id();
 326   ssl_.cert_status = net::CERT_STATUS_UNABLE_TO_CHECK_REVOCATION;
 327   ssl_.security_bits = 81;  // No error if > 80.
 328   int status = 0;
 329   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
 330   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
 331   ssl_.connection_status = status;
 332
 333   SetDefaultUIExpectations(mock_ui());
 334   EXPECT_CALL(*mock_ui(), SetSelectedTab(WebsiteSettingsUI::TAB_ID_CONNECTION));
 335
 336   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_ENCRYPTED,
 337             website_settings()->site_connection_status());
 338   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_CERT_REVOCATION_UNKNOWN,
 339             website_settings()->site_identity_status());
 340   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 341 }
 342
 343 TEST_F(WebsiteSettingsTest, HTTPSConnectionError) {
 344   ssl_.security_style = content::SECURITY_STYLE_AUTHENTICATED;
 345   ssl_.cert_id = cert_id();
 346   ssl_.cert_status = 0;
 347   ssl_.security_bits = -1;
 348   int status = 0;
 349   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
 350   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
 351   ssl_.connection_status = status;
 352
 353   SetDefaultUIExpectations(mock_ui());
 354   EXPECT_CALL(*mock_ui(), SetSelectedTab(WebsiteSettingsUI::TAB_ID_CONNECTION));
 355
 356   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_ENCRYPTED_ERROR,
 357             website_settings()->site_connection_status());
 358   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_CERT,
 359             website_settings()->site_identity_status());
 360   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 361 }
 362
 363 TEST_F(WebsiteSettingsTest, NoInfoBar) {
 364   SetDefaultUIExpectations(mock_ui());
 365   EXPECT_CALL(*mock_ui(), SetSelectedTab(
 366       WebsiteSettingsUI::TAB_ID_PERMISSIONS));
 367   EXPECT_EQ(0u, infobar_service()->infobar_count());
 368   website_settings()->OnUIClosing();
 369   EXPECT_EQ(0u, infobar_service()->infobar_count());
 370 }
 371
 372 TEST_F(WebsiteSettingsTest, ShowInfoBar) {
 373   EXPECT_CALL(*mock_ui(), SetIdentityInfo(_));
 374   EXPECT_CALL(*mock_ui(), SetCookieInfo(_));
 375   EXPECT_CALL(*mock_ui(), SetFirstVisit(base::string16()));
 376
 377   // SetPermissionInfo() is called once initially, and then again every time
 378   // OnSitePermissionChanged() is called.
 379   // TODO(markusheintz): This is a temporary hack to fix issue:
 380   // http://crbug.com/144203.
 381 #if defined(OS_MACOSX)
 382   EXPECT_CALL(*mock_ui(), SetPermissionInfo(_)).Times(2);
 383 #else
 384   EXPECT_CALL(*mock_ui(), SetPermissionInfo(_)).Times(1);
 385 #endif
 386
 387   EXPECT_CALL(*mock_ui(), SetSelectedTab(
 388       WebsiteSettingsUI::TAB_ID_PERMISSIONS));
 389   EXPECT_EQ(0u, infobar_service()->infobar_count());
 390   website_settings()->OnSitePermissionChanged(
 391       CONTENT_SETTINGS_TYPE_GEOLOCATION, CONTENT_SETTING_ALLOW);
 392   website_settings()->OnUIClosing();
 393   ASSERT_EQ(1u, infobar_service()->infobar_count());
 394
 395   infobar_service()->RemoveInfoBar(infobar_service()->infobar_at(0));
 396 }
 397
 398 TEST_F(WebsiteSettingsTest, AboutBlankPage) {
 399   SetURL("about:blank");
 400   SetDefaultUIExpectations(mock_ui());
 401   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_INTERNAL_PAGE,
 402             website_settings()->site_connection_status());
 403   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_INTERNAL_PAGE,
 404             website_settings()->site_identity_status());
 405   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 406 }
 407
 408 TEST_F(WebsiteSettingsTest, InternalPage) {
 409   SetURL("chrome://bookmarks");
 410   SetDefaultUIExpectations(mock_ui());
 411   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_INTERNAL_PAGE,
 412             website_settings()->site_connection_status());
 413   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_INTERNAL_PAGE,
 414             website_settings()->site_identity_status());
 415   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 416 }