The Tor Browser: comparison mobile/android/base/db/SQLiteBridgeContentProvider.java

--1:000000000000
+:e465aa16b1be
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this file,
+* You can obtain one at http://mozilla.org/MPL/2.0/. */
+package org.mozilla.gecko.db;
+import java.io.File;
+import java.util.HashMap;
+import org.mozilla.gecko.GeckoProfile;
+import org.mozilla.gecko.GeckoThread;
+import org.mozilla.gecko.Telemetry;
+import org.mozilla.gecko.mozglue.GeckoLoader;
+import org.mozilla.gecko.sqlite.SQLiteBridge;
+import org.mozilla.gecko.sqlite.SQLiteBridgeException;
+import android.content.ContentProvider;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.net.Uri;
+import android.text.TextUtils;
+import android.util.Log;
+/*
+* Provides a basic ContentProvider that sets up and sends queries through
+* SQLiteBridge. Content providers should extend this by setting the appropriate
+* table and version numbers in onCreate, and implementing the abstract methods:
+*
+*  public abstract String getTable(Uri uri);
+*  public abstract String getSortOrder(Uri uri, String aRequested);
+*  public abstract void setupDefaults(Uri uri, ContentValues values);
+*  public abstract void initGecko();
+*/
+public abstract class SQLiteBridgeContentProvider extends ContentProvider {
+private static final String ERROR_MESSAGE_DATABASE_IS_LOCKED = "Can't step statement: (5) database is locked";
+private HashMap<String, SQLiteBridge> mDatabasePerProfile;
+protected Context mContext = null;
+private final String mLogTag;
+protected SQLiteBridgeContentProvider(String logTag) {
+mLogTag = logTag;
+}
+/**
+* Subclasses must override this to allow error reporting code to compose
+* the correct histogram name.
+*
+* Ensure that you define the new histograms if you define a new class!
+*/
+protected abstract String getTelemetryPrefix();
+/**
+* Errors are recorded in telemetry using an enumerated histogram.
+*
+* <https://developer.mozilla.org/en-US/docs/Mozilla/Performance/
+* Adding_a_new_Telemetry_probe#Choosing_a_Histogram_Type>
+*
+* These are the allowable enumeration values. Keep these in sync with the
+* histogram definition!
+*
+*/
+private static enum TelemetryErrorOp {
+BULKINSERT (0),
+DELETE     (1),
+INSERT     (2),
+QUERY      (3),
+UPDATE     (4);
+private final int bucket;
+TelemetryErrorOp(final int bucket) {
+this.bucket = bucket;
+}
+public int getBucket() {
+return bucket;
+}
+}
+@Override
+public void shutdown() {
+if (mDatabasePerProfile == null) {
+return;
+}
+synchronized (this) {
+for (SQLiteBridge bridge : mDatabasePerProfile.values()) {
+if (bridge != null) {
+try {
+bridge.close();
+} catch (Exception ex) { }
+}
+}
+mDatabasePerProfile = null;
+}
+}
+@Override
+public void finalize() {
+shutdown();
+}
+/**
+* Return true of the query is from Firefox Sync.
+* @param uri query URI
+*/
+public static boolean isCallerSync(Uri uri) {
+String isSync = uri.getQueryParameter(BrowserContract.PARAM_IS_SYNC);
+return !TextUtils.isEmpty(isSync);
+}
+private SQLiteBridge getDB(Context context, final String databasePath) {
+SQLiteBridge bridge = null;
+boolean dbNeedsSetup = true;
+try {
+String resourcePath = context.getPackageResourcePath();
+GeckoLoader.loadSQLiteLibs(context, resourcePath);
+GeckoLoader.loadNSSLibs(context, resourcePath);
+bridge = SQLiteBridge.openDatabase(databasePath, null, 0);
+int version = bridge.getVersion();
+dbNeedsSetup = version != getDBVersion();
+} catch (SQLiteBridgeException ex) {
+// close the database
+if (bridge != null) {
+bridge.close();
+}
+// this will throw if the database can't be found
+// we should attempt to set it up if Gecko is running
+dbNeedsSetup = true;
+Log.e(mLogTag, "Error getting version ", ex);
+// if Gecko is not running, we should bail out. Otherwise we try to
+// let Gecko build the database for us
+if (!GeckoThread.checkLaunchState(GeckoThread.LaunchState.GeckoRunning)) {
+Log.e(mLogTag, "Can not set up database. Gecko is not running");
+return null;
+}
+}
+// If the database is not set up yet, or is the wrong schema version, we send an initialize
+// call to Gecko. Gecko will handle building the database file correctly, as well as any
+// migrations that are necessary
+if (dbNeedsSetup) {
+bridge = null;
+initGecko();
+}
+return bridge;
+}
+/**
+* Returns the absolute path of a database file depending on the specified profile and dbName.
+* @param profile
+*          the profile whose dbPath must be returned
+* @param dbName
+*          the name of the db file whose absolute path must be returned
+* @return the absolute path of the db file or <code>null</code> if it was not possible to retrieve a valid path
+*
+*/
+private String getDatabasePathForProfile(String profile, String dbName) {
+// Depends on the vagaries of GeckoProfile.get, so null check for safety.
+File profileDir = GeckoProfile.get(mContext, profile).getDir();
+if (profileDir == null) {
+return null;
+}
+String databasePath = new File(profileDir, dbName).getAbsolutePath();
+return databasePath;
+}
+/**
+* Returns a SQLiteBridge object according to the specified profile id and to the name of db related to the
+* current provider instance.
+* @param profile
+*          the id of the profile to be used to retrieve the related SQLiteBridge
+* @return the <code>SQLiteBridge</code> related to the specified profile id or <code>null</code> if it was
+*         not possible to retrieve a valid SQLiteBridge
+*/
+private SQLiteBridge getDatabaseForProfile(String profile) {
+if (TextUtils.isEmpty(profile)) {
+profile = GeckoProfile.get(mContext).getName();
+Log.d(mLogTag, "No profile provided, using '" + profile + "'");
+}
+final String dbName = getDBName();
+String mapKey = profile + "/" + dbName;
+SQLiteBridge db = null;
+synchronized (this) {
+db = mDatabasePerProfile.get(mapKey);
+if (db != null) {
+return db;
+}
+final String dbPath = getDatabasePathForProfile(profile, dbName);
+if (dbPath == null) {
+Log.e(mLogTag, "Failed to get a valid db path for profile '" + profile + "'' dbName '" + dbName + "'");
+return null;
+}
+db = getDB(mContext, dbPath);
+if (db != null) {
+mDatabasePerProfile.put(mapKey, db);
+}
+}
+return db;
+}
+/**
+* Returns a SQLiteBridge object according to the specified profile path and to the name of db related to the
+* current provider instance.
+* @param profilePath
+*          the profilePath to be used to retrieve the related SQLiteBridge
+* @return the <code>SQLiteBridge</code> related to the specified profile path or <code>null</code> if it was
+*         not possible to retrieve a valid <code>SQLiteBridge</code>
+*/
+private SQLiteBridge getDatabaseForProfilePath(String profilePath) {
+File profileDir = new File(profilePath, getDBName());
+final String dbPath = profileDir.getPath();
+return getDatabaseForDBPath(dbPath);
+}
+/**
+* Returns a SQLiteBridge object according to the specified file path.
+* @param dbPath
+*          the path of the file to be used to retrieve the related SQLiteBridge
+* @return the <code>SQLiteBridge</code> related to the specified file path or <code>null</code> if it was
+*         not possible to retrieve a valid <code>SQLiteBridge</code>
+*
+*/
+private SQLiteBridge getDatabaseForDBPath(String dbPath) {
+SQLiteBridge db = null;
+synchronized (this) {
+db = mDatabasePerProfile.get(dbPath);
+if (db != null) {
+return db;
+}
+db = getDB(mContext, dbPath);
+if (db != null) {
+mDatabasePerProfile.put(dbPath, db);
+}
+}
+return db;
+}
+/**
+* Returns a SQLiteBridge object to be used to perform operations on the given <code>Uri</code>.
+* @param uri
+*          the <code>Uri</code> to be used to retrieve the related SQLiteBridge
+* @return a <code>SQLiteBridge</code> object to be used on the given uri or <code>null</code> if it was
+*         not possible to retrieve a valid <code>SQLiteBridge</code>
+*
+*/
+private SQLiteBridge getDatabase(Uri uri) {
+String profile = null;
+String profilePath = null;
+profile = uri.getQueryParameter(BrowserContract.PARAM_PROFILE);
+profilePath = uri.getQueryParameter(BrowserContract.PARAM_PROFILE_PATH);
+// Testing will specify the absolute profile path
+if (profilePath != null) {
+return getDatabaseForProfilePath(profilePath);
+}
+return getDatabaseForProfile(profile);
+}
+@Override
+public boolean onCreate() {
+mContext = getContext();
+synchronized (this) {
+mDatabasePerProfile = new HashMap<String, SQLiteBridge>();
+}
+return true;
+}
+@Override
+public String getType(Uri uri) {
+return null;
+}
+@Override
+public int delete(Uri uri, String selection, String[] selectionArgs) {
+int deleted = 0;
+final SQLiteBridge db = getDatabase(uri);
+if (db == null) {
+return deleted;
+}
+try {
+deleted = db.delete(getTable(uri), selection, selectionArgs);
+} catch (SQLiteBridgeException ex) {
+reportError(ex, TelemetryErrorOp.DELETE);
+throw ex;
+}
+return deleted;
+}
+@Override
+public Uri insert(Uri uri, ContentValues values) {
+long id = -1;
+final SQLiteBridge db = getDatabase(uri);
+// If we can not get a SQLiteBridge instance, its likely that the database
+// has not been set up and Gecko is not running. We return null and expect
+// callers to try again later
+if (db == null) {
+return null;
+}
+setupDefaults(uri, values);
+boolean useTransaction = !db.inTransaction();
+try {
+if (useTransaction) {
+db.beginTransaction();
+}
+// onPreInsert does a check for the item in the deleted table in some cases
+// so we put it inside this transaction
+onPreInsert(values, uri, db);
+id = db.insert(getTable(uri), null, values);
+if (useTransaction) {
+db.setTransactionSuccessful();
+}
+} catch (SQLiteBridgeException ex) {
+reportError(ex, TelemetryErrorOp.INSERT);
+throw ex;
+} finally {
+if (useTransaction) {
+db.endTransaction();
+}
+}
+return ContentUris.withAppendedId(uri, id);
+}
+@Override
+public int bulkInsert(Uri uri, ContentValues[] allValues) {
+final SQLiteBridge db = getDatabase(uri);
+// If we can not get a SQLiteBridge instance, its likely that the database
+// has not been set up and Gecko is not running. We return 0 and expect
+// callers to try again later
+if (db == null) {
+return 0;
+}
+int rowsAdded = 0;
+String table = getTable(uri);
+try {
+db.beginTransaction();
+for (ContentValues initialValues : allValues) {
+ContentValues values = new ContentValues(initialValues);
+setupDefaults(uri, values);
+onPreInsert(values, uri, db);
+db.insert(table, null, values);
+rowsAdded++;
+}
+db.setTransactionSuccessful();
+} catch (SQLiteBridgeException ex) {
+reportError(ex, TelemetryErrorOp.BULKINSERT);
+throw ex;
+} finally {
+db.endTransaction();
+}
+if (rowsAdded > 0) {
+final boolean shouldSyncToNetwork = !isCallerSync(uri);
+mContext.getContentResolver().notifyChange(uri, null, shouldSyncToNetwork);
+}
+return rowsAdded;
+}
+@Override
+public int update(Uri uri, ContentValues values, String selection,
+String[] selectionArgs) {
+int updated = 0;
+final SQLiteBridge db = getDatabase(uri);
+// If we can not get a SQLiteBridge instance, its likely that the database
+// has not been set up and Gecko is not running. We return null and expect
+// callers to try again later
+if (db == null) {
+return updated;
+}
+onPreUpdate(values, uri, db);
+try {
+updated = db.update(getTable(uri), values, selection, selectionArgs);
+} catch (SQLiteBridgeException ex) {
+reportError(ex, TelemetryErrorOp.UPDATE);
+throw ex;
+}
+return updated;
+}
+@Override
+public Cursor query(Uri uri, String[] projection, String selection,
+String[] selectionArgs, String sortOrder) {
+Cursor cursor = null;
+final SQLiteBridge db = getDatabase(uri);
+// If we can not get a SQLiteBridge instance, its likely that the database
+// has not been set up and Gecko is not running. We return null and expect
+// callers to try again later
+if (db == null) {
+return cursor;
+}
+sortOrder = getSortOrder(uri, sortOrder);
+try {
+cursor = db.query(getTable(uri), projection, selection, selectionArgs, null, null, sortOrder, null);
+onPostQuery(cursor, uri, db);
+} catch (SQLiteBridgeException ex) {
+reportError(ex, TelemetryErrorOp.QUERY);
+throw ex;
+}
+return cursor;
+}
+private String getHistogram(SQLiteBridgeException e) {
+// If you add values here, make sure to update
+// toolkit/components/telemetry/Histograms.json.
+if (ERROR_MESSAGE_DATABASE_IS_LOCKED.equals(e.getMessage())) {
+return getTelemetryPrefix() + "_LOCKED";
+}
+return null;
+}
+protected void reportError(SQLiteBridgeException e, TelemetryErrorOp op) {
+Log.e(mLogTag, "Error in database " + op.name(), e);
+final String histogram = getHistogram(e);
+if (histogram == null) {
+return;
+}
+Telemetry.HistogramAdd(histogram, op.getBucket());
+}
+protected abstract String getDBName();
+protected abstract int getDBVersion();
+protected abstract String getTable(Uri uri);
+protected abstract String getSortOrder(Uri uri, String aRequested);
+protected abstract void setupDefaults(Uri uri, ContentValues values);
+protected abstract void initGecko();
+protected abstract void onPreInsert(ContentValues values, Uri uri, SQLiteBridge db);
+protected abstract void onPreUpdate(ContentValues values, Uri uri, SQLiteBridge db);
+protected abstract void onPostQuery(Cursor cursor, Uri uri, SQLiteBridge db);
+}

The Tor Browser / file comparison

comparison: mobile/android/base/db/SQLiteBridgeContentProvider.java

mobile/android/base/db/SQLiteBridgeContentProvider.java