Revert "EXP-5700: Change from global rollout opt-out to experiments and rollouts separately (#6888) (#6919)"

This reverts commit cf4f4a8.

Author: gruberb

components/nimbus/android/src/main/java/org/mozilla/experiments/nimbus/Nimbus.kt

@@ -141,30 +141,11 @@ open class Nimbus(
 
     private val nimbusClient: NimbusClientInterface
 
-    override var experimentParticipation: Boolean
-        get() = nimbusClient.getExperimentParticipation()
-        set(active) {
-            dbScope.launch {
-                nimbusClient.setExperimentParticipation(active)
-                applyPendingExperimentsOnThisThread()
-            }
-        }
-
-    override var rolloutParticipation: Boolean
-        get() = nimbusClient.getRolloutParticipation()
-        set(active) {
-            dbScope.launch {
-                nimbusClient.setRolloutParticipation(active)
-                applyPendingExperimentsOnThisThread()
-            }
-        }
-
     override var globalUserParticipation: Boolean
         get() = nimbusClient.getGlobalUserParticipation()
         set(active) {
             dbScope.launch {
-                setExperimentParticipationOnThisThread(active)
-                setRolloutParticipationOnThisThread(active)
+                setGlobalUserParticipationOnThisThread(active)
             }
         }
 
@@ -419,36 +400,13 @@ open class Nimbus(
 
     @WorkerThread
     @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
-    internal fun setExperimentParticipationOnThisThread(active: Boolean) =
-        withCatchAll("setExperimentParticipation") {
-            val enrolmentChanges = nimbusClient.setExperimentParticipation(active)
-            if (enrolmentChanges.isNotEmpty()) {
-                recordExperimentTelemetryEvents(enrolmentChanges)
-                postEnrolmentCalculation()
-            }
-        }
-
-    @WorkerThread
-    @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
-    internal fun setRolloutParticipationOnThisThread(active: Boolean) =
-        withCatchAll("setRolloutParticipation") {
-            val enrolmentChanges = nimbusClient.setRolloutParticipation(active)
-            if (enrolmentChanges.isNotEmpty()) {
-                recordExperimentTelemetryEvents(enrolmentChanges)
-                postEnrolmentCalculation()
-            }
-        }
-
-    @WorkerThread
-    @VisibleForTesting(otherwise = VisibleForTesting.PRIVATE)
-    internal fun setGlobalUserParticipationOnThisThread(active: Boolean) =
-        withCatchAll("setGlobalUserParticipation") {
-            val enrolmentChanges = nimbusClient.setGlobalUserParticipation(active)
-            if (enrolmentChanges.isNotEmpty()) {
-                recordExperimentTelemetryEvents(enrolmentChanges)
-                postEnrolmentCalculation()
-            }
+    internal fun setGlobalUserParticipationOnThisThread(active: Boolean) = withCatchAll("setGlobalUserParticipation") {
+        val enrolmentChanges = nimbusClient.setGlobalUserParticipation(active)
+        if (enrolmentChanges.isNotEmpty()) {
+            recordExperimentTelemetryEvents(enrolmentChanges)
+            postEnrolmentCalculation()
         }
+    }
 
     override fun optOut(experimentId: String) {
         dbScope.launch {

components/nimbus/android/src/main/java/org/mozilla/experiments/nimbus/NimbusInterface.kt

@@ -198,27 +198,11 @@ interface NimbusInterface : FeaturesInterface, NimbusMessagingInterface, NimbusE
      */
     fun resetTelemetryIdentifiers() = Unit
 
-    var globalUserParticipation: Boolean
-        get() = experimentParticipation && rolloutParticipation
-        set(value) {
-            experimentParticipation = value
-            rolloutParticipation = value
-        }
-
-    /**
-    * Control the opt out for experiments. This is likely a user action.
-    * When set to false, the user will be opted out of all experiments but not rollouts.
-    */
-    var experimentParticipation: Boolean
-        get() = true
-        set(_) = Unit
-
     /**
-    * Control the opt out for rollouts. This is likely a user action.
-    * When set to false, the user will be opted out of all rollouts but not experiments.
-    */
-    var rolloutParticipation: Boolean
-        get() = true
+     * Control the opt out for all experiments at once. This is likely a user action.
+     */
+    var globalUserParticipation: Boolean
+        get() = false
         set(_) = Unit
 
     override val events: NimbusEventStore

components/nimbus/android/src/test/java/org/mozilla/experiments/nimbus/NimbusTests.kt

@@ -450,8 +450,8 @@ class NimbusTests {
             NimbusEvents.disqualification.testGetValue(),
         )
 
-        // Opt out of experiments but keep rollouts
-        nimbus.setExperimentParticipationOnThisThread(false)
+        // Opt out of all experiments
+        nimbus.setGlobalUserParticipationOnThisThread(false)
 
         // Use the Glean test API to check that the valid event is present
         assertNotNull("Event must have a value", NimbusEvents.disqualification.testGetValue())

components/nimbus/src/enrollment.rs

@@ -75,21 +75,6 @@ impl Display for NotEnrolledReason {
     }
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct Participation {
-    pub in_experiments: bool,
-    pub in_rollouts: bool,
-}
-
-impl Default for Participation {
-    fn default() -> Self {
-        Self {
-            in_experiments: true,
-            in_rollouts: true,
-        }
-    }
-}
-
 // These are types we use internally for managing disqualifications.
 
 // ⚠️ Attention : Changes to this type should be accompanied by a new test  ⚠️
@@ -598,7 +583,7 @@ impl<'a> EnrollmentsEvolver<'a> {
 
     pub(crate) fn evolve_enrollments<E>(
         &mut self,
-        participation: Participation,
+        is_user_participating: bool,
         prev_experiments: &[E],
         next_experiments: &[Experiment],
         prev_enrollments: &[ExperimentEnrollment],
@@ -619,7 +604,7 @@ impl<'a> EnrollmentsEvolver<'a> {
         let next_rollouts = filter_experiments(next_experiments, ExperimentMetadata::is_rollout);
 
         let (next_ro_enrollments, ro_events) = self.evolve_enrollment_recipes(
-            participation.in_rollouts,
+            is_user_participating,
             &prev_rollouts,
             &next_rollouts,
             &ro_enrollments,
@@ -643,7 +628,7 @@ impl<'a> EnrollmentsEvolver<'a> {
             .collect();
 
         let (next_exp_enrollments, exp_events) = self.evolve_enrollment_recipes(
-            participation.in_experiments,
+            is_user_participating,
             &prev_experiments,
             &next_experiments,
             &prev_enrollments,

components/nimbus/src/nimbus.udl

@@ -239,7 +239,7 @@ interface NimbusClient {
     [Throws=NimbusError]
     sequence<AvailableExperiment> get_available_experiments();
 
-    /// Getter and setter for user's participation in experiments only.
+    /// Getter and setter for user's participation in all experiments.
     /// Possible values are:
     /// * `true`: the user will enroll in experiments as usual.
     /// * `false`: the user will not enroll in new experiments, and opt out of all existing ones.
@@ -276,7 +276,7 @@ interface NimbusClient {
     /// Toggles the enablement of the fetch. If `false`, then calling `fetch_experiments`
     /// returns immediately, having not done any fetching from remote settings.
     /// This is only useful for QA, and should not be used in production: use
-    /// `set_experiment_participation` or `set_rollout_participation` instead.
+    /// `set_global_user_participation` instead.
     [Throws=NimbusError]
     void set_fetch_enabled(boolean flag);
 

components/nimbus/src/stateful/enrollment.rs

@@ -1,11 +1,6 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
-use crate::enrollment::Participation;
-use crate::stateful::persistence::{
-    DB_KEY_EXPERIMENT_PARTICIPATION, DB_KEY_ROLLOUT_PARTICIPATION,
-    DEFAULT_EXPERIMENT_PARTICIPATION, DEFAULT_ROLLOUT_PARTICIPATION,
-};
 use crate::{
     enrollment::{
         map_enrollments, EnrollmentChangeEvent, EnrollmentChangeEventType, EnrollmentsEvolver,
@@ -19,6 +14,9 @@ use crate::{
     EnrolledExperiment, EnrollmentStatus, Experiment,
 };
 
+const DB_KEY_GLOBAL_USER_PARTICIPATION: &str = "user-opt-in";
+const DEFAULT_GLOBAL_USER_PARTICIPATION: bool = true;
+
 impl EnrollmentsEvolver<'_> {
     /// Convenient wrapper around `evolve_enrollments` that fetches the current state of experiments,
     /// enrollments and user participation from the database.
@@ -28,22 +26,15 @@ impl EnrollmentsEvolver<'_> {
         writer: &mut Writer,
         next_experiments: &[Experiment],
     ) -> Result<Vec<EnrollmentChangeEvent>> {
-        // Get separate participation states from the db
-        let is_participating_in_experiments = get_experiment_participation(db, writer)?;
-        let is_participating_in_rollouts = get_rollout_participation(db, writer)?;
-
-        let participation = Participation {
-            in_experiments: is_participating_in_experiments,
-            in_rollouts: is_participating_in_rollouts,
-        };
-
+        // Get the state from the db.
+        let is_user_participating = get_global_user_participation(db, writer)?;
         let experiments_store = db.get_store(StoreId::Experiments);
         let enrollments_store = db.get_store(StoreId::Enrollments);
         let prev_experiments: Vec<Experiment> = experiments_store.collect_all(writer)?;
         let prev_enrollments: Vec<ExperimentEnrollment> = enrollments_store.collect_all(writer)?;
         // Calculate the changes.
         let (next_enrollments, enrollments_change_events) = self.evolve_enrollments(
-            participation,
+            is_user_participating,
             &prev_experiments,
             next_experiments,
             &prev_enrollments,
@@ -180,41 +171,26 @@ pub fn unenroll_for_pref(
     Ok(events)
 }
 
-pub fn get_experiment_participation<'r>(
+pub fn get_global_user_participation<'r>(
     db: &Database,
     reader: &'r impl Readable<'r>,
 ) -> Result<bool> {
     let store = db.get_store(StoreId::Meta);
-    let opted_in = store.get::<bool, _>(reader, DB_KEY_EXPERIMENT_PARTICIPATION)?;
-    if let Some(opted_in) = opted_in {
-        Ok(opted_in)
-    } else {
-        Ok(DEFAULT_EXPERIMENT_PARTICIPATION)
-    }
-}
-
-pub fn get_rollout_participation<'r>(db: &Database, reader: &'r impl Readable<'r>) -> Result<bool> {
-    let store = db.get_store(StoreId::Meta);
-    let opted_in = store.get::<bool, _>(reader, DB_KEY_ROLLOUT_PARTICIPATION)?;
+    let opted_in = store.get::<bool, _>(reader, DB_KEY_GLOBAL_USER_PARTICIPATION)?;
     if let Some(opted_in) = opted_in {
         Ok(opted_in)
     } else {
-        Ok(DEFAULT_ROLLOUT_PARTICIPATION)
+        Ok(DEFAULT_GLOBAL_USER_PARTICIPATION)
     }
 }
 
-pub fn set_experiment_participation(
+pub fn set_global_user_participation(
     db: &Database,
     writer: &mut Writer,
     opt_in: bool,
 ) -> Result<()> {
     let store = db.get_store(StoreId::Meta);
-    store.put(writer, DB_KEY_EXPERIMENT_PARTICIPATION, &opt_in)
-}
-
-pub fn set_rollout_participation(db: &Database, writer: &mut Writer, opt_in: bool) -> Result<()> {
-    let store = db.get_store(StoreId::Meta);
-    store.put(writer, DB_KEY_ROLLOUT_PARTICIPATION, &opt_in)
+    store.put(writer, DB_KEY_GLOBAL_USER_PARTICIPATION, &opt_in)
 }
 
 /// Reset unique identifiers in response to application-level telemetry reset.

components/nimbus/src/stateful/nimbus_client.rs

@@ -26,9 +26,8 @@ use crate::{
         client::{create_client, SettingsClient},
         dbcache::DatabaseCache,
         enrollment::{
-            get_experiment_participation, get_rollout_participation, opt_in_with_branch, opt_out,
-            reset_telemetry_identifiers, set_experiment_participation, set_rollout_participation,
-            unenroll_for_pref,
+            get_global_user_participation, opt_in_with_branch, opt_out,
+            reset_telemetry_identifiers, set_global_user_participation, unenroll_for_pref,
         },
         gecko_prefs::{
             GeckoPref, GeckoPrefHandler, GeckoPrefState, GeckoPrefStore, PrefBranch,
@@ -253,73 +252,30 @@ impl NimbusClient {
             .ok_or(NimbusError::NoSuchExperiment(slug))
     }
 
-    pub fn get_experiment_participation(&self) -> Result<bool> {
-        let db = self.db()?;
-        let reader = db.read()?;
-        get_experiment_participation(db, &reader)
-    }
-
-    pub fn get_rollout_participation(&self) -> Result<bool> {
+    pub fn get_global_user_participation(&self) -> Result<bool> {
         let db = self.db()?;
         let reader = db.read()?;
-        get_rollout_participation(db, &reader)
+        get_global_user_participation(db, &reader)
     }
 
-    pub fn set_experiment_participation(
-        &self,
-        user_participating: bool,
-    ) -> Result<Vec<EnrollmentChangeEvent>> {
-        let db = self.db()?;
-        let mut writer = db.write()?;
-        let mut state = self.mutable_state.lock().unwrap();
-        set_experiment_participation(db, &mut writer, user_participating)?;
-
-        let existing_experiments: Vec<Experiment> =
-            db.get_store(StoreId::Experiments).collect_all(&writer)?;
-        let events = self.evolve_experiments(db, &mut writer, &mut state, &existing_experiments)?;
-        self.end_initialize(db, writer, &mut state)?;
-        Ok(events)
-    }
-
-    pub fn set_rollout_participation(
+    pub fn set_global_user_participation(
         &self,
         user_participating: bool,
     ) -> Result<Vec<EnrollmentChangeEvent>> {
         let db = self.db()?;
         let mut writer = db.write()?;
         let mut state = self.mutable_state.lock().unwrap();
-        set_rollout_participation(db, &mut writer, user_participating)?;
+        set_global_user_participation(db, &mut writer, user_participating)?;
 
         let existing_experiments: Vec<Experiment> =
             db.get_store(StoreId::Experiments).collect_all(&writer)?;
+        // We pass the existing experiments as "updated experiments"
+        // to the evolver.
         let events = self.evolve_experiments(db, &mut writer, &mut state, &existing_experiments)?;
         self.end_initialize(db, writer, &mut state)?;
         Ok(events)
     }
 
-    // DEPRECATED: Will be removed once Firefox is using the
-    // new get_experiment_participation and get_rollout_participation
-    pub fn get_global_user_participation(&self) -> Result<bool> {
-        // For simplicity, just return the experiment participation value
-        self.get_experiment_participation()
-    }
-
-    // DEPRECATED: Will be removed once Firefox is using the
-    // new set_experiment_participation and set_rollout_participation
-    pub fn set_global_user_participation(
-        &self,
-        user_participating: bool,
-    ) -> Result<Vec<EnrollmentChangeEvent>> {
-        // Call both set_experiment_participation and set_rollout_participation with the same value
-        let experiment_events = self.set_experiment_participation(user_participating)?;
-        let rollout_events = self.set_rollout_participation(user_participating)?;
-
-        // Combine the events from both calls
-        let mut all_events = experiment_events;
-        all_events.extend(rollout_events);
-        Ok(all_events)
-    }
-
     pub fn get_active_experiments(&self) -> Result<Vec<EnrolledExperiment>> {
         self.database_cache.get_active_experiments()
     }