Merge "Prefer arrays or precisely-sized ArrayLists where possible" into main (c787bd61) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/accounts/AccountManagerBackupHelper.java

+7 −5

Original line number	Diff line number	Diff line
		@@ -152,9 +152,9 @@ public final class AccountManagerBackupHelper {
		.getUserAccounts(userId);
		synchronized (accounts.dbLock) {
		synchronized (accounts.cacheLock) {
		List<Pair<String, Integer>> allAccountGrants = accounts.accountsDb
		Pair<String[], int[]> allAccountGrants = accounts.accountsDb
		.findAllAccountGrants();
		if (allAccountGrants.isEmpty()) {
		if (allAccountGrants.first == null \|\| allAccountGrants.first.length == 0) {
		return null;
		}
		try {
		@@ -166,9 +166,11 @@ public final class AccountManagerBackupHelper {

		PackageManager packageManager = mAccountManagerService.mContext
		.getPackageManager();
		for (Pair<String, Integer> grant : allAccountGrants) {
		final String accountName = grant.first;
		final int uid = grant.second;
		final String[] accountNames = allAccountGrants.first;
		final int[] uids = allAccountGrants.second;
		for (int i = 0; i < accountNames.length; i++) {
		final String accountName = accountNames[i];
		final int uid = uids[i];

		final String[] packageNames = packageManager.getPackagesForUid(uid);
		if (packageNames == null) {

services/core/java/com/android/server/accounts/AccountManagerService.java

+2 −6

Original line number	Diff line number	Diff line
		@@ -1520,9 +1520,8 @@ public class AccountManagerService
		private void purgeOldGrants(UserAccounts accounts) {
		synchronized (accounts.dbLock) {
		synchronized (accounts.cacheLock) {
		List<Integer> uids;
		try {
		uids = accounts.accountsDb.findAllUidGrants();
		int[] uids = accounts.accountsDb.findAllUidGrants();
		for (int uid : uids) {
		boolean packageExists = mPackageManager.getPackagesForUid(uid) != null;
		if (packageExists) {
		@@ -4843,10 +4842,7 @@ public class AccountManagerService
		try {
		UserAccounts accounts = getUserAccounts(userId);
		synchronized (accounts.dbLock) {
		List<Account> accountList = accounts.accountsDb.getSharedAccounts();
		Account[] accountArray = new Account[accountList.size()];
		accountList.toArray(accountArray);
		return accountArray;
		return accounts.accountsDb.getSharedAccounts();
		}
		} catch (SQLiteException e) {
		Log.w(TAG, "Could not get shared accounts for user " + userId, e);

services/core/java/com/android/server/accounts/AccountsDb.java

+25 −38

Original line number	Diff line number	Diff line
		@@ -724,27 +724,17 @@ class AccountsDb implements AutoCloseable {
		new String[] {account.name, account.type});
		}

		List<Account> getSharedAccounts() {
		Account[] getSharedAccounts() {
		SQLiteDatabase db = mDeDatabase.getReadableDatabase();
		ArrayList<Account> accountList = new ArrayList<>();
		Cursor cursor = null;
		try {
		cursor = db.query(TABLE_SHARED_ACCOUNTS, new String[] {ACCOUNTS_NAME, ACCOUNTS_TYPE},
		null, null, null, null, null);
		if (cursor != null && cursor.moveToFirst()) {
		int nameIndex = cursor.getColumnIndex(ACCOUNTS_NAME);
		int typeIndex = cursor.getColumnIndex(ACCOUNTS_TYPE);
		do {
		accountList.add(new Account(cursor.getString(nameIndex),
		cursor.getString(typeIndex)));
		} while (cursor.moveToNext());
		}
		} finally {
		if (cursor != null) {
		cursor.close();
		try (Cursor cursor = db.query(TABLE_SHARED_ACCOUNTS, new String[] {ACCOUNTS_NAME, ACCOUNTS_TYPE},
		null, null, null, null, null)) {
		Account[] accounts = new Account[cursor.getCount()];
		int i = 0;
		while (cursor.moveToNext()) {
		accounts[i++] = new Account(cursor.getString(0), cursor.getString(1));
		}
		return accounts;
		}
		return accountList;
		}

		long findSharedAccountId(Account account) {
		@@ -874,22 +864,19 @@ class AccountsDb implements AutoCloseable {
		new String[] {String.valueOf(accountId), authTokenType, String.valueOf(uid)}) > 0;
		}

		List<Integer> findAllUidGrants() {
		int[] findAllUidGrants() {
		SQLiteDatabase db = mDeDatabase.getReadableDatabase();
		List<Integer> result = new ArrayList<>();
		final Cursor cursor = db.query(TABLE_GRANTS,
		try (Cursor cursor = db.query(TABLE_GRANTS,
		new String[]{GRANTS_GRANTEE_UID},
		null, null, GRANTS_GRANTEE_UID, null, null);
		try {
		null, null, GRANTS_GRANTEE_UID, null, null)) {
		int[] result = new int[cursor.getCount()];
		int index = 0;
		while (cursor.moveToNext()) {
		final int uid = cursor.getInt(0);
		result.add(uid);
		}
		} finally {
		cursor.close();
		result[index++] = cursor.getInt(0);
		}
		return result;
		}
		}

		long findMatchingGrantsCount(int uid, String authTokenType, Account account) {
		SQLiteDatabase db = mDeDatabase.getReadableDatabase();
		@@ -1087,19 +1074,19 @@ class AccountsDb implements AutoCloseable {
		/**
		* Returns list of all grants as {@link Pair pairs} of account name and UID.
		*/
		List<Pair<String, Integer>> findAllAccountGrants() {
		Pair<String[], int[]> findAllAccountGrants() {
		SQLiteDatabase db = mDeDatabase.getReadableDatabase();
		try (Cursor cursor = db.rawQuery(ACCOUNT_ACCESS_GRANTS, null)) {
		if (cursor == null \|\| !cursor.moveToFirst()) {
		return Collections.emptyList();
		}
		List<Pair<String, Integer>> results = new ArrayList<>();
		do {
		final String accountName = cursor.getString(0);
		final int uid = cursor.getInt(1);
		results.add(Pair.create(accountName, uid));
		} while (cursor.moveToNext());
		return results;
		final int count = cursor.getCount();
		String[] accountNames = new String[count];
		int[] uids = new int[count];
		int i = 0;
		while (cursor.moveToNext()) {
		accountNames[i] = cursor.getString(0);
		uids[i] = cursor.getInt(1);
		i++;
		}
		return Pair.create(accountNames, uids);
		}
		}

services/tests/servicestests/src/com/android/server/accounts/AccountsDbTest.java

+9 −10

Original line number	Diff line number	Diff line
		@@ -222,8 +222,8 @@ public class AccountsDbTest {
		int testUid = 100500;
		long grantId = mAccountsDb.insertGrant(accId, "tokenType", testUid);
		assertTrue(grantId > 0);
		List<Integer> allUidGrants = mAccountsDb.findAllUidGrants();
		List<Integer> expectedUids = Arrays.asList(testUid);
		int[] allUidGrants = mAccountsDb.findAllUidGrants();
		int[] expectedUids = new int[]{testUid};
		assertEquals(expectedUids, allUidGrants);

		long matchingGrantsCount = mAccountsDb.findMatchingGrantsCount(
		@@ -237,14 +237,14 @@ public class AccountsDbTest {
		matchingGrantsCount = mAccountsDb.findMatchingGrantsCountAnyToken(testUid, account);
		assertEquals(1, matchingGrantsCount);

		List<Pair<String, Integer>> allAccountGrants = mAccountsDb.findAllAccountGrants();
		assertEquals(1, allAccountGrants.size());
		assertEquals(account.name, allAccountGrants.get(0).first);
		assertEquals(testUid, (int)allAccountGrants.get(0).second);
		Pair<String[], int[]> allAccountGrants = mAccountsDb.findAllAccountGrants();
		assertEquals(1, allAccountGrants.first.length);
		assertEquals(account.name, allAccountGrants.first[0]);
		assertEquals(testUid, allAccountGrants.second[0]);

		mAccountsDb.deleteGrantsByUid(testUid);
		allUidGrants = mAccountsDb.findAllUidGrants();
		assertTrue("Test grants should be removed", allUidGrants.isEmpty());
		assertEquals("Test grants should be removed", new int[]{}, allUidGrants);
		}

		@Test
		@@ -255,9 +255,8 @@ public class AccountsDbTest {
		long sharedAccId = mAccountsDb.insertSharedAccount(account);
		long foundSharedAccountId = mAccountsDb.findSharedAccountId(account);
		assertEquals(sharedAccId, foundSharedAccountId);
		List<Account> sharedAccounts = mAccountsDb.getSharedAccounts();
		List<Account> expectedList = Arrays.asList(account);
		assertEquals(expectedList, sharedAccounts);
		Account[] sharedAccounts = mAccountsDb.getSharedAccounts();
		assertEquals(new Account[] {account}, sharedAccounts);

		// Delete and verify
		mAccountsDb.deleteSharedAccount(account);