Refactor SecurityStateModel/Clients for simplicity and reusability.

chrome/browser/ui/website_settings/website_settings.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 <stddef.h>
 #include <stdint.h>
 
 #include <string>
@@ skipping 64 matching lines @@
 
 #if !defined(OS_ANDROID)
 #include "chrome/browser/ui/exclusive_access/exclusive_access_manager.h"
 #include "chrome/browser/ui/website_settings/website_settings_infobar_delegate.h"
 #endif
 
 using base::ASCIIToUTF16;
 using base::UTF8ToUTF16;
 using base::UTF16ToUTF8;
 using content::BrowserThread;
-using security_state::SecurityStateModel;
 
 namespace {
 
 // Events for UMA. Do not reorder or change!
 enum SSLCertificateDecisionsDidRevoke {
   USER_CERT_DECISIONS_NOT_REVOKED = 0,
   USER_CERT_DECISIONS_REVOKED,
   END_OF_SSL_CERTIFICATE_DECISIONS_DID_REVOKE_ENUM
 };
 
@@ skipping 23 matching lines @@
 bool ShouldShowPermission(ContentSettingsType type) {
 #if !defined(OS_ANDROID)
   // Autoplay is Android-only at the moment.
   if (type == CONTENT_SETTINGS_TYPE_AUTOPLAY)
     return false;
 #endif
 
   return true;
 }
 
-void CheckContentStatus(SecurityStateModel::ContentStatus content_status,
+void CheckContentStatus(security_state::ContentStatus content_status,
                         bool* displayed,
                         bool* ran) {
   switch (content_status) {
-    case SecurityStateModel::CONTENT_STATUS_DISPLAYED:
+    case security_state::CONTENT_STATUS_DISPLAYED:
       *displayed = true;
       break;
-    case SecurityStateModel::CONTENT_STATUS_RAN:
+    case security_state::CONTENT_STATUS_RAN:
       *ran = true;
       break;
-    case SecurityStateModel::CONTENT_STATUS_DISPLAYED_AND_RAN:
+    case security_state::CONTENT_STATUS_DISPLAYED_AND_RAN:
       *displayed = true;
       *ran = true;
       break;
-    case SecurityStateModel::CONTENT_STATUS_UNKNOWN:
-    case SecurityStateModel::CONTENT_STATUS_NONE:
+    case security_state::CONTENT_STATUS_UNKNOWN:
+    case security_state::CONTENT_STATUS_NONE:
       break;
   }
 }
 
 void CheckForInsecureContent(
-    const SecurityStateModel::SecurityInfo& security_info,
+    const security_state::SecurityInfo& security_info,
     bool* displayed,
     bool* ran) {
   CheckContentStatus(security_info.mixed_content_status, displayed, ran);
   // Only consider subresources with certificate errors if the main
   // resource was loaded over HTTPS without major certificate errors. If
   // the main resource had a certificate error, then it would not be
   // that useful (and would potentially be confusing) to warn about
   // subesources that had certificate errors too.
   if (net::IsCertStatusError(security_info.cert_status) &&
       !net::IsCertStatusMinorError(security_info.cert_status)) {
     return;
   }
   CheckContentStatus(security_info.content_with_cert_errors_status, displayed,
                      ran);
 }
 
 void GetSiteIdentityByMaliciousContentStatus(
-    security_state::SecurityStateModel::MaliciousContentStatus
-        malicious_content_status,
+    security_state::MaliciousContentStatus malicious_content_status,
     WebsiteSettings::SiteIdentityStatus* status,
     base::string16* details) {
   switch (malicious_content_status) {
-    case security_state::SecurityStateModel::MALICIOUS_CONTENT_STATUS_NONE:
+    case security_state::MALICIOUS_CONTENT_STATUS_NONE:
       NOTREACHED();
       break;
-    case security_state::SecurityStateModel::MALICIOUS_CONTENT_STATUS_MALWARE:
+    case security_state::MALICIOUS_CONTENT_STATUS_MALWARE:
       *status = WebsiteSettings::SITE_IDENTITY_STATUS_MALWARE;
       *details =
           l10n_util::GetStringUTF16(IDS_WEBSITE_SETTINGS_MALWARE_DETAILS);
       break;
-    case security_state::SecurityStateModel::
-        MALICIOUS_CONTENT_STATUS_SOCIAL_ENGINEERING:
+    case security_state::MALICIOUS_CONTENT_STATUS_SOCIAL_ENGINEERING:
       *status = WebsiteSettings::SITE_IDENTITY_STATUS_SOCIAL_ENGINEERING;
       *details = l10n_util::GetStringUTF16(
           IDS_WEBSITE_SETTINGS_SOCIAL_ENGINEERING_DETAILS);
       break;
-    case security_state::SecurityStateModel::
-        MALICIOUS_CONTENT_STATUS_UNWANTED_SOFTWARE:
+    case security_state::MALICIOUS_CONTENT_STATUS_UNWANTED_SOFTWARE:
       *status = WebsiteSettings::SITE_IDENTITY_STATUS_UNWANTED_SOFTWARE;
       *details = l10n_util::GetStringUTF16(
           IDS_WEBSITE_SETTINGS_UNWANTED_SOFTWARE_DETAILS);
       break;
   }
 }
 
 base::string16 GetSimpleSiteName(const GURL& url) {
   return url_formatter::FormatUrlForSecurityDisplay(
       url, url_formatter::SchemeDisplay::OMIT_HTTP_AND_HTTPS);
@@ skipping 13 matching lines @@
 };
 
 }  // namespace
 
 WebsiteSettings::WebsiteSettings(
     WebsiteSettingsUI* ui,
     Profile* profile,
     TabSpecificContentSettings* tab_specific_content_settings,
     content::WebContents* web_contents,
     const GURL& url,
-    const SecurityStateModel::SecurityInfo& security_info)
+    const security_state::SecurityInfo& security_info)
     : TabSpecificContentSettings::SiteDataObserver(
           tab_specific_content_settings),
       content::WebContentsObserver(web_contents),
       ui_(ui),
       show_info_bar_(false),
       site_url_(url),
       site_identity_status_(SITE_IDENTITY_STATUS_UNKNOWN),
       site_connection_status_(SITE_CONNECTION_STATUS_UNKNOWN),
       show_ssl_decision_revoke_button_(false),
       content_settings_(HostContentSettingsMapFactory::GetForProfile(profile)),
       chrome_ssl_host_state_delegate_(
           ChromeSSLHostStateDelegateFactory::GetForProfile(profile)),
       did_revoke_user_ssl_decisions_(false),
       profile_(profile),
-      security_level_(security_state::SecurityStateModel::NONE) {
+      security_level_(security_state::NONE) {
   Init(url, security_info);
 
   PresentSitePermissions();
   PresentSiteData();
   PresentSiteIdentity();
 
   // Every time the Website Settings UI is opened a |WebsiteSettings| object is
   // created. So this counts how ofter the Website Settings UI is opened.
   RecordWebsiteSettingsAction(WEBSITE_SETTINGS_OPENED);
 }
 
 WebsiteSettings::~WebsiteSettings() {
 }
 
 void WebsiteSettings::RecordWebsiteSettingsAction(
     WebsiteSettingsAction action) {
   UMA_HISTOGRAM_ENUMERATION("WebsiteSettings.Action",
                             action,
                             WEBSITE_SETTINGS_COUNT);
 
   std::string histogram_name;
 
   if (site_url_.SchemeIsCryptographic()) {
-    if (security_level_ == security_state::SecurityStateModel::SECURE ||
-        security_level_ == security_state::SecurityStateModel::EV_SECURE) {
+    if (security_level_ == security_state::SECURE ||
+        security_level_ == security_state::EV_SECURE) {
       UMA_HISTOGRAM_ENUMERATION("Security.PageInfo.Action.HttpsUrl.Valid",
                                 action, WEBSITE_SETTINGS_COUNT);
-    } else if (security_level_ == security_state::SecurityStateModel::NONE) {
+    } else if (security_level_ == security_state::NONE) {
       UMA_HISTOGRAM_ENUMERATION("Security.PageInfo.Action.HttpsUrl.Downgraded",
                                 action, WEBSITE_SETTINGS_COUNT);
-    } else if (security_level_ ==
-               security_state::SecurityStateModel::DANGEROUS) {
+    } else if (security_level_ == security_state::DANGEROUS) {
       UMA_HISTOGRAM_ENUMERATION("Security.PageInfo.Action.HttpsUrl.Dangerous",
                                 action, WEBSITE_SETTINGS_COUNT);
     }
     return;
   }
 
-  if (security_level_ ==
-      security_state::SecurityStateModel::HTTP_SHOW_WARNING) {
+  if (security_level_ == security_state::HTTP_SHOW_WARNING) {
     UMA_HISTOGRAM_ENUMERATION("Security.PageInfo.Action.HttpUrl.Warning",
                               action, WEBSITE_SETTINGS_COUNT);
-  } else if (security_level_ == security_state::SecurityStateModel::DANGEROUS) {
+  } else if (security_level_ == security_state::DANGEROUS) {
     UMA_HISTOGRAM_ENUMERATION("Security.PageInfo.Action.HttpUrl.Dangerous",
                               action, WEBSITE_SETTINGS_COUNT);
   } else {
     UMA_HISTOGRAM_ENUMERATION("Security.PageInfo.Action.HttpUrl.Neutral",
                               action, WEBSITE_SETTINGS_COUNT);
   }
 }
 
 void WebsiteSettings::OnSitePermissionChanged(ContentSettingsType type,
                                               ContentSetting setting) {
@@ skipping 77 matching lines @@
 #endif
 }
 
 void WebsiteSettings::OnRevokeSSLErrorBypassButtonPressed() {
   DCHECK(chrome_ssl_host_state_delegate_);
   chrome_ssl_host_state_delegate_->RevokeUserAllowExceptionsHard(
       site_url().host());
   did_revoke_user_ssl_decisions_ = true;
 }
 
-void WebsiteSettings::Init(
-    const GURL& url,
-    const SecurityStateModel::SecurityInfo& security_info) {
+void WebsiteSettings::Init(const GURL& url,
+                           const security_state::SecurityInfo& security_info) {
 #if !defined(OS_ANDROID) && !defined(OS_IOS)
   // On desktop, internal URLs aren't handled by this class. Instead, a
   // custom and simpler popup is shown.
   DCHECK(!url.SchemeIs(content::kChromeUIScheme) &&
          !url.SchemeIs(content::kChromeDevToolsScheme) &&
          !url.SchemeIs(content::kViewSourceScheme) &&
          !url.SchemeIs(content_settings::kExtensionScheme));
 #endif
 
   bool isChromeUINativeScheme = false;
@@ skipping 21 matching lines @@
     site_identity_details_ =
         l10n_util::GetStringUTF16(IDS_PAGE_INFO_INTERNAL_PAGE);
     site_connection_status_ = SITE_CONNECTION_STATUS_INTERNAL_PAGE;
     return;
   }
 
   // Identity section.
   certificate_ = security_info.certificate;
 
   if (security_info.malicious_content_status !=
-      security_state::SecurityStateModel::MALICIOUS_CONTENT_STATUS_NONE) {
+      security_state::MALICIOUS_CONTENT_STATUS_NONE) {
     // The site has been flagged by Safe Browsing as dangerous.
     GetSiteIdentityByMaliciousContentStatus(
         security_info.malicious_content_status, &site_identity_status_,
         &site_identity_details_);
   } else if (certificate_ &&
              (!net::IsCertStatusError(security_info.cert_status) ||
               net::IsCertStatusMinorError(security_info.cert_status))) {
     // HTTPS with no or minor errors.
     if (security_info.security_level ==
-        SecurityStateModel::SECURE_WITH_POLICY_INSTALLED_CERT) {
+        security_state::SECURE_WITH_POLICY_INSTALLED_CERT) {
       site_identity_status_ = SITE_IDENTITY_STATUS_ADMIN_PROVIDED_CERT;
       site_identity_details_ = l10n_util::GetStringFUTF16(
           IDS_CERT_POLICY_PROVIDED_CERT_MESSAGE, UTF8ToUTF16(url.host()));
     } else if (net::IsCertStatusMinorError(security_info.cert_status)) {
       site_identity_status_ = SITE_IDENTITY_STATUS_CERT_REVOCATION_UNKNOWN;
       base::string16 issuer_name(
           UTF8ToUTF16(certificate_->issuer().GetDisplayName()));
       if (issuer_name.empty()) {
         issuer_name.assign(l10n_util::GetStringUTF16(
             IDS_PAGE_INFO_SECURITY_TAB_UNKNOWN_PARTY));
@@ skipping 51 matching lines @@
             UTF8ToUTF16(certificate_->issuer().GetDisplayName()));
         if (issuer_name.empty()) {
           issuer_name.assign(l10n_util::GetStringUTF16(
               IDS_PAGE_INFO_SECURITY_TAB_UNKNOWN_PARTY));
         }
 
         site_identity_details_.assign(l10n_util::GetStringFUTF16(
             IDS_PAGE_INFO_SECURITY_TAB_SECURE_IDENTITY_VERIFIED, issuer_name));
       }
       switch (security_info.sha1_deprecation_status) {
-        case SecurityStateModel::DEPRECATED_SHA1_MINOR:
+        case security_state::DEPRECATED_SHA1_MINOR:
           site_identity_status_ =
               SITE_IDENTITY_STATUS_DEPRECATED_SIGNATURE_ALGORITHM_MINOR;
           site_identity_details_ +=
               UTF8ToUTF16("\n\n") +
               l10n_util::GetStringUTF16(
                   IDS_PAGE_INFO_SECURITY_TAB_DEPRECATED_SIGNATURE_ALGORITHM_MINOR);
           break;
-        case SecurityStateModel::DEPRECATED_SHA1_MAJOR:
+        case security_state::DEPRECATED_SHA1_MAJOR:
           site_identity_status_ =
               SITE_IDENTITY_STATUS_DEPRECATED_SIGNATURE_ALGORITHM_MAJOR;
           site_identity_details_ +=
               UTF8ToUTF16("\n\n") +
               l10n_util::GetStringUTF16(
                   IDS_PAGE_INFO_SECURITY_TAB_DEPRECATED_SIGNATURE_ALGORITHM_MAJOR);
           break;
-        case SecurityStateModel::NO_DEPRECATED_SHA1:
+        case security_state::NO_DEPRECATED_SHA1:
           // Nothing to do.
           break;
-        case SecurityStateModel::UNKNOWN_SHA1:
+        case security_state::UNKNOWN_SHA1:
           // UNKNOWN_SHA1 should only appear when certificate info has not been
           // initialized, in which case this if-statement should not be running
           // because there is no other cert info.
           NOTREACHED();
       }
     }
   } else {
     // HTTP or HTTPS with errors (not warnings).
     site_identity_details_.assign(l10n_util::GetStringUTF16(
         IDS_PAGE_INFO_SECURITY_TAB_INSECURE_IDENTITY));
@@ skipping 35 matching lines @@
     // loaded over HTTP or loaded over HTTPS with no cert.
     site_connection_status_ = SITE_CONNECTION_STATUS_UNENCRYPTED;
 
     site_connection_details_.assign(l10n_util::GetStringFUTF16(
         IDS_PAGE_INFO_SECURITY_TAB_NOT_ENCRYPTED_CONNECTION_TEXT,
         subject_name));
   } else if (security_info.security_bits < 0) {
     // Security strength is unknown.  Say nothing.
     site_connection_status_ = SITE_CONNECTION_STATUS_ENCRYPTED_ERROR;
   } else if (security_info.security_bits == 0) {
-    DCHECK_NE(security_info.security_level, SecurityStateModel::NONE);
+    DCHECK_NE(security_info.security_level, security_state::NONE);
     site_connection_status_ = SITE_CONNECTION_STATUS_ENCRYPTED_ERROR;
     site_connection_details_.assign(l10n_util::GetStringFUTF16(
         IDS_PAGE_INFO_SECURITY_TAB_NOT_ENCRYPTED_CONNECTION_TEXT,
         subject_name));
   } else {
     site_connection_status_ = SITE_CONNECTION_STATUS_ENCRYPTED;
 
     if (security_info.obsolete_ssl_status == net::OBSOLETE_SSL_NONE) {
       site_connection_details_.assign(l10n_util::GetStringFUTF16(
           IDS_PAGE_INFO_SECURITY_TAB_ENCRYPTED_CONNECTION_TEXT,
@@ skipping 209 matching lines @@
   info.connection_status = site_connection_status_;
   info.connection_status_description =
       UTF16ToUTF8(site_connection_details_);
   info.identity_status = site_identity_status_;
   info.identity_status_description =
       UTF16ToUTF8(site_identity_details_);
   info.certificate = certificate_;
   info.show_ssl_decision_revoke_button = show_ssl_decision_revoke_button_;
   ui_->SetIdentityInfo(info);
 }