Add interstitial info to certificate reports

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/bind.h"
 #include "base/bind_helpers.h"
 #include "base/build_time.h"
 #include "base/callback_helpers.h"
@@ skipping 569 matching lines @@
   renderer_preferences_util::UpdateFromSystemSettings(
       prefs, profile, web_contents());
 }
 
 void SSLBlockingPage::OnProceed() {
   metrics_helper()->RecordUserDecision(
       SecurityInterstitialMetricsHelper::PROCEED);
 
   // Finish collecting information about invalid certificates, if the
   // user opted in to.
-  FinishCertCollection();
+  FinishCertCollection(CertificateErrorReport::USER_PROCEEDED);
 
   RecordSSLExpirationPageEventState(
       expired_but_previously_allowed_, true, overridable_);
   // Accepting the certificate resumes the loading of the page.
   NotifyAllowCertificate();
 }
 
 void SSLBlockingPage::OnDontProceed() {
   metrics_helper()->RecordUserDecision(
       SecurityInterstitialMetricsHelper::DONT_PROCEED);
 
   // Finish collecting information about invalid certificates, if the
   // user opted in to.
-  FinishCertCollection();
+  FinishCertCollection(CertificateErrorReport::USER_DID_NOT_PROCEED);
 
   RecordSSLExpirationPageEventState(
       expired_but_previously_allowed_, false, overridable_);
   NotifyDenyCertificate();
 }
 
 void SSLBlockingPage::NotifyDenyCertificate() {
   // It's possible that callback_ may not exist if the user clicks "Proceed"
   // followed by pressing the back button before the interstitial is hidden.
   // In that case the certificate will still be treated as allowed.
@@ skipping 28 matching lines @@
 std::string SSLBlockingPage::GetSamplingEventName() const {
   std::string event_name(kEventNameBase);
   if (overridable_)
     event_name.append(kEventOverridable);
   else
     event_name.append(kEventNotOverridable);
   event_name.append(net::ErrorToString(cert_error_));
   return event_name;
 }
 
-void SSLBlockingPage::FinishCertCollection() {
+void SSLBlockingPage::FinishCertCollection(
+    CertificateErrorReport::ProceedDecision user_proceeded) {
   if (!ShouldShowCertificateReporterCheckbox())
     return;
 
   const bool enabled =
       IsPrefEnabled(prefs::kSafeBrowsingExtendedReportingEnabled);
 
   if (!enabled)
     return;
 
   metrics_helper()->RecordUserInteraction(
       SecurityInterstitialMetricsHelper::EXTENDED_REPORTING_IS_ENABLED);
 
   if (ShouldReportCertificateError()) {
     std::string serialized_report;
     CertificateErrorReport report(request_url().host(), ssl_info_);
 
+    CertificateErrorReport::InterstitialReason report_interstitial_reason;
+    switch (interstitial_reason_) {
+      case SSL_REASON_SSL:
+        report_interstitial_reason = CertificateErrorReport::INTERSTITIAL_SSL;
+        break;
+      case SSL_REASON_BAD_CLOCK:
+        report_interstitial_reason = CertificateErrorReport::INTERSTITIAL_CLOCK;
+        break;
+    }
+
+    report.SetInterstitialInfo(
+        report_interstitial_reason, user_proceeded,
+        overridable_ ? CertificateErrorReport::INTERSTITIAL_OVERRIDABLE
+                     : CertificateErrorReport::INTERSTITIAL_NOT_OVERRIDABLE);
+
     if (!report.Serialize(&serialized_report)) {
       LOG(ERROR) << "Failed to serialize certificate report.";
       return;
     }
 
     ssl_cert_reporter_->ReportInvalidCertificateChain(serialized_report);
   }
 }
 
 bool SSLBlockingPage::ShouldShowCertificateReporterCheckbox() {
@@ skipping 34 matching lines @@
 
 // static
 bool SSLBlockingPage::IsOverridable(int options_mask,
                                     const Profile* const profile) {
   const bool is_overridable =
       (options_mask & SSLBlockingPage::OVERRIDABLE) &&
       !(options_mask & SSLBlockingPage::STRICT_ENFORCEMENT) &&
       profile->GetPrefs()->GetBoolean(prefs::kSSLErrorOverrideAllowed);
   return is_overridable;
 }