Merge cherrypicks of [4787603, 4787134, 4787604, 4786834, 4787135, 4787488,... (e94adc9b) · Commits · e / os / android_frameworks_base

core/java/android/database/sqlite/SQLiteDatabase.java

+2 −1

Original line number	Diff line number	Diff line
		@@ -1732,7 +1732,8 @@ public final class SQLiteDatabase extends SQLiteClosable {
		executeSql(sql, bindArgs);
		}

		private int executeSql(String sql, Object[] bindArgs) throws SQLException {
		/** {@hide} */
		public int executeSql(String sql, Object[] bindArgs) throws SQLException {
		acquireReference();
		try {
		if (DatabaseUtils.getSqlStatementType(sql) == DatabaseUtils.STATEMENT_ATTACH) {

core/java/android/database/sqlite/SQLiteQueryBuilder.java

+234 −34

Original line number	Diff line number	Diff line
		@@ -16,17 +16,25 @@

		package android.database.sqlite;

		import android.annotation.NonNull;
		import android.annotation.Nullable;
		import android.content.ContentValues;
		import android.database.Cursor;
		import android.database.DatabaseUtils;
		import android.os.Build;
		import android.os.CancellationSignal;
		import android.os.OperationCanceledException;
		import android.provider.BaseColumns;
		import android.text.TextUtils;
		import android.util.Log;

		import libcore.util.EmptyArray;

		import java.util.Arrays;
		import java.util.Iterator;
		import java.util.Map;
		import java.util.Map.Entry;
		import java.util.Objects;
		import java.util.Set;
		import java.util.regex.Pattern;

		@@ -95,9 +103,6 @@ public class SQLiteQueryBuilder
		if (mWhereClause == null) {
		mWhereClause = new StringBuilder(inWhere.length() + 16);
		}
		if (mWhereClause.length() == 0) {
		mWhereClause.append('(');
		}
		mWhereClause.append(inWhere);
		}

		@@ -115,9 +120,6 @@ public class SQLiteQueryBuilder
		if (mWhereClause == null) {
		mWhereClause = new StringBuilder(inWhere.length() + 16);
		}
		if (mWhereClause.length() == 0) {
		mWhereClause.append('(');
		}
		DatabaseUtils.appendEscapedSQLString(mWhereClause, inWhere);
		}

		@@ -376,6 +378,11 @@ public class SQLiteQueryBuilder
		return null;
		}

		final String sql;
		final String unwrappedSql = buildQuery(
		projectionIn, selection, groupBy, having,
		sortOrder, limit);

		if (mStrict && selection != null && selection.length() > 0) {
		// Validate the user-supplied selection to detect syntactic anomalies
		// in the selection string that could indicate a SQL injection attempt.
		@@ -384,24 +391,166 @@ public class SQLiteQueryBuilder
		// originally specified. An attacker cannot create an expression that
		// would escape the SQL expression while maintaining balanced parentheses
		// in both the wrapped and original forms.
		String sqlForValidation = buildQuery(projectionIn, "(" + selection + ")", groupBy,

		// NOTE: The ordering of the below operations is important; we must
		// execute the wrapped query to ensure the untrusted clause has been
		// fully isolated.

		// Validate the unwrapped query
		db.validateSql(unwrappedSql, cancellationSignal); // will throw if query is invalid

		// Execute wrapped query for extra protection
		final String wrappedSql = buildQuery(projectionIn, wrap(selection), groupBy,
		having, sortOrder, limit);
		db.validateSql(sqlForValidation, cancellationSignal); // will throw if query is invalid
		sql = wrappedSql;
		} else {
		// Execute unwrapped query
		sql = unwrappedSql;
		}

		String sql = buildQuery(
		projectionIn, selection, groupBy, having,
		sortOrder, limit);

		final String[] sqlArgs = selectionArgs;
		if (Log.isLoggable(TAG, Log.DEBUG)) {
		Log.d(TAG, "Performing query: " + sql);
		if (Build.IS_DEBUGGABLE) {
		Log.d(TAG, sql + " with args " + Arrays.toString(sqlArgs));
		} else {
		Log.d(TAG, sql);
		}
		}
		return db.rawQueryWithFactory(
		mFactory, sql, selectionArgs,
		mFactory, sql, sqlArgs,
		SQLiteDatabase.findEditTable(mTables),
		cancellationSignal); // will throw if query is invalid
		}

		/**
		* Perform an update by combining all current settings and the
		* information passed into this method.
		*
		* @param db the database to update on
		* @param selection A filter declaring which rows to return,
		* formatted as an SQL WHERE clause (excluding the WHERE
		* itself). Passing null will return all rows for the given URL.
		* @param selectionArgs You may include ?s in selection, which
		* will be replaced by the values from selectionArgs, in order
		* that they appear in the selection. The values will be bound
		* as Strings.
		* @return the number of rows updated
		* @hide
		*/
		public int update(@NonNull SQLiteDatabase db, @NonNull ContentValues values,
		@Nullable String selection, @Nullable String[] selectionArgs) {
		Objects.requireNonNull(mTables, "No tables defined");
		Objects.requireNonNull(db, "No database defined");
		Objects.requireNonNull(values, "No values defined");

		final String sql;
		final String unwrappedSql = buildUpdate(values, selection);

		if (mStrict) {
		// Validate the user-supplied selection to detect syntactic anomalies
		// in the selection string that could indicate a SQL injection attempt.
		// The idea is to ensure that the selection clause is a valid SQL expression
		// by compiling it twice: once wrapped in parentheses and once as
		// originally specified. An attacker cannot create an expression that
		// would escape the SQL expression while maintaining balanced parentheses
		// in both the wrapped and original forms.

		// NOTE: The ordering of the below operations is important; we must
		// execute the wrapped query to ensure the untrusted clause has been
		// fully isolated.

		// Validate the unwrapped query
		db.validateSql(unwrappedSql, null); // will throw if query is invalid

		// Execute wrapped query for extra protection
		final String wrappedSql = buildUpdate(values, wrap(selection));
		sql = wrappedSql;
		} else {
		// Execute unwrapped query
		sql = unwrappedSql;
		}

		if (selectionArgs == null) {
		selectionArgs = EmptyArray.STRING;
		}
		final String[] rawKeys = values.keySet().toArray(EmptyArray.STRING);
		final int valuesLength = rawKeys.length;
		final Object[] sqlArgs = new Object[valuesLength + selectionArgs.length];
		for (int i = 0; i < sqlArgs.length; i++) {
		if (i < valuesLength) {
		sqlArgs[i] = values.get(rawKeys[i]);
		} else {
		sqlArgs[i] = selectionArgs[i - valuesLength];
		}
		}
		if (Log.isLoggable(TAG, Log.DEBUG)) {
		if (Build.IS_DEBUGGABLE) {
		Log.d(TAG, sql + " with args " + Arrays.toString(sqlArgs));
		} else {
		Log.d(TAG, sql);
		}
		}
		return db.executeSql(sql, sqlArgs);
		}

		/**
		* Perform a delete by combining all current settings and the
		* information passed into this method.
		*
		* @param db the database to delete on
		* @param selection A filter declaring which rows to return,
		* formatted as an SQL WHERE clause (excluding the WHERE
		* itself). Passing null will return all rows for the given URL.
		* @param selectionArgs You may include ?s in selection, which
		* will be replaced by the values from selectionArgs, in order
		* that they appear in the selection. The values will be bound
		* as Strings.
		* @return the number of rows deleted
		* @hide
		*/
		public int delete(@NonNull SQLiteDatabase db, @Nullable String selection,
		@Nullable String[] selectionArgs) {
		Objects.requireNonNull(mTables, "No tables defined");
		Objects.requireNonNull(db, "No database defined");

		final String sql;
		final String unwrappedSql = buildDelete(selection);

		if (mStrict) {
		// Validate the user-supplied selection to detect syntactic anomalies
		// in the selection string that could indicate a SQL injection attempt.
		// The idea is to ensure that the selection clause is a valid SQL expression
		// by compiling it twice: once wrapped in parentheses and once as
		// originally specified. An attacker cannot create an expression that
		// would escape the SQL expression while maintaining balanced parentheses
		// in both the wrapped and original forms.

		// NOTE: The ordering of the below operations is important; we must
		// execute the wrapped query to ensure the untrusted clause has been
		// fully isolated.

		// Validate the unwrapped query
		db.validateSql(unwrappedSql, null); // will throw if query is invalid

		// Execute wrapped query for extra protection
		final String wrappedSql = buildDelete(wrap(selection));
		sql = wrappedSql;
		} else {
		// Execute unwrapped query
		sql = unwrappedSql;
		}

		final String[] sqlArgs = selectionArgs;
		if (Log.isLoggable(TAG, Log.DEBUG)) {
		if (Build.IS_DEBUGGABLE) {
		Log.d(TAG, sql + " with args " + Arrays.toString(sqlArgs));
		} else {
		Log.d(TAG, sql);
		}
		}
		return db.executeSql(sql, sqlArgs);
		}

		/**
		* Construct a SELECT statement suitable for use in a group of
		* SELECT statements that will be joined through UNION operators
		@@ -434,28 +583,10 @@ public class SQLiteQueryBuilder
		String[] projectionIn, String selection, String groupBy,
		String having, String sortOrder, String limit) {
		String[] projection = computeProjection(projectionIn);

		StringBuilder where = new StringBuilder();
		boolean hasBaseWhereClause = mWhereClause != null && mWhereClause.length() > 0;

		if (hasBaseWhereClause) {
		where.append(mWhereClause.toString());
		where.append(')');
		}

		// Tack on the user's selection, if present.
		if (selection != null && selection.length() > 0) {
		if (hasBaseWhereClause) {
		where.append(" AND ");
		}

		where.append('(');
		where.append(selection);
		where.append(')');
		}
		String where = computeWhere(selection);

		return buildQueryString(
		mDistinct, mTables, projection, where.toString(),
		mDistinct, mTables, projection, where,
		groupBy, having, sortOrder, limit);
		}

		@@ -472,6 +603,42 @@ public class SQLiteQueryBuilder
		return buildQuery(projectionIn, selection, groupBy, having, sortOrder, limit);
		}

		/** {@hide} */
		public String buildUpdate(ContentValues values, String selection) {
		if (values == null \|\| values.size() == 0) {
		throw new IllegalArgumentException("Empty values");
		}

		StringBuilder sql = new StringBuilder(120);
		sql.append("UPDATE ");
		sql.append(mTables);
		sql.append(" SET ");

		final String[] rawKeys = values.keySet().toArray(EmptyArray.STRING);
		for (int i = 0; i < rawKeys.length; i++) {
		if (i > 0) {
		sql.append(',');
		}
		sql.append(rawKeys[i]);
		sql.append("=?");
		}

		final String where = computeWhere(selection);
		appendClause(sql, " WHERE ", where);
		return sql.toString();
		}

		/** {@hide} */
		public String buildDelete(String selection) {
		StringBuilder sql = new StringBuilder(120);
		sql.append("DELETE FROM ");
		sql.append(mTables);

		final String where = computeWhere(selection);
		appendClause(sql, " WHERE ", where);
		return sql.toString();
		}

		/**
		* Construct a SELECT statement suitable for use in a group of
		* SELECT statements that will be joined through UNION operators
		@@ -645,4 +812,37 @@ public class SQLiteQueryBuilder
		}
		return null;
		}

		private @Nullable String computeWhere(@Nullable String selection) {
		final boolean hasInternal = !TextUtils.isEmpty(mWhereClause);
		final boolean hasExternal = !TextUtils.isEmpty(selection);

		if (hasInternal \|\| hasExternal) {
		final StringBuilder where = new StringBuilder();
		if (hasInternal) {
		where.append('(').append(mWhereClause).append(')');
		}
		if (hasInternal && hasExternal) {
		where.append(" AND ");
		}
		if (hasExternal) {
		where.append('(').append(selection).append(')');
		}
		return where.toString();
		} else {
		return null;
		}
		}

		/**
		* Wrap given argument in parenthesis, unless it's {@code null} or
		* {@code ()}, in which case return it verbatim.
		*/
		private @Nullable String wrap(@Nullable String arg) {
		if (TextUtils.isEmpty(arg)) {
		return arg;
		} else {
		return "(" + arg + ")";
		}
		}
		}

core/java/android/text/Layout.java

+164 −6

Original line number	Diff line number	Diff line
		@@ -975,6 +975,32 @@ public abstract class Layout {
		return TextUtils.packRangeInLong(0, getLineEnd(line));
		}

		/**
		* Checks if the trailing BiDi level should be used for an offset
		*
		* This method is useful when the offset is at the BiDi level transition point and determine
		* which run need to be used. For example, let's think about following input: (L* denotes
		* Left-to-Right characters, R* denotes Right-to-Left characters.)
		* Input (Logical Order): L1 L2 L3 R1 R2 R3 L4 L5 L6
		* Input (Display Order): L1 L2 L3 R3 R2 R1 L4 L5 L6
		*
		* Then, think about selecting the range (3, 6). The offset=3 and offset=6 are ambiguous here
		* since they are at the BiDi transition point. In Android, the offset is considered to be
		* associated with the trailing run if the BiDi level of the trailing run is higher than of the
		* previous run. In this case, the BiDi level of the input text is as follows:
		*
		* Input (Logical Order): L1 L2 L3 R1 R2 R3 L4 L5 L6
		* BiDi Run: [ Run 0 ][ Run 1 ][ Run 2 ]
		* BiDi Level: 0 0 0 1 1 1 0 0 0
		*
		* Thus, offset = 3 is part of Run 1 and this method returns true for offset = 3, since the BiDi
		* level of Run 1 is higher than the level of Run 0. Similarly, the offset = 6 is a part of Run
		* 1 and this method returns false for the offset = 6 since the BiDi level of Run 1 is higher
		* than the level of Run 2.
		*
		* @returns true if offset is at the BiDi level transition point and trailing BiDi level is
		* higher than previous BiDi level. See above for the detail.
		*/
		private boolean primaryIsTrailingPrevious(int offset) {
		int line = getLineForOffset(offset);
		int lineStart = getLineStart(line);
		@@ -1024,6 +1050,41 @@ public abstract class Layout {
		return levelBefore < levelAt;
		}

		/**
		* Computes in linear time the results of calling
		* #primaryIsTrailingPrevious for all offsets on a line.
		* @param line The line giving the offsets we compute the information for
		* @return The array of results, indexed from 0, where 0 corresponds to the line start offset
		*/
		private boolean[] primaryIsTrailingPreviousAllLineOffsets(int line) {
		int lineStart = getLineStart(line);
		int lineEnd = getLineEnd(line);
		int[] runs = getLineDirections(line).mDirections;

		boolean[] trailing = new boolean[lineEnd - lineStart + 1];

		byte[] level = new byte[lineEnd - lineStart + 1];
		for (int i = 0; i < runs.length; i += 2) {
		int start = lineStart + runs[i];
		int limit = start + (runs[i + 1] & RUN_LENGTH_MASK);
		if (limit > lineEnd) {
		limit = lineEnd;
		}
		level[limit - lineStart - 1] =
		(byte) ((runs[i + 1] >>> RUN_LEVEL_SHIFT) & RUN_LEVEL_MASK);
		}

		for (int i = 0; i < runs.length; i += 2) {
		int start = lineStart + runs[i];
		byte currentLevel = (byte) ((runs[i + 1] >>> RUN_LEVEL_SHIFT) & RUN_LEVEL_MASK);
		trailing[start - lineStart] = currentLevel > (start == lineStart
		? (getParagraphDirection(line) == 1 ? 0 : 1)
		: level[start - lineStart - 1]);
		}

		return trailing;
		}

		/**
		* Get the primary horizontal position for the specified text offset.
		* This is the location where a new character would be inserted in
		@@ -1103,6 +1164,60 @@ public abstract class Layout {
		return getLineStartPos(line, left, right) + wid;
		}

		/**
		* Computes in linear time the results of calling
		* #getHorizontal for all offsets on a line.
		* @param line The line giving the offsets we compute information for
		* @param clamped Whether to clamp the results to the width of the layout
		* @param primary Whether the results should be the primary or the secondary horizontal
		* @return The array of results, indexed from 0, where 0 corresponds to the line start offset
		*/
		private float[] getLineHorizontals(int line, boolean clamped, boolean primary) {
		int start = getLineStart(line);
		int end = getLineEnd(line);
		int dir = getParagraphDirection(line);
		boolean hasTab = getLineContainsTab(line);
		Directions directions = getLineDirections(line);

		TabStops tabStops = null;
		if (hasTab && mText instanceof Spanned) {
		// Just checking this line should be good enough, tabs should be
		// consistent across all lines in a paragraph.
		TabStopSpan[] tabs = getParagraphSpans((Spanned) mText, start, end, TabStopSpan.class);
		if (tabs.length > 0) {
		tabStops = new TabStops(TAB_INCREMENT, tabs); // XXX should reuse
		}
		}

		TextLine tl = TextLine.obtain();
		tl.set(mPaint, mText, start, end, dir, directions, hasTab, tabStops);
		boolean[] trailings = primaryIsTrailingPreviousAllLineOffsets(line);
		if (!primary) {
		for (int offset = 0; offset < trailings.length; ++offset) {
		trailings[offset] = !trailings[offset];
		}
		}
		float[] wid = tl.measureAllOffsets(trailings, null);
		TextLine.recycle(tl);

		if (clamped) {
		for (int offset = 0; offset <= wid.length; ++offset) {
		if (wid[offset] > mWidth) {
		wid[offset] = mWidth;
		}
		}
		}
		int left = getParagraphLeft(line);
		int right = getParagraphRight(line);

		int lineStartPos = getLineStartPos(line, left, right);
		float[] horizontal = new float[end - start + 1];
		for (int offset = 0; offset < horizontal.length; ++offset) {
		horizontal[offset] = lineStartPos + wid[offset];
		}
		return horizontal;
		}

		/**
		* Get the leftmost position that should be exposed for horizontal
		* scrolling on the specified line.
		@@ -1329,6 +1444,8 @@ public abstract class Layout {
		// XXX: we don't care about tabs as we just use TextLine#getOffsetToLeftRightOf here.
		tl.set(mPaint, mText, lineStartOffset, lineEndOffset, getParagraphDirection(line), dirs,
		false, null);
		final HorizontalMeasurementProvider horizontal =
		new HorizontalMeasurementProvider(line, primary);

		final int max;
		if (line == getLineCount() - 1) {
		@@ -1338,7 +1455,7 @@ public abstract class Layout {
		!isRtlCharAt(lineEndOffset - 1)) + lineStartOffset;
		}
		int best = lineStartOffset;
		float bestdist = Math.abs(getHorizontal(best, primary) - horiz);
		float bestdist = Math.abs(horizontal.get(lineStartOffset) - horiz);

		for (int i = 0; i < dirs.mDirections.length; i += 2) {
		int here = lineStartOffset + dirs.mDirections[i];
		@@ -1354,7 +1471,7 @@ public abstract class Layout {
		guess = (high + low) / 2;
		int adguess = getOffsetAtStartOf(guess);

		if (getHorizontal(adguess, primary) * swap >= horiz * swap) {
		if (horizontal.get(adguess) * swap >= horiz * swap) {
		high = guess;
		} else {
		low = guess;
		@@ -1368,9 +1485,9 @@ public abstract class Layout {
		int aft = tl.getOffsetToLeftRightOf(low - lineStartOffset, isRtl) + lineStartOffset;
		low = tl.getOffsetToLeftRightOf(aft - lineStartOffset, !isRtl) + lineStartOffset;
		if (low >= here && low < there) {
		float dist = Math.abs(getHorizontal(low, primary) - horiz);
		float dist = Math.abs(horizontal.get(low) - horiz);
		if (aft < there) {
		float other = Math.abs(getHorizontal(aft, primary) - horiz);
		float other = Math.abs(horizontal.get(aft) - horiz);

		if (other < dist) {
		dist = other;
		@@ -1385,7 +1502,7 @@ public abstract class Layout {
		}
		}

		float dist = Math.abs(getHorizontal(here, primary) - horiz);
		float dist = Math.abs(horizontal.get(here) - horiz);

		if (dist < bestdist) {
		bestdist = dist;
		@@ -1393,7 +1510,7 @@ public abstract class Layout {
		}
		}

		float dist = Math.abs(getHorizontal(max, primary) - horiz);
		float dist = Math.abs(horizontal.get(max) - horiz);

		if (dist <= bestdist) {
		bestdist = dist;
		@@ -1404,6 +1521,47 @@ public abstract class Layout {
		return best;
		}

		/**
		* Responds to #getHorizontal queries, by selecting the better strategy between:
		* - calling #getHorizontal explicitly for each query
		* - precomputing all #getHorizontal measurements, and responding to any query in constant time
		* The first strategy is used for LTR-only text, while the second is used for all other cases.
		* The class is currently only used in #getOffsetForHorizontal, so reuse with care in other
		* contexts.
		*/
		private class HorizontalMeasurementProvider {
		private final int mLine;
		private final boolean mPrimary;

		private float[] mHorizontals;
		private int mLineStartOffset;

		HorizontalMeasurementProvider(final int line, final boolean primary) {
		mLine = line;
		mPrimary = primary;
		init();
		}

		private void init() {
		final Directions dirs = getLineDirections(mLine);
		if (dirs == DIRS_ALL_LEFT_TO_RIGHT) {
		return;
		}

		mHorizontals = getLineHorizontals(mLine, false, mPrimary);
		mLineStartOffset = getLineStart(mLine);
		}

		float get(final int offset) {
		if (mHorizontals == null \|\| offset < mLineStartOffset
		\|\| offset >= mLineStartOffset + mHorizontals.length) {
		return getHorizontal(offset, mPrimary);
		} else {
		return mHorizontals[offset - mLineStartOffset];
		}
		}
		}

		/**
		* Return the text offset after the last character on the specified line.
		*/

core/java/android/text/TextLine.java

+92 −0

File changed.

Preview size limit exceeded, changes collapsed.

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

+12 −5

Original line number	Diff line number	Diff line
		@@ -8841,10 +8841,17 @@ public class ActivityManagerService extends IActivityManager.Stub
		}
		}

		// If we're extending a persistable grant, then we always need to create
		// the grant data structure so that take/release APIs work
		// Figure out the value returned when access is allowed
		final int allowedResult;
		if ((modeFlags & Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION) != 0) {
		return targetUid;
		// If we're extending a persistable grant, then we need to return
		// "targetUid" so that we always create a grant data structure to
		// support take/release APIs
		allowedResult = targetUid;
		} else {
		// Otherwise, we can return "-1" to indicate that no grant data
		// structures need to be created
		allowedResult = -1;
		}

		if (targetUid >= 0) {
		@@ -8853,7 +8860,7 @@ public class ActivityManagerService extends IActivityManager.Stub
		// No need to grant the target this permission.
		if (DEBUG_URI_PERMISSION) Slog.v(TAG_URI_PERMISSION,
		"Target " + targetPkg + " already has full permission to " + grantUri);
		return -1;
		return allowedResult;
		}
		} else {
		// First... there is no target package, so can anyone access it?
		@@ -8869,7 +8876,7 @@ public class ActivityManagerService extends IActivityManager.Stub
		}
		}
		if (allowed) {
		return -1;
		return allowedResult;
		}
		}