Componentize SecurityStateModel

chrome/browser/ui/website_settings/website_settings_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/ui/website_settings/website_settings.h"
 
 #include "base/at_exit.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 61 matching lines @@
 
 class WebsiteSettingsTest : public ChromeRenderViewHostTestHarness {
  public:
   WebsiteSettingsTest() : cert_id_(0), url_("http://www.example.com") {}
 
   ~WebsiteSettingsTest() override {}
 
   void SetUp() override {
     ChromeRenderViewHostTestHarness::SetUp();
     // Setup stub SSLStatus.
-    security_info_.security_level = SecurityStateModel::NONE;
+    security_info_.security_level = security_state::NONE;
 
     // Create the certificate.
     cert_id_ = 1;
     base::Time start_date = base::Time::Now();
     base::Time expiration_date = base::Time::FromInternalValue(
         start_date.ToInternalValue() + base::Time::kMicrosecondsPerWeek);
     cert_ = new net::X509Certificate("subject",
                                      "issuer",
                                      start_date,
                                      expiration_date);
@@ skipping 23 matching lines @@
     EXPECT_CALL(*mock_ui, SetIdentityInfo(_));
     EXPECT_CALL(*mock_ui, SetCookieInfo(_));
   }
 
   void SetURL(const std::string& url) { url_ = GURL(url); }
 
   const GURL& url() const { return url_; }
   MockCertStore* cert_store() { return &cert_store_; }
   int cert_id() { return cert_id_; }
   MockWebsiteSettingsUI* mock_ui() { return mock_ui_.get(); }
-  const SecurityStateModel::SecurityInfo& security_info() {
-    return security_info_;
-  }
+  const security_state::SecurityInfo& security_info() { return security_info_; }
   TabSpecificContentSettings* tab_specific_content_settings() {
     return TabSpecificContentSettings::FromWebContents(web_contents());
   }
   InfoBarService* infobar_service() {
     return InfoBarService::FromWebContents(web_contents());
   }
 
   WebsiteSettings* website_settings() {
     if (!website_settings_.get()) {
       website_settings_.reset(new WebsiteSettings(
           mock_ui(), profile(), tab_specific_content_settings(), web_contents(),
           url(), security_info(), cert_store()));
     }
     return website_settings_.get();
   }
 
-  SecurityStateModel::SecurityInfo security_info_;
+  security_state::SecurityInfo security_info_;
 
  private:
   scoped_ptr<WebsiteSettings> website_settings_;
   scoped_ptr<MockWebsiteSettingsUI> mock_ui_;
   int cert_id_;
   scoped_refptr<net::X509Certificate> cert_;
   MockCertStore cert_store_;
   GURL url_;
 };
 
@@ skipping 125 matching lines @@
   EXPECT_CALL(*mock_ui(), SetSelectedTab(
       WebsiteSettingsUI::TAB_ID_PERMISSIONS));
   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_UNENCRYPTED,
             website_settings()->site_connection_status());
   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_NO_CERT,
             website_settings()->site_identity_status());
   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 }
 
 TEST_F(WebsiteSettingsTest, HTTPSConnection) {
-  security_info_.security_level = SecurityStateModel::SECURE;
+  security_info_.security_level = security_state::SECURE;
   security_info_.scheme_is_cryptographic = true;
   security_info_.cert_id = cert_id();
   security_info_.cert_status = 0;
   security_info_.security_bits = 81;  // No error if > 80.
   int status = 0;
   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
   security_info_.connection_status = status;
 
   SetDefaultUIExpectations(mock_ui());
   EXPECT_CALL(*mock_ui(), SetSelectedTab(
       WebsiteSettingsUI::TAB_ID_PERMISSIONS));
 
   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_ENCRYPTED,
             website_settings()->site_connection_status());
   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_CERT,
             website_settings()->site_identity_status());
   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 }
 
 TEST_F(WebsiteSettingsTest, HTTPSPassiveMixedContent) {
-  security_info_.security_level = SecurityStateModel::NONE;
+  security_info_.security_level = security_state::NONE;
   security_info_.scheme_is_cryptographic = true;
   security_info_.cert_id = cert_id();
   security_info_.cert_status = 0;
   security_info_.security_bits = 81;  // No error if > 80.
-  security_info_.mixed_content_status =
-      SecurityStateModel::DISPLAYED_MIXED_CONTENT;
+  security_info_.mixed_content_status = security_state::DISPLAYED_MIXED_CONTENT;
   int status = 0;
   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
   security_info_.connection_status = status;
 
   SetDefaultUIExpectations(mock_ui());
   EXPECT_CALL(*mock_ui(), SetSelectedTab(WebsiteSettingsUI::TAB_ID_CONNECTION));
 
   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_MIXED_CONTENT,
             website_settings()->site_connection_status());
   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_CERT,
             website_settings()->site_identity_status());
   EXPECT_EQ(IDR_PAGEINFO_WARNING_MINOR,
             WebsiteSettingsUI::GetConnectionIconID(
                 website_settings()->site_connection_status()));
   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 }
 
 TEST_F(WebsiteSettingsTest, HTTPSActiveMixedContent) {
-  security_info_.security_level = SecurityStateModel::SECURITY_ERROR;
+  security_info_.security_level = security_state::SECURITY_ERROR;
   security_info_.scheme_is_cryptographic = true;
   security_info_.cert_id = cert_id();
   security_info_.cert_status = 0;
   security_info_.security_bits = 81;  // No error if > 80.
   security_info_.mixed_content_status =
-      SecurityStateModel::RAN_AND_DISPLAYED_MIXED_CONTENT;
+      security_state::RAN_AND_DISPLAYED_MIXED_CONTENT;
   int status = 0;
   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
   security_info_.connection_status = status;
 
   SetDefaultUIExpectations(mock_ui());
   EXPECT_CALL(*mock_ui(), SetSelectedTab(WebsiteSettingsUI::TAB_ID_CONNECTION));
 
   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_MIXED_SCRIPT,
             website_settings()->site_connection_status());
   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_CERT,
             website_settings()->site_identity_status());
   EXPECT_EQ(IDR_PAGEINFO_BAD,
             WebsiteSettingsUI::GetConnectionIconID(
                 website_settings()->site_connection_status()));
   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 }
 
 TEST_F(WebsiteSettingsTest, HTTPSEVCert) {
   scoped_refptr<net::X509Certificate> ev_cert =
       net::X509Certificate::CreateFromBytes(
           reinterpret_cast<const char*>(google_der),
           sizeof(google_der));
   int ev_cert_id = 1;
   EXPECT_CALL(*cert_store(), RetrieveCert(ev_cert_id, _)).WillRepeatedly(
       DoAll(SetArgPointee<1>(ev_cert), Return(true)));
 
-  security_info_.security_level = SecurityStateModel::NONE;
+  security_info_.security_level = security_state::NONE;
   security_info_.scheme_is_cryptographic = true;
   security_info_.cert_id = ev_cert_id;
   security_info_.cert_status = net::CERT_STATUS_IS_EV;
   security_info_.security_bits = 81;  // No error if > 80.
-  security_info_.mixed_content_status =
-      SecurityStateModel::DISPLAYED_MIXED_CONTENT;
+  security_info_.mixed_content_status = security_state::DISPLAYED_MIXED_CONTENT;
   int status = 0;
   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
   security_info_.connection_status = status;
 
   SetDefaultUIExpectations(mock_ui());
   EXPECT_CALL(*mock_ui(), SetSelectedTab(WebsiteSettingsUI::TAB_ID_CONNECTION));
 
   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_MIXED_CONTENT,
             website_settings()->site_connection_status());
   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_EV_CERT,
             website_settings()->site_identity_status());
   EXPECT_EQ(base::UTF8ToUTF16("Google Inc"),
             website_settings()->organization_name());
 }
 
 TEST_F(WebsiteSettingsTest, HTTPSRevocationError) {
-  security_info_.security_level = SecurityStateModel::SECURE;
+  security_info_.security_level = security_state::SECURE;
   security_info_.scheme_is_cryptographic = true;
   security_info_.cert_id = cert_id();
   security_info_.cert_status = net::CERT_STATUS_UNABLE_TO_CHECK_REVOCATION;
   security_info_.security_bits = 81;  // No error if > 80.
   int status = 0;
   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
   security_info_.connection_status = status;
 
   SetDefaultUIExpectations(mock_ui());
   EXPECT_CALL(*mock_ui(), SetSelectedTab(WebsiteSettingsUI::TAB_ID_CONNECTION));
 
   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_ENCRYPTED,
             website_settings()->site_connection_status());
   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_CERT_REVOCATION_UNKNOWN,
             website_settings()->site_identity_status());
   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 }
 
 TEST_F(WebsiteSettingsTest, HTTPSConnectionError) {
-  security_info_.security_level = SecurityStateModel::SECURE;
+  security_info_.security_level = security_state::SECURE;
   security_info_.scheme_is_cryptographic = true;
   security_info_.cert_id = cert_id();
   security_info_.cert_status = 0;
   security_info_.security_bits = -1;
   int status = 0;
   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
   security_info_.connection_status = status;
 
   SetDefaultUIExpectations(mock_ui());
   EXPECT_CALL(*mock_ui(), SetSelectedTab(WebsiteSettingsUI::TAB_ID_CONNECTION));
 
   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_ENCRYPTED_ERROR,
             website_settings()->site_connection_status());
   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_CERT,
             website_settings()->site_identity_status());
   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 }
 
 TEST_F(WebsiteSettingsTest, HTTPSPolicyCertConnection) {
-  security_info_.security_level = SecurityStateModel::SECURITY_POLICY_WARNING;
+  security_info_.security_level = security_state::SECURITY_POLICY_WARNING;
   security_info_.scheme_is_cryptographic = true;
   security_info_.cert_id = cert_id();
   security_info_.cert_status = 0;
   security_info_.security_bits = 81;  // No error if > 80.
   int status = 0;
   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
   security_info_.connection_status = status;
 
   SetDefaultUIExpectations(mock_ui());
   EXPECT_CALL(*mock_ui(), SetSelectedTab(WebsiteSettingsUI::TAB_ID_CONNECTION));
 
   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_ENCRYPTED,
             website_settings()->site_connection_status());
   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_ADMIN_PROVIDED_CERT,
             website_settings()->site_identity_status());
   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 }
 
 TEST_F(WebsiteSettingsTest, HTTPSSHA1Minor) {
-  security_info_.security_level = SecurityStateModel::NONE;
+  security_info_.security_level = security_state::NONE;
   security_info_.scheme_is_cryptographic = true;
   security_info_.cert_id = cert_id();
   security_info_.cert_status = 0;
   security_info_.security_bits = 81;  // No error if > 80.
   int status = 0;
   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
   security_info_.connection_status = status;
   security_info_.sha1_deprecation_status =
-      SecurityStateModel::DEPRECATED_SHA1_MINOR;
+      security_state::DEPRECATED_SHA1_MINOR;
 
   SetDefaultUIExpectations(mock_ui());
   EXPECT_CALL(*mock_ui(), SetSelectedTab(WebsiteSettingsUI::TAB_ID_CONNECTION));
 
   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_ENCRYPTED,
             website_settings()->site_connection_status());
   EXPECT_EQ(WebsiteSettings::
                 SITE_IDENTITY_STATUS_DEPRECATED_SIGNATURE_ALGORITHM_MINOR,
             website_settings()->site_identity_status());
   EXPECT_EQ(base::string16(), website_settings()->organization_name());
   EXPECT_EQ(IDR_PAGEINFO_WARNING_MINOR,
             WebsiteSettingsUI::GetIdentityIconID(
                 website_settings()->site_identity_status()));
 }
 
 TEST_F(WebsiteSettingsTest, HTTPSSHA1Major) {
-  security_info_.security_level = SecurityStateModel::NONE;
+  security_info_.security_level = security_state::NONE;
   security_info_.scheme_is_cryptographic = true;
   security_info_.cert_id = cert_id();
   security_info_.cert_status = 0;
   security_info_.security_bits = 81;  // No error if > 80.
   int status = 0;
   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
   security_info_.connection_status = status;
   security_info_.sha1_deprecation_status =
-      SecurityStateModel::DEPRECATED_SHA1_MAJOR;
+      security_state::DEPRECATED_SHA1_MAJOR;
 
   SetDefaultUIExpectations(mock_ui());
   EXPECT_CALL(*mock_ui(), SetSelectedTab(WebsiteSettingsUI::TAB_ID_CONNECTION));
 
   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_ENCRYPTED,
             website_settings()->site_connection_status());
   EXPECT_EQ(WebsiteSettings::
                 SITE_IDENTITY_STATUS_DEPRECATED_SIGNATURE_ALGORITHM_MAJOR,
             website_settings()->site_identity_status());
   EXPECT_EQ(base::string16(), website_settings()->organization_name());
   EXPECT_EQ(IDR_PAGEINFO_BAD,
             WebsiteSettingsUI::GetIdentityIconID(
                 website_settings()->site_identity_status()));
 }
 
 // All SCTs are from unknown logs.
 TEST_F(WebsiteSettingsTest, UnknownSCTs) {
-  security_info_.security_level = SecurityStateModel::SECURE;
+  security_info_.security_level = security_state::SECURE;
   security_info_.scheme_is_cryptographic = true;
   security_info_.cert_id = cert_id();
   security_info_.cert_status = 0;
   security_info_.security_bits = 81;  // No error if > 80.
   int status = 0;
   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
   security_info_.connection_status = status;
 
   security_info_.sct_verify_statuses.push_back(net::ct::SCT_STATUS_LOG_UNKNOWN);
   security_info_.sct_verify_statuses.push_back(net::ct::SCT_STATUS_LOG_UNKNOWN);
 
   SetDefaultUIExpectations(mock_ui());
   EXPECT_CALL(*mock_ui(), SetSelectedTab(WebsiteSettingsUI::TAB_ID_CONNECTION));
 
   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_ENCRYPTED,
             website_settings()->site_connection_status());
   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_CT_ERROR,
             website_settings()->site_identity_status());
   EXPECT_EQ(IDR_PAGEINFO_BAD, WebsiteSettingsUI::GetIdentityIconID(
                                   website_settings()->site_identity_status()));
 }
 
 // All SCTs are invalid.
 TEST_F(WebsiteSettingsTest, InvalidSCTs) {
-  security_info_.security_level = SecurityStateModel::SECURE;
+  security_info_.security_level = security_state::SECURE;
   security_info_.scheme_is_cryptographic = true;
   security_info_.cert_id = cert_id();
   security_info_.cert_status = 0;
   security_info_.security_bits = 81;  // No error if > 80.
   int status = 0;
   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
   security_info_.connection_status = status;
 
   security_info_.sct_verify_statuses.push_back(net::ct::SCT_STATUS_INVALID);
   security_info_.sct_verify_statuses.push_back(net::ct::SCT_STATUS_INVALID);
 
   SetDefaultUIExpectations(mock_ui());
   EXPECT_CALL(*mock_ui(), SetSelectedTab(WebsiteSettingsUI::TAB_ID_CONNECTION));
 
   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_ENCRYPTED,
             website_settings()->site_connection_status());
   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_CT_ERROR,
             website_settings()->site_identity_status());
   EXPECT_EQ(IDR_PAGEINFO_BAD, WebsiteSettingsUI::GetIdentityIconID(
                                   website_settings()->site_identity_status()));
 }
 
 // All SCTs are valid.
 TEST_F(WebsiteSettingsTest, ValidSCTs) {
-  security_info_.security_level = SecurityStateModel::SECURE;
+  security_info_.security_level = security_state::SECURE;
   security_info_.scheme_is_cryptographic = true;
   security_info_.cert_id = cert_id();
   security_info_.cert_status = 0;
   security_info_.security_bits = 81;  // No error if > 80.
   int status = 0;
   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
   security_info_.connection_status = status;
 
   security_info_.sct_verify_statuses.push_back(net::ct::SCT_STATUS_OK);
@@ skipping 13 matching lines @@
 
 // All SCTs are valid for an EV cert.
 TEST_F(WebsiteSettingsTest, ValidSCTsEV) {
   scoped_refptr<net::X509Certificate> ev_cert =
       net::X509Certificate::CreateFromBytes(
           reinterpret_cast<const char*>(google_der), sizeof(google_der));
   int ev_cert_id = 1;
   EXPECT_CALL(*cert_store(), RetrieveCert(ev_cert_id, _))
       .WillRepeatedly(DoAll(SetArgPointee<1>(ev_cert), Return(true)));
 
-  security_info_.security_level = SecurityStateModel::SECURE;
+  security_info_.security_level = security_state::SECURE;
   security_info_.scheme_is_cryptographic = true;
   security_info_.cert_id = ev_cert_id;
   security_info_.cert_status = net::CERT_STATUS_IS_EV;
   security_info_.security_bits = 81;  // No error if > 80.
   int status = 0;
   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
   security_info_.connection_status = status;
 
   security_info_.sct_verify_statuses.push_back(net::ct::SCT_STATUS_OK);
   security_info_.sct_verify_statuses.push_back(net::ct::SCT_STATUS_OK);
 
   SetDefaultUIExpectations(mock_ui());
   EXPECT_CALL(*mock_ui(),
               SetSelectedTab(WebsiteSettingsUI::TAB_ID_PERMISSIONS));
 
   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_ENCRYPTED,
             website_settings()->site_connection_status());
   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_EV_CERT,
             website_settings()->site_identity_status());
   EXPECT_EQ(IDR_PAGEINFO_GOOD, WebsiteSettingsUI::GetIdentityIconID(
                                    website_settings()->site_identity_status()));
 }
 
 // A mix of unknown and invalid SCTs.
 TEST_F(WebsiteSettingsTest, UnknownAndInvalidSCTs) {
-  security_info_.security_level = SecurityStateModel::SECURE;
+  security_info_.security_level = security_state::SECURE;
   security_info_.scheme_is_cryptographic = true;
   security_info_.cert_id = cert_id();
   security_info_.cert_status = 0;
   security_info_.security_bits = 81;  // No error if > 80.
   int status = 0;
   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
   security_info_.connection_status = status;
 
   security_info_.sct_verify_statuses.push_back(net::ct::SCT_STATUS_LOG_UNKNOWN);
   security_info_.sct_verify_statuses.push_back(net::ct::SCT_STATUS_INVALID);
 
   SetDefaultUIExpectations(mock_ui());
   EXPECT_CALL(*mock_ui(), SetSelectedTab(WebsiteSettingsUI::TAB_ID_CONNECTION));
 
   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_ENCRYPTED,
             website_settings()->site_connection_status());
   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_CT_ERROR,
             website_settings()->site_identity_status());
   EXPECT_EQ(IDR_PAGEINFO_BAD, WebsiteSettingsUI::GetIdentityIconID(
                                   website_settings()->site_identity_status()));
 }
 
 // At least one SCT is valid and one is from an unknown log.
 TEST_F(WebsiteSettingsTest, ValidAndUnknownSCTs) {
-  security_info_.security_level = SecurityStateModel::SECURE;
+  security_info_.security_level = security_state::SECURE;
   security_info_.scheme_is_cryptographic = true;
   security_info_.cert_id = cert_id();
   security_info_.cert_status = 0;
   security_info_.security_bits = 81;  // No error if > 80.
   int status = 0;
   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
   security_info_.connection_status = status;
 
   security_info_.sct_verify_statuses.push_back(net::ct::SCT_STATUS_OK);
@@ skipping 51 matching lines @@
 
 TEST_F(WebsiteSettingsTest, InternalPage) {
   SetURL("chrome://bookmarks");
   SetDefaultUIExpectations(mock_ui());
   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_INTERNAL_PAGE,
             website_settings()->site_connection_status());
   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_INTERNAL_PAGE,
             website_settings()->site_identity_status());
   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 }