Merge "Use the processName from ProcessRecord instead of ApplicationInfo" (f26ca17d) · Commits · e / os / android_frameworks_base

apex/jobscheduler/service/java/com/android/server/job/JobSchedulerService.java

+2 −1

Original line number	Diff line number	Diff line
		@@ -2287,7 +2287,8 @@ public class JobSchedulerService extends com.android.server.SystemService
		}

		// Everything else checked out so far, so this is the final yes/no check
		final boolean appIsBad = mActivityManagerInternal.isAppBad(service.applicationInfo);
		final boolean appIsBad = mActivityManagerInternal.isAppBad(
		service.processName, service.applicationInfo.uid);
		if (DEBUG && appIsBad) {
		Slog.i(TAG, "App is bad for " + job.toShortString() + " so not runnable");
		}

core/java/android/app/ActivityManagerInternal.java

+2 −2

Original line number	Diff line number	Diff line
		@@ -387,8 +387,8 @@ public abstract class ActivityManagerInternal {
		/** Returns true if the given uid is the app in the foreground. */
		public abstract boolean isAppForeground(int uid);

		/** Returns true if the given uid is currently marked 'bad' */
		public abstract boolean isAppBad(ApplicationInfo info);
		/** Returns true if the given process name and uid is currently marked 'bad' */
		public abstract boolean isAppBad(String processName, int uid);

		/** Remove pending backup for the given userId. */
		public abstract void clearPendingBackup(@UserIdInt int userId);

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

+4 −4

Original line number	Diff line number	Diff line
		@@ -6012,9 +6012,9 @@ public class ActivityManagerService extends IActivityManager.Stub
		}
		}

		private boolean isAppBad(ApplicationInfo info) {
		private boolean isAppBad(final String processName, final int uid) {
		synchronized (this) {
		return mAppErrors.isBadProcessLocked(info);
		return mAppErrors.isBadProcessLocked(processName, uid);
		}
		}

		@@ -19713,8 +19713,8 @@ public class ActivityManagerService extends IActivityManager.Stub
		}

		@Override
		public boolean isAppBad(ApplicationInfo info) {
		return ActivityManagerService.this.isAppBad(info);
		public boolean isAppBad(final String processName, final int uid) {
		return ActivityManagerService.this.isAppBad(processName, uid);
		}

		@Override

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

+18 −19

Original line number	Diff line number	Diff line
		@@ -33,7 +33,6 @@ import android.app.ApplicationExitInfo;
		import android.content.ActivityNotFoundException;
		import android.content.Context;
		import android.content.Intent;
		import android.content.pm.ApplicationInfo;
		import android.content.pm.VersionedPackage;
		import android.net.Uri;
		import android.os.Binder;
		@@ -263,16 +262,16 @@ class AppErrors {
		return needSep;
		}

		boolean isBadProcessLocked(ApplicationInfo info) {
		return mBadProcesses.get(info.processName, info.uid) != null;
		boolean isBadProcessLocked(final String processName, final int uid) {
		return mBadProcesses.get(processName, uid) != null;
		}

		void clearBadProcessLocked(ApplicationInfo info) {
		mBadProcesses.remove(info.processName, info.uid);
		void clearBadProcessLocked(final String processName, final int uid) {
		mBadProcesses.remove(processName, uid);
		}

		void resetProcessCrashTimeLocked(ApplicationInfo info) {
		mProcessCrashTimes.remove(info.processName, info.uid);
		void resetProcessCrashTimeLocked(final String processName, final int uid) {
		mProcessCrashTimes.remove(processName, uid);
		}

		void resetProcessCrashTimeLocked(boolean resetEntireUser, int appId, int userId) {
		@@ -548,7 +547,7 @@ class AppErrors {
		if (r != null && !r.isolated && res != AppErrorDialog.RESTART) {
		// XXX Can't keep track of crash time for isolated processes,
		// since they don't have a persistent identity.
		mProcessCrashTimes.put(r.info.processName, r.uid,
		mProcessCrashTimes.put(r.processName, r.uid,
		SystemClock.uptimeMillis());
		}
		}
		@@ -695,8 +694,8 @@ class AppErrors {
		boolean tryAgain = false;

		if (!app.isolated) {
		crashTime = mProcessCrashTimes.get(app.info.processName, app.uid);
		crashTimePersistent = mProcessCrashTimesPersistent.get(app.info.processName, app.uid);
		crashTime = mProcessCrashTimes.get(app.processName, app.uid);
		crashTimePersistent = mProcessCrashTimesPersistent.get(app.processName, app.uid);
		} else {
		crashTime = crashTimePersistent = null;
		}
		@@ -723,10 +722,10 @@ class AppErrors {
		if (crashTime != null && now < crashTime + ProcessList.MIN_CRASH_INTERVAL) {
		// The process crashed again very quickly. If it was a bound foreground service, let's
		// try to restart again in a while, otherwise the process loses!
		Slog.w(TAG, "Process " + app.info.processName
		Slog.w(TAG, "Process " + app.processName
		+ " has crashed too many times: killing!");
		EventLog.writeEvent(EventLogTags.AM_PROCESS_CRASHED_TOO_MUCH,
		app.userId, app.info.processName, app.uid);
		app.userId, app.processName, app.uid);
		mService.mAtmInternal.onHandleAppCrash(app.getWindowProcessController());
		if (!app.isPersistent()) {
		// We don't want to start this process again until the user
		@@ -734,13 +733,13 @@ class AppErrors {
		// need to keep it running. If a persistent process is actually
		// repeatedly crashing, then badness for everyone.
		EventLog.writeEvent(EventLogTags.AM_PROC_BAD, app.userId, app.uid,
		app.info.processName);
		app.processName);
		if (!app.isolated) {
		// XXX We don't have a way to mark isolated processes
		// as bad, since they don't have a peristent identity.
		mBadProcesses.put(app.info.processName, app.uid,
		mBadProcesses.put(app.processName, app.uid,
		new BadProcessInfo(now, shortMsg, longMsg, stackTrace));
		mProcessCrashTimes.remove(app.info.processName, app.uid);
		mProcessCrashTimes.remove(app.processName, app.uid);
		}
		app.bad = true;
		app.removed = true;
		@@ -785,8 +784,8 @@ class AppErrors {
		if (!app.isolated) {
		// XXX Can't keep track of crash times for isolated processes,
		// because they don't have a persistent identity.
		mProcessCrashTimes.put(app.info.processName, app.uid, now);
		mProcessCrashTimesPersistent.put(app.info.processName, app.uid, now);
		mProcessCrashTimes.put(app.processName, app.uid, now);
		mProcessCrashTimesPersistent.put(app.processName, app.uid, now);
		}

		if (app.crashHandler != null) mService.mHandler.post(app.crashHandler);
		@@ -829,7 +828,7 @@ class AppErrors {
		}
		Long crashShowErrorTime = null;
		if (!proc.isolated) {
		crashShowErrorTime = mProcessCrashShowDialogTimes.get(proc.info.processName,
		crashShowErrorTime = mProcessCrashShowDialogTimes.get(proc.processName,
		proc.uid);
		}
		final boolean showFirstCrash = Settings.Global.getInt(
		@@ -850,7 +849,7 @@ class AppErrors {
		&& (showFirstCrash \|\| showFirstCrashDevOption \|\| data.repeating)) {
		proc.getDialogController().showCrashDialogs(data);
		if (!proc.isolated) {
		mProcessCrashShowDialogTimes.put(proc.info.processName, proc.uid, now);
		mProcessCrashShowDialogTimes.put(proc.processName, proc.uid, now);
		}
		} else {
		// The device is asleep, so just pretend that the user

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

+6 −6

Original line number	Diff line number	Diff line
		@@ -2359,9 +2359,9 @@ public final class ProcessList {
		if ((intentFlags & Intent.FLAG_FROM_BACKGROUND) != 0) {
		// If we are in the background, then check to see if this process
		// is bad. If so, we will just silently fail.
		if (mService.mAppErrors.isBadProcessLocked(info)) {
		if (mService.mAppErrors.isBadProcessLocked(processName, info.uid)) {
		if (DEBUG_PROCESSES) Slog.v(TAG, "Bad process: " + info.uid
		+ "/" + info.processName);
		+ "/" + processName);
		return null;
		}
		} else {
		@@ -2370,13 +2370,13 @@ public final class ProcessList {
		// least one crash dialog again, and make the process good again
		// if it had been bad.
		if (DEBUG_PROCESSES) Slog.v(TAG, "Clearing bad process: " + info.uid
		+ "/" + info.processName);
		mService.mAppErrors.resetProcessCrashTimeLocked(info);
		if (mService.mAppErrors.isBadProcessLocked(info)) {
		+ "/" + processName);
		mService.mAppErrors.resetProcessCrashTimeLocked(processName, info.uid);
		if (mService.mAppErrors.isBadProcessLocked(processName, info.uid)) {
		EventLog.writeEvent(EventLogTags.AM_PROC_GOOD,
		UserHandle.getUserId(info.uid), info.uid,
		info.processName);
		mService.mAppErrors.clearBadProcessLocked(info);
		mService.mAppErrors.clearBadProcessLocked(processName, info.uid);
		if (app != null) {
		app.bad = false;
		}