Cleaning up recoverability_detection flag

This flag has been released in 24Q3 and can be cleaned up.
Following go/android-flags-guidelines#how-to-delete-a-flag

Bug: 397017037
Test: TH
Flag: EXEMPT cleaning flag
Change-Id: Icfb659537eea62a85ab75d6bebb0068efe928b1c

11 files changed, 39 insertions, 410 deletions

diff --git a/services/core/java/com/android/server/pm/PackageInstallerService.java b/services/core/java/com/android/server/pm/PackageInstallerService.java
index e1fcc6650650..2d0bb258e89f 100644
--- a/services/core/java/com/android/server/pm/PackageInstallerService.java
+++ b/services/core/java/com/android/server/pm/PackageInstallerService.java
@@ -805,22 +805,20 @@ public class PackageInstallerService extends IPackageInstaller.Stub implements
             }
         }
 
-        if (Flags.recoverabilityDetection()) {
-            if (params.rollbackImpactLevel == PackageManager.ROLLBACK_USER_IMPACT_HIGH
-                    || params.rollbackImpactLevel
-                    == PackageManager.ROLLBACK_USER_IMPACT_ONLY_MANUAL) {
-                if ((params.installFlags & PackageManager.INSTALL_ENABLE_ROLLBACK) == 0) {
-                    throw new IllegalArgumentException(
-                            "Can't set rollbackImpactLevel when rollback is not enabled");
-                }
-                if (mContext.checkCallingOrSelfPermission(Manifest.permission.MANAGE_ROLLBACKS)
-                        != PackageManager.PERMISSION_GRANTED) {
-                    throw new SecurityException(
-                            "Setting rollbackImpactLevel requires the MANAGE_ROLLBACKS permission");
-                }
-            } else if (params.rollbackImpactLevel < 0) {
-                throw new IllegalArgumentException("rollbackImpactLevel can't be negative.");
+        if (params.rollbackImpactLevel == PackageManager.ROLLBACK_USER_IMPACT_HIGH
+                || params.rollbackImpactLevel
+                == PackageManager.ROLLBACK_USER_IMPACT_ONLY_MANUAL) {
+            if ((params.installFlags & PackageManager.INSTALL_ENABLE_ROLLBACK) == 0) {
+                throw new IllegalArgumentException(
+                        "Can't set rollbackImpactLevel when rollback is not enabled");
+            }
+            if (mContext.checkCallingOrSelfPermission(Manifest.permission.MANAGE_ROLLBACKS)
+                    != PackageManager.PERMISSION_GRANTED) {
+                throw new SecurityException(
+                        "Setting rollbackImpactLevel requires the MANAGE_ROLLBACKS permission");
             }
+        } else if (params.rollbackImpactLevel < 0) {
+            throw new IllegalArgumentException("rollbackImpactLevel can't be negative.");
         }
 
         boolean isApex = (params.installFlags & PackageManager.INSTALL_APEX) != 0;
diff --git a/services/core/java/com/android/server/pm/PackageManagerShellCommand.java b/services/core/java/com/android/server/pm/PackageManagerShellCommand.java
index aa235c2258ac..cf598e89c988 100644
--- a/services/core/java/com/android/server/pm/PackageManagerShellCommand.java
+++ b/services/core/java/com/android/server/pm/PackageManagerShellCommand.java
@@ -3561,9 +3561,6 @@ class PackageManagerShellCommand extends ShellCommand {
                     sessionParams.setEnableRollback(true, rollbackStrategy);
                     break;
                 case "--rollback-impact-level":
-                    if (!Flags.recoverabilityDetection()) {
-                        throw new IllegalArgumentException("Unknown option " + opt);
-                    }
                     int rollbackImpactLevel = Integer.parseInt(peekNextArg());
                     if (rollbackImpactLevel < PackageManager.ROLLBACK_USER_IMPACT_LOW
                             || rollbackImpactLevel
@@ -4775,11 +4772,9 @@ class PackageManagerShellCommand extends ShellCommand {
         pw.println("      --full: cause the app to be installed as a non-ephemeral full app");
         pw.println("      --enable-rollback: enable rollbacks for the upgrade.");
         pw.println("          0=restore (default), 1=wipe, 2=retain");
-        if (Flags.recoverabilityDetection()) {
-            pw.println(
-                    "      --rollback-impact-level: set device impact required for rollback.");
-            pw.println("          0=low (default), 1=high, 2=manual only");
-        }
+        pw.println(
+                "      --rollback-impact-level: set device impact required for rollback.");
+        pw.println("          0=low (default), 1=high, 2=manual only");
         pw.println("      --install-location: force the install location:");
         pw.println("          0=auto, 1=internal only, 2=prefer external");
         pw.println("      --install-reason: indicates why the app is being installed:");
diff --git a/services/core/java/com/android/server/pm/VerifyingSession.java b/services/core/java/com/android/server/pm/VerifyingSession.java
index dd60a155f2fb..8510ee70cc56 100644
--- a/services/core/java/com/android/server/pm/VerifyingSession.java
+++ b/services/core/java/com/android/server/pm/VerifyingSession.java
@@ -179,8 +179,7 @@ final class VerifyingSession {
         // Perform package verification and enable rollback (unless we are simply moving the
         // package).
         if (!mOriginInfo.mExisting) {
-            final boolean verifyForRollback = Flags.recoverabilityDetection()
-                    ? !isARollback() : true;
+            final boolean verifyForRollback = !isARollback();
             if (!isApex() && !isArchivedInstallation() && verifyForRollback) {
                 // TODO(b/182426975): treat APEX as APK when APK verification is concerned
                 sendApkVerificationRequest(pkgLite);
diff --git a/services/core/java/com/android/server/rollback/Rollback.java b/services/core/java/com/android/server/rollback/Rollback.java
index ab756f2a755b..5347ca46ab31 100644
--- a/services/core/java/com/android/server/rollback/Rollback.java
+++ b/services/core/java/com/android/server/rollback/Rollback.java
@@ -29,7 +29,6 @@ import android.annotation.WorkerThread;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentSender;
-import android.content.pm.Flags;
 import android.content.pm.PackageInstaller;
 import android.content.pm.PackageManager;
 import android.content.pm.PackageManagerInternal;
@@ -965,9 +964,7 @@ class Rollback {
         ipw.println("-stateDescription: " + mStateDescription);
         ipw.println("-timestamp: " + getTimestamp());
         ipw.println("-rollbackLifetimeMillis: " + getRollbackLifetimeMillis());
-        if (Flags.recoverabilityDetection()) {
-            ipw.println("-rollbackImpactLevel: " + info.getRollbackImpactLevel());
-        }
+        ipw.println("-rollbackImpactLevel: " + info.getRollbackImpactLevel());
         ipw.println("-isStaged: " + isStaged());
         ipw.println("-originalSessionId: " + getOriginalSessionId());
         ipw.println("-packages:");
diff --git a/services/core/java/com/android/server/rollback/RollbackManagerServiceImpl.java b/services/core/java/com/android/server/rollback/RollbackManagerServiceImpl.java
index 2e6be5bb56a8..9ed52d8b3504 100644
--- a/services/core/java/com/android/server/rollback/RollbackManagerServiceImpl.java
+++ b/services/core/java/com/android/server/rollback/RollbackManagerServiceImpl.java
@@ -1244,17 +1244,12 @@ class RollbackManagerServiceImpl extends IRollbackManager.Stub implements Rollba
         rollback.makeAvailable();
         mPackageHealthObserver.notifyRollbackAvailable(rollback.info);
 
-        if (Flags.recoverabilityDetection()) {
-            if (rollback.info.getRollbackImpactLevel() == PackageManager.ROLLBACK_USER_IMPACT_LOW) {
-                // TODO(zezeozue): Provide API to explicitly start observing instead
-                // of doing this for all rollbacks. If we do this for all rollbacks,
-                // should document in PackageInstaller.SessionParams#setEnableRollback
-                // After enabling and committing any rollback, observe packages and
-                // prepare to rollback if packages crashes too frequently.
-                mPackageWatchdog.startExplicitHealthCheck(rollback.getPackageNames(),
-                        mRollbackLifetimeDurationInMillis, mPackageHealthObserver);
-            }
-        } else {
+        if (rollback.info.getRollbackImpactLevel() == PackageManager.ROLLBACK_USER_IMPACT_LOW) {
+            // TODO(zezeozue): Provide API to explicitly start observing instead
+            // of doing this for all rollbacks. If we do this for all rollbacks,
+            // should document in PackageInstaller.SessionParams#setEnableRollback
+            // After enabling and committing any rollback, observe packages and
+            // prepare to rollback if packages crashes too frequently.
             mPackageWatchdog.startExplicitHealthCheck(rollback.getPackageNames(),
                     mRollbackLifetimeDurationInMillis, mPackageHealthObserver);
         }
diff --git a/services/core/java/com/android/server/rollback/RollbackStore.java b/services/core/java/com/android/server/rollback/RollbackStore.java
index 50db1e4ac30e..6dc40323f2ee 100644
--- a/services/core/java/com/android/server/rollback/RollbackStore.java
+++ b/services/core/java/com/android/server/rollback/RollbackStore.java
@@ -197,9 +197,7 @@ class RollbackStore {
         json.put("isStaged", rollback.isStaged());
         json.put("causePackages", versionedPackagesToJson(rollback.getCausePackages()));
         json.put("committedSessionId", rollback.getCommittedSessionId());
-        if (Flags.recoverabilityDetection()) {
-            json.put("rollbackImpactLevel", rollback.getRollbackImpactLevel());
-        }
+        json.put("rollbackImpactLevel", rollback.getRollbackImpactLevel());
         return json;
     }
 
@@ -211,11 +209,9 @@ class RollbackStore {
                 versionedPackagesFromJson(json.getJSONArray("causePackages")),
                 json.getInt("committedSessionId"));
 
-        if (Flags.recoverabilityDetection()) {
-                // to make it backward compatible.
-            rollbackInfo.setRollbackImpactLevel(json.optInt("rollbackImpactLevel",
-                    PackageManager.ROLLBACK_USER_IMPACT_LOW));
-        }
+        // to make it backward compatible.
+        rollbackInfo.setRollbackImpactLevel(json.optInt("rollbackImpactLevel",
+                PackageManager.ROLLBACK_USER_IMPACT_LOW));
 
         return rollbackInfo;
     }
diff --git a/services/java/com/android/server/SystemServer.java b/services/java/com/android/server/SystemServer.java
index 2bbd69c65eb8..e158310455ac 100644
--- a/services/java/com/android/server/SystemServer.java
+++ b/services/java/com/android/server/SystemServer.java
@@ -1279,12 +1279,6 @@ public final class SystemServer implements Dumpable {
         if (!Flags.refactorCrashrecovery()) {
             // Initialize RescueParty.
             CrashRecoveryAdaptor.rescuePartyRegisterHealthObserver(mSystemContext);
-            if (!Flags.recoverabilityDetection()) {
-                // Now that we have the bare essentials of the OS up and running, take
-                // note that we just booted, which might send out a rescue party if
-                // we're stuck in a runtime restart loop.
-                CrashRecoveryAdaptor.packageWatchdogNoteBoot(mSystemContext);
-            }
         }
 
 
@@ -1558,14 +1552,6 @@ public final class SystemServer implements Dumpable {
         boolean enableVrService = context.getPackageManager().hasSystemFeature(
                 PackageManager.FEATURE_VR_MODE_HIGH_PERFORMANCE);
 
-        if (!Flags.recoverabilityDetection()) {
-            // For debugging RescueParty
-            if (Build.IS_DEBUGGABLE
-                    && SystemProperties.getBoolean("debug.crash_system", false)) {
-                throw new RuntimeException();
-            }
-        }
-
         try {
             final String SECONDARY_ZYGOTE_PRELOAD = "SecondaryZygotePreload";
             // We start the preload ~1s before the webview factory preparation, to
@@ -3091,13 +3077,11 @@ public final class SystemServer implements Dumpable {
             CrashRecoveryAdaptor.initializeCrashrecoveryModuleService(mSystemServiceManager);
             t.traceEnd();
         } else {
-            if (Flags.recoverabilityDetection()) {
-                // Now that we have the essential services needed for mitigations, register the boot
-                // with package watchdog.
-                // Note that we just booted, which might send out a rescue party if we're stuck in a
-                // runtime restart loop.
-                CrashRecoveryAdaptor.packageWatchdogNoteBoot(mSystemContext);
-            }
+            // Now that we have the essential services needed for mitigations, register the boot
+            // with package watchdog.
+            // Note that we just booted, which might send out a rescue party if we're stuck in a
+            // runtime restart loop.
+            CrashRecoveryAdaptor.packageWatchdogNoteBoot(mSystemContext);
         }
 
         t.traceBegin("MakeDisplayManagerServiceReady");
@@ -3511,12 +3495,10 @@ public final class SystemServer implements Dumpable {
      * are updated outside of OTA; and to avoid breaking dependencies from system into apexes.
      */
     private void startApexServices(@NonNull TimingsTraceAndSlog t) {
-        if (Flags.recoverabilityDetection()) {
-            // For debugging RescueParty
-            if (Build.IS_DEBUGGABLE
-                    && SystemProperties.getBoolean("debug.crash_system", false)) {
-                throw new RuntimeException();
-            }
+        // For debugging RescueParty
+        if (Build.IS_DEBUGGABLE
+                && SystemProperties.getBoolean("debug.crash_system", false)) {
+            throw new RuntimeException();
         }
 
         t.traceBegin("startApexServices");
diff --git a/services/tests/mockingservicestests/src/com/android/server/RescuePartyTest.java b/services/tests/mockingservicestests/src/com/android/server/RescuePartyTest.java
index 6c73f0a33a67..eda5e8613dba 100644
--- a/services/tests/mockingservicestests/src/com/android/server/RescuePartyTest.java
+++ b/services/tests/mockingservicestests/src/com/android/server/RescuePartyTest.java
@@ -23,7 +23,6 @@ import static com.android.dx.mockito.inline.extended.ExtendedMockito.anyLong;
 import static com.android.dx.mockito.inline.extended.ExtendedMockito.anyString;
 import static com.android.dx.mockito.inline.extended.ExtendedMockito.doAnswer;
 import static com.android.dx.mockito.inline.extended.ExtendedMockito.doReturn;
-import static com.android.dx.mockito.inline.extended.ExtendedMockito.verify;
 import static com.android.dx.mockito.inline.extended.ExtendedMockito.when;
 import static com.android.server.PackageWatchdog.MITIGATION_RESULT_SKIPPED;
 import static com.android.server.PackageWatchdog.MITIGATION_RESULT_SUCCESS;
@@ -34,8 +33,6 @@ import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.ArgumentMatchers.isNull;
-import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.spy;
 
 import android.content.ContentResolver;
@@ -43,12 +40,8 @@ import android.content.Context;
 import android.content.pm.ApplicationInfo;
 import android.content.pm.PackageManager;
 import android.content.pm.VersionedPackage;
-import android.crashrecovery.flags.Flags;
 import android.os.RecoverySystem;
 import android.os.SystemProperties;
-import android.os.UserHandle;
-import android.platform.test.flag.junit.FlagsParameterization;
-import android.platform.test.flag.junit.SetFlagsRule;
 import android.provider.DeviceConfig;
 import android.provider.Settings;
 
@@ -59,14 +52,8 @@ import com.android.server.am.SettingsToPropertiesMapper;
 
 import org.junit.After;
 import org.junit.Before;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
 import org.mockito.Answers;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
 import org.mockito.Mock;
 import org.mockito.MockitoSession;
 import org.mockito.quality.Strictness;
@@ -75,34 +62,19 @@ import org.mockito.stubbing.Answer;
 import java.lang.reflect.Field;
 import java.util.HashMap;
 import java.util.HashSet;
-import java.util.List;
 import java.util.concurrent.TimeUnit;
 
 
 /**
  * Test RescueParty.
  */
-@RunWith(Parameterized.class)
 public class RescuePartyTest {
-    @Rule
-    public SetFlagsRule mSetFlagsRule;
     private static final long CURRENT_NETWORK_TIME_MILLIS = 0L;
-    private static final String FAKE_NATIVE_NAMESPACE1 = "native1";
-    private static final String FAKE_NATIVE_NAMESPACE2 = "native2";
-    private static final String[] FAKE_RESET_NATIVE_NAMESPACES =
-            {FAKE_NATIVE_NAMESPACE1, FAKE_NATIVE_NAMESPACE2};
 
     private static VersionedPackage sFailingPackage = new VersionedPackage("com.package.name", 1);
     private static final String PROP_DISABLE_RESCUE = "persist.sys.disable_rescue";
-    private static final String CALLING_PACKAGE1 = "com.package.name1";
-    private static final String CALLING_PACKAGE2 = "com.package.name2";
-    private static final String CALLING_PACKAGE3 = "com.package.name3";
     private static final String PERSISTENT_PACKAGE = "com.persistent.package";
     private static final String NON_PERSISTENT_PACKAGE = "com.nonpersistent.package";
-    private static final String NAMESPACE1 = "namespace1";
-    private static final String NAMESPACE2 = "namespace2";
-    private static final String NAMESPACE3 = "namespace3";
-    private static final String NAMESPACE4 = "namespace4";
     private static final String PROP_DEVICE_CONFIG_DISABLE_FLAG =
             "persist.device_config.configuration.disable_rescue_party";
     private static final String PROP_DISABLE_FACTORY_RESET_FLAG =
@@ -126,21 +98,6 @@ public class RescuePartyTest {
     // Mock only sysprop apis
     private PackageWatchdog.BootThreshold mSpyBootThreshold;
 
-    @Captor
-    private ArgumentCaptor<DeviceConfig.MonitorCallback> mMonitorCallbackCaptor;
-    @Captor
-    private ArgumentCaptor<List<String>> mPackageListCaptor;
-
-    @Parameters(name = "{0}")
-    public static List<FlagsParameterization> getFlags() {
-        return FlagsParameterization.allCombinationsOf(
-                Flags.FLAG_RECOVERABILITY_DETECTION);
-    }
-
-    public RescuePartyTest(FlagsParameterization flags) {
-        mSetFlagsRule = new SetFlagsRule(flags);
-    }
-
     @Before
     public void setUp() throws Exception {
         mSession =
@@ -419,25 +376,6 @@ public class RescuePartyTest {
     }
 
 
-    private void verifySettingsResets(int resetMode, String[] resetNamespaces,
-            HashMap<String, Integer> configResetVerifiedTimesMap) {
-        verifyOnlySettingsReset(resetMode);
-    }
-
-    private void verifyOnlySettingsReset(int resetMode) {
-        verify(() -> Settings.Global.resetToDefaultsAsUser(mMockContentResolver, null,
-                resetMode, UserHandle.USER_SYSTEM));
-        verify(() -> Settings.Secure.resetToDefaultsAsUser(eq(mMockContentResolver), isNull(),
-                eq(resetMode), anyInt()));
-    }
-
-    private void verifyNoSettingsReset(int resetMode) {
-        verify(() -> Settings.Global.resetToDefaultsAsUser(mMockContentResolver, null,
-                resetMode, UserHandle.USER_SYSTEM), never());
-        verify(() -> Settings.Secure.resetToDefaultsAsUser(eq(mMockContentResolver), isNull(),
-                eq(resetMode), anyInt()), never());
-    }
-
     private void noteBoot(int mitigationCount) {
         RescuePartyObserver.getInstance(mMockContext).onExecuteBootLoopMitigation(mitigationCount);
     }
diff --git a/services/tests/mockingservicestests/src/com/android/server/rollback/RollbackPackageHealthObserverTest.java b/services/tests/mockingservicestests/src/com/android/server/rollback/RollbackPackageHealthObserverTest.java
index 347dc81c6734..fb4d81ac831c 100644
--- a/services/tests/mockingservicestests/src/com/android/server/rollback/RollbackPackageHealthObserverTest.java
+++ b/services/tests/mockingservicestests/src/com/android/server/rollback/RollbackPackageHealthObserverTest.java
@@ -43,7 +43,6 @@ import android.content.pm.VersionedPackage;
 import android.content.rollback.PackageRollbackInfo;
 import android.content.rollback.RollbackInfo;
 import android.content.rollback.RollbackManager;
-import android.crashrecovery.flags.Flags;
 import android.os.Handler;
 import android.os.MessageQueue;
 import android.os.SystemProperties;
@@ -273,7 +272,6 @@ public class RollbackPackageHealthObserverTest {
     @Test
     public void healthCheckFailed_impactLevelLow_onePackage()
             throws PackageManager.NameNotFoundException {
-        mSetFlagsRule.enableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
         VersionedPackage appAFrom = new VersionedPackage(APP_A, VERSION_CODE_2);
         VersionedPackage appATo = new VersionedPackage(APP_A, VERSION_CODE);
         PackageRollbackInfo packageRollbackInfo = new PackageRollbackInfo(appAFrom, appATo,
@@ -304,7 +302,6 @@ public class RollbackPackageHealthObserverTest {
     @Test
     public void healthCheckFailed_impactLevelHigh_onePackage()
             throws PackageManager.NameNotFoundException {
-        mSetFlagsRule.enableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
         VersionedPackage appAFrom = new VersionedPackage(APP_A, VERSION_CODE_2);
         VersionedPackage appATo = new VersionedPackage(APP_A, VERSION_CODE);
         PackageRollbackInfo packageRollbackInfo = new PackageRollbackInfo(appAFrom, appATo,
@@ -335,7 +332,6 @@ public class RollbackPackageHealthObserverTest {
     @Test
     public void healthCheckFailed_impactLevelManualOnly_onePackage()
             throws PackageManager.NameNotFoundException {
-        mSetFlagsRule.enableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
         VersionedPackage appAFrom = new VersionedPackage(APP_A, VERSION_CODE_2);
         VersionedPackage appATo = new VersionedPackage(APP_A, VERSION_CODE);
         PackageRollbackInfo packageRollbackInfo = new PackageRollbackInfo(appAFrom, appATo,
@@ -365,7 +361,6 @@ public class RollbackPackageHealthObserverTest {
     @Test
     public void healthCheckFailed_impactLevelLowAndHigh_onePackage()
             throws PackageManager.NameNotFoundException {
-        mSetFlagsRule.enableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
         VersionedPackage appAFrom = new VersionedPackage(APP_A, VERSION_CODE_2);
         VersionedPackage appATo = new VersionedPackage(APP_A, VERSION_CODE);
         PackageRollbackInfo packageRollbackInfo = new PackageRollbackInfo(appAFrom, appATo,
@@ -404,7 +399,6 @@ public class RollbackPackageHealthObserverTest {
     @Test
     public void execute_impactLevelLow_nativeCrash_rollback()
             throws PackageManager.NameNotFoundException {
-        mSetFlagsRule.enableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
         int rollbackId = 1;
         VersionedPackage appAFrom = new VersionedPackage(APP_A, VERSION_CODE_2);
         VersionedPackage appATo = new VersionedPackage(APP_A, VERSION_CODE);
@@ -438,7 +432,6 @@ public class RollbackPackageHealthObserverTest {
     @Test
     public void execute_impactLevelLow_rollbackFailedPackage()
             throws PackageManager.NameNotFoundException {
-        mSetFlagsRule.enableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
         int rollbackId1 = 1;
         VersionedPackage appAFrom = new VersionedPackage(APP_A, VERSION_CODE_2);
         VersionedPackage appATo = new VersionedPackage(APP_A, VERSION_CODE);
@@ -483,7 +476,6 @@ public class RollbackPackageHealthObserverTest {
     @Test
     public void execute_impactLevelLow_rollbackAll()
             throws PackageManager.NameNotFoundException {
-        mSetFlagsRule.enableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
         int rollbackId1 = 1;
         VersionedPackage appAFrom = new VersionedPackage(APP_A, VERSION_CODE_2);
         VersionedPackage appATo = new VersionedPackage(APP_A, VERSION_CODE);
@@ -530,7 +522,6 @@ public class RollbackPackageHealthObserverTest {
     @Test
     public void execute_impactLevelLowAndHigh_rollbackLow()
             throws PackageManager.NameNotFoundException {
-        mSetFlagsRule.enableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
         int rollbackId1 = 1;
         VersionedPackage appAFrom = new VersionedPackage(APP_A, VERSION_CODE_2);
         VersionedPackage appATo = new VersionedPackage(APP_A, VERSION_CODE);
@@ -578,7 +569,6 @@ public class RollbackPackageHealthObserverTest {
     @Test
     public void execute_impactLevelHigh_rollbackHigh()
             throws PackageManager.NameNotFoundException {
-        mSetFlagsRule.enableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
         int rollbackId2 = 2;
         VersionedPackage appBFrom = new VersionedPackage(APP_B, VERSION_CODE_2);
         VersionedPackage appBTo = new VersionedPackage(APP_B, VERSION_CODE);
@@ -612,7 +602,6 @@ public class RollbackPackageHealthObserverTest {
      */
     @Test
     public void onBootLoop_impactLevelLow_onePackage() throws PackageManager.NameNotFoundException {
-        mSetFlagsRule.enableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
         VersionedPackage appAFrom = new VersionedPackage(APP_A, VERSION_CODE_2);
         VersionedPackage appATo = new VersionedPackage(APP_A, VERSION_CODE);
         PackageRollbackInfo packageRollbackInfo = new PackageRollbackInfo(appAFrom, appATo,
@@ -637,7 +626,6 @@ public class RollbackPackageHealthObserverTest {
     @Test
     public void onBootLoop_impactLevelHigh_onePackage()
             throws PackageManager.NameNotFoundException {
-        mSetFlagsRule.enableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
         VersionedPackage appAFrom = new VersionedPackage(APP_A, VERSION_CODE_2);
         VersionedPackage appATo = new VersionedPackage(APP_A, VERSION_CODE);
         PackageRollbackInfo packageRollbackInfo = new PackageRollbackInfo(appAFrom, appATo,
@@ -662,7 +650,6 @@ public class RollbackPackageHealthObserverTest {
     @Test
     public void onBootLoop_impactLevelHighDisableHighImpactRollback_onePackage()
             throws PackageManager.NameNotFoundException {
-        mSetFlagsRule.enableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
         SystemProperties.set(PROP_DISABLE_HIGH_IMPACT_ROLLBACK_FLAG, Boolean.toString(true));
         VersionedPackage appAFrom = new VersionedPackage(APP_A, VERSION_CODE_2);
         VersionedPackage appATo = new VersionedPackage(APP_A, VERSION_CODE);
@@ -692,7 +679,6 @@ public class RollbackPackageHealthObserverTest {
     @Test
     public void onBootLoop_impactLevelManualOnly_onePackage()
             throws PackageManager.NameNotFoundException {
-        mSetFlagsRule.enableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
         VersionedPackage appAFrom = new VersionedPackage(APP_A, VERSION_CODE_2);
         VersionedPackage appATo = new VersionedPackage(APP_A, VERSION_CODE);
         PackageRollbackInfo packageRollbackInfo = new PackageRollbackInfo(appAFrom, appATo,
@@ -720,7 +706,6 @@ public class RollbackPackageHealthObserverTest {
     @Test
     public void onBootLoop_impactLevelLowAndHigh_onePackage()
             throws PackageManager.NameNotFoundException {
-        mSetFlagsRule.enableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
         VersionedPackage appAFrom = new VersionedPackage(APP_A, VERSION_CODE_2);
         VersionedPackage appATo = new VersionedPackage(APP_A, VERSION_CODE);
         PackageRollbackInfo packageRollbackInfo = new PackageRollbackInfo(appAFrom, appATo,
@@ -757,7 +742,6 @@ public class RollbackPackageHealthObserverTest {
     @Test
     public void executeBootLoopMitigation_impactLevelLow_rollbackAll()
             throws PackageManager.NameNotFoundException {
-        mSetFlagsRule.enableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
         int rollbackId1 = 1;
         VersionedPackage appAFrom = new VersionedPackage(APP_A, VERSION_CODE_2);
         VersionedPackage appATo = new VersionedPackage(APP_A, VERSION_CODE);
@@ -802,7 +786,6 @@ public class RollbackPackageHealthObserverTest {
     @Test
     public void executeBootLoopMitigation_impactLevelLowAndHigh_rollbackLow()
             throws PackageManager.NameNotFoundException {
-        mSetFlagsRule.enableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
         int rollbackId1 = 1;
         VersionedPackage appAFrom = new VersionedPackage(APP_A, VERSION_CODE_2);
         VersionedPackage appATo = new VersionedPackage(APP_A, VERSION_CODE);
@@ -847,7 +830,6 @@ public class RollbackPackageHealthObserverTest {
     @Test
     public void executeBootLoopMitigation_impactLevelHigh_rollbackHigh()
             throws PackageManager.NameNotFoundException {
-        mSetFlagsRule.enableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
         int rollbackId2 = 2;
         VersionedPackage appBFrom = new VersionedPackage(APP_B, VERSION_CODE_2);
         VersionedPackage appBTo = new VersionedPackage(APP_B, VERSION_CODE);
@@ -882,7 +864,6 @@ public class RollbackPackageHealthObserverTest {
     @Test
     public void execute_impactLevelLowAndManual_rollbackLowImpactOnly()
             throws PackageManager.NameNotFoundException, InterruptedException {
-        mSetFlagsRule.enableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
         int rollbackId1 = 1;
         VersionedPackage appAFrom = new VersionedPackage(APP_A, VERSION_CODE_2);
         VersionedPackage appATo = new VersionedPackage(APP_A, VERSION_CODE);
@@ -928,7 +909,6 @@ public class RollbackPackageHealthObserverTest {
     @Test
     public void execute_impactLevelManual_rollbackLowImpactOnly()
             throws PackageManager.NameNotFoundException {
-        mSetFlagsRule.enableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
         int rollbackId1 = 1;
         VersionedPackage appAFrom = new VersionedPackage(APP_A, VERSION_CODE_2);
         VersionedPackage appATo = new VersionedPackage(APP_A, VERSION_CODE);
@@ -962,7 +942,6 @@ public class RollbackPackageHealthObserverTest {
     @Test
     public void executeBootLoopMitigation_impactLevelHighMultiplePackage_rollbackHigh()
             throws PackageManager.NameNotFoundException {
-        mSetFlagsRule.enableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
         int rollbackId1 = 1;
         VersionedPackage appBFrom = new VersionedPackage(APP_B, VERSION_CODE_2);
         VersionedPackage appBTo = new VersionedPackage(APP_B, VERSION_CODE);
@@ -1008,7 +987,6 @@ public class RollbackPackageHealthObserverTest {
     @Test
     public void executeBootLoopMitigation_impactLevelHighKillSwitchTrue_rollbackHigh()
             throws PackageManager.NameNotFoundException {
-        mSetFlagsRule.enableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
         SystemProperties.set(PROP_DISABLE_HIGH_IMPACT_ROLLBACK_FLAG, Boolean.toString(true));
         int rollbackId1 = 1;
         VersionedPackage appBFrom = new VersionedPackage(APP_B, VERSION_CODE_2);
diff --git a/tests/PackageWatchdog/src/com/android/server/CrashRecoveryTest.java b/tests/PackageWatchdog/src/com/android/server/CrashRecoveryTest.java
index 4c16a756fbdc..c2ab0550ea05 100644
--- a/tests/PackageWatchdog/src/com/android/server/CrashRecoveryTest.java
+++ b/tests/PackageWatchdog/src/com/android/server/CrashRecoveryTest.java
@@ -133,7 +133,6 @@ public class CrashRecoveryTest {
 
     @Before
     public void setUp() throws Exception {
-        mSetFlagsRule.enableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
         MockitoAnnotations.initMocks(this);
         new File(InstrumentationRegistry.getContext().getFilesDir(),
                 "package-watchdog.xml").delete();
@@ -766,8 +765,6 @@ public class CrashRecoveryTest {
             watchdog.notifyPackageFailure(packages, failureReason);
         }
         mTestLooper.dispatchAll();
-        if (Flags.recoverabilityDetection()) {
-            moveTimeForwardAndDispatch(watchdog.DEFAULT_MITIGATION_WINDOW_MS);
-        }
+        moveTimeForwardAndDispatch(watchdog.DEFAULT_MITIGATION_WINDOW_MS);
     }
 }
diff --git a/tests/PackageWatchdog/src/com/android/server/PackageWatchdogTest.java b/tests/PackageWatchdog/src/com/android/server/PackageWatchdogTest.java
index 1c50cb1b55fd..b8274841f65b 100644
--- a/tests/PackageWatchdog/src/com/android/server/PackageWatchdogTest.java
+++ b/tests/PackageWatchdog/src/com/android/server/PackageWatchdogTest.java
@@ -150,7 +150,6 @@ public class PackageWatchdogTest {
 
     @Before
     public void setUp() throws Exception {
-        mSetFlagsRule.enableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
         MockitoAnnotations.initMocks(this);
         new File(InstrumentationRegistry.getContext().getFilesDir(),
                 "package-watchdog.xml").delete();
@@ -480,60 +479,6 @@ public class PackageWatchdogTest {
         assertThat(observer.mHealthCheckFailedPackages).isEmpty();
     }
 
-
-    /**
-     * Test package failure and notifies only least impact observers.
-     */
-    @Test
-    public void testPackageFailureNotifyAllDifferentImpacts() throws Exception {
-        mSetFlagsRule.disableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
-        PackageWatchdog watchdog = createWatchdog();
-        TestObserver observerNone = new TestObserver(OBSERVER_NAME_1,
-                PackageHealthObserverImpact.USER_IMPACT_LEVEL_0);
-        TestObserver observerHigh = new TestObserver(OBSERVER_NAME_2,
-                PackageHealthObserverImpact.USER_IMPACT_LEVEL_100);
-        TestObserver observerMid = new TestObserver(OBSERVER_NAME_3,
-                PackageHealthObserverImpact.USER_IMPACT_LEVEL_30);
-        TestObserver observerLow = new TestObserver(OBSERVER_NAME_4,
-                PackageHealthObserverImpact.USER_IMPACT_LEVEL_10);
-
-        // Start observing for all impact observers
-        watchdog.registerHealthObserver(mTestExecutor, observerNone);
-        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A, APP_B, APP_C, APP_D),
-                SHORT_DURATION, observerNone);
-        watchdog.registerHealthObserver(mTestExecutor, observerHigh);
-        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A, APP_B, APP_C), SHORT_DURATION,
-                observerHigh);
-        watchdog.registerHealthObserver(mTestExecutor, observerMid);
-        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A, APP_B), SHORT_DURATION,
-                observerMid);
-        watchdog.registerHealthObserver(mTestExecutor, observerLow);
-        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observerLow);
-
-        // Then fail all apps above the threshold
-        raiseFatalFailureAndDispatch(watchdog,
-                Arrays.asList(new VersionedPackage(APP_A, VERSION_CODE),
-                        new VersionedPackage(APP_B, VERSION_CODE),
-                        new VersionedPackage(APP_C, VERSION_CODE),
-                        new VersionedPackage(APP_D, VERSION_CODE)),
-                PackageWatchdog.FAILURE_REASON_UNKNOWN);
-
-        // Verify least impact observers are notifed of package failures
-        List<String> observerNonePackages = observerNone.mMitigatedPackages;
-        List<String> observerHighPackages = observerHigh.mMitigatedPackages;
-        List<String> observerMidPackages = observerMid.mMitigatedPackages;
-        List<String> observerLowPackages = observerLow.mMitigatedPackages;
-
-        // APP_D failure observed by only observerNone is not caught cos its impact is none
-        assertThat(observerNonePackages).isEmpty();
-        // APP_C failure is caught by observerHigh cos it's the lowest impact observer
-        assertThat(observerHighPackages).containsExactly(APP_C);
-        // APP_B failure is caught by observerMid cos it's the lowest impact observer
-        assertThat(observerMidPackages).containsExactly(APP_B);
-        // APP_A failure is caught by observerLow cos it's the lowest impact observer
-        assertThat(observerLowPackages).containsExactly(APP_A);
-    }
-
     @Test
     public void testPackageFailureNotifyAllDifferentImpactsRecoverability() throws Exception {
         PackageWatchdog watchdog = createWatchdog();
@@ -583,84 +528,6 @@ public class PackageWatchdogTest {
         assertThat(observerLowPackages).containsExactly(APP_A);
     }
 
-    /**
-     * Test package failure and least impact observers are notified successively.
-     * State transistions:
-     *
-     * <ul>
-     * <li>(observer1:low, observer2:mid) -> {observer1}
-     * <li>(observer1:high, observer2:mid) -> {observer2}
-     * <li>(observer1:high, observer2:none) -> {observer1}
-     * <li>(observer1:none, observer2:none) -> {}
-     * <ul>
-     */
-    @Test
-    public void testPackageFailureNotifyLeastImpactSuccessively() throws Exception {
-        mSetFlagsRule.disableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
-        PackageWatchdog watchdog = createWatchdog();
-        TestObserver observerFirst = new TestObserver(OBSERVER_NAME_1,
-                PackageHealthObserverImpact.USER_IMPACT_LEVEL_10);
-        TestObserver observerSecond = new TestObserver(OBSERVER_NAME_2,
-                PackageHealthObserverImpact.USER_IMPACT_LEVEL_30);
-
-        // Start observing for observerFirst and observerSecond with failure handling
-        watchdog.registerHealthObserver(mTestExecutor, observerFirst);
-        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), LONG_DURATION, observerFirst);
-        watchdog.registerHealthObserver(mTestExecutor, observerSecond);
-        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), LONG_DURATION, observerSecond);
-
-        // Then fail APP_A above the threshold
-        raiseFatalFailureAndDispatch(watchdog,
-                Arrays.asList(new VersionedPackage(APP_A, VERSION_CODE)),
-                PackageWatchdog.FAILURE_REASON_UNKNOWN);
-
-        // Verify only observerFirst is notifed
-        assertThat(observerFirst.mMitigatedPackages).containsExactly(APP_A);
-        assertThat(observerSecond.mMitigatedPackages).isEmpty();
-
-        // After observerFirst handles failure, next action it has is high impact
-        observerFirst.mImpact = PackageHealthObserverImpact.USER_IMPACT_LEVEL_100;
-        observerFirst.mMitigatedPackages.clear();
-        observerSecond.mMitigatedPackages.clear();
-
-        // Then fail APP_A again above the threshold
-        raiseFatalFailureAndDispatch(watchdog,
-                Arrays.asList(new VersionedPackage(APP_A, VERSION_CODE)),
-                PackageWatchdog.FAILURE_REASON_UNKNOWN);
-
-        // Verify only observerSecond is notifed cos it has least impact
-        assertThat(observerSecond.mMitigatedPackages).containsExactly(APP_A);
-        assertThat(observerFirst.mMitigatedPackages).isEmpty();
-
-        // After observerSecond handles failure, it has no further actions
-        observerSecond.mImpact = PackageHealthObserverImpact.USER_IMPACT_LEVEL_0;
-        observerFirst.mMitigatedPackages.clear();
-        observerSecond.mMitigatedPackages.clear();
-
-        // Then fail APP_A again above the threshold
-        raiseFatalFailureAndDispatch(watchdog,
-                Arrays.asList(new VersionedPackage(APP_A, VERSION_CODE)),
-                PackageWatchdog.FAILURE_REASON_UNKNOWN);
-
-        // Verify only observerFirst is notifed cos it has the only action
-        assertThat(observerFirst.mMitigatedPackages).containsExactly(APP_A);
-        assertThat(observerSecond.mMitigatedPackages).isEmpty();
-
-        // After observerFirst handles failure, it too has no further actions
-        observerFirst.mImpact = PackageHealthObserverImpact.USER_IMPACT_LEVEL_0;
-        observerFirst.mMitigatedPackages.clear();
-        observerSecond.mMitigatedPackages.clear();
-
-        // Then fail APP_A again above the threshold
-        raiseFatalFailureAndDispatch(watchdog,
-                Arrays.asList(new VersionedPackage(APP_A, VERSION_CODE)),
-                PackageWatchdog.FAILURE_REASON_UNKNOWN);
-
-        // Verify no observer is notified cos no actions left
-        assertThat(observerFirst.mMitigatedPackages).isEmpty();
-        assertThat(observerSecond.mMitigatedPackages).isEmpty();
-    }
-
     @Test
     public void testPackageFailureNotifyLeastImpactSuccessivelyRecoverability() throws Exception {
         PackageWatchdog watchdog = createWatchdog();
@@ -727,34 +594,6 @@ public class PackageWatchdogTest {
         assertThat(observerSecond.mMitigatedPackages).isEmpty();
     }
 
-    /**
-     * Test package failure and notifies only one observer even with observer impact tie.
-     */
-    @Test
-    public void testPackageFailureNotifyOneSameImpact() throws Exception {
-        mSetFlagsRule.disableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
-        PackageWatchdog watchdog = createWatchdog();
-        TestObserver observer1 = new TestObserver(OBSERVER_NAME_1,
-                PackageHealthObserverImpact.USER_IMPACT_LEVEL_100);
-        TestObserver observer2 = new TestObserver(OBSERVER_NAME_2,
-                PackageHealthObserverImpact.USER_IMPACT_LEVEL_100);
-
-        // Start observing for observer1 and observer2 with failure handling
-        watchdog.registerHealthObserver(mTestExecutor, observer2);
-        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observer2);
-        watchdog.registerHealthObserver(mTestExecutor, observer1);
-        watchdog.startExplicitHealthCheck(Arrays.asList(APP_A), SHORT_DURATION, observer1);
-
-        // Then fail APP_A above the threshold
-        raiseFatalFailureAndDispatch(watchdog,
-                Arrays.asList(new VersionedPackage(APP_A, VERSION_CODE)),
-                PackageWatchdog.FAILURE_REASON_UNKNOWN);
-
-        // Verify only one observer is notifed
-        assertThat(observer1.mMitigatedPackages).containsExactly(APP_A);
-        assertThat(observer2.mMitigatedPackages).isEmpty();
-    }
-
     @Test
     public void testPackageFailureNotifyOneSameImpactRecoverabilityDetection() throws Exception {
         PackageWatchdog watchdog = createWatchdog();
@@ -1015,27 +854,6 @@ public class PackageWatchdogTest {
 
     @Test
     @RequiresFlagsDisabled(Flags.FLAG_REFACTOR_CRASHRECOVERY)
-    public void testNetworkStackFailure() {
-        mSetFlagsRule.disableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
-        final PackageWatchdog wd = createWatchdog();
-
-        // Start observing with failure handling
-        TestObserver observer = new TestObserver(OBSERVER_NAME_1,
-                PackageHealthObserverImpact.USER_IMPACT_LEVEL_100);
-        wd.startExplicitHealthCheck(Collections.singletonList(APP_A), SHORT_DURATION, observer);
-
-        // Notify of NetworkStack failure
-        mConnectivityModuleCallbackCaptor.getValue().onNetworkStackFailure(APP_A);
-
-        // Run handler so package failures are dispatched to observers
-        mTestLooper.dispatchAll();
-
-        // Verify the NetworkStack observer is notified
-        assertThat(observer.mMitigatedPackages).containsExactly(APP_A);
-    }
-
-    @Test
-    @RequiresFlagsDisabled(Flags.FLAG_REFACTOR_CRASHRECOVERY)
     public void testNetworkStackFailureRecoverabilityDetection() {
         final PackageWatchdog wd = createWatchdog();
 
@@ -1270,21 +1088,6 @@ public class PackageWatchdogTest {
         assertThat(persistentObserver.mHealthCheckFailedPackages).isEmpty();
     }
 
-
-    /** Ensure that boot loop mitigation is done when the number of boots meets the threshold. */
-    @Test
-    public void testBootLoopDetection_meetsThreshold() {
-        mSetFlagsRule.disableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
-        PackageWatchdog watchdog = createWatchdog();
-        TestObserver bootObserver = new TestObserver(OBSERVER_NAME_1);
-        watchdog.registerHealthObserver(mTestExecutor, bootObserver);
-        for (int i = 0; i < PackageWatchdog.DEFAULT_BOOT_LOOP_TRIGGER_COUNT; i++) {
-            watchdog.noteBoot();
-        }
-        mTestLooper.dispatchAll();
-        assertThat(bootObserver.mitigatedBootLoop()).isTrue();
-    }
-
     @Test
     public void testBootLoopDetection_meetsThresholdRecoverability() {
         PackageWatchdog watchdog = createWatchdog();
@@ -1330,27 +1133,6 @@ public class PackageWatchdogTest {
         assertThat(bootObserver.mitigatedBootLoop()).isFalse();
     }
 
-    /**
-     * Ensure that boot loop mitigation is done for the observer with the lowest user impact
-     */
-    @Test
-    public void testBootLoopMitigationDoneForLowestUserImpact() {
-        mSetFlagsRule.disableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
-        PackageWatchdog watchdog = createWatchdog();
-        TestObserver bootObserver1 = new TestObserver(OBSERVER_NAME_1);
-        bootObserver1.setImpact(PackageHealthObserverImpact.USER_IMPACT_LEVEL_10);
-        TestObserver bootObserver2 = new TestObserver(OBSERVER_NAME_2);
-        bootObserver2.setImpact(PackageHealthObserverImpact.USER_IMPACT_LEVEL_30);
-        watchdog.registerHealthObserver(mTestExecutor, bootObserver1);
-        watchdog.registerHealthObserver(mTestExecutor, bootObserver2);
-        for (int i = 0; i < PackageWatchdog.DEFAULT_BOOT_LOOP_TRIGGER_COUNT; i++) {
-            watchdog.noteBoot();
-        }
-        mTestLooper.dispatchAll();
-        assertThat(bootObserver1.mitigatedBootLoop()).isTrue();
-        assertThat(bootObserver2.mitigatedBootLoop()).isFalse();
-    }
-
     @Test
     public void testBootLoopMitigationDoneForLowestUserImpactRecoverability() {
         PackageWatchdog watchdog = createWatchdog();
@@ -1368,32 +1150,6 @@ public class PackageWatchdogTest {
         assertThat(bootObserver2.mitigatedBootLoop()).isFalse();
     }
 
-    /**
-     * Ensure that the correct mitigation counts are sent to the boot loop observer.
-     */
-    @Test
-    public void testMultipleBootLoopMitigation() {
-        mSetFlagsRule.disableFlags(Flags.FLAG_RECOVERABILITY_DETECTION);
-        PackageWatchdog watchdog = createWatchdog();
-        TestObserver bootObserver = new TestObserver(OBSERVER_NAME_1);
-        watchdog.registerHealthObserver(mTestExecutor, bootObserver);
-        for (int i = 0; i < 4; i++) {
-            for (int j = 0; j < PackageWatchdog.DEFAULT_BOOT_LOOP_TRIGGER_COUNT; j++) {
-                watchdog.noteBoot();
-            }
-        }
-
-        moveTimeForwardAndDispatch(PackageWatchdog.DEFAULT_DEESCALATION_WINDOW_MS + 1);
-
-        for (int i = 0; i < 4; i++) {
-            for (int j = 0; j < PackageWatchdog.DEFAULT_BOOT_LOOP_TRIGGER_COUNT; j++) {
-                watchdog.noteBoot();
-            }
-        }
-        mTestLooper.dispatchAll();
-        assertThat(bootObserver.mBootMitigationCounts).isEqualTo(List.of(1, 2, 3, 4, 1, 2, 3, 4));
-    }
-
     @Test
     public void testMultipleBootLoopMitigationRecoverabilityLowImpact() {
         PackageWatchdog watchdog = createWatchdog();
@@ -1800,9 +1556,7 @@ public class PackageWatchdogTest {
             watchdog.notifyPackageFailure(packages, failureReason);
         }
         mTestLooper.dispatchAll();
-        if (Flags.recoverabilityDetection()) {
-            moveTimeForwardAndDispatch(watchdog.DEFAULT_MITIGATION_WINDOW_MS);
-        }
+        moveTimeForwardAndDispatch(watchdog.DEFAULT_MITIGATION_WINDOW_MS);
     }
 
     private PackageWatchdog createWatchdog() {