Make Sber1/2 pref metrics into Nullable Booleans so we can track how often these prefs are unset.

components/safe_browsing_db/safe_browsing_prefs.cc

 // Copyright (c) 2016 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 "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "components/prefs/pref_service.h"
 #include "components/safe_browsing_db/safe_browsing_prefs.h"
 
@@ skipping 39 matching lines @@
 // The Extended Reporting pref that is currently active, used for UMA metrics.
 // These values are written to logs.  New enum values can be added, but
 // existing enums must never be renumbered or deleted and reused.
 enum ActiveExtendedReportingPref {
   SBER1_PREF = 0,
   SBER2_PREF = 1,
   // New prefs must be added before MAX_SBER_PREF
   MAX_SBER_PREF
 };
 
+// A histogram for tracking a nullable boolean, which can be false, true or
+// null. These values are written to logs. New enum values can be added, but
+// existing enums must never be renumbered or deleted and reused.
+enum NullableBoolean {
+  NULLABLE_BOOLEAN_FALSE = 0,
+  NULLABLE_BOOLEAN_TRUE = 1,
+  NULLABLE_BOOLEAN_NULL = 2,
+  MAX_NULLABLE_BOOLEAN
+};
+
+NullableBoolean GetPrefValueOrNull(const PrefService& prefs,
+                                   const std::string& pref_name) {
+  if (!prefs.HasPrefPath(pref_name)) {
+    return NULLABLE_BOOLEAN_NULL;
+  }
+  return prefs.GetBoolean(pref_name) ? NULLABLE_BOOLEAN_TRUE
+                                     : NULLABLE_BOOLEAN_FALSE;
+}
+
 // Update the correct UMA metric based on which pref was changed and which UI
 // the change was made on.
 void RecordExtendedReportingPrefChanged(
     const PrefService& prefs,
     safe_browsing::ExtendedReportingOptInLocation location) {
   bool pref_value = safe_browsing::IsExtendedReportingEnabled(prefs);
 
   if (safe_browsing::IsScout(prefs)) {
     switch (location) {
       case safe_browsing::SBER_OPTIN_SITE_CHROME_SETTINGS:
@@ skipping 48 matching lines @@
 }
 }  // namespace
 
 namespace prefs {
 const char kSafeBrowsingExtendedReportingEnabled[] =
     "safebrowsing.extended_reporting_enabled";
 const char kSafeBrowsingScoutReportingEnabled[] =
     "safebrowsing.scout_reporting_enabled";
 const char kSafeBrowsingScoutGroupSelected[] =
     "safebrowsing.scout_group_selected";
+const char kSafeBrowsingSawInterstitialExtendedReporting[] =
+    "safebrowsing.saw_interstitial_sber1";
+const char kSafeBrowsingSawInterstitialScoutReporting[] =
+    "safebrowsing.saw_interstitial_sber2";
 }  // namespace prefs
 
 namespace safe_browsing {
 
 const char kSwitchForceScoutGroup[] = "force-scout-group";
 
 const base::Feature kCanShowScoutOptIn{"CanShowScoutOptIn",
                                        base::FEATURE_DISABLED_BY_DEFAULT};
 
 const base::Feature kOnlyShowScoutOptIn{"OnlyShowScoutOptIn",
@@ skipping 79 matching lines @@
       UMA_HISTOGRAM_ENUMERATION(kScoutTransitionMetricName,
                                 CAN_SHOW_SCOUT_OPT_IN_WAIT_FOR_INTERSTITIAL,
                                 MAX_REASONS);
     }
   } else {
     // Both experiment features are off, so this is the Control group. We must
     // handle the possibility that the user was previously in an experiment
     // group (above) that was reverted. We want to restore the user to a
     // reasonable state based on the ScoutGroup and ScoutReporting preferences.
     UMA_HISTOGRAM_ENUMERATION(kScoutTransitionMetricName, CONTROL, MAX_REASONS);
+    bool transitioned = false;
     if (prefs->GetBoolean(prefs::kSafeBrowsingScoutReportingEnabled)) {
       // User opted-in to Scout which is broader than legacy Extended Reporting.
       // Opt them in to Extended Reporting.
       prefs->SetBoolean(prefs::kSafeBrowsingExtendedReportingEnabled, true);
       UMA_HISTOGRAM_ENUMERATION(kScoutTransitionMetricName,
                                 ROLLBACK_SBER2_IMPLIES_SBER1, MAX_REASONS);
+      transitioned = true;
     } else if (prefs->GetBoolean(prefs::kSafeBrowsingScoutGroupSelected)) {
       // User was in the Scout Group (ie: seeing the Scout opt-in text) but did
       // NOT opt-in to Scout. Assume this was a conscious choice and remove
       // their legacy Extended Reporting opt-in as well. The user will have a
       // chance to evaluate their choice next time they see the opt-in text.
 
       // We make the Extended Reporting pref mimic the state of the Scout
       // Reporting pref. So we either Clear it or set it to False.
       if (prefs->HasPrefPath(prefs::kSafeBrowsingScoutReportingEnabled)) {
         // Scout Reporting pref was explicitly set to false, so set the SBER
         // pref to false.
         prefs->SetBoolean(prefs::kSafeBrowsingExtendedReportingEnabled, false);
         UMA_HISTOGRAM_ENUMERATION(kScoutTransitionMetricName,
                                   ROLLBACK_NO_SBER2_SET_SBER1_FALSE,
                                   MAX_REASONS);
       } else {
         // Scout Reporting pref is unset, so clear the SBER pref.
         prefs->ClearPref(prefs::kSafeBrowsingExtendedReportingEnabled);
         UMA_HISTOGRAM_ENUMERATION(kScoutTransitionMetricName,
                                   ROLLBACK_NO_SBER2_CLEAR_SBER1, MAX_REASONS);
       }
+      transitioned = true;
     }
 
     // Also clear both the Scout settings to start over from a clean state and
     // avoid the above logic from triggering on next restart.
     prefs->ClearPref(prefs::kSafeBrowsingScoutGroupSelected);
     prefs->ClearPref(prefs::kSafeBrowsingScoutReportingEnabled);
+
+    // Also forget that the user has seen any interstitials if they're
+    // reverting back to a clean state.
+    if (transitioned) {
+      prefs->ClearPref(prefs::kSafeBrowsingSawInterstitialExtendedReporting);
+      prefs->ClearPref(prefs::kSafeBrowsingSawInterstitialScoutReporting);
+    }
   }
 }
 
 bool IsExtendedReportingEnabled(const PrefService& prefs) {
   return prefs.GetBoolean(GetExtendedReportingPrefName(prefs));
 }
 
 bool IsScout(const PrefService& prefs) {
   return GetExtendedReportingPrefName(prefs) ==
          prefs::kSafeBrowsingScoutReportingEnabled;
 }
 
 void RecordExtendedReportingMetrics(const PrefService& prefs) {
   // This metric tracks the extended browsing opt-in based on whichever setting
   // the user is currently seeing. It tells us whether extended reporting is
   // happening for this user.
   UMA_HISTOGRAM_BOOLEAN("SafeBrowsing.Pref.Extended",
                         IsExtendedReportingEnabled(prefs));
 
+  // Track whether this user has ever seen a security interstitial.
+  UMA_HISTOGRAM_BOOLEAN(
+      "SafeBrowsing.Pref.SawInterstitial.SBER1Pref",
+      prefs.GetBoolean(prefs::kSafeBrowsingSawInterstitialExtendedReporting));
+  UMA_HISTOGRAM_BOOLEAN(
+      "SafeBrowsing.Pref.SawInterstitial.SBER2Pref",
+      prefs.GetBoolean(prefs::kSafeBrowsingSawInterstitialScoutReporting));
+
   // These metrics track the Scout transition.
   if (prefs.GetBoolean(prefs::kSafeBrowsingScoutGroupSelected)) {
     // Users in the Scout group: currently seeing the Scout opt-in.
-    UMA_HISTOGRAM_BOOLEAN(
+    UMA_HISTOGRAM_ENUMERATION(
         "SafeBrowsing.Pref.Scout.ScoutGroup.SBER1Pref",
-        prefs.GetBoolean(prefs::kSafeBrowsingExtendedReportingEnabled));
-    UMA_HISTOGRAM_BOOLEAN(
+        GetPrefValueOrNull(prefs, prefs::kSafeBrowsingExtendedReportingEnabled),
+        MAX_NULLABLE_BOOLEAN);
+    UMA_HISTOGRAM_ENUMERATION(
         "SafeBrowsing.Pref.Scout.ScoutGroup.SBER2Pref",
-        prefs.GetBoolean(prefs::kSafeBrowsingScoutReportingEnabled));
+        GetPrefValueOrNull(prefs, prefs::kSafeBrowsingScoutReportingEnabled),
+        MAX_NULLABLE_BOOLEAN);
   } else {
     // Users not in the Scout group: currently seeing the SBER opt-in.
-    UMA_HISTOGRAM_BOOLEAN(
+    UMA_HISTOGRAM_ENUMERATION(
         "SafeBrowsing.Pref.Scout.NoScoutGroup.SBER1Pref",
-        prefs.GetBoolean(prefs::kSafeBrowsingExtendedReportingEnabled));
+        GetPrefValueOrNull(prefs, prefs::kSafeBrowsingExtendedReportingEnabled),
+        MAX_NULLABLE_BOOLEAN);
     // The following metric is a corner case. User was previously in the
     // Scout group and was able to opt-in to the Scout pref, but was since
     // removed from the Scout group (eg: by rolling back a Scout experiment).
-    UMA_HISTOGRAM_BOOLEAN(
+    UMA_HISTOGRAM_ENUMERATION(
         "SafeBrowsing.Pref.Scout.NoScoutGroup.SBER2Pref",
-        prefs.GetBoolean(prefs::kSafeBrowsingScoutReportingEnabled));
+        GetPrefValueOrNull(prefs, prefs::kSafeBrowsingScoutReportingEnabled),
+        MAX_NULLABLE_BOOLEAN);
   }
 }
 
 void SetExtendedReportingPrefAndMetric(
     PrefService* prefs,
     bool value,
     ExtendedReportingOptInLocation location) {
   prefs->SetBoolean(GetExtendedReportingPrefName(*prefs), value);
   RecordExtendedReportingPrefChanged(*prefs, location);
 }
@@ skipping 68 matching lines @@
 void UpdatePrefsBeforeSecurityInterstitial(PrefService* prefs) {
   // Move the user into the Scout Group if the CanShowScoutOptIn experiment is
   // enabled and they're not in the group already.
   if (base::FeatureList::IsEnabled(kCanShowScoutOptIn) &&
       !prefs->GetBoolean(prefs::kSafeBrowsingScoutGroupSelected)) {
     prefs->SetBoolean(prefs::kSafeBrowsingScoutGroupSelected, true);
     UMA_HISTOGRAM_ENUMERATION(kScoutTransitionMetricName,
                               CAN_SHOW_SCOUT_OPT_IN_SAW_FIRST_INTERSTITIAL,
                               MAX_REASONS);
   }
+
+  // Remember that this user saw an interstitial with the current opt-in text.
+  prefs->SetBoolean(IsScout(*prefs)
+                        ? prefs::kSafeBrowsingSawInterstitialScoutReporting
+                        : prefs::kSafeBrowsingSawInterstitialExtendedReporting,
+                    true);
 }
 
 }  // namespace safe_browsing