Transfer data from BP1 to BP2

 Also move BP1 to provider package

Change-Id: I082df8f675d32e2b9072914eab4ee1d50543e169

2 files changed, 1225 insertions, 1 deletions

diff --git a/src/com/android/browser/provider/BrowserProvider.java b/src/com/android/browser/provider/BrowserProvider.java
new file mode 100644
index 0000000..b55b84a
--- /dev/null
+++ b/src/com/android/browser/provider/BrowserProvider.java
@@ -0,0 +1,1150 @@
+/*
+ * Copyright (C) 2006 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 com.android.browser.provider;
+
+import com.android.browser.BrowserSettings;
+import com.android.browser.R;
+import com.android.browser.search.SearchEngine;
+
+import android.app.SearchManager;
+import android.app.backup.BackupManager;
+import android.content.ContentProvider;
+import android.content.ContentResolver;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.Editor;
+import android.content.UriMatcher;
+import android.content.res.Configuration;
+import android.database.AbstractCursor;
+import android.database.Cursor;
+import android.database.DatabaseUtils;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.net.Uri;
+import android.os.Process;
+import android.preference.PreferenceManager;
+import android.provider.Browser;
+import android.provider.Browser.BookmarkColumns;
+import android.speech.RecognizerResultsIntent;
+import android.text.TextUtils;
+import android.util.Log;
+import android.util.Patterns;
+
+import java.io.File;
+import java.io.FilenameFilter;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+
+public class BrowserProvider extends ContentProvider {
+
+    private SQLiteOpenHelper mOpenHelper;
+    private BackupManager mBackupManager;
+    static final String sDatabaseName = "browser.db";
+    private static final String TAG = "BrowserProvider";
+    private static final String ORDER_BY = "visits DESC, date DESC";
+
+    private static final String PICASA_URL = "http://picasaweb.google.com/m/" +
+            "viewer?source=androidclient";
+
+    static final String[] TABLE_NAMES = new String[] {
+        "bookmarks", "searches"
+    };
+    private static final String[] SUGGEST_PROJECTION = new String[] {
+            "_id", "url", "title", "bookmark", "user_entered"
+    };
+    private static final String SUGGEST_SELECTION =
+            "(url LIKE ? OR url LIKE ? OR url LIKE ? OR url LIKE ?"
+                + " OR title LIKE ?) AND (bookmark = 1 OR user_entered = 1)";
+    private String[] SUGGEST_ARGS = new String[5];
+
+    // shared suggestion array index, make sure to match COLUMNS
+    private static final int SUGGEST_COLUMN_INTENT_ACTION_ID = 1;
+    private static final int SUGGEST_COLUMN_INTENT_DATA_ID = 2;
+    private static final int SUGGEST_COLUMN_TEXT_1_ID = 3;
+    private static final int SUGGEST_COLUMN_TEXT_2_ID = 4;
+    private static final int SUGGEST_COLUMN_TEXT_2_URL_ID = 5;
+    private static final int SUGGEST_COLUMN_ICON_1_ID = 6;
+    private static final int SUGGEST_COLUMN_ICON_2_ID = 7;
+    private static final int SUGGEST_COLUMN_QUERY_ID = 8;
+    private static final int SUGGEST_COLUMN_INTENT_EXTRA_DATA = 9;
+
+    // how many suggestions will be shown in dropdown
+    // 0..SHORT: filled by browser db
+    private static final int MAX_SUGGEST_SHORT_SMALL = 3;
+    // SHORT..LONG: filled by search suggestions
+    private static final int MAX_SUGGEST_LONG_SMALL = 6;
+
+    // large screen size shows more
+    private static final int MAX_SUGGEST_SHORT_LARGE = 6;
+    private static final int MAX_SUGGEST_LONG_LARGE = 9;
+
+
+    // shared suggestion columns
+    private static final String[] COLUMNS = new String[] {
+            "_id",
+            SearchManager.SUGGEST_COLUMN_INTENT_ACTION,
+            SearchManager.SUGGEST_COLUMN_INTENT_DATA,
+            SearchManager.SUGGEST_COLUMN_TEXT_1,
+            SearchManager.SUGGEST_COLUMN_TEXT_2,
+            SearchManager.SUGGEST_COLUMN_TEXT_2_URL,
+            SearchManager.SUGGEST_COLUMN_ICON_1,
+            SearchManager.SUGGEST_COLUMN_ICON_2,
+            SearchManager.SUGGEST_COLUMN_QUERY,
+            SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA};
+
+
+    // make sure that these match the index of TABLE_NAMES
+    static final int URI_MATCH_BOOKMARKS = 0;
+    private static final int URI_MATCH_SEARCHES = 1;
+    // (id % 10) should match the table name index
+    private static final int URI_MATCH_BOOKMARKS_ID = 10;
+    private static final int URI_MATCH_SEARCHES_ID = 11;
+    //
+    private static final int URI_MATCH_SUGGEST = 20;
+    private static final int URI_MATCH_BOOKMARKS_SUGGEST = 21;
+
+    private static final UriMatcher URI_MATCHER;
+
+    static {
+        URI_MATCHER = new UriMatcher(UriMatcher.NO_MATCH);
+        URI_MATCHER.addURI("browser", TABLE_NAMES[URI_MATCH_BOOKMARKS],
+                URI_MATCH_BOOKMARKS);
+        URI_MATCHER.addURI("browser", TABLE_NAMES[URI_MATCH_BOOKMARKS] + "/#",
+                URI_MATCH_BOOKMARKS_ID);
+        URI_MATCHER.addURI("browser", TABLE_NAMES[URI_MATCH_SEARCHES],
+                URI_MATCH_SEARCHES);
+        URI_MATCHER.addURI("browser", TABLE_NAMES[URI_MATCH_SEARCHES] + "/#",
+                URI_MATCH_SEARCHES_ID);
+        URI_MATCHER.addURI("browser", SearchManager.SUGGEST_URI_PATH_QUERY,
+                URI_MATCH_SUGGEST);
+        URI_MATCHER.addURI("browser",
+                TABLE_NAMES[URI_MATCH_BOOKMARKS] + "/" + SearchManager.SUGGEST_URI_PATH_QUERY,
+                URI_MATCH_BOOKMARKS_SUGGEST);
+    }
+
+    // 1 -> 2 add cache table
+    // 2 -> 3 update history table
+    // 3 -> 4 add passwords table
+    // 4 -> 5 add settings table
+    // 5 -> 6 ?
+    // 6 -> 7 ?
+    // 7 -> 8 drop proxy table
+    // 8 -> 9 drop settings table
+    // 9 -> 10 add form_urls and form_data
+    // 10 -> 11 add searches table
+    // 11 -> 12 modify cache table
+    // 12 -> 13 modify cache table
+    // 13 -> 14 correspond with Google Bookmarks schema
+    // 14 -> 15 move couple of tables to either browser private database or webview database
+    // 15 -> 17 Set it up for the SearchManager
+    // 17 -> 18 Added favicon in bookmarks table for Home shortcuts
+    // 18 -> 19 Remove labels table
+    // 19 -> 20 Added thumbnail
+    // 20 -> 21 Added touch_icon
+    // 21 -> 22 Remove "clientid"
+    // 22 -> 23 Added user_entered
+    // 23 -> 24 Url not allowed to be null anymore.
+    private static final int DATABASE_VERSION = 24;
+
+    // Regular expression which matches http://, followed by some stuff, followed by
+    // optionally a trailing slash, all matched as separate groups.
+    private static final Pattern STRIP_URL_PATTERN = Pattern.compile("^(http://)(.*?)(/$)?");
+
+    private BrowserSettings mSettings;
+
+    private int mMaxSuggestionShortSize;
+    private int mMaxSuggestionLongSize;
+
+    public BrowserProvider() {
+    }
+
+    // XXX: This is a major hack to remove our dependency on gsf constants and
+    // its content provider. http://b/issue?id=2425179
+    public static String getClientId(ContentResolver cr) {
+        String ret = "android-google";
+        Cursor legacyClientIdCursor = null;
+        Cursor searchClientIdCursor = null;
+
+        // search_client_id includes search prefix, legacy client_id does not include prefix
+        try {
+            searchClientIdCursor = cr.query(Uri.parse("content://com.google.settings/partner"),
+               new String[] { "value" }, "name='search_client_id'", null, null);
+            if (searchClientIdCursor != null && searchClientIdCursor.moveToNext()) {
+                ret = searchClientIdCursor.getString(0);
+            } else {
+                legacyClientIdCursor = cr.query(Uri.parse("content://com.google.settings/partner"),
+                    new String[] { "value" }, "name='client_id'", null, null);
+                if (legacyClientIdCursor != null && legacyClientIdCursor.moveToNext()) {
+                    ret = "ms-" + legacyClientIdCursor.getString(0);
+                }
+            }
+        } catch (RuntimeException ex) {
+            // fall through to return the default
+        } finally {
+            if (legacyClientIdCursor != null) {
+                legacyClientIdCursor.close();
+            }
+            if (searchClientIdCursor != null) {
+                searchClientIdCursor.close();
+            }
+        }
+        return ret;
+    }
+
+    private static CharSequence replaceSystemPropertyInString(Context context, CharSequence srcString) {
+        StringBuffer sb = new StringBuffer();
+        int lastCharLoc = 0;
+
+        final String client_id = getClientId(context.getContentResolver());
+
+        for (int i = 0; i < srcString.length(); ++i) {
+            char c = srcString.charAt(i);
+            if (c == '{') {
+                sb.append(srcString.subSequence(lastCharLoc, i));
+                lastCharLoc = i;
+          inner:
+                for (int j = i; j < srcString.length(); ++j) {
+                    char k = srcString.charAt(j);
+                    if (k == '}') {
+                        String propertyKeyValue = srcString.subSequence(i + 1, j).toString();
+                        if (propertyKeyValue.equals("CLIENT_ID")) {
+                            sb.append(client_id);
+                        } else {
+                            sb.append("unknown");
+                        }
+                        lastCharLoc = j + 1;
+                        i = j;
+                        break inner;
+                    }
+                }
+            }
+        }
+        if (srcString.length() - lastCharLoc > 0) {
+            // Put on the tail, if there is one
+            sb.append(srcString.subSequence(lastCharLoc, srcString.length()));
+        }
+        return sb;
+    }
+
+    static class DatabaseHelper extends SQLiteOpenHelper {
+        private Context mContext;
+
+        public DatabaseHelper(Context context) {
+            super(context, sDatabaseName, null, DATABASE_VERSION);
+            mContext = context;
+        }
+
+        @Override
+        public void onCreate(SQLiteDatabase db) {
+            db.execSQL("CREATE TABLE bookmarks (" +
+                    "_id INTEGER PRIMARY KEY," +
+                    "title TEXT," +
+                    "url TEXT NOT NULL," +
+                    "visits INTEGER," +
+                    "date LONG," +
+                    "created LONG," +
+                    "description TEXT," +
+                    "bookmark INTEGER," +
+                    "favicon BLOB DEFAULT NULL," +
+                    "thumbnail BLOB DEFAULT NULL," +
+                    "touch_icon BLOB DEFAULT NULL," +
+                    "user_entered INTEGER" +
+                    ");");
+
+            final CharSequence[] bookmarks = mContext.getResources()
+                    .getTextArray(R.array.bookmarks);
+            int size = bookmarks.length;
+            try {
+                for (int i = 0; i < size; i = i + 2) {
+                    CharSequence bookmarkDestination = replaceSystemPropertyInString(mContext, bookmarks[i + 1]);
+                    db.execSQL("INSERT INTO bookmarks (title, url, visits, " +
+                            "date, created, bookmark)" + " VALUES('" +
+                            bookmarks[i] + "', '" + bookmarkDestination +
+                            "', 0, 0, 0, 1);");
+                }
+            } catch (ArrayIndexOutOfBoundsException e) {
+            }
+
+            db.execSQL("CREATE TABLE searches (" +
+                    "_id INTEGER PRIMARY KEY," +
+                    "search TEXT," +
+                    "date LONG" +
+                    ");");
+        }
+
+        @Override
+        public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+            Log.w(TAG, "Upgrading database from version " + oldVersion + " to "
+                    + newVersion);
+            if (oldVersion == 18) {
+                db.execSQL("DROP TABLE IF EXISTS labels");
+            }
+            if (oldVersion <= 19) {
+                db.execSQL("ALTER TABLE bookmarks ADD COLUMN thumbnail BLOB DEFAULT NULL;");
+            }
+            if (oldVersion < 21) {
+                db.execSQL("ALTER TABLE bookmarks ADD COLUMN touch_icon BLOB DEFAULT NULL;");
+            }
+            if (oldVersion < 22) {
+                db.execSQL("DELETE FROM bookmarks WHERE (bookmark = 0 AND url LIKE \"%.google.%client=ms-%\")");
+                removeGears();
+            }
+            if (oldVersion < 23) {
+                db.execSQL("ALTER TABLE bookmarks ADD COLUMN user_entered INTEGER;");
+            }
+            if (oldVersion < 24) {
+                /* SQLite does not support ALTER COLUMN, hence the lengthy code. */
+                db.execSQL("DELETE FROM bookmarks WHERE url IS NULL;");
+                db.execSQL("ALTER TABLE bookmarks RENAME TO bookmarks_temp;");
+                db.execSQL("CREATE TABLE bookmarks (" +
+                        "_id INTEGER PRIMARY KEY," +
+                        "title TEXT," +
+                        "url TEXT NOT NULL," +
+                        "visits INTEGER," +
+                        "date LONG," +
+                        "created LONG," +
+                        "description TEXT," +
+                        "bookmark INTEGER," +
+                        "favicon BLOB DEFAULT NULL," +
+                        "thumbnail BLOB DEFAULT NULL," +
+                        "touch_icon BLOB DEFAULT NULL," +
+                        "user_entered INTEGER" +
+                        ");");
+                db.execSQL("INSERT INTO bookmarks SELECT * FROM bookmarks_temp;");
+                db.execSQL("DROP TABLE bookmarks_temp;");
+            } else {
+                db.execSQL("DROP TABLE IF EXISTS bookmarks");
+                db.execSQL("DROP TABLE IF EXISTS searches");
+                onCreate(db);
+            }
+        }
+
+        private void removeGears() {
+            new Thread() {
+                @Override
+                public void run() {
+                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
+                    String browserDataDirString = mContext.getApplicationInfo().dataDir;
+                    final String appPluginsDirString = "app_plugins";
+                    final String gearsPrefix = "gears";
+                    File appPluginsDir = new File(browserDataDirString + File.separator
+                            + appPluginsDirString);
+                    if (!appPluginsDir.exists()) {
+                        return;
+                    }
+                    // Delete the Gears plugin files
+                    File[] gearsFiles = appPluginsDir.listFiles(new FilenameFilter() {
+                        public boolean accept(File dir, String filename) {
+                            return filename.startsWith(gearsPrefix);
+                        }
+                    });
+                    for (int i = 0; i < gearsFiles.length; ++i) {
+                        if (gearsFiles[i].isDirectory()) {
+                            deleteDirectory(gearsFiles[i]);
+                        } else {
+                            gearsFiles[i].delete();
+                        }
+                    }
+                    // Delete the Gears data files
+                    File gearsDataDir = new File(browserDataDirString + File.separator
+                            + gearsPrefix);
+                    if (!gearsDataDir.exists()) {
+                        return;
+                    }
+                    deleteDirectory(gearsDataDir);
+                }
+
+                private void deleteDirectory(File currentDir) {
+                    File[] files = currentDir.listFiles();
+                    for (int i = 0; i < files.length; ++i) {
+                        if (files[i].isDirectory()) {
+                            deleteDirectory(files[i]);
+                        }
+                        files[i].delete();
+                    }
+                    currentDir.delete();
+                }
+            }.start();
+        }
+    }
+
+    @Override
+    public boolean onCreate() {
+        final Context context = getContext();
+        boolean xlargeScreenSize = (context.getResources().getConfiguration().screenLayout
+                & Configuration.SCREENLAYOUT_SIZE_MASK)
+                == Configuration.SCREENLAYOUT_SIZE_XLARGE;
+        boolean isPortrait = (context.getResources().getConfiguration().orientation
+                == Configuration.ORIENTATION_PORTRAIT);
+
+
+        if (xlargeScreenSize && isPortrait) {
+            mMaxSuggestionLongSize = MAX_SUGGEST_LONG_LARGE;
+            mMaxSuggestionShortSize = MAX_SUGGEST_SHORT_LARGE;
+        } else {
+            mMaxSuggestionLongSize = MAX_SUGGEST_LONG_SMALL;
+            mMaxSuggestionShortSize = MAX_SUGGEST_SHORT_SMALL;
+        }
+        mOpenHelper = new DatabaseHelper(context);
+        mBackupManager = new BackupManager(context);
+        // we added "picasa web album" into default bookmarks for version 19.
+        // To avoid erasing the bookmark table, we added it explicitly for
+        // version 18 and 19 as in the other cases, we will erase the table.
+        if (DATABASE_VERSION == 18 || DATABASE_VERSION == 19) {
+            SharedPreferences p = PreferenceManager
+                    .getDefaultSharedPreferences(context);
+            boolean fix = p.getBoolean("fix_picasa", true);
+            if (fix) {
+                fixPicasaBookmark();
+                Editor ed = p.edit();
+                ed.putBoolean("fix_picasa", false);
+                ed.apply();
+            }
+        }
+        mSettings = BrowserSettings.getInstance();
+        return true;
+    }
+
+    private void fixPicasaBookmark() {
+        SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+        Cursor cursor = db.rawQuery("SELECT _id FROM bookmarks WHERE " +
+                "bookmark = 1 AND url = ?", new String[] { PICASA_URL });
+        try {
+            if (!cursor.moveToFirst()) {
+                // set "created" so that it will be on the top of the list
+                db.execSQL("INSERT INTO bookmarks (title, url, visits, " +
+                        "date, created, bookmark)" + " VALUES('" +
+                        getContext().getString(R.string.picasa) + "', '"
+                        + PICASA_URL + "', 0, 0, " + new Date().getTime()
+                        + ", 1);");
+            }
+        } finally {
+            if (cursor != null) {
+                cursor.close();
+            }
+        }
+    }
+
+    /*
+     * Subclass AbstractCursor so we can combine multiple Cursors and add
+     * "Search the web".
+     * Here are the rules.
+     * 1. We only have MAX_SUGGESTION_LONG_ENTRIES in the list plus
+     *      "Search the web";
+     * 2. If bookmark/history entries has a match, "Search the web" shows up at
+     *      the second place. Otherwise, "Search the web" shows up at the first
+     *      place.
+     */
+    private class MySuggestionCursor extends AbstractCursor {
+        private Cursor  mHistoryCursor;
+        private Cursor  mSuggestCursor;
+        private int     mHistoryCount;
+        private int     mSuggestionCount;
+        private boolean mIncludeWebSearch;
+        private String  mString;
+        private int     mSuggestText1Id;
+        private int     mSuggestText2Id;
+        private int     mSuggestText2UrlId;
+        private int     mSuggestQueryId;
+        private int     mSuggestIntentExtraDataId;
+
+        public MySuggestionCursor(Cursor hc, Cursor sc, String string) {
+            mHistoryCursor = hc;
+            mSuggestCursor = sc;
+            mHistoryCount = hc != null ? hc.getCount() : 0;
+            mSuggestionCount = sc != null ? sc.getCount() : 0;
+            if (mSuggestionCount > (mMaxSuggestionLongSize - mHistoryCount)) {
+                mSuggestionCount = mMaxSuggestionLongSize - mHistoryCount;
+            }
+            mString = string;
+            mIncludeWebSearch = string.length() > 0;
+
+            // Some web suggest providers only give suggestions and have no description string for
+            // items. The order of the result columns may be different as well. So retrieve the
+            // column indices for the fields we need now and check before using below.
+            if (mSuggestCursor == null) {
+                mSuggestText1Id = -1;
+                mSuggestText2Id = -1;
+                mSuggestText2UrlId = -1;
+                mSuggestQueryId = -1;
+                mSuggestIntentExtraDataId = -1;
+            } else {
+                mSuggestText1Id = mSuggestCursor.getColumnIndex(
+                                SearchManager.SUGGEST_COLUMN_TEXT_1);
+                mSuggestText2Id = mSuggestCursor.getColumnIndex(
+                                SearchManager.SUGGEST_COLUMN_TEXT_2);
+                mSuggestText2UrlId = mSuggestCursor.getColumnIndex(
+                        SearchManager.SUGGEST_COLUMN_TEXT_2_URL);
+                mSuggestQueryId = mSuggestCursor.getColumnIndex(
+                                SearchManager.SUGGEST_COLUMN_QUERY);
+                mSuggestIntentExtraDataId = mSuggestCursor.getColumnIndex(
+                                SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA);
+            }
+        }
+
+        @Override
+        public boolean onMove(int oldPosition, int newPosition) {
+            if (mHistoryCursor == null) {
+                return false;
+            }
+            if (mIncludeWebSearch) {
+                if (mHistoryCount == 0 && newPosition == 0) {
+                    return true;
+                } else if (mHistoryCount > 0) {
+                    if (newPosition == 0) {
+                        mHistoryCursor.moveToPosition(0);
+                        return true;
+                    } else if (newPosition == 1) {
+                        return true;
+                    }
+                }
+                newPosition--;
+            }
+            if (mHistoryCount > newPosition) {
+                mHistoryCursor.moveToPosition(newPosition);
+            } else {
+                mSuggestCursor.moveToPosition(newPosition - mHistoryCount);
+            }
+            return true;
+        }
+
+        @Override
+        public int getCount() {
+            if (mIncludeWebSearch) {
+                return mHistoryCount + mSuggestionCount + 1;
+            } else {
+                return mHistoryCount + mSuggestionCount;
+            }
+        }
+
+        @Override
+        public String[] getColumnNames() {
+            return COLUMNS;
+        }
+
+        @Override
+        public String getString(int columnIndex) {
+            if ((mPos != -1 && mHistoryCursor != null)) {
+                int type = -1; // 0: web search; 1: history; 2: suggestion
+                if (mIncludeWebSearch) {
+                    if (mHistoryCount == 0 && mPos == 0) {
+                        type = 0;
+                    } else if (mHistoryCount > 0) {
+                        if (mPos == 0) {
+                            type = 1;
+                        } else if (mPos == 1) {
+                            type = 0;
+                        }
+                    }
+                    if (type == -1) type = (mPos - 1) < mHistoryCount ? 1 : 2;
+                } else {
+                    type = mPos < mHistoryCount ? 1 : 2;
+                }
+
+                switch(columnIndex) {
+                    case SUGGEST_COLUMN_INTENT_ACTION_ID:
+                        if (type == 1) {
+                            return Intent.ACTION_VIEW;
+                        } else {
+                            return Intent.ACTION_SEARCH;
+                        }
+
+                    case SUGGEST_COLUMN_INTENT_DATA_ID:
+                        if (type == 1) {
+                            return mHistoryCursor.getString(1);
+                        } else {
+                            return null;
+                        }
+
+                    case SUGGEST_COLUMN_TEXT_1_ID:
+                        if (type == 0) {
+                            return mString;
+                        } else if (type == 1) {
+                            return getHistoryTitle();
+                        } else {
+                            if (mSuggestText1Id == -1) return null;
+                            return mSuggestCursor.getString(mSuggestText1Id);
+                        }
+
+                    case SUGGEST_COLUMN_TEXT_2_ID:
+                        if (type == 0) {
+                            return getContext().getString(R.string.search_the_web);
+                        } else if (type == 1) {
+                            return null;  // Use TEXT_2_URL instead
+                        } else {
+                            if (mSuggestText2Id == -1) return null;
+                            return mSuggestCursor.getString(mSuggestText2Id);
+                        }
+
+                    case SUGGEST_COLUMN_TEXT_2_URL_ID:
+                        if (type == 0) {
+                            return null;
+                        } else if (type == 1) {
+                            return getHistoryUrl();
+                        } else {
+                            if (mSuggestText2UrlId == -1) return null;
+                            return mSuggestCursor.getString(mSuggestText2UrlId);
+                        }
+
+                    case SUGGEST_COLUMN_ICON_1_ID:
+                        if (type == 1) {
+                            if (mHistoryCursor.getInt(3) == 1) {
+                                return Integer.valueOf(
+                                        R.drawable.ic_search_category_bookmark)
+                                        .toString();
+                            } else {
+                                return Integer.valueOf(
+                                        R.drawable.ic_search_category_history)
+                                        .toString();
+                            }
+                        } else {
+                            return Integer.valueOf(
+                                    R.drawable.ic_search_category_suggest)
+                                    .toString();
+                        }
+
+                    case SUGGEST_COLUMN_ICON_2_ID:
+                        return "0";
+
+                    case SUGGEST_COLUMN_QUERY_ID:
+                        if (type == 0) {
+                            return mString;
+                        } else if (type == 1) {
+                            // Return the url in the intent query column. This is ignored
+                            // within the browser because our searchable is set to
+                            // android:searchMode="queryRewriteFromData", but it is used by
+                            // global search for query rewriting.
+                            return mHistoryCursor.getString(1);
+                        } else {
+                            if (mSuggestQueryId == -1) return null;
+                            return mSuggestCursor.getString(mSuggestQueryId);
+                        }
+
+                    case SUGGEST_COLUMN_INTENT_EXTRA_DATA:
+                        if (type == 0) {
+                            return null;
+                        } else if (type == 1) {
+                            return null;
+                        } else {
+                            if (mSuggestIntentExtraDataId == -1) return null;
+                            return mSuggestCursor.getString(mSuggestIntentExtraDataId);
+                        }
+                }
+            }
+            return null;
+        }
+
+        @Override
+        public double getDouble(int column) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public float getFloat(int column) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public int getInt(int column) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public long getLong(int column) {
+            if ((mPos != -1) && column == 0) {
+                return mPos;        // use row# as the _Id
+            }
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public short getShort(int column) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public boolean isNull(int column) {
+            throw new UnsupportedOperationException();
+        }
+
+        // TODO Temporary change, finalize after jq's changes go in
+        @Override
+        public void deactivate() {
+            if (mHistoryCursor != null) {
+                mHistoryCursor.deactivate();
+            }
+            if (mSuggestCursor != null) {
+                mSuggestCursor.deactivate();
+            }
+            super.deactivate();
+        }
+
+        @Override
+        public boolean requery() {
+            return (mHistoryCursor != null ? mHistoryCursor.requery() : false) |
+                    (mSuggestCursor != null ? mSuggestCursor.requery() : false);
+        }
+
+        // TODO Temporary change, finalize after jq's changes go in
+        @Override
+        public void close() {
+            super.close();
+            if (mHistoryCursor != null) {
+                mHistoryCursor.close();
+                mHistoryCursor = null;
+            }
+            if (mSuggestCursor != null) {
+                mSuggestCursor.close();
+                mSuggestCursor = null;
+            }
+        }
+
+        /**
+         * Provides the title (text line 1) for a browser suggestion, which should be the
+         * webpage title. If the webpage title is empty, returns the stripped url instead.
+         *
+         * @return the title string to use
+         */
+        private String getHistoryTitle() {
+            String title = mHistoryCursor.getString(2 /* webpage title */);
+            if (TextUtils.isEmpty(title) || TextUtils.getTrimmedLength(title) == 0) {
+                title = stripUrl(mHistoryCursor.getString(1 /* url */));
+            }
+            return title;
+        }
+
+        /**
+         * Provides the subtitle (text line 2) for a browser suggestion, which should be the
+         * webpage url. If the webpage title is empty, then the url should go in the title
+         * instead, and the subtitle should be empty, so this would return null.
+         *
+         * @return the subtitle string to use, or null if none
+         */
+        private String getHistoryUrl() {
+            String title = mHistoryCursor.getString(2 /* webpage title */);
+            if (TextUtils.isEmpty(title) || TextUtils.getTrimmedLength(title) == 0) {
+                return null;
+            } else {
+                return stripUrl(mHistoryCursor.getString(1 /* url */));
+            }
+        }
+
+    }
+
+    private static class ResultsCursor extends AbstractCursor {
+        // Array indices for RESULTS_COLUMNS
+        private static final int RESULT_ACTION_ID = 1;
+        private static final int RESULT_DATA_ID = 2;
+        private static final int RESULT_TEXT_ID = 3;
+        private static final int RESULT_ICON_ID = 4;
+        private static final int RESULT_EXTRA_ID = 5;
+
+        private static final String[] RESULTS_COLUMNS = new String[] {
+                "_id",
+                SearchManager.SUGGEST_COLUMN_INTENT_ACTION,
+                SearchManager.SUGGEST_COLUMN_INTENT_DATA,
+                SearchManager.SUGGEST_COLUMN_TEXT_1,
+                SearchManager.SUGGEST_COLUMN_ICON_1,
+                SearchManager.SUGGEST_COLUMN_INTENT_EXTRA_DATA
+        };
+        private final ArrayList<String> mResults;
+        public ResultsCursor(ArrayList<String> results) {
+            mResults = results;
+        }
+        @Override
+        public int getCount() { return mResults.size(); }
+
+        @Override
+        public String[] getColumnNames() {
+            return RESULTS_COLUMNS;
+        }
+
+        @Override
+        public String getString(int column) {
+            switch (column) {
+                case RESULT_ACTION_ID:
+                    return RecognizerResultsIntent.ACTION_VOICE_SEARCH_RESULTS;
+                case RESULT_TEXT_ID:
+                // The data is used when the phone is in landscape mode.  We
+                // still want to show the result string.
+                case RESULT_DATA_ID:
+                    return mResults.get(mPos);
+                case RESULT_EXTRA_ID:
+                    // The Intent's extra data will store the index into
+                    // mResults so the BrowserActivity will know which result to
+                    // use.
+                    return Integer.toString(mPos);
+                case RESULT_ICON_ID:
+                    return Integer.valueOf(R.drawable.magnifying_glass)
+                            .toString();
+                default:
+                    return null;
+            }
+        }
+        @Override
+        public short getShort(int column) {
+            throw new UnsupportedOperationException();
+        }
+        @Override
+        public int getInt(int column) {
+            throw new UnsupportedOperationException();
+        }
+        @Override
+        public long getLong(int column) {
+            if ((mPos != -1) && column == 0) {
+                return mPos;        // use row# as the _id
+            }
+            throw new UnsupportedOperationException();
+        }
+        @Override
+        public float getFloat(int column) {
+            throw new UnsupportedOperationException();
+        }
+        @Override
+        public double getDouble(int column) {
+            throw new UnsupportedOperationException();
+        }
+        @Override
+        public boolean isNull(int column) {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    /** Contains custom suggestions results set by the UI */
+    private ResultsCursor mResultsCursor;
+    /** Locks access to {@link #mResultsCursor} */
+    private Object mResultsCursorLock = new Object();
+
+    /**
+     * Provide a set of results to be returned to query, intended to be used
+     * by the SearchDialog when the BrowserActivity is in voice search mode.
+     * @param results Strings to display in the dropdown from the SearchDialog
+     */
+    public /* package */ void setQueryResults(ArrayList<String> results) {
+        synchronized (mResultsCursorLock) {
+            if (results == null) {
+                mResultsCursor = null;
+            } else {
+                mResultsCursor = new ResultsCursor(results);
+            }
+        }
+    }
+
+    @Override
+    public Cursor query(Uri url, String[] projectionIn, String selection,
+            String[] selectionArgs, String sortOrder)
+            throws IllegalStateException {
+        int match = URI_MATCHER.match(url);
+        if (match == -1) {
+            throw new IllegalArgumentException("Unknown URL");
+        }
+
+        // If results for the suggestion are already ready just return them directly
+        synchronized (mResultsCursorLock) {
+            if (match == URI_MATCH_SUGGEST && mResultsCursor != null) {
+                Cursor results = mResultsCursor;
+                mResultsCursor = null;
+                return results;
+            }
+        }
+
+        if (match == URI_MATCH_SUGGEST || match == URI_MATCH_BOOKMARKS_SUGGEST) {
+            // Handle suggestions
+            return doSuggestQuery(selection, selectionArgs, match == URI_MATCH_BOOKMARKS_SUGGEST);
+        }
+
+        String[] projection = null;
+        if (projectionIn != null && projectionIn.length > 0) {
+            projection = new String[projectionIn.length + 1];
+            System.arraycopy(projectionIn, 0, projection, 0, projectionIn.length);
+            projection[projectionIn.length] = "_id AS _id";
+        }
+
+        String whereClause = null;
+        if (match == URI_MATCH_BOOKMARKS_ID || match == URI_MATCH_SEARCHES_ID) {
+            whereClause = "_id = " + url.getPathSegments().get(1);
+        }
+
+        Cursor c = mOpenHelper.getReadableDatabase().query(TABLE_NAMES[match % 10], projection,
+                DatabaseUtils.concatenateWhere(whereClause, selection), selectionArgs,
+                null, null, sortOrder, null);
+        c.setNotificationUri(getContext().getContentResolver(), url);
+        return c;
+    }
+
+    private Cursor doSuggestQuery(String selection, String[] selectionArgs, boolean bookmarksOnly) {
+        String suggestSelection;
+        String [] myArgs;
+        if (selectionArgs[0] == null || selectionArgs[0].equals("")) {
+            return new MySuggestionCursor(null, null, "");
+        } else {
+            String like = selectionArgs[0] + "%";
+            if (selectionArgs[0].startsWith("http")
+                    || selectionArgs[0].startsWith("file")) {
+                myArgs = new String[1];
+                myArgs[0] = like;
+                suggestSelection = selection;
+            } else {
+                SUGGEST_ARGS[0] = "http://" + like;
+                SUGGEST_ARGS[1] = "http://www." + like;
+                SUGGEST_ARGS[2] = "https://" + like;
+                SUGGEST_ARGS[3] = "https://www." + like;
+                // To match against titles.
+                SUGGEST_ARGS[4] = like;
+                myArgs = SUGGEST_ARGS;
+                suggestSelection = SUGGEST_SELECTION;
+            }
+        }
+
+        Cursor c = mOpenHelper.getReadableDatabase().query(TABLE_NAMES[URI_MATCH_BOOKMARKS],
+                SUGGEST_PROJECTION, suggestSelection, myArgs, null, null,
+                ORDER_BY, Integer.toString(mMaxSuggestionLongSize));
+
+        if (bookmarksOnly || Patterns.WEB_URL.matcher(selectionArgs[0]).matches()) {
+            return new MySuggestionCursor(c, null, "");
+        } else {
+            // get search suggestions if there is still space in the list
+            if (myArgs != null && myArgs.length > 1
+                    && c.getCount() < (MAX_SUGGEST_SHORT_SMALL - 1)) {
+                SearchEngine searchEngine = mSettings.getSearchEngine();
+                if (searchEngine != null && searchEngine.supportsSuggestions()) {
+                    Cursor sc = searchEngine.getSuggestions(getContext(), selectionArgs[0]);
+                    return new MySuggestionCursor(c, sc, selectionArgs[0]);
+                }
+            }
+            return new MySuggestionCursor(c, null, selectionArgs[0]);
+        }
+    }
+
+    @Override
+    public String getType(Uri url) {
+        int match = URI_MATCHER.match(url);
+        switch (match) {
+            case URI_MATCH_BOOKMARKS:
+                return "vnd.android.cursor.dir/bookmark";
+
+            case URI_MATCH_BOOKMARKS_ID:
+                return "vnd.android.cursor.item/bookmark";
+
+            case URI_MATCH_SEARCHES:
+                return "vnd.android.cursor.dir/searches";
+
+            case URI_MATCH_SEARCHES_ID:
+                return "vnd.android.cursor.item/searches";
+
+            case URI_MATCH_SUGGEST:
+                return SearchManager.SUGGEST_MIME_TYPE;
+
+            default:
+                throw new IllegalArgumentException("Unknown URL");
+        }
+    }
+
+    @Override
+    public Uri insert(Uri url, ContentValues initialValues) {
+        boolean isBookmarkTable = false;
+        SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+
+        int match = URI_MATCHER.match(url);
+        Uri uri = null;
+        switch (match) {
+            case URI_MATCH_BOOKMARKS: {
+                // Insert into the bookmarks table
+                long rowID = db.insert(TABLE_NAMES[URI_MATCH_BOOKMARKS], "url",
+                        initialValues);
+                if (rowID > 0) {
+                    uri = ContentUris.withAppendedId(Browser.BOOKMARKS_URI,
+                            rowID);
+                }
+                isBookmarkTable = true;
+                break;
+            }
+
+            case URI_MATCH_SEARCHES: {
+                // Insert into the searches table
+                long rowID = db.insert(TABLE_NAMES[URI_MATCH_SEARCHES], "url",
+                        initialValues);
+                if (rowID > 0) {
+                    uri = ContentUris.withAppendedId(Browser.SEARCHES_URI,
+                            rowID);
+                }
+                break;
+            }
+
+            default:
+                throw new IllegalArgumentException("Unknown URL");
+        }
+
+        if (uri == null) {
+            throw new IllegalArgumentException("Unknown URL");
+        }
+        getContext().getContentResolver().notifyChange(uri, null);
+
+        // Back up the new bookmark set if we just inserted one.
+        // A row created when bookmarks are added from scratch will have
+        // bookmark=1 in the initial value set.
+        if (isBookmarkTable
+                && initialValues.containsKey(BookmarkColumns.BOOKMARK)
+                && initialValues.getAsInteger(BookmarkColumns.BOOKMARK) != 0) {
+            mBackupManager.dataChanged();
+        }
+        return uri;
+    }
+
+    @Override
+    public int delete(Uri url, String where, String[] whereArgs) {
+        SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+
+        int match = URI_MATCHER.match(url);
+        if (match == -1 || match == URI_MATCH_SUGGEST) {
+            throw new IllegalArgumentException("Unknown URL");
+        }
+
+        // need to know whether it's the bookmarks table for a couple of reasons
+        boolean isBookmarkTable = (match == URI_MATCH_BOOKMARKS_ID);
+        String id = null;
+
+        if (isBookmarkTable || match == URI_MATCH_SEARCHES_ID) {
+            StringBuilder sb = new StringBuilder();
+            if (where != null && where.length() > 0) {
+                sb.append("( ");
+                sb.append(where);
+                sb.append(" ) AND ");
+            }
+            id = url.getPathSegments().get(1);
+            sb.append("_id = ");
+            sb.append(id);
+            where = sb.toString();
+        }
+
+        ContentResolver cr = getContext().getContentResolver();
+
+        // we'lll need to back up the bookmark set if we are about to delete one
+        if (isBookmarkTable) {
+            Cursor cursor = cr.query(Browser.BOOKMARKS_URI,
+                    new String[] { BookmarkColumns.BOOKMARK },
+                    "_id = " + id, null, null);
+            if (cursor.moveToNext()) {
+                if (cursor.getInt(0) != 0) {
+                    // yep, this record is a bookmark
+                    mBackupManager.dataChanged();
+                }
+            }
+            cursor.close();
+        }
+
+        int count = db.delete(TABLE_NAMES[match % 10], where, whereArgs);
+        cr.notifyChange(url, null);
+        return count;
+    }
+
+    @Override
+    public int update(Uri url, ContentValues values, String where,
+            String[] whereArgs) {
+        SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+
+        int match = URI_MATCHER.match(url);
+        if (match == -1 || match == URI_MATCH_SUGGEST) {
+            throw new IllegalArgumentException("Unknown URL");
+        }
+
+        if (match == URI_MATCH_BOOKMARKS_ID || match == URI_MATCH_SEARCHES_ID) {
+            StringBuilder sb = new StringBuilder();
+            if (where != null && where.length() > 0) {
+                sb.append("( ");
+                sb.append(where);
+                sb.append(" ) AND ");
+            }
+            String id = url.getPathSegments().get(1);
+            sb.append("_id = ");
+            sb.append(id);
+            where = sb.toString();
+        }
+
+        ContentResolver cr = getContext().getContentResolver();
+
+        // Not all bookmark-table updates should be backed up.  Look to see
+        // whether we changed the title, url, or "is a bookmark" state, and
+        // request a backup if so.
+        if (match == URI_MATCH_BOOKMARKS_ID || match == URI_MATCH_BOOKMARKS) {
+            boolean changingBookmarks = false;
+            // Alterations to the bookmark field inherently change the bookmark
+            // set, so we don't need to query the record; we know a priori that
+            // we will need to back up this change.
+            if (values.containsKey(BookmarkColumns.BOOKMARK)) {
+                changingBookmarks = true;
+            } else if ((values.containsKey(BookmarkColumns.TITLE)
+                     || values.containsKey(BookmarkColumns.URL))
+                     && values.containsKey(BookmarkColumns._ID)) {
+                // If a title or URL has been changed, check to see if it is to
+                // a bookmark.  The ID should have been included in the update,
+                // so use it.
+                Cursor cursor = cr.query(Browser.BOOKMARKS_URI,
+                        new String[] { BookmarkColumns.BOOKMARK },
+                        BookmarkColumns._ID + " = "
+                        + values.getAsString(BookmarkColumns._ID), null, null);
+                if (cursor.moveToNext()) {
+                    changingBookmarks = (cursor.getInt(0) != 0);
+                }
+                cursor.close();
+            }
+
+            // if this *is* a bookmark row we're altering, we need to back it up.
+            if (changingBookmarks) {
+                mBackupManager.dataChanged();
+            }
+        }
+
+        int ret = db.update(TABLE_NAMES[match % 10], values, where, whereArgs);
+        cr.notifyChange(url, null);
+        return ret;
+    }
+
+    /**
+     * Strips the provided url of preceding "http://" and any trailing "/". Does not
+     * strip "https://". If the provided string cannot be stripped, the original string
+     * is returned.
+     *
+     * TODO: Put this in TextUtils to be used by other packages doing something similar.
+     *
+     * @param url a url to strip, like "http://www.google.com/"
+     * @return a stripped url like "www.google.com", or the original string if it could
+     *         not be stripped
+     */
+    private static String stripUrl(String url) {
+        if (url == null) return null;
+        Matcher m = STRIP_URL_PATTERN.matcher(url);
+        if (m.matches() && m.groupCount() == 3) {
+            return m.group(2);
+        } else {
+            return url;
+        }
+    }
+
+    public static Cursor getBookmarksSuggestions(ContentResolver cr, String constraint) {
+        Uri uri = Uri.parse("content://browser/" + SearchManager.SUGGEST_URI_PATH_QUERY);
+        return cr.query(uri, SUGGEST_PROJECTION, SUGGEST_SELECTION,
+            new String[] { constraint }, ORDER_BY);
+    }
+
+}
diff --git a/src/com/android/browser/provider/BrowserProvider2.java b/src/com/android/browser/provider/BrowserProvider2.java
index 7a6dfbb..a8739ca 100644
--- a/src/com/android/browser/provider/BrowserProvider2.java
+++ b/src/com/android/browser/provider/BrowserProvider2.java
@@ -64,6 +64,7 @@ import android.provider.SyncStateContract;
 import android.text.TextUtils;
 
 import java.io.ByteArrayOutputStream;
+import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.Arrays;
@@ -398,7 +399,80 @@ public class BrowserProvider2 extends SQLiteContentProvider {
 
             mSyncHelper.createDatabase(db);
 
-            createDefaultBookmarks(db);
+            if (!importFromBrowserProvider(db)) {
+                createDefaultBookmarks(db);
+            }
+        }
+
+        boolean importFromBrowserProvider(SQLiteDatabase db) {
+            Context context = getContext();
+            File oldDbFile = context.getDatabasePath(BrowserProvider.sDatabaseName);
+            if (oldDbFile.exists()) {
+                BrowserProvider.DatabaseHelper helper =
+                        new BrowserProvider.DatabaseHelper(context);
+                SQLiteDatabase oldDb = helper.getWritableDatabase();
+                Cursor c = null;
+                try {
+                    String table = BrowserProvider.TABLE_NAMES[BrowserProvider.URI_MATCH_BOOKMARKS];
+                    // Import bookmarks
+                    c = oldDb.query(table,
+                            new String[] {
+                            BookmarkColumns.URL, // 0
+                            BookmarkColumns.TITLE, // 1
+                            BookmarkColumns.FAVICON, // 2
+                            BookmarkColumns.TOUCH_ICON, // 3
+                            }, BookmarkColumns.BOOKMARK + "!=0", null,
+                            null, null, null);
+                    if (c != null) {
+                        while (c.moveToNext()) {
+                            ContentValues values = new ContentValues();
+                            values.put(Bookmarks.URL, c.getString(0));
+                            values.put(Bookmarks.TITLE, c.getString(1));
+                            values.put(Bookmarks.POSITION, 0);
+                            values.put(Bookmarks.PARENT, FIXED_ID_ROOT);
+                            ContentValues imageValues = new ContentValues();
+                            imageValues.put(Images.URL, c.getString(0));
+                            imageValues.put(Images.FAVICON, c.getBlob(2));
+                            imageValues.put(Images.TOUCH_ICON, c.getBlob(3));
+                            db.insertOrThrow(TABLE_IMAGES, Images.THUMBNAIL, imageValues);
+                            db.insertOrThrow(TABLE_BOOKMARKS, Bookmarks.DIRTY, values);
+                        }
+                        c.close();
+                    }
+                    // Import history
+                    c = oldDb.query(table,
+                            new String[] {
+                            BookmarkColumns.URL, // 0
+                            BookmarkColumns.TITLE, // 1
+                            BookmarkColumns.VISITS, // 2
+                            BookmarkColumns.DATE, // 3
+                            BookmarkColumns.CREATED, // 4
+                            }, null, null, null, null, null);
+                    if (c != null) {
+                        while (c.moveToNext()) {
+                            ContentValues values = new ContentValues();
+                            values.put(History.URL, c.getString(0));
+                            values.put(History.TITLE, c.getString(1));
+                            values.put(History.VISITS, c.getInt(2));
+                            values.put(History.DATE_LAST_VISITED, c.getLong(3));
+                            values.put(History.DATE_CREATED, c.getLong(4));
+                            db.insertOrThrow(TABLE_HISTORY, History.FAVICON, values);
+                        }
+                        c.close();
+                    }
+                    // Wipe the old DB, in case the delete fails.
+                    oldDb.delete(table, null, null);
+                } finally {
+                    if (c != null) c.close();
+                    oldDb.close();
+                    helper.close();
+                }
+                if (!oldDbFile.delete()) {
+                    oldDbFile.deleteOnExit();
+                }
+                return true;
+            }
+            return false;
         }
 
         void createAccountsView(SQLiteDatabase db) {