Refactor SecurityStateModel/Clients for simplicity and reusability.

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 <string>
 #include <vector>
 
 #include "base/at_exit.h"
@@ skipping 23 matching lines @@
 #include "net/cert/cert_status_flags.h"
 #include "net/cert/x509_certificate.h"
 #include "net/ssl/ssl_connection_status_flags.h"
 #include "net/test/cert_test_util.h"
 #include "net/test/test_certificate_data.h"
 #include "net/test/test_data_directory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::SSLStatus;
-using security_state::SecurityStateModel;
 using testing::_;
 using testing::AnyNumber;
 using testing::Invoke;
 using testing::Return;
 using testing::SetArgPointee;
 
 namespace {
 
 // SSL cipher suite like specified in RFC5246 Appendix A.5. "The Cipher Suite".
 // Without the CR_ prefix, this clashes with the OS X 10.8 headers.
@@ skipping 39 matching lines @@
 class WebsiteSettingsTest : public ChromeRenderViewHostTestHarness {
  public:
   WebsiteSettingsTest() : 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_ =
         net::ImportCertFromFile(net::GetTestCertsDirectory(), "ok_cert.pem");
     ASSERT_TRUE(cert_);
 
     TabSpecificContentSettings::CreateForWebContents(web_contents());
     InfoBarService::CreateForWebContents(web_contents());
 
     // Setup mock ui.
@@ skipping 27 matching lines @@
       last_chosen_object_info_.push_back(std::move(chosen_object_info));
   }
 
   void ResetMockUI() { mock_ui_.reset(new MockWebsiteSettingsUI()); }
 
   void ClearWebsiteSettings() { website_settings_.reset(nullptr); }
 
   const GURL& url() const { return url_; }
   scoped_refptr<net::X509Certificate> cert() { return cert_; }
   MockWebsiteSettingsUI* mock_ui() { return mock_ui_.get(); }
-  const SecurityStateModel::SecurityInfo& security_info() {
+  const security_state::SecurityInfo& security_info() {
     return security_info_;
   }
   const std::vector<std::unique_ptr<WebsiteSettingsUI::ChosenObjectInfo>>&
   last_chosen_object_info() {
     return last_chosen_object_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()));
     }
     return website_settings_.get();
   }
 
   device::MockUsbService& usb_service() {
     return *device_client_.usb_service();
   }
 
-  SecurityStateModel::SecurityInfo security_info_;
+  security_state::SecurityInfo security_info_;
 
  private:
   device::MockDeviceClient device_client_;
   std::unique_ptr<WebsiteSettings> website_settings_;
   std::unique_ptr<MockWebsiteSettingsUI> mock_ui_;
   scoped_refptr<net::X509Certificate> cert_;
   GURL url_;
   std::vector<std::unique_ptr<WebsiteSettingsUI::ChosenObjectInfo>>
       last_chosen_object_info_;
 };
@@ skipping 162 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_.certificate = cert();
   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, InsecureContent) {
   struct TestCase {
-    SecurityStateModel::SecurityLevel security_level;
+    security_state::SecurityLevel security_level;
     net::CertStatus cert_status;
-    SecurityStateModel::ContentStatus mixed_content_status;
-    SecurityStateModel::ContentStatus content_with_cert_errors_status;
+    security_state::ContentStatus mixed_content_status;
+    security_state::ContentStatus content_with_cert_errors_status;
     WebsiteSettings::SiteConnectionStatus expected_site_connection_status;
     WebsiteSettings::SiteIdentityStatus expected_site_identity_status;
     int expected_connection_icon_id;
   };
 
   const TestCase kTestCases[] = {
       // Passive mixed content.
-      {SecurityStateModel::NONE, 0,
-       SecurityStateModel::CONTENT_STATUS_DISPLAYED,
-       SecurityStateModel::CONTENT_STATUS_NONE,
+      {security_state::NONE, 0, security_state::CONTENT_STATUS_DISPLAYED,
+       security_state::CONTENT_STATUS_NONE,
        WebsiteSettings::SITE_CONNECTION_STATUS_INSECURE_PASSIVE_SUBRESOURCE,
        WebsiteSettings::SITE_IDENTITY_STATUS_CERT, IDR_PAGEINFO_WARNING_MINOR},
       // Passive mixed content with a cert error on the main resource.
-      {SecurityStateModel::DANGEROUS, net::CERT_STATUS_DATE_INVALID,
-       SecurityStateModel::CONTENT_STATUS_DISPLAYED,
-       SecurityStateModel::CONTENT_STATUS_NONE,
+      {security_state::DANGEROUS, net::CERT_STATUS_DATE_INVALID,
+       security_state::CONTENT_STATUS_DISPLAYED,
+       security_state::CONTENT_STATUS_NONE,
        WebsiteSettings::SITE_CONNECTION_STATUS_INSECURE_PASSIVE_SUBRESOURCE,
        WebsiteSettings::SITE_IDENTITY_STATUS_ERROR, IDR_PAGEINFO_WARNING_MINOR},
       // Active and passive mixed content.
-      {SecurityStateModel::DANGEROUS, 0,
-       SecurityStateModel::CONTENT_STATUS_DISPLAYED_AND_RAN,
-       SecurityStateModel::CONTENT_STATUS_NONE,
+      {security_state::DANGEROUS, 0,
+       security_state::CONTENT_STATUS_DISPLAYED_AND_RAN,
+       security_state::CONTENT_STATUS_NONE,
        WebsiteSettings::SITE_CONNECTION_STATUS_INSECURE_ACTIVE_SUBRESOURCE,
        WebsiteSettings::SITE_IDENTITY_STATUS_CERT, IDR_PAGEINFO_BAD},
       // Active and passive mixed content with a cert error on the main
       // resource.
-      {SecurityStateModel::DANGEROUS, net::CERT_STATUS_DATE_INVALID,
-       SecurityStateModel::CONTENT_STATUS_DISPLAYED_AND_RAN,
-       SecurityStateModel::CONTENT_STATUS_NONE,
+      {security_state::DANGEROUS, net::CERT_STATUS_DATE_INVALID,
+       security_state::CONTENT_STATUS_DISPLAYED_AND_RAN,
+       security_state::CONTENT_STATUS_NONE,
        WebsiteSettings::SITE_CONNECTION_STATUS_INSECURE_ACTIVE_SUBRESOURCE,
        WebsiteSettings::SITE_IDENTITY_STATUS_ERROR, IDR_PAGEINFO_BAD},
       // Active mixed content.
-      {SecurityStateModel::DANGEROUS, 0, SecurityStateModel::CONTENT_STATUS_RAN,
-       SecurityStateModel::CONTENT_STATUS_NONE,
+      {security_state::DANGEROUS, 0, security_state::CONTENT_STATUS_RAN,
+       security_state::CONTENT_STATUS_NONE,
        WebsiteSettings::SITE_CONNECTION_STATUS_INSECURE_ACTIVE_SUBRESOURCE,
        WebsiteSettings::SITE_IDENTITY_STATUS_CERT, IDR_PAGEINFO_BAD},
       // Active mixed content with a cert error on the main resource.
-      {SecurityStateModel::DANGEROUS, net::CERT_STATUS_DATE_INVALID,
-       SecurityStateModel::CONTENT_STATUS_RAN,
-       SecurityStateModel::CONTENT_STATUS_NONE,
+      {security_state::DANGEROUS, net::CERT_STATUS_DATE_INVALID,
+       security_state::CONTENT_STATUS_RAN, security_state::CONTENT_STATUS_NONE,
        WebsiteSettings::SITE_CONNECTION_STATUS_INSECURE_ACTIVE_SUBRESOURCE,
        WebsiteSettings::SITE_IDENTITY_STATUS_ERROR, IDR_PAGEINFO_BAD},
 
       // Passive subresources with cert errors.
-      {SecurityStateModel::NONE, 0, SecurityStateModel::CONTENT_STATUS_NONE,
-       SecurityStateModel::CONTENT_STATUS_DISPLAYED,
+      {security_state::NONE, 0, security_state::CONTENT_STATUS_NONE,
+       security_state::CONTENT_STATUS_DISPLAYED,
        WebsiteSettings::SITE_CONNECTION_STATUS_INSECURE_PASSIVE_SUBRESOURCE,
        WebsiteSettings::SITE_IDENTITY_STATUS_CERT, IDR_PAGEINFO_WARNING_MINOR},
       // Passive subresources with cert errors, with a cert error on the
       // main resource also. In this case, the subresources with
       // certificate errors are ignored: if the main resource had a cert
       // error, it's not that useful to warn about subresources with cert
       // errors as well.
-      {SecurityStateModel::DANGEROUS, net::CERT_STATUS_DATE_INVALID,
-       SecurityStateModel::CONTENT_STATUS_NONE,
-       SecurityStateModel::CONTENT_STATUS_DISPLAYED,
+      {security_state::DANGEROUS, net::CERT_STATUS_DATE_INVALID,
+       security_state::CONTENT_STATUS_NONE,
+       security_state::CONTENT_STATUS_DISPLAYED,
        WebsiteSettings::SITE_CONNECTION_STATUS_ENCRYPTED,
        WebsiteSettings::SITE_IDENTITY_STATUS_ERROR, IDR_PAGEINFO_GOOD},
       // Passive and active subresources with cert errors.
-      {SecurityStateModel::DANGEROUS, 0,
-       SecurityStateModel::CONTENT_STATUS_NONE,
-       SecurityStateModel::CONTENT_STATUS_DISPLAYED_AND_RAN,
+      {security_state::DANGEROUS, 0, security_state::CONTENT_STATUS_NONE,
+       security_state::CONTENT_STATUS_DISPLAYED_AND_RAN,
        WebsiteSettings::SITE_CONNECTION_STATUS_INSECURE_ACTIVE_SUBRESOURCE,
        WebsiteSettings::SITE_IDENTITY_STATUS_CERT, IDR_PAGEINFO_BAD},
       // Passive and active subresources with cert errors, with a cert
       // error on the main resource also.
-      {SecurityStateModel::DANGEROUS, net::CERT_STATUS_DATE_INVALID,
-       SecurityStateModel::CONTENT_STATUS_NONE,
-       SecurityStateModel::CONTENT_STATUS_DISPLAYED_AND_RAN,
+      {security_state::DANGEROUS, net::CERT_STATUS_DATE_INVALID,
+       security_state::CONTENT_STATUS_NONE,
+       security_state::CONTENT_STATUS_DISPLAYED_AND_RAN,
        WebsiteSettings::SITE_CONNECTION_STATUS_ENCRYPTED,
        WebsiteSettings::SITE_IDENTITY_STATUS_ERROR, IDR_PAGEINFO_GOOD},
       // Active subresources with cert errors.
-      {SecurityStateModel::DANGEROUS, 0,
-       SecurityStateModel::CONTENT_STATUS_NONE,
-       SecurityStateModel::CONTENT_STATUS_RAN,
+      {security_state::DANGEROUS, 0, security_state::CONTENT_STATUS_NONE,
+       security_state::CONTENT_STATUS_RAN,
        WebsiteSettings::SITE_CONNECTION_STATUS_INSECURE_ACTIVE_SUBRESOURCE,
        WebsiteSettings::SITE_IDENTITY_STATUS_CERT, IDR_PAGEINFO_BAD},
       // Active subresources with cert errors, with a cert error on the main
       // resource also.
-      {SecurityStateModel::DANGEROUS, net::CERT_STATUS_DATE_INVALID,
-       SecurityStateModel::CONTENT_STATUS_NONE,
-       SecurityStateModel::CONTENT_STATUS_RAN,
+      {security_state::DANGEROUS, net::CERT_STATUS_DATE_INVALID,
+       security_state::CONTENT_STATUS_NONE, security_state::CONTENT_STATUS_RAN,
        WebsiteSettings::SITE_CONNECTION_STATUS_ENCRYPTED,
        WebsiteSettings::SITE_IDENTITY_STATUS_ERROR, IDR_PAGEINFO_GOOD},
 
       // Passive mixed content and subresources with cert errors.
-      {SecurityStateModel::NONE, 0,
-       SecurityStateModel::CONTENT_STATUS_DISPLAYED,
-       SecurityStateModel::CONTENT_STATUS_DISPLAYED,
+      {security_state::NONE, 0, security_state::CONTENT_STATUS_DISPLAYED,
+       security_state::CONTENT_STATUS_DISPLAYED,
        WebsiteSettings::SITE_CONNECTION_STATUS_INSECURE_PASSIVE_SUBRESOURCE,
        WebsiteSettings::SITE_IDENTITY_STATUS_CERT, IDR_PAGEINFO_WARNING_MINOR},
       // Passive mixed content and active subresources with cert errors.
-      {SecurityStateModel::DANGEROUS, 0,
-       SecurityStateModel::CONTENT_STATUS_DISPLAYED,
-       SecurityStateModel::CONTENT_STATUS_RAN,
+      {security_state::DANGEROUS, 0, security_state::CONTENT_STATUS_DISPLAYED,
+       security_state::CONTENT_STATUS_RAN,
        WebsiteSettings::SITE_CONNECTION_STATUS_INSECURE_ACTIVE_SUBRESOURCE,
        WebsiteSettings::SITE_IDENTITY_STATUS_CERT, IDR_PAGEINFO_BAD},
       // Active mixed content and passive subresources with cert errors.
-      {SecurityStateModel::DANGEROUS, 0, SecurityStateModel::CONTENT_STATUS_RAN,
-       SecurityStateModel::CONTENT_STATUS_DISPLAYED,
+      {security_state::DANGEROUS, 0, security_state::CONTENT_STATUS_RAN,
+       security_state::CONTENT_STATUS_DISPLAYED,
        WebsiteSettings::SITE_CONNECTION_STATUS_INSECURE_ACTIVE_SUBRESOURCE,
        WebsiteSettings::SITE_IDENTITY_STATUS_CERT, IDR_PAGEINFO_BAD},
       // Passive mixed content, active subresources with cert errors, and a cert
       // error on the main resource.
-      {SecurityStateModel::DANGEROUS, net::CERT_STATUS_DATE_INVALID,
-       SecurityStateModel::CONTENT_STATUS_DISPLAYED,
-       SecurityStateModel::CONTENT_STATUS_RAN,
+      {security_state::DANGEROUS, net::CERT_STATUS_DATE_INVALID,
+       security_state::CONTENT_STATUS_DISPLAYED,
+       security_state::CONTENT_STATUS_RAN,
        WebsiteSettings::SITE_CONNECTION_STATUS_INSECURE_PASSIVE_SUBRESOURCE,
        WebsiteSettings::SITE_IDENTITY_STATUS_ERROR, IDR_PAGEINFO_WARNING_MINOR},
   };
 
   for (const auto& test : kTestCases) {
     ResetMockUI();
     ClearWebsiteSettings();
-    security_info_ = SecurityStateModel::SecurityInfo();
+    security_info_ = security_state::SecurityInfo();
     security_info_.security_level = test.security_level;
     security_info_.scheme_is_cryptographic = true;
     security_info_.certificate = cert();
     security_info_.cert_status = test.cert_status;
     security_info_.security_bits = 81;  // No error if > 80.
     security_info_.mixed_content_status = test.mixed_content_status;
     security_info_.content_with_cert_errors_status =
         test.content_with_cert_errors_status;
     int status = 0;
     status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
@@ skipping 14 matching lines @@
     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));
 
-  security_info_.security_level = SecurityStateModel::NONE;
+  security_info_.security_level = security_state::NONE;
   security_info_.scheme_is_cryptographic = true;
   security_info_.certificate = ev_cert;
   security_info_.cert_status = net::CERT_STATUS_IS_EV;
   security_info_.security_bits = 81;  // No error if > 80.
   security_info_.mixed_content_status =
-      SecurityStateModel::CONTENT_STATUS_DISPLAYED;
+      security_state::CONTENT_STATUS_DISPLAYED;
   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_INSECURE_PASSIVE_SUBRESOURCE,
       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_.certificate = cert();
   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_.certificate = cert();
   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::SECURE_WITH_POLICY_INSTALLED_CERT;
+      security_state::SECURE_WITH_POLICY_INSTALLED_CERT;
   security_info_.scheme_is_cryptographic = true;
   security_info_.certificate = cert();
   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_.certificate = cert();
   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_.certificate = cert();
   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_.certificate = cert();
   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_.certificate = cert();
   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_TIMESTAMP);
   security_info_.sct_verify_statuses.push_back(
       net::ct::SCT_STATUS_INVALID_SIGNATURE);
 
   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_.certificate = cert();
   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 10 matching lines @@
   EXPECT_EQ(IDR_PAGEINFO_GOOD, WebsiteSettingsUI::GetIdentityIconID(
                                    website_settings()->site_identity_status()));
 }
 
 // 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));
 
-  security_info_.security_level = SecurityStateModel::SECURE;
+  security_info_.security_level = security_state::SECURE;
   security_info_.scheme_is_cryptographic = true;
   security_info_.certificate = ev_cert;
   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_.certificate = cert();
   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_SIGNATURE);
 
   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_.certificate = cert();
   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 61 matching lines @@
             website_settings()->site_identity_status());
   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 }
 #endif
 
 // Tests that metrics are recorded on a WebsiteSettings for pages with
 // various security levels.
 TEST_F(WebsiteSettingsTest, SecurityLevelMetrics) {
   struct TestCase {
     const std::string url;
-    const SecurityStateModel::SecurityLevel security_level;
+    const security_state::SecurityLevel security_level;
     const std::string histogram_name;
   };
   const char kGenericHistogram[] = "WebsiteSettings.Action";
 
   const TestCase kTestCases[] = {
-      {"https://example.test", SecurityStateModel::SECURE,
+      {"https://example.test", security_state::SECURE,
        "Security.PageInfo.Action.HttpsUrl.Valid"},
-      {"https://example.test", SecurityStateModel::EV_SECURE,
+      {"https://example.test", security_state::EV_SECURE,
        "Security.PageInfo.Action.HttpsUrl.Valid"},
-      {"https://example2.test", SecurityStateModel::NONE,
+      {"https://example2.test", security_state::NONE,
        "Security.PageInfo.Action.HttpsUrl.Downgraded"},
-      {"https://example.test", SecurityStateModel::DANGEROUS,
+      {"https://example.test", security_state::DANGEROUS,
        "Security.PageInfo.Action.HttpsUrl.Dangerous"},
-      {"http://example.test", SecurityStateModel::HTTP_SHOW_WARNING,
+      {"http://example.test", security_state::HTTP_SHOW_WARNING,
        "Security.PageInfo.Action.HttpUrl.Warning"},
-      {"http://example.test", SecurityStateModel::DANGEROUS,
+      {"http://example.test", security_state::DANGEROUS,
        "Security.PageInfo.Action.HttpUrl.Dangerous"},
-      {"http://example.test", SecurityStateModel::NONE,
+      {"http://example.test", security_state::NONE,
        "Security.PageInfo.Action.HttpUrl.Neutral"},
   };
 
   for (const auto& test : kTestCases) {
     base::HistogramTester histograms;
     SetURL(test.url);
     security_info_.security_level = test.security_level;
     ResetMockUI();
     ClearWebsiteSettings();
     SetDefaultUIExpectations(mock_ui());
@@ skipping 20 matching lines @@
     histograms.ExpectTotalCount(test.histogram_name, 2);
     histograms.ExpectBucketCount(
         test.histogram_name,
         WebsiteSettings::WebsiteSettingsAction::WEBSITE_SETTINGS_OPENED, 1);
     histograms.ExpectBucketCount(test.histogram_name,
                                  WebsiteSettings::WebsiteSettingsAction::
                                      WEBSITE_SETTINGS_PERMISSIONS_TAB_SELECTED,
                                  1);
   }
 }