Revert "Revert cf4f4a8 (#6954)" (#6957)

This reverts commit 0cbf0dc.

Author: gruberb

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

@@ -141,11 +141,30 @@ 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 {
-                setGlobalUserParticipationOnThisThread(active)
+                setExperimentParticipationOnThisThread(active)
+                setRolloutParticipationOnThisThread(active)
             }
         }
 
@@ -400,13 +419,36 @@ open class Nimbus(
 
     @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 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()
+            }
         }
-    }
 
     override fun optOut(experimentId: String) {
         dbScope.launch {

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

@@ -198,11 +198,27 @@ interface NimbusInterface : FeaturesInterface, NimbusMessagingInterface, NimbusE
      */
     fun resetTelemetryIdentifiers() = Unit
 
-    /**
-     * Control the opt out for all experiments at once. This is likely a user action.
-     */
     var globalUserParticipation: Boolean
-        get() = false
+        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
         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 all experiments
-        nimbus.setGlobalUserParticipationOnThisThread(false)
+        // Opt out of experiments but keep rollouts
+        nimbus.setExperimentParticipationOnThisThread(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,6 +75,21 @@ 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  ⚠️
@@ -583,7 +598,7 @@ impl<'a> EnrollmentsEvolver<'a> {
 
     pub(crate) fn evolve_enrollments<E>(
         &mut self,
-        is_user_participating: bool,
+        participation: Participation,
         prev_experiments: &[E],
         next_experiments: &[Experiment],
         prev_enrollments: &[ExperimentEnrollment],
@@ -604,7 +619,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(
-            is_user_participating,
+            participation.in_rollouts,
             &prev_rollouts,
             &next_rollouts,
             &ro_enrollments,
@@ -628,7 +643,7 @@ impl<'a> EnrollmentsEvolver<'a> {
             .collect();
 
         let (next_exp_enrollments, exp_events) = self.evolve_enrollment_recipes(
-            is_user_participating,
+            participation.in_experiments,
             &prev_experiments,
             &next_experiments,
             &prev_enrollments,

components/nimbus/src/nimbus.udl

@@ -239,6 +239,26 @@ interface NimbusClient {
     [Throws=NimbusError]
     sequence<AvailableExperiment> get_available_experiments();
 
+    /// Getter and setter for user's participation in experiments only.
+    /// 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.
+    [Throws=NimbusError]
+    boolean get_experiment_participation();
+
+    [Throws=NimbusError]
+    sequence<EnrollmentChangeEvent> set_experiment_participation(boolean opt_in);
+
+    /// Getter and setter for user's participation in rollouts.
+    /// Possible values are:
+    /// * `true`: the user will enroll in rollouts as usual.
+    /// * `false`: the user will not enroll in new rollouts, and opt out of all existing ones.
+    [Throws=NimbusError]
+    boolean get_rollout_participation();
+
+    [Throws=NimbusError]
+    sequence<EnrollmentChangeEvent> set_rollout_participation(boolean opt_in);
+
     /// Getter and setter for global user participation (applies to both experiments and rollouts).
     /// For simplicity, the getter returns the experiment participation value.
     [Throws=NimbusError]
@@ -256,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_global_user_participation` instead.
+    /// `set_experiment_participation` or `set_rollout_participation` instead.
     [Throws=NimbusError]
     void set_fetch_enabled(boolean flag);
 

components/nimbus/src/stateful/enrollment.rs

@@ -1,6 +1,11 @@
 /* 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,
@@ -14,9 +19,6 @@ 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.
@@ -26,15 +28,22 @@ impl EnrollmentsEvolver<'_> {
         writer: &mut Writer,
         next_experiments: &[Experiment],
     ) -> Result<Vec<EnrollmentChangeEvent>> {
-        // Get the state from the db.
-        let is_user_participating = get_global_user_participation(db, writer)?;
+        // 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,
+        };
+
         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(
-            is_user_participating,
+            participation,
             &prev_experiments,
             next_experiments,
             &prev_enrollments,
@@ -171,26 +180,41 @@ pub fn unenroll_for_pref(
     Ok(events)
 }
 
-pub fn get_global_user_participation<'r>(
+pub fn get_experiment_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_GLOBAL_USER_PARTICIPATION)?;
+    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)?;
     if let Some(opted_in) = opted_in {
         Ok(opted_in)
     } else {
-        Ok(DEFAULT_GLOBAL_USER_PARTICIPATION)
+        Ok(DEFAULT_ROLLOUT_PARTICIPATION)
     }
 }
 
-pub fn set_global_user_participation(
+pub fn set_experiment_participation(
     db: &Database,
     writer: &mut Writer,
     opt_in: bool,
 ) -> Result<()> {
     let store = db.get_store(StoreId::Meta);
-    store.put(writer, DB_KEY_GLOBAL_USER_PARTICIPATION, &opt_in)
+    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)
 }
 
 /// Reset unique identifiers in response to application-level telemetry reset.

components/nimbus/src/stateful/nimbus_client.rs

@@ -26,8 +26,9 @@ use crate::{
         client::{create_client, SettingsClient},
         dbcache::DatabaseCache,
         enrollment::{
-            get_global_user_participation, opt_in_with_branch, opt_out,
-            reset_telemetry_identifiers, set_global_user_participation, unenroll_for_pref,
+            get_experiment_participation, get_rollout_participation, opt_in_with_branch, opt_out,
+            reset_telemetry_identifiers, set_experiment_participation, set_rollout_participation,
+            unenroll_for_pref,
         },
         gecko_prefs::{
             GeckoPref, GeckoPrefHandler, GeckoPrefState, GeckoPrefStore, PrefBranch,
@@ -252,30 +253,73 @@ impl NimbusClient {
             .ok_or(NimbusError::NoSuchExperiment(slug))
     }
 
-    pub fn get_global_user_participation(&self) -> Result<bool> {
+    pub fn get_experiment_participation(&self) -> Result<bool> {
         let db = self.db()?;
         let reader = db.read()?;
-        get_global_user_participation(db, &reader)
+        get_experiment_participation(db, &reader)
     }
 
-    pub fn set_global_user_participation(
+    pub fn get_rollout_participation(&self) -> Result<bool> {
+        let db = self.db()?;
+        let reader = db.read()?;
+        get_rollout_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_global_user_participation(db, &mut writer, user_participating)?;
+        set_experiment_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)
     }
 
+    pub fn set_rollout_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)?;
+
+        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)
+    }
+
+    // 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()
     }