Create a component for SSL error handling

chrome/browser/ssl/ssl_error_classification.cc

 // Copyright 2014 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 <vector>
 
 #include "chrome/browser/ssl/ssl_error_classification.h"
 
 #include "base/build_time.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/ssl/ssl_error_info.h"
+#include "components/ssl_errors/error_info.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_contents.h"
 #include "net/base/net_util.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/cert/x509_cert_types.h"
 #include "net/cert/x509_certificate.h"
 #include "url/gurl.h"
 
 #if defined(ENABLE_CAPTIVE_PORTAL_DETECTION)
 #include "chrome/browser/captive_portal/captive_portal_service.h"
@@ skipping 144 matching lines @@
   else if (captive_portal_no_response_)
     RecordCaptivePortalEventStats(
         overridable ?
         CAPTIVE_PORTAL_NO_RESPONSE_OVERRIDABLE :
         CAPTIVE_PORTAL_NO_RESPONSE);
 #endif
 }
 
 void SSLErrorClassification::RecordUMAStatistics(
     bool overridable) const {
-  SSLErrorInfo::ErrorType type =
-      SSLErrorInfo::NetErrorToErrorType(cert_error_);
-  UMA_HISTOGRAM_ENUMERATION(
-      "interstitial.ssl_error_type", type, SSLErrorInfo::END_OF_ENUM);
+  ssl_errors::ErrorInfo::ErrorType type =
+      ssl_errors::ErrorInfo::NetErrorToErrorType(cert_error_);
+  UMA_HISTOGRAM_ENUMERATION("interstitial.ssl_error_type", type,
+                            ssl_errors::ErrorInfo::END_OF_ENUM);
   switch (type) {
-    case SSLErrorInfo::CERT_DATE_INVALID: {
+    case ssl_errors::ErrorInfo::CERT_DATE_INVALID: {
       if (IsUserClockInThePast(base::Time::NowFromSystemTime())) {
         RecordSSLInterstitialCause(overridable, CLOCK_PAST);
       } else if (IsUserClockInTheFuture(base::Time::NowFromSystemTime())) {
         RecordSSLInterstitialCause(overridable, CLOCK_FUTURE);
       } else if (cert_.HasExpired() && TimePassedSinceExpiry().InDays() < 28) {
         RecordSSLInterstitialCause(overridable, EXPIRED_RECENTLY);
       }
       break;
     }
-    case SSLErrorInfo::CERT_COMMON_NAME_INVALID: {
+    case ssl_errors::ErrorInfo::CERT_COMMON_NAME_INVALID: {
       std::string host_name = request_url_.host();
       if (IsHostNameKnownTLD(host_name)) {
         Tokens host_name_tokens = Tokenize(host_name);
         if (IsWWWSubDomainMatch())
           RecordSSLInterstitialCause(overridable, WWW_SUBDOMAIN_MATCH);
         if (IsSubDomainOutsideWildcard(host_name_tokens))
           RecordSSLInterstitialCause(overridable, SUBDOMAIN_OUTSIDE_WILDCARD);
         std::vector<std::string> dns_names;
         cert_.GetDNSNames(&dns_names);
         std::vector<Tokens> dns_name_tokens = GetTokenizedDNSNames(dns_names);
         if (NameUnderAnyNames(host_name_tokens, dns_name_tokens))
           RecordSSLInterstitialCause(overridable, SUBDOMAIN_MATCH);
         if (AnyNamesUnderName(dns_name_tokens, host_name_tokens))
           RecordSSLInterstitialCause(overridable, SUBDOMAIN_INVERSE_MATCH);
         if (IsCertLikelyFromMultiTenantHosting())
           RecordSSLInterstitialCause(overridable, LIKELY_MULTI_TENANT_HOSTING);
         if (IsCertLikelyFromSameDomain())
           RecordSSLInterstitialCause(overridable, LIKELY_SAME_DOMAIN);
       } else {
          RecordSSLInterstitialCause(overridable, HOST_NAME_NOT_KNOWN_TLD);
       }
       break;
     }
-    case SSLErrorInfo::CERT_AUTHORITY_INVALID: {
+    case ssl_errors::ErrorInfo::CERT_AUTHORITY_INVALID: {
       const std::string& hostname = request_url_.HostNoBrackets();
       if (net::IsLocalhost(hostname))
         RecordSSLInterstitialCause(overridable, LOCALHOST);
       if (IsHostnameNonUniqueOrDotless(hostname))
         RecordSSLInterstitialCause(overridable, PRIVATE_URL);
       if (captive_portal_probe_completed_ && captive_portal_detected_)
         RecordSSLInterstitialCause(overridable, AUTHORITY_ERROR_CAPTIVE_PORTAL);
       if (net::X509Certificate::IsSelfSigned(cert_.os_cert_handle()))
         RecordSSLInterstitialCause(overridable, SELF_SIGNED);
       break;
@@ skipping 317 matching lines @@
     // sure we don't clear the captive protal flag, since the interstitial was
     // potentially caused by the captive portal.
     captive_portal_detected_ = captive_portal_detected_ ||
         (results->result == captive_portal::RESULT_BEHIND_CAPTIVE_PORTAL);
     // Also keep track of non-HTTP portals and error cases.
     captive_portal_no_response_ = captive_portal_no_response_ ||
         (results->result == captive_portal::RESULT_NO_RESPONSE);
   }
 #endif
 }