Merge "Cleanup com.android.server.am.limit_priority_scope." into main (7cd4858f) · Commits · e / os / android_frameworks_base

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.