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"
 #include "base/command_line.h"
 #include "base/i18n/rtl.h"
 #include "base/i18n/time_formatting.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/process/launch.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/interstitials/security_interstitial_metrics_helper.h"
+#include "chrome/browser/net/cert_logger.pb.h"
+#include "chrome/browser/net/certificate_error_reporter.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_preferences_util.h"
 #include "chrome/browser/ssl/ssl_cert_reporter.h"
 #include "chrome/browser/ssl/ssl_error_classification.h"
 #include "chrome/browser/ssl/ssl_error_info.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/chromium_strings.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/google/core/browser/google_util.h"
@@ skipping 29 matching lines @@
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/chrome_pages.h"
 #include "chrome/common/url_constants.h"
 #endif
 
 using base::ASCIIToUTF16;
 using base::TimeTicks;
+using chrome_browser_net::CertificateErrorReporter;
 using content::InterstitialPage;
 using content::InterstitialPageDelegate;
 using content::NavigationController;
 using content::NavigationEntry;
 
 // Constants for the HTTPSErrorReporter Finch experiment
 const char kHTTPSErrorReporterFinchExperimentName[] = "ReportCertificateErrors";
 const char kHTTPSErrorReporterFinchGroupShowPossiblySend[] =
     "ShowAndPossiblySend";
 const char kHTTPSErrorReporterFinchParamName[] = "sendingThreshold";
@@ skipping 489 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(true);

[Ryan Sleevi, 2015/04/16 01:44:10]

Suggestion: Reuse the enum (SecurityInterstitialMetricsHelper seems public - is
it? If not, perhaps a new enum?); it's not clear what the "true" / "false" are
here

Alternatively (less ideally, but depending on scope, may be cleaner)
FinishCertCollection(true /*proceeded*/);
FinishCertCollection(false /*proceeded*/);

But can you can see, "false proceeded" isn't exactly clear

 
   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(false);
 
   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(bool proceeded) {
   if (!ShouldShowCertificateReporterCheckbox())
     return;
 
   const bool enabled =
       IsPrefEnabled(prefs::kSafeBrowsingExtendedReportingEnabled);
 
   if (!enabled)
     return;
 
   metrics_helper()->RecordUserInteraction(
       SecurityInterstitialMetricsHelper::EXTENDED_REPORTING_IS_ENABLED);
 
   if (ShouldReportCertificateError()) {
-    ssl_cert_reporter_->ReportInvalidCertificateChain(request_url().host(),
-                                                      ssl_info_);
+    chrome_browser_net::CertLoggerRequest report;
+    CertificateErrorReporter::BuildReport(
+        request_url().host(), ssl_info_,
+        SSLErrorInfo::NetErrorToErrorType(cert_error_), interstitial_reason_,
+        proceeded ? CertificateErrorReporter::USER_PROCEEDED
+                  : CertificateErrorReporter::USER_DID_NOT_PROCEED,
+        overridable_ ? CertificateErrorReporter::OVERRIDABLE
+                     : CertificateErrorReporter::NOT_OVERRIDABLE,
+        &report);
+    ssl_cert_reporter_->SendReport(report);
   }
 }
 
 bool SSLBlockingPage::ShouldShowCertificateReporterCheckbox() {
   // Only show the checkbox iff the user is part of the respective Finch group
   // and the window is not incognito and the feature is not disabled by policy.
   const bool in_incognito =
       web_contents()->GetBrowserContext()->IsOffTheRecord();
   return base::FieldTrialList::FindFullName(
              kHTTPSErrorReporterFinchExperimentName) ==
@@ skipping 18 matching lines @@
     }
   }
   return false;
 }
 
 // static
 bool SSLBlockingPage::IsOptionsOverridable(int options_mask) {
   return (options_mask & SSLBlockingPage::OVERRIDABLE) &&
          !(options_mask & SSLBlockingPage::STRICT_ENFORCEMENT);
 }