Add Rappor metrics for Safe Browsing and SSL interstitials.

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 69 matching lines @@
 
 // Events for UMA. Do not reorder or change!
 enum SSLExpirationAndDecision {
   EXPIRED_AND_PROCEED,
   EXPIRED_AND_DO_NOT_PROCEED,
   NOT_EXPIRED_AND_PROCEED,
   NOT_EXPIRED_AND_DO_NOT_PROCEED,
   END_OF_SSL_EXPIRATION_AND_DECISION,
 };
 
+// Rappor prefix
+const char kSSLRapporPrefix[] = "ssl";
+
 void RecordSSLExpirationPageEventState(bool expired_but_previously_allowed,
                                        bool proceed,
                                        bool overridable) {
   SSLExpirationAndDecision event;
   if (expired_but_previously_allowed && proceed)
     event = EXPIRED_AND_PROCEED;
   else if (expired_but_previously_allowed && !proceed)
     event = EXPIRED_AND_DO_NOT_PROCEED;
   else if (!expired_but_previously_allowed && proceed)
     event = NOT_EXPIRED_AND_PROCEED;
@@ skipping 126 matching lines @@
       ssl_info_(ssl_info),
       overridable_(IsOptionsOverridable(options_mask)),
       danger_overridable_(true),
       strict_enforcement_((options_mask & STRICT_ENFORCEMENT) != 0),
       expired_but_previously_allowed_(
           (options_mask & EXPIRED_BUT_PREVIOUSLY_ALLOWED) != 0) {
   interstitial_reason_ =
       IsErrorDueToBadClock(base::Time::NowFromSystemTime(), cert_error_) ?
       SSL_REASON_BAD_CLOCK : SSL_REASON_SSL;
 
+  // We collapse the Rappor metric name to just "ssl" so we don't leak
+  // the "overridable" bit.  We skip Rappor altogether for bad clocks.
   // This must be done after calculating |interstitial_reason_| above.
-  uma_helper_.reset(new SecurityInterstitialUmaHelper(
-      web_contents, request_url, GetHistogramPrefix(), GetSamplingEventName()));
-  uma_helper_->RecordUserDecision(SecurityInterstitialUmaHelper::SHOW);
-  uma_helper_->RecordUserInteraction(
-      SecurityInterstitialUmaHelper::TOTAL_VISITS);
+  metrics_helper_.reset(new SecurityInterstitialMetricsHelper(
+      web_contents, request_url, GetUmaHistogramPrefix(), kSSLRapporPrefix,
+      (interstitial_reason_ == SSL_REASON_BAD_CLOCK
+           ? SecurityInterstitialMetricsHelper::SKIP_RAPPOR
+           : SecurityInterstitialMetricsHelper::REPORT_RAPPOR),
+      GetSamplingEventName()));
+
+  metrics_helper_->RecordUserDecision(SecurityInterstitialMetricsHelper::SHOW);
+  metrics_helper_->RecordUserInteraction(
+      SecurityInterstitialMetricsHelper::TOTAL_VISITS);
 
   ssl_error_classification_.reset(new SSLErrorClassification(
       web_contents,
       base::Time::NowFromSystemTime(),
       request_url,
       cert_error_,
       *ssl_info_.cert.get()));
   ssl_error_classification_->RecordUMAStatistics(overridable_);
 #if defined(ENABLE_CAPTIVE_PORTAL_DETECTION)
   ssl_error_classification_->RecordCaptivePortalUMAStatistics(overridable_);
 #endif
 
   // Creating an interstitial without showing (e.g. from chrome://interstitials)
   // it leaks memory, so don't create it here.
 }
 
 bool SSLBlockingPage::ShouldCreateNewNavigation() const {
   return true;
 }
 
 const void* SSLBlockingPage::GetTypeForTesting() const {
   return SSLBlockingPage::kTypeForTesting;
 }
 
 SSLBlockingPage::~SSLBlockingPage() {
   if (!callback_.is_null()) {
     // The page is closed without the user having chosen what to do, default to
     // deny.
-    uma_helper_->RecordUserDecision(
-        SecurityInterstitialUmaHelper::DONT_PROCEED);
+    metrics_helper_->RecordUserDecision(
+        SecurityInterstitialMetricsHelper::DONT_PROCEED);
     RecordSSLExpirationPageEventState(
         expired_but_previously_allowed_, false, overridable_);
     NotifyDenyCertificate();
   }
 }
 
 void SSLBlockingPage::PopulateInterstitialStrings(
     base::DictionaryValue* load_time_data) {
   CHECK(load_time_data);
   base::string16 url(GetFormattedHostName());
@@ skipping 162 matching lines @@
       interstitial_page()->DontProceed();
       break;
     }
     case CMD_PROCEED: {
       if (danger_overridable_) {
         interstitial_page()->Proceed();
       }
       break;
     }
     case CMD_MORE: {
-      uma_helper_->RecordUserInteraction(
-          SecurityInterstitialUmaHelper::SHOW_ADVANCED);
+      metrics_helper_->RecordUserInteraction(
+          SecurityInterstitialMetricsHelper::SHOW_ADVANCED);
       break;
     }
     case CMD_RELOAD: {
-      uma_helper_->RecordUserInteraction(
-          SecurityInterstitialUmaHelper::RELOAD);
+      metrics_helper_->RecordUserInteraction(
+          SecurityInterstitialMetricsHelper::RELOAD);
       // The interstitial can't refresh itself.
       web_contents()->GetController().Reload(true);
       break;
     }
     case CMD_HELP: {
-      uma_helper_->RecordUserInteraction(
-          SecurityInterstitialUmaHelper::SHOW_LEARN_MORE);
+      metrics_helper_->RecordUserInteraction(
+          SecurityInterstitialMetricsHelper::SHOW_LEARN_MORE);
       content::NavigationController::LoadURLParams help_page_params(
           google_util::AppendGoogleLocaleParam(
               GURL(kHelpURL), g_browser_process->GetApplicationLocale()));
       web_contents()->GetController().LoadURLWithParams(help_page_params);
       break;
     }
     case CMD_CLOCK: {
-      uma_helper_->RecordUserInteraction(
-          SecurityInterstitialUmaHelper::OPEN_TIME_SETTINGS);
+      metrics_helper_->RecordUserInteraction(
+          SecurityInterstitialMetricsHelper::OPEN_TIME_SETTINGS);
       LaunchDateAndTimeSettings();
       break;
     }
     default: {
       NOTREACHED();
     }
   }
 }
 
 void SSLBlockingPage::OverrideRendererPrefs(
       content::RendererPreferences* prefs) {
   Profile* profile = Profile::FromBrowserContext(
       web_contents()->GetBrowserContext());
   renderer_preferences_util::UpdateFromSystemSettings(
       prefs, profile, web_contents());
 }
 
 void SSLBlockingPage::OnProceed() {
-  uma_helper_->RecordUserDecision(SecurityInterstitialUmaHelper::PROCEED);
+  metrics_helper_->RecordUserDecision(
+      SecurityInterstitialMetricsHelper::PROCEED);
   RecordSSLExpirationPageEventState(
       expired_but_previously_allowed_, true, overridable_);
   // Accepting the certificate resumes the loading of the page.
   NotifyAllowCertificate();
 }
 
 void SSLBlockingPage::OnDontProceed() {
-  uma_helper_->RecordUserDecision(SecurityInterstitialUmaHelper::DONT_PROCEED);
+  metrics_helper_->RecordUserDecision(
+      SecurityInterstitialMetricsHelper::DONT_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.
   if (callback_.is_null())
     return;
 
   callback_.Run(false);
   callback_.Reset();
 }
 
 void SSLBlockingPage::NotifyAllowCertificate() {
   DCHECK(!callback_.is_null());
 
   callback_.Run(true);
   callback_.Reset();
 }
 
-std::string SSLBlockingPage::GetHistogramPrefix() const {
+std::string SSLBlockingPage::GetUmaHistogramPrefix() const {
   switch (interstitial_reason_) {
     case SSL_REASON_SSL:
       if (overridable_)
         return "ssl_overridable";
       else
         return "ssl_nonoverridable";
     case SSL_REASON_BAD_CLOCK:
       return "bad_clock";
   }
   NOTREACHED();
   return std::string();
 }
 
 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;
 }
 
 // static
 bool SSLBlockingPage::IsOptionsOverridable(int options_mask) {
   return (options_mask & SSLBlockingPage::OVERRIDABLE) &&
          !(options_mask & SSLBlockingPage::STRICT_ENFORCEMENT);
 }