Find reasons for the SSL common name invalid error.

chrome/browser/ssl/ssl_blocking_page.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/ssl/ssl_blocking_page.h"
 
 #include "base/build_time.h"
 #include "base/command_line.h"
 #include "base/i18n/rtl.h"
 #include "base/i18n/time_formatting.h"
@@ skipping 246 matching lines @@
     if (history_service) {
       history_service->GetVisibleVisitCountToHost(
           request_url_,
           base::Bind(&SSLBlockingPage::OnGotHistoryCount,
                      base::Unretained(this)),
           &request_tracker_);
     }
   }
   if (SSLErrorInfo::NetErrorToErrorType(cert_error_) ==
       SSLErrorInfo::CERT_DATE_INVALID) {
-    SSLErrorClassification::RecordUMAStatistics(overridable_ &&
-                                                !strict_enforcement_);
+    SSLErrorClassification ssl_error_classification(

[felt, 2014/07/16 22:47:33]

you should create a single SSLErrorClassification object and call its methods
repeatedly

[radhikabhar, 2014/07/17 01:02:11]

Done.

+        base::Time::NowFromSystemTime(),
+        request_url_,
+        *ssl_info_.cert.get());
+    ssl_error_classification.RecordUMAStatisticsDateInvalid(

[felt, 2014/07/16 23:31:47]

Actually, wouldn't it make more sense to just have one public method
RecordUMAStatistics, then have a switch statement inside of it based on the
error type that does the appropriate UMA stats? that way SSLBlockingPage doesn't
need to handle any of this logic.

[radhikabhar, 2014/07/17 01:02:11]

Done.

+        overridable_ && !strict_enforcement_);
+  }
+
+  if (SSLErrorInfo::NetErrorToErrorType(cert_error_) ==

[felt, 2014/07/16 22:47:33]

you should probably save the error type instead of calling NetErrorToErrorType
every time

[radhikabhar, 2014/07/17 01:02:11]

Done.

+      SSLErrorInfo::CERT_COMMON_NAME_INVALID) {
+    SSLErrorClassification ssl_error_classification
+        (base::Time::NowFromSystemTime(),
+         request_url_,
+         *ssl_info_.cert.get());
+    ssl_error_classification.RecordUMAStatisticsNameInvalid(
+        overridable_ && !strict_enforcement_);
+  }
+
+  if (SSLErrorInfo::NetErrorToErrorType(cert_error_) ==
+      SSLErrorInfo::CERT_AUTHORITY_INVALID) {
+    SSLErrorClassification ssl_error_classification(
+        base::Time::NowFromSystemTime(),
+        request_url_,
+        *ssl_info_.cert.get());
+    ssl_error_classification.RecordUMAStatisticsAuthorityInvalid(
+        overridable_ && !strict_enforcement_);
   }
 
 #if defined(ENABLE_CAPTIVE_PORTAL_DETECTION)
   CaptivePortalService* captive_portal_service =
       CaptivePortalServiceFactory::GetForProfile(profile);
   captive_portal_detection_enabled_ = captive_portal_service ->enabled();
   captive_portal_service ->DetectCaptivePortal();
   registrar_.Add(this,
                  chrome::NOTIFICATION_CAPTIVE_PORTAL_CHECK_RESULT,
                  content::Source<Profile>(profile));
@@ skipping 442 matching lines @@
     // sure we don't clear the captive portal 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
 }