Move error classification into the ssl_errors component

components/ssl_errors/error_classification.h

-// Copyright 2014 The Chromium Authors. All rights reserved.
+// 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.
 
-#ifndef CHROME_BROWSER_SSL_SSL_ERROR_CLASSIFICATION_H_
-#define CHROME_BROWSER_SSL_SSL_ERROR_CLASSIFICATION_H_
+#ifndef COMPONENTS_SSL_ERRORS_ERROR_CLASSIFICATION_H_
+#define COMPONENTS_SSL_ERRORS_ERROR_CLASSIFICATION_H_
 
 #include <string>
 #include <vector>
 
 #include "base/time/time.h"
-#include "content/public/browser/notification_observer.h"
-#include "content/public/browser/notification_registrar.h"
 #include "net/cert/x509_certificate.h"
 #include "url/gurl.h"
 
-namespace content {
-class WebContents;
-}
+namespace ssl_errors {
 
-// This class classifies characteristics of SSL errors, including information
-// about captive portal detection.
-//
-// This class should only be used on the UI thread because its
-// implementation uses captive_portal::CaptivePortalService which can only be
-// accessed on the UI thread.
-class SSLErrorClassification : public content::NotificationObserver {
+// This class classifies characteristics of SSL errors.
+class ErrorClassification {
  public:
-  SSLErrorClassification(content::WebContents* web_contents,
-                         const base::Time& current_time,
-                         const GURL& url,
-                         int cert_error,
-                         const net::X509Certificate& cert);
-  ~SSLErrorClassification() override;
+  ErrorClassification(const base::Time& current_time,
+                      const GURL& url,
+                      int cert_error,
+                      const net::X509Certificate& cert);
+  ~ErrorClassification();
 
   // Returns true if the system time is in the past.
   static bool IsUserClockInThePast(const base::Time& time_now);
 
   // Returns true if the system time is too far in the future or the user is
   // using a version of Chrome which is more than 1 year old.
   static bool IsUserClockInTheFuture(const base::Time& time_now);
 
   // Sets a clock for browser tests that check the build time. Used by
   // IsUserClockInThePast and IsUserClockInTheFuture.
@@ skipping 19 matching lines @@
   //     www.food.example.com ~ example.com -> false
   //     mail.example.com ~ example.com -> false
   static bool GetWWWSubDomainMatch(const std::string& host_name,
                                    const std::vector<std::string>& dns_names,
                                    std::string* www_match_host_name);
 
   // A function which calculates the severity score when the ssl error is
   // |CERT_DATE_INVALID|. The calculated score is between 0.0 and 1.0, higher
   // being more severe, indicating how severe the certificate's
   // date invalid error is.
   void InvalidDateSeverityScore();

[estark, 2015/09/23 22:42:19]

While you're here: it doesn't look like this method (or the two below it) are
ever actually used anywhere. Is that true? Can we remove them?

 
   // A function which calculates the severity score when the ssl error is
   // |CERT_COMMON_NAME_INVALID|. The calculated score is between 0.0 and 1.0,
   // higher being more severe, indicating how severe the certificate's common
   // name invalid error is.
   void InvalidCommonNameSeverityScore();
 
   // A function which calculates the severity score when the ssl error is
   // |CERT_AUTHORITY_INVALID|, returns a score between 0.0 and 1.0, higher
   // values being more severe, indicating how severe the certificate's
   // authority invalid error is.
   void InvalidAuthoritySeverityScore();
 
   void RecordUMAStatistics(bool overridable) const;
-  void RecordCaptivePortalUMAStatistics(bool overridable) const;
   base::TimeDelta TimePassedSinceExpiry() const;
 
  private:
-  FRIEND_TEST_ALL_PREFIXES(SSLErrorClassificationTest, TestDateInvalidScore);
-  FRIEND_TEST_ALL_PREFIXES(SSLErrorClassificationTest, TestNameMismatch);
-  FRIEND_TEST_ALL_PREFIXES(SSLErrorClassificationTest,
-                           TestHostNameHasKnownTLD);
+  FRIEND_TEST_ALL_PREFIXES(ErrorClassificationTest, TestDateInvalidScore);
+  FRIEND_TEST_ALL_PREFIXES(ErrorClassificationTest, TestNameMismatch);
+  FRIEND_TEST_ALL_PREFIXES(ErrorClassificationTest, TestHostNameHasKnownTLD);
 
   typedef std::vector<std::string> Tokens;
 
   // Returns true if the hostname has a known Top Level Domain.
   static bool IsHostNameKnownTLD(const std::string& host_name);
 
   // Returns true if GetWWWSubDomainMatch finds a www mismatch.
   bool IsWWWSubDomainMatch() const;
 
   // Returns true if |child| is a subdomain of any of the |potential_parents|.
   bool NameUnderAnyNames(const Tokens& child,
-                        const std::vector<Tokens>& potential_parents) const;
+                         const std::vector<Tokens>& potential_parents) const;
 
   // Returns true if any of the |potential_children| is a subdomain of the
   // |parent|. The inverse case should be treated carefully as this is most
   // likely a MITM attack. We don't want foo.appspot.com to be able to MITM for
   // appspot.com.
   bool AnyNamesUnderName(const std::vector<Tokens>& potential_children,
-                        const Tokens& parent) const;
+                         const Tokens& parent) const;
 
   // Returns true if |hostname| is too broad for the scope of a wildcard
   // certificate. E.g.:
   //
   //     a.b.example.com ~ *.example.com --> true
   //     b.example.com ~ *.example.com --> false
   bool IsSubDomainOutsideWildcard(const Tokens& hostname) const;
 
   // Returns true if the certificate is a shared certificate. Note - This
   // function should be used with caution (only for UMA histogram) as an
@@ skipping 19 matching lines @@
   //                           Tokenize("example.com"))
   // --> 2.
   size_t FindSubDomainDifference(const Tokens& potential_subdomain,
                                  const Tokens& parent) const;
 
   static Tokens Tokenize(const std::string& name);
 
   float CalculateScoreTimePassedSinceExpiry() const;
   float CalculateScoreEnvironments() const;
 
-  // content::NotificationObserver:
-  void Observe(int type,
-               const content::NotificationSource& source,
-               const content::NotificationDetails& details) override;
-
-  content::WebContents* web_contents_;
   // This stores the current time.

[estark, 2015/09/23 22:42:19]

nit on pre-existing code, which must surely be the most annoying kind of nit: I
feel like this comment doesn't add much.

   base::Time current_time_;
   const GURL request_url_;
   int cert_error_;
   // This stores the certificate.
   const net::X509Certificate& cert_;
-  // Is captive portal detection enabled?
-  bool captive_portal_detection_enabled_;
-  // Did the probe complete before the interstitial was closed?
-  bool captive_portal_probe_completed_;
-  // Did the captive portal probe receive an error or get a non-HTTP response?
-  bool captive_portal_no_response_;
-  // Was a captive portal detected?
-  bool captive_portal_detected_;
-
-  content::NotificationRegistrar registrar_;
 };
 
-#endif  // CHROME_BROWSER_SSL_SSL_ERROR_CLASSIFICATION_H_
+}  // namespace ssl_errors
+
+#endif  // COMPONENTS_SSL_ERRORS_ERROR_CLASSIFICATION_H_