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(SetSelectedTab, void(TabId tab_id));
  69 };
  70
  71 class WebsiteSettingsTest : public ChromeRenderViewHostTestHarness {
  72  public:
  73   WebsiteSettingsTest() : cert_id_(0), url_("http://www.example.com") {}
  74
  75   ~WebsiteSettingsTest() override {}
  76
  77   void SetUp() override {
  78     ChromeRenderViewHostTestHarness::SetUp();
  79     // Setup stub SSLStatus.
  80     ssl_.security_style = content::SECURITY_STYLE_UNAUTHENTICATED;
  81
  82     // Create the certificate.
  83     cert_id_ = 1;
  84     base::Time start_date = base::Time::Now();
  85     base::Time expiration_date = base::Time::FromInternalValue(
  86         start_date.ToInternalValue() + base::Time::kMicrosecondsPerWeek);
  87     cert_ = new net::X509Certificate("subject",
  88                                      "issuer",
  89                                      start_date,
  90                                      expiration_date);
  91
  92     TabSpecificContentSettings::CreateForWebContents(web_contents());
  93     InfoBarService::CreateForWebContents(web_contents());
  94
  95     // Setup the mock cert store.
  96     EXPECT_CALL(cert_store_, RetrieveCert(cert_id_, _) )
  97         .Times(AnyNumber())
  98         .WillRepeatedly(DoAll(SetArgPointee<1>(cert_), Return(true)));
  99
 100     // Setup mock ui.
 101     mock_ui_.reset(new MockWebsiteSettingsUI());
 102   }
 103
 104   void TearDown() override {
 105     ASSERT_TRUE(website_settings_.get())
 106         << "No WebsiteSettings instance created.";
 107     RenderViewHostTestHarness::TearDown();
 108     website_settings_.reset();
 109   }
 110
 111   void SetDefaultUIExpectations(MockWebsiteSettingsUI* mock_ui) {
 112     // During creation |WebsiteSettings| makes the following calls to the ui.
 113     EXPECT_CALL(*mock_ui, SetPermissionInfo(_));
 114     EXPECT_CALL(*mock_ui, SetIdentityInfo(_));
 115     EXPECT_CALL(*mock_ui, SetCookieInfo(_));
 116   }
 117
 118   void SetURL(std::string url) { url_ = GURL(url); }
 119
 120   const GURL& url() const { return url_; }
 121   MockCertStore* cert_store() { return &cert_store_; }
 122   int cert_id() { return cert_id_; }
 123   MockWebsiteSettingsUI* mock_ui() { return mock_ui_.get(); }
 124   const SSLStatus& ssl() { return ssl_; }
 125   TabSpecificContentSettings* tab_specific_content_settings() {
 126     return TabSpecificContentSettings::FromWebContents(web_contents());
 127   }
 128   InfoBarService* infobar_service() {
 129     return InfoBarService::FromWebContents(web_contents());
 130   }
 131
 132   WebsiteSettings* website_settings() {
 133     if (!website_settings_.get()) {
 134       website_settings_.reset(new WebsiteSettings(
 135           mock_ui(), profile(), tab_specific_content_settings(),
 136           web_contents(), url(), ssl(), cert_store()));
 137     }
 138     return website_settings_.get();
 139   }
 140
 141   SSLStatus ssl_;
 142
 143  private:
 144   scoped_ptr<WebsiteSettings> website_settings_;
 145   scoped_ptr<MockWebsiteSettingsUI> mock_ui_;
 146   int cert_id_;
 147   scoped_refptr<net::X509Certificate> cert_;
 148   MockCertStore cert_store_;
 149   GURL url_;
 150 };
 151
 152 }  // namespace
 153
 154 TEST_F(WebsiteSettingsTest, OnPermissionsChanged) {
 155   // Setup site permissions.
 156   HostContentSettingsMap* content_settings =
 157       profile()->GetHostContentSettingsMap();
 158   ContentSetting setting = content_settings->GetContentSetting(
 159       url(), url(), CONTENT_SETTINGS_TYPE_POPUPS, std::string());
 160   EXPECT_EQ(setting, CONTENT_SETTING_BLOCK);
 161 #if defined(ENABLE_PLUGINS)
 162   setting = content_settings->GetContentSetting(
 163       url(), url(), CONTENT_SETTINGS_TYPE_PLUGINS, std::string());
 164   EXPECT_EQ(setting, CONTENT_SETTING_ALLOW);
 165 #endif
 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
 182   // SetPermissionInfo() is called once initially, and then again every time
 183   // OnSitePermissionChanged() is called.
 184 // TODO(markusheintz): This is a temporary hack to fix issue: http://crbug.com/144203.
 185 #if defined(OS_MACOSX)
 186   EXPECT_CALL(*mock_ui(), SetPermissionInfo(_)).Times(7);
 187 #else
 188   EXPECT_CALL(*mock_ui(), SetPermissionInfo(_)).Times(1);
 189 #endif
 190   EXPECT_CALL(*mock_ui(), SetSelectedTab(
 191       WebsiteSettingsUI::TAB_ID_PERMISSIONS));
 192
 193   // Execute code under tests.
 194   website_settings()->OnSitePermissionChanged(CONTENT_SETTINGS_TYPE_POPUPS,
 195                                               CONTENT_SETTING_ALLOW);
 196   website_settings()->OnSitePermissionChanged(CONTENT_SETTINGS_TYPE_PLUGINS,
 197                                               CONTENT_SETTING_BLOCK);
 198   website_settings()->OnSitePermissionChanged(CONTENT_SETTINGS_TYPE_GEOLOCATION,
 199                                               CONTENT_SETTING_ALLOW);
 200   website_settings()->OnSitePermissionChanged(
 201       CONTENT_SETTINGS_TYPE_NOTIFICATIONS, CONTENT_SETTING_ALLOW);
 202   website_settings()->OnSitePermissionChanged(
 203       CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, CONTENT_SETTING_ALLOW);
 204   website_settings()->OnSitePermissionChanged(
 205       CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, CONTENT_SETTING_ALLOW);
 206
 207   // Verify that the site permissions were changed correctly.
 208   setting = content_settings->GetContentSetting(
 209       url(), url(), CONTENT_SETTINGS_TYPE_POPUPS, std::string());
 210   EXPECT_EQ(setting, CONTENT_SETTING_ALLOW);
 211   setting = content_settings->GetContentSetting(
 212       url(), url(), CONTENT_SETTINGS_TYPE_PLUGINS, std::string());
 213   EXPECT_EQ(setting, CONTENT_SETTING_BLOCK);
 214   setting = content_settings->GetContentSetting(
 215       url(), url(), CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string());
 216   EXPECT_EQ(setting, CONTENT_SETTING_ALLOW);
 217   setting = content_settings->GetContentSetting(
 218       url(), url(), CONTENT_SETTINGS_TYPE_NOTIFICATIONS, std::string());
 219   EXPECT_EQ(setting, CONTENT_SETTING_ALLOW);
 220   setting = content_settings->GetContentSetting(
 221       url(), url(), CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, std::string());
 222   EXPECT_EQ(setting, CONTENT_SETTING_ALLOW);
 223   setting = content_settings->GetContentSetting(
 224       url(), url(), CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, std::string());
 225   EXPECT_EQ(setting, CONTENT_SETTING_ALLOW);
 226 }
 227
 228 TEST_F(WebsiteSettingsTest, OnPermissionsChanged_Fullscreen) {
 229   // Setup site permissions.
 230   HostContentSettingsMap* content_settings =
 231       profile()->GetHostContentSettingsMap();
 232   ContentSetting setting = content_settings->GetContentSetting(
 233       url(), url(), CONTENT_SETTINGS_TYPE_FULLSCREEN, std::string());
 234   EXPECT_EQ(setting, CONTENT_SETTING_ASK);
 235
 236   EXPECT_CALL(*mock_ui(), SetIdentityInfo(_));
 237   EXPECT_CALL(*mock_ui(), SetCookieInfo(_));
 238   EXPECT_CALL(*mock_ui(), SetSelectedTab(
 239       WebsiteSettingsUI::TAB_ID_PERMISSIONS));
 240
 241   // SetPermissionInfo() is called once initially, and then again every time
 242   // OnSitePermissionChanged() is called.
 243   // TODO(markusheintz): This is a temporary hack to fix issue:
 244   // http://crbug.com/144203.
 245 #if defined(OS_MACOSX)
 246   EXPECT_CALL(*mock_ui(), SetPermissionInfo(_)).Times(3);
 247 #else
 248   EXPECT_CALL(*mock_ui(), SetPermissionInfo(_)).Times(1);
 249 #endif
 250
 251   // Execute code under tests.
 252   website_settings()->OnSitePermissionChanged(CONTENT_SETTINGS_TYPE_FULLSCREEN,
 253                                               CONTENT_SETTING_ALLOW);
 254
 255   // Verify that the site permissions were changed correctly.
 256   setting = content_settings->GetContentSetting(
 257       url(), url(), CONTENT_SETTINGS_TYPE_FULLSCREEN, std::string());
 258   EXPECT_EQ(setting, CONTENT_SETTING_ALLOW);
 259
 260   // ... and that the primary pattern must match the secondary one.
 261   setting = content_settings->GetContentSetting(
 262       url(), GURL("https://test.com"),
 263       CONTENT_SETTINGS_TYPE_FULLSCREEN, std::string());
 264   EXPECT_EQ(setting, CONTENT_SETTING_ASK);
 265
 266
 267   // Resetting the setting should move the permission back to ASK.
 268   website_settings()->OnSitePermissionChanged(CONTENT_SETTINGS_TYPE_FULLSCREEN,
 269                                               CONTENT_SETTING_ASK);
 270
 271   setting = content_settings->GetContentSetting(
 272       url(), url(), CONTENT_SETTINGS_TYPE_FULLSCREEN, std::string());
 273   EXPECT_EQ(setting, CONTENT_SETTING_ASK);
 274 }
 275
 276 TEST_F(WebsiteSettingsTest, OnSiteDataAccessed) {
 277   EXPECT_CALL(*mock_ui(), SetPermissionInfo(_));
 278   EXPECT_CALL(*mock_ui(), SetIdentityInfo(_));
 279   EXPECT_CALL(*mock_ui(), SetCookieInfo(_)).Times(2);
 280   EXPECT_CALL(*mock_ui(), SetSelectedTab(
 281       WebsiteSettingsUI::TAB_ID_PERMISSIONS));
 282
 283   website_settings()->OnSiteDataAccessed();
 284 }
 285
 286 TEST_F(WebsiteSettingsTest, HTTPConnection) {
 287   SetDefaultUIExpectations(mock_ui());
 288   EXPECT_CALL(*mock_ui(), SetSelectedTab(
 289       WebsiteSettingsUI::TAB_ID_PERMISSIONS));
 290   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_UNENCRYPTED,
 291             website_settings()->site_connection_status());
 292   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_NO_CERT,
 293             website_settings()->site_identity_status());
 294   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 295 }
 296
 297 TEST_F(WebsiteSettingsTest, HTTPSConnection) {
 298   ssl_.security_style = content::SECURITY_STYLE_AUTHENTICATED;
 299   ssl_.cert_id = cert_id();
 300   ssl_.cert_status = 0;
 301   ssl_.security_bits = 81;  // No error if > 80.
 302   int status = 0;
 303   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
 304   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
 305   ssl_.connection_status = status;
 306
 307   SetDefaultUIExpectations(mock_ui());
 308   EXPECT_CALL(*mock_ui(), SetSelectedTab(
 309       WebsiteSettingsUI::TAB_ID_PERMISSIONS));
 310
 311   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_ENCRYPTED,
 312             website_settings()->site_connection_status());
 313   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_CERT,
 314             website_settings()->site_identity_status());
 315   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 316 }
 317
 318 TEST_F(WebsiteSettingsTest, HTTPSMixedContent) {
 319   ssl_.security_style = content::SECURITY_STYLE_AUTHENTICATED;
 320   ssl_.cert_id = cert_id();
 321   ssl_.cert_status = 0;
 322   ssl_.security_bits = 81;  // No error if > 80.
 323   ssl_.content_status = SSLStatus::DISPLAYED_INSECURE_CONTENT;
 324   int status = 0;
 325   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
 326   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
 327   ssl_.connection_status = status;
 328
 329   SetDefaultUIExpectations(mock_ui());
 330   EXPECT_CALL(*mock_ui(), SetSelectedTab(WebsiteSettingsUI::TAB_ID_CONNECTION));
 331
 332   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_MIXED_CONTENT,
 333             website_settings()->site_connection_status());
 334   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_CERT,
 335             website_settings()->site_identity_status());
 336   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 337 }
 338
 339 TEST_F(WebsiteSettingsTest, HTTPSEVCert) {
 340   scoped_refptr<net::X509Certificate> ev_cert =
 341       net::X509Certificate::CreateFromBytes(
 342           reinterpret_cast<const char*>(google_der),
 343           sizeof(google_der));
 344   int ev_cert_id = 1;
 345   EXPECT_CALL(*cert_store(), RetrieveCert(ev_cert_id, _)).WillRepeatedly(
 346       DoAll(SetArgPointee<1>(ev_cert), Return(true)));
 347
 348   ssl_.security_style = content::SECURITY_STYLE_AUTHENTICATED;
 349   ssl_.cert_id = ev_cert_id;
 350   ssl_.cert_status = net::CERT_STATUS_IS_EV;
 351   ssl_.security_bits = 81;  // No error if > 80.
 352   ssl_.content_status = SSLStatus::DISPLAYED_INSECURE_CONTENT;
 353   int status = 0;
 354   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
 355   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
 356   ssl_.connection_status = status;
 357
 358   SetDefaultUIExpectations(mock_ui());
 359   EXPECT_CALL(*mock_ui(), SetSelectedTab(WebsiteSettingsUI::TAB_ID_CONNECTION));
 360
 361   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_MIXED_CONTENT,
 362             website_settings()->site_connection_status());
 363   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_EV_CERT,
 364             website_settings()->site_identity_status());
 365   EXPECT_EQ(base::UTF8ToUTF16("Google Inc"),
 366             website_settings()->organization_name());
 367 }
 368
 369 TEST_F(WebsiteSettingsTest, HTTPSRevocationError) {
 370   ssl_.security_style = content::SECURITY_STYLE_AUTHENTICATED;
 371   ssl_.cert_id = cert_id();
 372   ssl_.cert_status = net::CERT_STATUS_UNABLE_TO_CHECK_REVOCATION;
 373   ssl_.security_bits = 81;  // No error if > 80.
 374   int status = 0;
 375   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
 376   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
 377   ssl_.connection_status = status;
 378
 379   SetDefaultUIExpectations(mock_ui());
 380   EXPECT_CALL(*mock_ui(), SetSelectedTab(WebsiteSettingsUI::TAB_ID_CONNECTION));
 381
 382   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_ENCRYPTED,
 383             website_settings()->site_connection_status());
 384   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_CERT_REVOCATION_UNKNOWN,
 385             website_settings()->site_identity_status());
 386   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 387 }
 388
 389 TEST_F(WebsiteSettingsTest, HTTPSConnectionError) {
 390   ssl_.security_style = content::SECURITY_STYLE_AUTHENTICATED;
 391   ssl_.cert_id = cert_id();
 392   ssl_.cert_status = 0;
 393   ssl_.security_bits = -1;
 394   int status = 0;
 395   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
 396   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
 397   ssl_.connection_status = status;
 398
 399   SetDefaultUIExpectations(mock_ui());
 400   EXPECT_CALL(*mock_ui(), SetSelectedTab(WebsiteSettingsUI::TAB_ID_CONNECTION));
 401
 402   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_ENCRYPTED_ERROR,
 403             website_settings()->site_connection_status());
 404   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_CERT,
 405             website_settings()->site_identity_status());
 406   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 407 }
 408
 409 #if !defined(OS_ANDROID)
 410 TEST_F(WebsiteSettingsTest, NoInfoBar) {
 411   SetDefaultUIExpectations(mock_ui());
 412   EXPECT_CALL(*mock_ui(), SetSelectedTab(
 413       WebsiteSettingsUI::TAB_ID_PERMISSIONS));
 414   EXPECT_EQ(0u, infobar_service()->infobar_count());
 415   website_settings()->OnUIClosing();
 416   EXPECT_EQ(0u, infobar_service()->infobar_count());
 417 }
 418
 419 TEST_F(WebsiteSettingsTest, ShowInfoBar) {
 420   EXPECT_CALL(*mock_ui(), SetIdentityInfo(_));
 421   EXPECT_CALL(*mock_ui(), SetCookieInfo(_));
 422
 423   // SetPermissionInfo() is called once initially, and then again every time
 424   // OnSitePermissionChanged() is called.
 425   // TODO(markusheintz): This is a temporary hack to fix issue:
 426   // http://crbug.com/144203.
 427 #if defined(OS_MACOSX)
 428   EXPECT_CALL(*mock_ui(), SetPermissionInfo(_)).Times(2);
 429 #else
 430   EXPECT_CALL(*mock_ui(), SetPermissionInfo(_)).Times(1);
 431 #endif
 432
 433   EXPECT_CALL(*mock_ui(), SetSelectedTab(
 434       WebsiteSettingsUI::TAB_ID_PERMISSIONS));
 435   EXPECT_EQ(0u, infobar_service()->infobar_count());
 436   website_settings()->OnSitePermissionChanged(
 437       CONTENT_SETTINGS_TYPE_GEOLOCATION, CONTENT_SETTING_ALLOW);
 438   website_settings()->OnUIClosing();
 439   ASSERT_EQ(1u, infobar_service()->infobar_count());
 440
 441   infobar_service()->RemoveInfoBar(infobar_service()->infobar_at(0));
 442 }
 443 #endif
 444
 445 TEST_F(WebsiteSettingsTest, AboutBlankPage) {
 446   SetURL("about:blank");
 447   SetDefaultUIExpectations(mock_ui());
 448   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_INTERNAL_PAGE,
 449             website_settings()->site_connection_status());
 450   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_INTERNAL_PAGE,
 451             website_settings()->site_identity_status());
 452   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 453 }
 454
 455 TEST_F(WebsiteSettingsTest, InternalPage) {
 456   SetURL("chrome://bookmarks");
 457   SetDefaultUIExpectations(mock_ui());
 458   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_INTERNAL_PAGE,
 459             website_settings()->site_connection_status());
 460   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_INTERNAL_PAGE,
 461             website_settings()->site_identity_status());
 462   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 463 }