Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit cef8127b authored by Sudheer Shanka's avatar Sudheer Shanka
Browse files

Cleanup com.android.server.am.limit_priority_scope.

Fixes: 423988879
Test: n/a
Flag: EXEMPT removing com.android.server.am.limit_priority_scope
Change-Id: Ie8830e9eff4af862d21db2b34ff301d1195bb754
parent 1d4abc78
Loading
Loading
Loading
Loading
+48 −70
Original line number Diff line number Diff line
@@ -794,7 +794,6 @@ final class BroadcastRecord extends Binder {
                blockedUntilBeyondCount[i] = i;
            }
        } else {
            if (Flags.limitPriorityScope()) {
            final boolean[] changeEnabled = calculateChangeStateForReceivers(
                    receivers, LIMIT_PRIORITY_SCOPE, platformCompat);

@@ -852,27 +851,6 @@ final class BroadcastRecord extends Binder {
                            && currentTrancheChangeDisabledIndex == -1))) {
                Arrays.fill(blockedUntilBeyondCount, -1);
            }
            } else {
                // When sending a prioritized broadcast, we only need to wait
                // for the previous tranche of receivers to be terminated
                int lastPriority = 0;
                int lastPriorityIndex = 0;
                for (int i = 0; i < N; i++) {
                    final int thisPriority = getReceiverPriority(receivers.get(i));
                    if ((i == 0) || (thisPriority != lastPriority)) {
                        lastPriority = thisPriority;
                        lastPriorityIndex = i;
                        blockedUntilBeyondCount[i] = i;
                    } else {
                        blockedUntilBeyondCount[i] = lastPriorityIndex;
                    }
                }
                // If the entire list is in the same priority tranche, mark as -1 to
                // indicate that none of them need to wait
                if (N > 0 && blockedUntilBeyondCount[N - 1] == 0) {
                    Arrays.fill(blockedUntilBeyondCount, -1);
                }
            }
        }
        return blockedUntilBeyondCount;
    }
+0 −8
Original line number Diff line number Diff line
package: "com.android.server.am"
container: "system"

flag {
    name: "limit_priority_scope"
    namespace: "backstage_power"
    description: "Limit the scope of receiver priorities to within a process"
    is_fixed_read_only: true
    bug: "369487976"
}

flag {
    name: "avoid_note_op_at_enqueue"
    namespace: "backstage_power"
+0 −272
Original line number Diff line number Diff line
@@ -683,19 +683,6 @@ public final class BroadcastQueueImplTest extends BaseBroadcastQueueTest {
                List.of(makeMockRegisteredReceiver()), null, false), REASON_CONTAINS_ALARM);
    }

    @DisableFlags(Flags.FLAG_LIMIT_PRIORITY_SCOPE)
    @Test
    public void testRunnableAt_Cached_Prioritized_NonDeferrable_flagDisabled() {
        final List receivers = List.of(
                withPriority(makeManifestReceiver(PACKAGE_RED, PACKAGE_RED), 10),
                withPriority(makeManifestReceiver(PACKAGE_GREEN, PACKAGE_GREEN), -10));
        final BroadcastOptions options = BroadcastOptions.makeBasic()
                .setDeferralPolicy(BroadcastOptions.DEFERRAL_POLICY_NONE);
        doRunnableAt_Cached(makeBroadcastRecord(makeMockIntent(), options,
                receivers, null, false), REASON_CONTAINS_PRIORITIZED);
    }

    @EnableFlags(Flags.FLAG_LIMIT_PRIORITY_SCOPE)
    @Test
    public void testRunnableAt_Cached_Prioritized_NonDeferrable() {
        final List receivers = List.of(
@@ -718,7 +705,6 @@ public final class BroadcastQueueImplTest extends BaseBroadcastQueueTest {
                receivers, mock(IIntentReceiver.class), true), REASON_CONTAINS_ORDERED);
    }

    @EnableFlags(Flags.FLAG_LIMIT_PRIORITY_SCOPE)
    @Test
    public void testRunnableAt_Cached_Prioritized_NonDeferrable_changeIdDisabled() {
        doReturn(false).when(mPlatformCompat).isChangeEnabledInternalNoLogging(
@@ -1179,62 +1165,6 @@ public final class BroadcastQueueImplTest extends BaseBroadcastQueueTest {
        verifyPendingRecords(blueQueue, List.of(screenOn));
    }

    @DisableFlags(Flags.FLAG_LIMIT_PRIORITY_SCOPE)
    @SuppressWarnings("GuardedBy")
    @Test
    public void testDeliveryGroupPolicy_prioritized_diffReceivers_flagDisabled() {
        final Intent screenOn = new Intent(Intent.ACTION_SCREEN_ON);
        final Intent screenOff = new Intent(Intent.ACTION_SCREEN_OFF);
        final BroadcastOptions screenOnOffOptions = BroadcastOptions.makeBasic()
                .setDeliveryGroupPolicy(BroadcastOptions.DELIVERY_GROUP_POLICY_MOST_RECENT)
                .setDeliveryGroupMatchingKey("screenOnOff", Intent.ACTION_SCREEN_ON);

        final Object greenReceiver = withPriority(
                makeManifestReceiver(PACKAGE_GREEN, CLASS_GREEN), 10);
        final Object redReceiver = withPriority(
                makeManifestReceiver(PACKAGE_RED, CLASS_RED), 5);
        final Object blueReceiver = withPriority(
                makeManifestReceiver(PACKAGE_BLUE, CLASS_BLUE), 0);

        mImpl.enqueueBroadcastLocked(makeBroadcastRecord(screenOn, screenOnOffOptions,
                List.of(greenReceiver, blueReceiver), false));
        mImpl.enqueueBroadcastLocked(makeBroadcastRecord(screenOff, screenOnOffOptions,
                List.of(greenReceiver, redReceiver, blueReceiver), false));
        final BroadcastProcessQueue greenQueue = mImpl.getProcessQueue(PACKAGE_GREEN,
                getUidForPackage(PACKAGE_GREEN));
        final BroadcastProcessQueue redQueue = mImpl.getProcessQueue(PACKAGE_RED,
                getUidForPackage(PACKAGE_RED));
        final BroadcastProcessQueue blueQueue = mImpl.getProcessQueue(PACKAGE_BLUE,
                getUidForPackage(PACKAGE_BLUE));
        verifyPendingRecords(greenQueue, List.of(screenOff));
        verifyPendingRecords(redQueue, List.of(screenOff));
        verifyPendingRecords(blueQueue, List.of(screenOff));

        assertTrue(greenQueue.isEmpty());
        assertTrue(redQueue.isEmpty());
        assertTrue(blueQueue.isEmpty());

        mImpl.enqueueBroadcastLocked(makeBroadcastRecord(screenOff, screenOnOffOptions,
                List.of(greenReceiver, redReceiver, blueReceiver), false));
        mImpl.enqueueBroadcastLocked(makeBroadcastRecord(screenOn, screenOnOffOptions,
                List.of(greenReceiver, blueReceiver), false));
        verifyPendingRecords(greenQueue, List.of(screenOff, screenOn));
        verifyPendingRecords(redQueue, List.of(screenOff));
        verifyPendingRecords(blueQueue, List.of(screenOff, screenOn));

        final BroadcastRecord screenOffRecord = makeBroadcastRecord(screenOff, screenOnOffOptions,
                List.of(greenReceiver, redReceiver, blueReceiver), false);
        screenOffRecord.setDeliveryState(2, BroadcastRecord.DELIVERY_DEFERRED,
                "testDeliveryGroupPolicy_prioritized_diffReceivers_flagDisabled");
        mImpl.enqueueBroadcastLocked(screenOffRecord);
        mImpl.enqueueBroadcastLocked(makeBroadcastRecord(screenOn, screenOnOffOptions,
                List.of(greenReceiver, blueReceiver), false));
        verifyPendingRecords(greenQueue, List.of(screenOff, screenOn));
        verifyPendingRecords(redQueue, List.of(screenOff));
        verifyPendingRecords(blueQueue, List.of(screenOn));
    }

    @EnableFlags(Flags.FLAG_LIMIT_PRIORITY_SCOPE)
    @SuppressWarnings("GuardedBy")
    @Test
    public void testDeliveryGroupPolicy_prioritized_diffReceivers() {
@@ -1289,7 +1219,6 @@ public final class BroadcastQueueImplTest extends BaseBroadcastQueueTest {
        verifyPendingRecords(blueQueue, List.of(screenOn));
    }

    @EnableFlags(Flags.FLAG_LIMIT_PRIORITY_SCOPE)
    @SuppressWarnings("GuardedBy")
    @Test
    public void testDeliveryGroupPolicy_prioritized_diffReceivers_changeIdDisabled() {
@@ -1907,103 +1836,6 @@ public final class BroadcastQueueImplTest extends BaseBroadcastQueueTest {
        verifyPendingRecords(redQueue, List.of(userPresent, timeTick));
    }

    @DisableFlags(Flags.FLAG_LIMIT_PRIORITY_SCOPE)
    @Test
    public void testDeliveryDeferredForCached_flagDisabled() throws Exception {
        final ProcessRecord greenProcess = makeProcessRecord(makeApplicationInfo(PACKAGE_GREEN));
        final ProcessRecord redProcess = makeProcessRecord(makeApplicationInfo(PACKAGE_RED));

        final Intent timeTick = new Intent(Intent.ACTION_TIME_TICK);
        final BroadcastRecord timeTickRecord = makeBroadcastRecord(timeTick,
                List.of(makeRegisteredReceiver(greenProcess, 0)));

        final Intent batteryChanged = new Intent(Intent.ACTION_BATTERY_CHANGED);
        final BroadcastOptions optionsBatteryChanged =
                BroadcastOptions.makeWithDeferUntilActive(true);
        final BroadcastRecord batteryChangedRecord = makeBroadcastRecord(batteryChanged,
                optionsBatteryChanged,
                List.of(makeRegisteredReceiver(greenProcess, 10),
                        makeRegisteredReceiver(redProcess, 0)),
                false /* ordered */);

        mImpl.enqueueBroadcastLocked(timeTickRecord);
        mImpl.enqueueBroadcastLocked(batteryChangedRecord);

        final BroadcastProcessQueue greenQueue = mImpl.getProcessQueue(PACKAGE_GREEN,
                getUidForPackage(PACKAGE_GREEN));
        final BroadcastProcessQueue redQueue = mImpl.getProcessQueue(PACKAGE_RED,
                getUidForPackage(PACKAGE_RED));
        assertEquals(BroadcastProcessQueue.REASON_NORMAL, greenQueue.getRunnableAtReason());
        assertFalse(greenQueue.shouldBeDeferred());
        assertEquals(BroadcastProcessQueue.REASON_BLOCKED, redQueue.getRunnableAtReason());
        assertFalse(redQueue.shouldBeDeferred());

        // Simulate process state change
        greenQueue.setProcessAndUidState(greenProcess, false /* uidForeground */,
                true /* processFreezable */);
        greenQueue.updateDeferredStates(mImpl.mBroadcastConsumerDeferApply,
                mImpl.mBroadcastConsumerDeferClear);

        assertEquals(BroadcastProcessQueue.REASON_CACHED, greenQueue.getRunnableAtReason());
        assertTrue(greenQueue.shouldBeDeferred());
        // Once the broadcasts to green process are deferred, broadcasts to red process
        // shouldn't be blocked anymore.
        assertEquals(BroadcastProcessQueue.REASON_NORMAL, redQueue.getRunnableAtReason());
        assertFalse(redQueue.shouldBeDeferred());

        // All broadcasts to green process should be deferred.
        greenQueue.forEachMatchingBroadcast(BROADCAST_PREDICATE_ANY, (r, i) -> {
            assertEquals("Unexpected state for " + r,
                    BroadcastRecord.DELIVERY_DEFERRED, r.getDeliveryState(i));
        }, false /* andRemove */);
        redQueue.forEachMatchingBroadcast(BROADCAST_PREDICATE_ANY, (r, i) -> {
            assertEquals("Unexpected state for " + r,
                    BroadcastRecord.DELIVERY_PENDING, r.getDeliveryState(i));
        }, false /* andRemove */);

        final Intent packageChanged = new Intent(Intent.ACTION_PACKAGE_CHANGED);
        final BroadcastRecord packageChangedRecord = makeBroadcastRecord(packageChanged,
                List.of(makeRegisteredReceiver(greenProcess, 0)));
        mImpl.enqueueBroadcastLocked(packageChangedRecord);

        assertEquals(BroadcastProcessQueue.REASON_CACHED, greenQueue.getRunnableAtReason());
        assertTrue(greenQueue.shouldBeDeferred());
        assertEquals(BroadcastProcessQueue.REASON_NORMAL, redQueue.getRunnableAtReason());
        assertFalse(redQueue.shouldBeDeferred());

        // All broadcasts to the green process, including the newly enqueued one, should be
        // deferred.
        greenQueue.forEachMatchingBroadcast(BROADCAST_PREDICATE_ANY, (r, i) -> {
            assertEquals("Unexpected state for " + r,
                    BroadcastRecord.DELIVERY_DEFERRED, r.getDeliveryState(i));
        }, false /* andRemove */);
        redQueue.forEachMatchingBroadcast(BROADCAST_PREDICATE_ANY, (r, i) -> {
            assertEquals("Unexpected state for " + r,
                    BroadcastRecord.DELIVERY_PENDING, r.getDeliveryState(i));
        }, false /* andRemove */);

        // Simulate process state change
        greenQueue.setProcessAndUidState(greenProcess, false /* uidForeground */,
                false /* processFreezable */);
        greenQueue.updateDeferredStates(mImpl.mBroadcastConsumerDeferApply,
                mImpl.mBroadcastConsumerDeferClear);

        assertEquals(BroadcastProcessQueue.REASON_NORMAL, greenQueue.getRunnableAtReason());
        assertFalse(greenQueue.shouldBeDeferred());
        assertEquals(BroadcastProcessQueue.REASON_NORMAL, redQueue.getRunnableAtReason());
        assertFalse(redQueue.shouldBeDeferred());

        greenQueue.forEachMatchingBroadcast(BROADCAST_PREDICATE_ANY, (r, i) -> {
            assertEquals("Unexpected state for " + r,
                    BroadcastRecord.DELIVERY_PENDING, r.getDeliveryState(i));
        }, false /* andRemove */);
        redQueue.forEachMatchingBroadcast(BROADCAST_PREDICATE_ANY, (r, i) -> {
            assertEquals("Unexpected state for " + r,
                    BroadcastRecord.DELIVERY_PENDING, r.getDeliveryState(i));
        }, false /* andRemove */);
    }

    @EnableFlags(Flags.FLAG_LIMIT_PRIORITY_SCOPE)
    @SuppressWarnings("GuardedBy")
    @Test
    public void testDeliveryDeferredForCached_changeIdDisabled() throws Exception {
@@ -2104,110 +1936,6 @@ public final class BroadcastQueueImplTest extends BaseBroadcastQueueTest {
        }, false /* andRemove */);
    }

    @DisableFlags(Flags.FLAG_LIMIT_PRIORITY_SCOPE)
    @SuppressWarnings("GuardedBy")
    @Test
    public void testDeliveryDeferredForCached_withInfiniteDeferred_flagDisabled() throws Exception {
        final ProcessRecord greenProcess = makeProcessRecord(makeApplicationInfo(PACKAGE_GREEN));
        final ProcessRecord redProcess = makeProcessRecord(makeApplicationInfo(PACKAGE_RED));

        final Intent timeTick = new Intent(Intent.ACTION_TIME_TICK);
        final BroadcastOptions optionsTimeTick = BroadcastOptions.makeWithDeferUntilActive(true);
        final BroadcastRecord timeTickRecord = makeBroadcastRecord(timeTick, optionsTimeTick,
                List.of(makeRegisteredReceiver(greenProcess, 0)), false /* ordered */);

        final Intent batteryChanged = new Intent(Intent.ACTION_BATTERY_CHANGED);
        final BroadcastOptions optionsBatteryChanged =
                BroadcastOptions.makeWithDeferUntilActive(true);
        final BroadcastRecord batteryChangedRecord = makeBroadcastRecord(batteryChanged,
                optionsBatteryChanged,
                List.of(makeRegisteredReceiver(greenProcess, 10),
                        makeRegisteredReceiver(redProcess, 0)),
                false /* ordered */);

        mImpl.enqueueBroadcastLocked(timeTickRecord);
        mImpl.enqueueBroadcastLocked(batteryChangedRecord);

        final BroadcastProcessQueue greenQueue = mImpl.getProcessQueue(PACKAGE_GREEN,
                getUidForPackage(PACKAGE_GREEN));
        final BroadcastProcessQueue redQueue = mImpl.getProcessQueue(PACKAGE_RED,
                getUidForPackage(PACKAGE_RED));
        assertEquals(BroadcastProcessQueue.REASON_NORMAL, greenQueue.getRunnableAtReason());
        assertFalse(greenQueue.shouldBeDeferred());
        assertEquals(BroadcastProcessQueue.REASON_BLOCKED, redQueue.getRunnableAtReason());
        assertFalse(redQueue.shouldBeDeferred());

        // Simulate process state change
        greenQueue.setProcessAndUidState(greenProcess, false /* uidForeground */,
                true /* processFreezable */);
        greenQueue.updateDeferredStates(mImpl.mBroadcastConsumerDeferApply,
                mImpl.mBroadcastConsumerDeferClear);

        assertEquals(BroadcastProcessQueue.REASON_CACHED_INFINITE_DEFER,
                greenQueue.getRunnableAtReason());
        assertTrue(greenQueue.shouldBeDeferred());
        // Once the broadcasts to green process are deferred, broadcasts to red process
        // shouldn't be blocked anymore.
        assertEquals(BroadcastProcessQueue.REASON_NORMAL, redQueue.getRunnableAtReason());
        assertFalse(redQueue.shouldBeDeferred());

        // All broadcasts to green process should be deferred.
        greenQueue.forEachMatchingBroadcast(BROADCAST_PREDICATE_ANY, (r, i) -> {
            assertEquals("Unexpected state for " + r,
                    BroadcastRecord.DELIVERY_DEFERRED, r.getDeliveryState(i));
        }, false /* andRemove */);
        redQueue.forEachMatchingBroadcast(BROADCAST_PREDICATE_ANY, (r, i) -> {
            assertEquals("Unexpected state for " + r,
                    BroadcastRecord.DELIVERY_PENDING, r.getDeliveryState(i));
        }, false /* andRemove */);

        final Intent packageChanged = new Intent(Intent.ACTION_PACKAGE_CHANGED);
        final BroadcastOptions optionsPackageChanged =
                BroadcastOptions.makeWithDeferUntilActive(true);
        final BroadcastRecord packageChangedRecord = makeBroadcastRecord(packageChanged,
                optionsPackageChanged,
                List.of(makeRegisteredReceiver(greenProcess, 0)), false /* ordered */);
        mImpl.enqueueBroadcastLocked(packageChangedRecord);

        assertEquals(BroadcastProcessQueue.REASON_CACHED_INFINITE_DEFER,
                greenQueue.getRunnableAtReason());
        assertTrue(greenQueue.shouldBeDeferred());
        assertEquals(BroadcastProcessQueue.REASON_NORMAL, redQueue.getRunnableAtReason());
        assertFalse(redQueue.shouldBeDeferred());

        // All broadcasts to the green process, including the newly enqueued one, should be
        // deferred.
        greenQueue.forEachMatchingBroadcast(BROADCAST_PREDICATE_ANY, (r, i) -> {
            assertEquals("Unexpected state for " + r,
                    BroadcastRecord.DELIVERY_DEFERRED, r.getDeliveryState(i));
        }, false /* andRemove */);
        redQueue.forEachMatchingBroadcast(BROADCAST_PREDICATE_ANY, (r, i) -> {
            assertEquals("Unexpected state for " + r,
                    BroadcastRecord.DELIVERY_PENDING, r.getDeliveryState(i));
        }, false /* andRemove */);

        // Simulate process state change
        greenQueue.setProcessAndUidState(greenProcess, false /* uidForeground */,
                false /* processFreezable */);
        greenQueue.updateDeferredStates(mImpl.mBroadcastConsumerDeferApply,
                mImpl.mBroadcastConsumerDeferClear);

        assertEquals(BroadcastProcessQueue.REASON_NORMAL, greenQueue.getRunnableAtReason());
        assertFalse(greenQueue.shouldBeDeferred());
        assertEquals(BroadcastProcessQueue.REASON_NORMAL, redQueue.getRunnableAtReason());
        assertFalse(redQueue.shouldBeDeferred());

        greenQueue.forEachMatchingBroadcast(BROADCAST_PREDICATE_ANY, (r, i) -> {
            assertEquals("Unexpected state for " + r,
                    BroadcastRecord.DELIVERY_PENDING, r.getDeliveryState(i));
        }, false /* andRemove */);
        redQueue.forEachMatchingBroadcast(BROADCAST_PREDICATE_ANY, (r, i) -> {
            assertEquals("Unexpected state for " + r,
                    BroadcastRecord.DELIVERY_PENDING, r.getDeliveryState(i));
        }, false /* andRemove */);
    }

    @EnableFlags(Flags.FLAG_LIMIT_PRIORITY_SCOPE)
    @Test
    public void testDeliveryDeferredForCached_withInfiniteDeferred_changeIdDisabled()
            throws Exception {
+0 −78
Original line number Diff line number Diff line
@@ -77,7 +77,6 @@ import android.os.IBinder;
import android.os.PowerExemptionManager;
import android.os.SystemClock;
import android.os.UserHandle;
import android.platform.test.annotations.DisableFlags;
import android.platform.test.annotations.EnableFlags;
import android.platform.test.annotations.RequiresFlagsEnabled;
import android.util.ArrayMap;
@@ -1585,54 +1584,6 @@ public class BroadcastQueueTest extends BaseBroadcastQueueTest {
        verifyScheduleReceiver(times(1), systemApp, airplane, USER_GUEST);
    }

    /**
     * Verify that when dispatching we respect tranches of priority.
     */
    @DisableFlags(Flags.FLAG_LIMIT_PRIORITY_SCOPE)
    @SuppressWarnings("DistinctVarargsChecker")
    @Test
    public void testPriority_flagDisabled() throws Exception {
        final ProcessRecord callerApp = makeActiveProcessRecord(PACKAGE_RED);
        final ProcessRecord receiverBlueApp = makeActiveProcessRecord(PACKAGE_BLUE);
        final ProcessRecord receiverGreenApp = makeActiveProcessRecord(PACKAGE_GREEN);
        final ProcessRecord receiverYellowApp = makeActiveProcessRecord(PACKAGE_YELLOW);

        // Enqueue a normal broadcast that will go to several processes, and
        // then enqueue a foreground broadcast that risks reordering
        final Intent timezone = new Intent(Intent.ACTION_TIMEZONE_CHANGED);
        final Intent airplane = new Intent(Intent.ACTION_AIRPLANE_MODE_CHANGED);
        airplane.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
        enqueueBroadcast(makeBroadcastRecord(timezone, callerApp,
                List.of(makeRegisteredReceiver(receiverBlueApp, 10),
                        makeRegisteredReceiver(receiverGreenApp, 10),
                        makeManifestReceiver(PACKAGE_BLUE, CLASS_BLUE),
                        makeManifestReceiver(PACKAGE_YELLOW, CLASS_YELLOW),
                        makeRegisteredReceiver(receiverYellowApp, -10))));
        enqueueBroadcast(makeBroadcastRecord(airplane, callerApp,
                List.of(makeRegisteredReceiver(receiverBlueApp))));
        waitForIdle();

        // Ignore the final foreground broadcast
        mScheduledBroadcasts.remove(makeScheduledBroadcast(receiverBlueApp, airplane));
        assertEquals(5, mScheduledBroadcasts.size());

        // We're only concerned about enforcing ordering between tranches;
        // within a tranche we're okay with reordering
        assertEquals(
                Set.of(makeScheduledBroadcast(receiverBlueApp, timezone),
                        makeScheduledBroadcast(receiverGreenApp, timezone)),
                Set.of(mScheduledBroadcasts.remove(0),
                        mScheduledBroadcasts.remove(0)));
        assertEquals(
                Set.of(makeScheduledBroadcast(receiverBlueApp, timezone),
                        makeScheduledBroadcast(receiverYellowApp, timezone)),
                Set.of(mScheduledBroadcasts.remove(0),
                        mScheduledBroadcasts.remove(0)));
        assertEquals(
                Set.of(makeScheduledBroadcast(receiverYellowApp, timezone)),
                Set.of(mScheduledBroadcasts.remove(0)));
    }

    /**
     * Verify that when dispatching we respect tranches of priority.
     */
@@ -1685,7 +1636,6 @@ public class BroadcastQueueTest extends BaseBroadcastQueueTest {
    /**
     * Verify that when dispatching we respect tranches of priority.
     */
    @EnableFlags(Flags.FLAG_LIMIT_PRIORITY_SCOPE)
    @SuppressWarnings("DistinctVarargsChecker")
    @Test
    public void testPriority_changeIdDisabled() throws Exception {
@@ -2492,33 +2442,6 @@ public class BroadcastQueueTest extends BaseBroadcastQueueTest {
                .isLessThan(getReceiverScheduledTime(timeTickRecord, receiverBlue));
    }

    @DisableFlags(Flags.FLAG_LIMIT_PRIORITY_SCOPE)
    @Test
    public void testPrioritizedBroadcastDelivery_uidForeground_flagDisabled() throws Exception {
        final ProcessRecord callerApp = makeActiveProcessRecord(PACKAGE_RED);
        final ProcessRecord receiverBlueApp = makeActiveProcessRecord(PACKAGE_BLUE);
        final ProcessRecord receiverGreenApp = makeActiveProcessRecord(PACKAGE_GREEN);

        mUidObserver.onUidStateChanged(receiverGreenApp.info.uid,
                ActivityManager.PROCESS_STATE_TOP, 0, ActivityManager.PROCESS_CAPABILITY_NONE);
        waitForIdle();

        final Intent timeTick = new Intent(Intent.ACTION_TIME_TICK);

        final BroadcastFilter receiverBlue = makeRegisteredReceiver(receiverBlueApp, 10);
        final BroadcastFilter receiverGreen = makeRegisteredReceiver(receiverGreenApp, 5);
        final BroadcastRecord prioritizedRecord = makeBroadcastRecord(timeTick, callerApp,
                List.of(receiverBlue, receiverGreen));

        enqueueBroadcast(prioritizedRecord);

        waitForIdle();
        // Verify that uid foreground-ness does not impact that delivery of prioritized broadcast.
        // That is, broadcast to receiverBlueApp gets scheduled before the one to receiverGreenApp.
        assertThat(getReceiverScheduledTime(prioritizedRecord, receiverGreen))
                .isGreaterThan(getReceiverScheduledTime(prioritizedRecord, receiverBlue));
    }

    @Test
    public void testOrderedBroadcastDelivery_uidForeground() throws Exception {
        final ProcessRecord callerApp = makeActiveProcessRecord(PACKAGE_RED);
@@ -2546,7 +2469,6 @@ public class BroadcastQueueTest extends BaseBroadcastQueueTest {
                .isGreaterThan(getReceiverScheduledTime(prioritizedRecord, receiverBlue));
    }

    @EnableFlags(Flags.FLAG_LIMIT_PRIORITY_SCOPE)
    @Test
    public void testPrioritizedBroadcastDelivery_uidForeground_changeIdDisabled() throws Exception {
        final ProcessRecord callerApp = makeActiveProcessRecord(PACKAGE_RED);
+0 −103

File changed.

Preview size limit exceeded, changes collapsed.