Refactor SecurityStateModel/Clients for simplicity and reusability.

components/security_state/core/security_state_model.cc

 // Copyright 2015 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 "components/security_state/security_state_model.h"
+#include "components/security_state/core/security_state_model.h"
 
 #include <stdint.h>
 
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
-#include "components/security_state/security_state_model_client.h"
-#include "components/security_state/switches.h"
+#include "components/security_state/core/switches.h"
 #include "net/ssl/ssl_cipher_suite_names.h"
 #include "net/ssl/ssl_connection_status_flags.h"
 
 namespace security_state {
 
 namespace {
 
 // Do not change or reorder this enum, and add new values at the end. It is used
 // in the MarkHttpAs histogram.
 enum MarkHttpStatus { NEUTRAL, NON_SECURE, HTTP_SHOW_WARNING, LAST_STATUS };
@@ skipping 88 matching lines @@
     return SecurityStateModel::CONTENT_STATUS_DISPLAYED_AND_RAN;
   if (ran)
     return SecurityStateModel::CONTENT_STATUS_RAN;
   if (displayed)
     return SecurityStateModel::CONTENT_STATUS_DISPLAYED;
   return SecurityStateModel::CONTENT_STATUS_NONE;
 }
 
 SecurityStateModel::SecurityLevel GetSecurityLevelForRequest(
     const SecurityStateModel::VisibleSecurityState& visible_security_state,
-    SecurityStateModelClient* client,
+    bool used_policy_installed_certificate,
     SecurityStateModel::SHA1DeprecationStatus sha1_status,
     SecurityStateModel::ContentStatus mixed_content_status,
     SecurityStateModel::ContentStatus content_with_cert_errors_status) {
   DCHECK(visible_security_state.connection_info_initialized ||
          visible_security_state.fails_malware_check);
 
   // Override the connection security information if the website failed the
   // browser's malware checks.
   if (visible_security_state.fails_malware_check)
     return SecurityStateModel::DANGEROUS;
 
   GURL url = visible_security_state.url;
 
   bool is_cryptographic_with_certificate =
       (url.SchemeIsCryptographic() && visible_security_state.certificate);
 
   // Set the security level to DANGEROUS for major certificate errors.
   if (is_cryptographic_with_certificate &&
       net::IsCertStatusError(visible_security_state.cert_status) &&
       !net::IsCertStatusMinorError(visible_security_state.cert_status)) {
     return SecurityStateModel::DANGEROUS;
   }
 
   // Choose the appropriate security level for HTTP requests.
   if (!is_cryptographic_with_certificate) {
-    if (!client->IsOriginSecure(url) && url.IsStandard()) {
+    if (!IsOriginSecure(url) && url.IsStandard()) {
       return GetSecurityLevelForNonSecureFieldTrial(
           visible_security_state.displayed_password_field_on_http ||
           visible_security_state.displayed_credit_card_field_on_http);
     }
     return SecurityStateModel::NONE;
   }
 
   // Downgrade the security level for active insecure subresources.
   if (mixed_content_status == SecurityStateModel::CONTENT_STATUS_RAN ||
       mixed_content_status ==
           SecurityStateModel::CONTENT_STATUS_DISPLAYED_AND_RAN ||
       content_with_cert_errors_status ==
           SecurityStateModel::CONTENT_STATUS_RAN ||
       content_with_cert_errors_status ==
           SecurityStateModel::CONTENT_STATUS_DISPLAYED_AND_RAN) {
     return SecurityStateModel::kRanInsecureContentLevel;
   }
 
   // Report if there is a policy cert first, before reporting any other
   // authenticated-but-with-errors cases. A policy cert is a strong
   // indicator of a MITM being present (the enterprise), while the
   // other authenticated-but-with-errors indicate something may
   // be wrong, or may be wrong in the future, but is unclear now.
-  if (client->UsedPolicyInstalledCertificate())
+  if (used_policy_installed_certificate)
     return SecurityStateModel::SECURE_WITH_POLICY_INSTALLED_CERT;
 
   if (sha1_status == SecurityStateModel::DEPRECATED_SHA1_MAJOR)
     return SecurityStateModel::DANGEROUS;
   if (sha1_status == SecurityStateModel::DEPRECATED_SHA1_MINOR)
     return SecurityStateModel::NONE;
 
   // Active mixed content is handled above.
   DCHECK_NE(SecurityStateModel::CONTENT_STATUS_RAN, mixed_content_status);
   DCHECK_NE(SecurityStateModel::CONTENT_STATUS_DISPLAYED_AND_RAN,
@@ skipping 12 matching lines @@
   }
 
   if ((visible_security_state.cert_status & net::CERT_STATUS_IS_EV) &&
       visible_security_state.certificate) {
     return SecurityStateModel::EV_SECURE;
   }
   return SecurityStateModel::SECURE;
 }
 
 void SecurityInfoForRequest(
-    SecurityStateModelClient* client,
     const SecurityStateModel::VisibleSecurityState& visible_security_state,
+    bool used_policy_installed_certificate,
     SecurityStateModel::SecurityInfo* security_info) {
   if (!visible_security_state.connection_info_initialized) {
     *security_info = SecurityStateModel::SecurityInfo();
     security_info->fails_malware_check =
         visible_security_state.fails_malware_check;
     if (security_info->fails_malware_check) {
       security_info->security_level = GetSecurityLevelForRequest(
-          visible_security_state, client, SecurityStateModel::UNKNOWN_SHA1,
+          visible_security_state, used_policy_installed_certificate,
+          SecurityStateModel::UNKNOWN_SHA1,
           SecurityStateModel::CONTENT_STATUS_UNKNOWN,
           SecurityStateModel::CONTENT_STATUS_UNKNOWN);
     }
     return;
   }
   security_info->certificate = visible_security_state.certificate;
   security_info->sha1_deprecation_status =
       GetSHA1DeprecationStatus(visible_security_state);
   security_info->mixed_content_status =
       GetContentStatus(visible_security_state.displayed_mixed_content,
@@ skipping 14 matching lines @@
       visible_security_state.sct_verify_statuses;
 
   security_info->fails_malware_check =
       visible_security_state.fails_malware_check;
 
   security_info->displayed_private_user_data_input_on_http =
       visible_security_state.displayed_password_field_on_http ||
       visible_security_state.displayed_credit_card_field_on_http;
 
   security_info->security_level = GetSecurityLevelForRequest(
-      visible_security_state, client, security_info->sha1_deprecation_status,
+      visible_security_state, used_policy_installed_certificate,
+      security_info->sha1_deprecation_status,
       security_info->mixed_content_status,
       security_info->content_with_cert_errors_status);
 }
 
 }  // namespace
 
 const SecurityStateModel::SecurityLevel
     SecurityStateModel::kDisplayedInsecureContentLevel =
         SecurityStateModel::NONE;
 const SecurityStateModel::SecurityLevel
@@ skipping 15 matching lines @@
       pkp_bypassed(false),
       displayed_private_user_data_input_on_http(false) {}
 
 SecurityStateModel::SecurityInfo::~SecurityInfo() {}
 
 SecurityStateModel::SecurityStateModel() {}
 
 SecurityStateModel::~SecurityStateModel() {}
 
 void SecurityStateModel::GetSecurityInfo(
-    SecurityStateModel::SecurityInfo* result) const {
-  VisibleSecurityState new_visible_state;
-  client_->GetVisibleSecurityState(&new_visible_state);
-  SecurityInfoForRequest(client_, new_visible_state, result);
-}
-
-void SecurityStateModel::SetClient(SecurityStateModelClient* client) {
-  client_ = client;
+    SecurityStateModel::SecurityInfo* result,
+    std::unique_ptr<VisibleSecurityState> visible_security_state,
+    bool used_policy_installed_certificate) const {
+  SecurityInfoForRequest(*visible_security_state,
+                         used_policy_installed_certificate, result);
 }
 
 SecurityStateModel::VisibleSecurityState::VisibleSecurityState()
     : fails_malware_check(false),
       connection_info_initialized(false),
       cert_status(0),
       connection_status(0),
       key_exchange_group(0),
       security_bits(-1),
       displayed_mixed_content(false),
@@ skipping 22 matching lines @@
               other.displayed_content_with_cert_errors &&
           ran_content_with_cert_errors == other.ran_content_with_cert_errors &&
           pkp_bypassed == other.pkp_bypassed &&
           displayed_password_field_on_http ==
               other.displayed_password_field_on_http &&
           displayed_credit_card_field_on_http ==
               other.displayed_credit_card_field_on_http);
 }
 
 }  // namespace security_state