Import Android SDK Platform P [4524038]

/google/data/ro/projects/android/fetch_artifact \
    --bid 4524038 \
    --target sdk_phone_armv7-win_sdk \
    sdk-repo-linux-sources-4524038.zip

AndroidVersion.ApiLevel has been modified to appear as 28

Change-Id: Ic193bf1cf0cae78d4f2bfb4fbddfe42025c5c3c2

4 files changed, 149 insertions, 1 deletions

diff --git a/android/database/sqlite/SQLiteCompatibilityWalFlags.java b/android/database/sqlite/SQLiteCompatibilityWalFlags.java
new file mode 100644
index 00000000..5bf3a7c4
--- /dev/null
+++ b/android/database/sqlite/SQLiteCompatibilityWalFlags.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.database.sqlite;
+
+import android.app.ActivityThread;
+import android.app.Application;
+import android.provider.Settings;
+import android.text.TextUtils;
+import android.util.KeyValueListParser;
+import android.util.Log;
+
+import com.android.internal.annotations.VisibleForTesting;
+
+/**
+ * Helper class for accessing
+ * {@link Settings.Global#SQLITE_COMPATIBILITY_WAL_FLAGS global compatibility WAL settings}.
+ *
+ * <p>The value of {@link Settings.Global#SQLITE_COMPATIBILITY_WAL_FLAGS} is cached on first access
+ * for consistent behavior across all connections opened in the process.
+ * @hide
+ */
+public class SQLiteCompatibilityWalFlags {
+
+    private static final String TAG = "SQLiteCompatibilityWalFlags";
+
+    private static volatile boolean sInitialized;
+    private static volatile boolean sFlagsSet;
+    private static volatile boolean sCompatibilityWalSupported;
+    private static volatile String sWALSyncMode;
+    // This flag is used to avoid recursive initialization due to circular dependency on Settings
+    private static volatile boolean sCallingGlobalSettings;
+
+    /**
+     * @hide
+     */
+    @VisibleForTesting
+    public static boolean areFlagsSet() {
+        initIfNeeded();
+        return sFlagsSet;
+    }
+
+    /**
+     * @hide
+     */
+    @VisibleForTesting
+    public static boolean isCompatibilityWalSupported() {
+        initIfNeeded();
+        return sCompatibilityWalSupported;
+    }
+
+    /**
+     * @hide
+     */
+    @VisibleForTesting
+    public static String getWALSyncMode() {
+        initIfNeeded();
+        return sWALSyncMode;
+    }
+
+    private static void initIfNeeded() {
+        if (sInitialized || sCallingGlobalSettings) {
+            return;
+        }
+        ActivityThread activityThread = ActivityThread.currentActivityThread();
+        Application app = activityThread == null ? null : activityThread.getApplication();
+        String flags = null;
+        if (app == null) {
+            Log.w(TAG, "Cannot read global setting "
+                    + Settings.Global.SQLITE_COMPATIBILITY_WAL_FLAGS + " - "
+                    + "Application state not available");
+        } else {
+            try {
+                sCallingGlobalSettings = true;
+                flags = Settings.Global.getString(app.getContentResolver(),
+                        Settings.Global.SQLITE_COMPATIBILITY_WAL_FLAGS);
+            } finally {
+                sCallingGlobalSettings = false;
+            }
+        }
+
+        init(flags);
+    }
+
+    /**
+     * @hide
+     */
+    @VisibleForTesting
+    public static void init(String flags) {
+        if (TextUtils.isEmpty(flags)) {
+            sInitialized = true;
+            return;
+        }
+        KeyValueListParser parser = new KeyValueListParser(',');
+        try {
+            parser.setString(flags);
+        } catch (IllegalArgumentException e) {
+            Log.e(TAG, "Setting has invalid format: " + flags, e);
+            sInitialized = true;
+            return;
+        }
+        sCompatibilityWalSupported = parser.getBoolean("compatibility_wal_supported",
+                SQLiteGlobal.isCompatibilityWalSupported());
+        sWALSyncMode = parser.getString("wal_syncmode", SQLiteGlobal.getWALSyncMode());
+        Log.i(TAG, "Read compatibility WAL flags: compatibility_wal_supported="
+                + sCompatibilityWalSupported + ", wal_syncmode=" + sWALSyncMode);
+        sFlagsSet = true;
+        sInitialized = true;
+    }
+
+    /**
+     * @hide
+     */
+    @VisibleForTesting
+    public static void reset() {
+        sInitialized = false;
+        sFlagsSet = false;
+        sCompatibilityWalSupported = false;
+        sWALSyncMode = null;
+    }
+}
diff --git a/android/database/sqlite/SQLiteConnection.java b/android/database/sqlite/SQLiteConnection.java
index 2c93a7fe..7717b8d3 100644
--- a/android/database/sqlite/SQLiteConnection.java
+++ b/android/database/sqlite/SQLiteConnection.java
@@ -296,7 +296,11 @@ public final class SQLiteConnection implements CancellationSignal.OnCancelListen
                     && mConfiguration.syncMode == null && mConfiguration.useCompatibilityWal;
             if (walEnabled || useCompatibilityWal) {
                 setJournalMode("WAL");
-                setSyncMode(SQLiteGlobal.getWALSyncMode());
+                if (useCompatibilityWal && SQLiteCompatibilityWalFlags.areFlagsSet()) {
+                    setSyncMode(SQLiteCompatibilityWalFlags.getWALSyncMode());
+                } else {
+                    setSyncMode(SQLiteGlobal.getWALSyncMode());
+                }
             } else {
                 setJournalMode(mConfiguration.journalMode == null
                         ? SQLiteGlobal.getDefaultJournalMode() : mConfiguration.journalMode);
diff --git a/android/database/sqlite/SQLiteConnectionPool.java b/android/database/sqlite/SQLiteConnectionPool.java
index 5adb1196..b2117003 100644
--- a/android/database/sqlite/SQLiteConnectionPool.java
+++ b/android/database/sqlite/SQLiteConnectionPool.java
@@ -1094,6 +1094,12 @@ public final class SQLiteConnectionPool implements Closeable {
             printer.println("  Open: " + mIsOpen);
             printer.println("  Max connections: " + mMaxConnectionPoolSize);
             printer.println("  Total execution time: " + mTotalExecutionTimeCounter);
+            if (SQLiteCompatibilityWalFlags.areFlagsSet()) {
+                printer.println("  Compatibility WAL settings: compatibility_wal_supported="
+                        + SQLiteCompatibilityWalFlags
+                        .isCompatibilityWalSupported() + ", wal_syncmode="
+                        + SQLiteCompatibilityWalFlags.getWALSyncMode());
+            }
             if (mConfiguration.isLookasideConfigSet()) {
                 printer.println("  Lookaside config: sz=" + mConfiguration.lookasideSlotSize
                         + " cnt=" + mConfiguration.lookasideSlotCount);
diff --git a/android/database/sqlite/SQLiteDatabase.java b/android/database/sqlite/SQLiteDatabase.java
index 09bb9c69..c1c0812e 100644
--- a/android/database/sqlite/SQLiteDatabase.java
+++ b/android/database/sqlite/SQLiteDatabase.java
@@ -289,6 +289,10 @@ public final class SQLiteDatabase extends SQLiteClosable {
         mConfigurationLocked.journalMode = journalMode;
         mConfigurationLocked.syncMode = syncMode;
         mConfigurationLocked.useCompatibilityWal = SQLiteGlobal.isCompatibilityWalSupported();
+        if (!mConfigurationLocked.isInMemoryDb() && SQLiteCompatibilityWalFlags.areFlagsSet()) {
+            mConfigurationLocked.useCompatibilityWal = SQLiteCompatibilityWalFlags
+                    .isCompatibilityWalSupported();
+        }
     }
 
     @Override