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

services/core/java/com/android/server/am/BroadcastRecord.java

+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;

    }

services/core/java/com/android/server/am/broadcasts_flags.aconfig

+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"

services/tests/mockingservicestests/src/com/android/server/am/BroadcastQueueImplTest.java

+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 {

services/tests/mockingservicestests/src/com/android/server/am/BroadcastQueueTest.java

+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);

services/tests/mockingservicestests/src/com/android/server/am/BroadcastRecordTest.java

+0 −103

File changed.

Preview size limit exceeded, changes collapsed.