auto import from //depot/cupcake/@135843

33 files changed, 12726 insertions, 0 deletions

diff --git a/src/com/android/browser/AddBookmarkPage.java b/src/com/android/browser/AddBookmarkPage.java
new file mode 100644
index 0000000..cf3fe70
--- /dev/null
+++ b/src/com/android/browser/AddBookmarkPage.java
@@ -0,0 +1,226 @@
+/*
+ * 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;
+
+import android.app.Activity;
+import android.content.ContentResolver;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Intent;
+import android.content.res.Resources;
+import android.database.Cursor;
+import android.net.ParseException;
+import android.net.WebAddress;
+import android.os.Bundle;
+import android.provider.Browser;
+import android.view.View;
+import android.view.Window;
+import android.webkit.WebIconDatabase;
+import android.widget.EditText;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import java.util.Date;
+
+public class AddBookmarkPage extends Activity {
+
+    private final String LOGTAG = "Bookmarks";
+
+    private EditText    mTitle;
+    private EditText    mAddress;
+    private TextView    mButton;
+    private View        mCancelButton;
+    private boolean     mEditingExisting;
+    private Bundle      mMap;
+    
+    private static final String[]   mProjection = 
+        { "_id", "url", "bookmark", "created", "title", "visits" };
+    private static final String     WHERE_CLAUSE = "url = ?";
+    private final String[]          SELECTION_ARGS = new String[1];
+
+    private View.OnClickListener mSaveBookmark = new View.OnClickListener() {
+        public void onClick(View v) {
+            if (save()) {
+                finish();
+                Toast.makeText(AddBookmarkPage.this, R.string.bookmark_saved,
+                        Toast.LENGTH_LONG).show();
+            }
+        }
+    };
+
+    private View.OnClickListener mCancel = new View.OnClickListener() {
+        public void onClick(View v) {
+            finish();
+        }
+    };
+
+    protected void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+        requestWindowFeature(Window.FEATURE_LEFT_ICON);
+        setContentView(R.layout.browser_add_bookmark);
+        setTitle(R.string.save_to_bookmarks);
+        getWindow().setFeatureDrawableResource(Window.FEATURE_LEFT_ICON, R.drawable.ic_dialog_bookmark);
+        
+        String title = null;
+        String url = null;
+        mMap = getIntent().getExtras();
+        if (mMap != null) {
+            Bundle b = mMap.getBundle("bookmark");
+            if (b != null) {
+                mMap = b;
+                mEditingExisting = true;
+                setTitle(R.string.edit_bookmark);
+            }
+            title = mMap.getString("title");
+            url = mMap.getString("url");
+        }
+
+        mTitle = (EditText) findViewById(R.id.title);
+        mTitle.setText(title);
+        mAddress = (EditText) findViewById(R.id.address);
+        mAddress.setText(url);
+
+
+        View.OnClickListener accept = mSaveBookmark;
+        mButton = (TextView) findViewById(R.id.OK);
+        mButton.setOnClickListener(accept);
+
+        mCancelButton = findViewById(R.id.cancel);
+        mCancelButton.setOnClickListener(mCancel);
+        
+        if (!getWindow().getDecorView().isInTouchMode()) {
+            mButton.requestFocus();
+        }
+    }
+    
+    /**
+     *  Save the data to the database. 
+     *  Also, change the view to dialog stating 
+     *  that the webpage has been saved.
+     */
+    boolean save() {
+        String title = mTitle.getText().toString().trim();
+        String unfilteredUrl = 
+                BrowserActivity.fixUrl(mAddress.getText().toString());
+        boolean emptyTitle = title.length() == 0;
+        boolean emptyUrl = unfilteredUrl.trim().length() == 0;
+        Resources r = getResources();
+        if (emptyTitle || emptyUrl) {
+            if (emptyTitle) {
+                mTitle.setError(r.getText(R.string.bookmark_needs_title));
+            }
+            if (emptyUrl) {
+                mAddress.setError(r.getText(R.string.bookmark_needs_url));
+            }
+            return false;
+        }
+        String url = unfilteredUrl;
+        if (!(url.startsWith("about:") || url.startsWith("data:") || url
+                .startsWith("file:"))) {
+            WebAddress address;
+            try {
+                address = new WebAddress(unfilteredUrl);
+            } catch (ParseException e) {
+                mAddress.setError(r.getText(R.string.bookmark_url_not_valid));
+                return false;
+            }
+            if (address.mHost.length() == 0) {
+                mAddress.setError(r.getText(R.string.bookmark_url_not_valid));
+                return false;
+            }
+            url = address.toString();
+        }
+        try {
+            if (mEditingExisting) {
+                mMap.putString("title", title);
+                mMap.putString("url", url);
+                setResult(RESULT_OK, (new Intent()).setAction(
+                        getIntent().toString()).putExtras(mMap));
+            } else {
+                // Want to append to the beginning of the list
+                long creationTime = new Date().getTime();
+                SELECTION_ARGS[0] = url;
+                ContentResolver cr = getContentResolver();
+                Cursor c = cr.query(Browser.BOOKMARKS_URI,
+                        mProjection,
+                        WHERE_CLAUSE,
+                        SELECTION_ARGS,
+                        null);
+                ContentValues map = new ContentValues();
+                if (c.moveToFirst() && c.getInt(c.getColumnIndexOrThrow(
+                        Browser.BookmarkColumns.BOOKMARK)) == 0) {
+                    // This means we have been to this site but not bookmarked
+                    // it, so convert the history item to a bookmark                    
+                    map.put(Browser.BookmarkColumns.CREATED, creationTime);
+                    map.put(Browser.BookmarkColumns.TITLE, title);
+                    map.put(Browser.BookmarkColumns.BOOKMARK, 1);
+                    cr.update(Browser.BOOKMARKS_URI, map, 
+                            "_id = " + c.getInt(0), null);
+                } else {
+                    int count = c.getCount();
+                    boolean matchedTitle = false;
+                    for (int i = 0; i < count; i++) {
+                        // One or more bookmarks already exist for this site.
+                        // Check the names of each
+                        c.moveToPosition(i);
+                        if (c.getString(c.getColumnIndexOrThrow(
+                                Browser.BookmarkColumns.TITLE)).equals(title)) {
+                            // The old bookmark has the same name.
+                            // Update its creation time.
+                            map.put(Browser.BookmarkColumns.CREATED,
+                                    creationTime);
+                            cr.update(Browser.BOOKMARKS_URI, map, 
+                                    "_id = " + c.getInt(0), null);
+                            matchedTitle = true;
+                        }
+                    }
+                    if (!matchedTitle) {
+                        // Adding a bookmark for a site the user has visited,
+                        // or a new bookmark (with a different name) for a site
+                        // the user has visited
+                        map.put(Browser.BookmarkColumns.TITLE, title);
+                        map.put(Browser.BookmarkColumns.URL, url);
+                        map.put(Browser.BookmarkColumns.CREATED, creationTime);
+                        map.put(Browser.BookmarkColumns.BOOKMARK, 1);
+                        map.put(Browser.BookmarkColumns.DATE, 0);
+                        int visits = 0;
+                        if (count > 0) {
+                            // The user has already bookmarked, and possibly
+                            // visited this site.  However, they are creating
+                            // a new bookmark with the same url but a different
+                            // name.  The new bookmark should have the same
+                            // number of visits as the already created bookmark.
+                            visits = c.getInt(c.getColumnIndexOrThrow(
+                                    Browser.BookmarkColumns.VISITS));
+                        }
+                        // Bookmark starts with 3 extra visits so that it will
+                        // bubble up in the most visited and goto search box
+                        map.put(Browser.BookmarkColumns.VISITS, visits + 3);
+                        cr.insert(Browser.BOOKMARKS_URI, map);
+                    }
+                }
+                WebIconDatabase.getInstance().retainIconForPageUrl(url);
+                c.deactivate();
+                setResult(RESULT_OK);
+            }
+        } catch (IllegalStateException e) {
+            setTitle(r.getText(R.string.no_database));
+            return false;
+        }
+        return true;
+    }
+}
diff --git a/src/com/android/browser/AddNewBookmark.java b/src/com/android/browser/AddNewBookmark.java
new file mode 100644
index 0000000..a75d002
--- /dev/null
+++ b/src/com/android/browser/AddNewBookmark.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2008 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;
+
+import android.content.Context;
+import android.view.LayoutInflater;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+/**
+ *  Custom layout for an item representing a bookmark in the browser.
+ */
+ // FIXME: Remove BrowserBookmarkItem
+class AddNewBookmark extends LinearLayout {
+
+    private TextView    mTextView;
+    private TextView    mUrlText;
+    private ImageView   mImageView;
+
+    /**
+     *  Instantiate a bookmark item, including a default favicon.
+     *
+     *  @param context  The application context for the item.
+     */
+    AddNewBookmark(Context context) {
+        super(context);
+
+        setWillNotDraw(false);
+        LayoutInflater factory = LayoutInflater.from(context);
+        factory.inflate(R.layout.add_new_bookmark, this);
+        mTextView = (TextView) findViewById(R.id.title);
+        mUrlText = (TextView) findViewById(R.id.url);
+        mImageView = (ImageView) findViewById(R.id.favicon);
+    }
+    
+    /**
+     *  Copy this BookmarkItem to item.
+     *  @param item BookmarkItem to receive the info from this BookmarkItem.
+     */
+    /* package */ void copyTo(AddNewBookmark item) {
+        item.mTextView.setText(mTextView.getText());
+        item.mUrlText.setText(mUrlText.getText());
+        item.mImageView.setImageDrawable(mImageView.getDrawable());
+    }
+    
+    /**
+     *  Set the new url for the bookmark item.
+     *  @param url  The new url for the bookmark item.
+     */
+    /* package */ void setUrl(String url) {
+        mUrlText.setText(url);
+    }
+}
diff --git a/src/com/android/browser/BookmarkItem.java b/src/com/android/browser/BookmarkItem.java
new file mode 100644
index 0000000..a70dd4f
--- /dev/null
+++ b/src/com/android/browser/BookmarkItem.java
@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) 2008 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;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+/**
+ *  Custom layout for an item representing a bookmark in the browser.
+ */
+class BookmarkItem extends LinearLayout {
+
+    protected TextView    mTextView;
+    protected TextView    mUrlText;
+    protected ImageView   mImageView;
+    protected String      mUrl;
+
+    /**
+     *  Instantiate a bookmark item, including a default favicon.
+     *
+     *  @param context  The application context for the item.
+     */
+    BookmarkItem(Context context) {
+        super(context);
+
+        LayoutInflater factory = LayoutInflater.from(context);
+        factory.inflate(R.layout.history_item, this);
+        mTextView = (TextView) findViewById(R.id.title);
+        mUrlText = (TextView) findViewById(R.id.url);
+        mImageView = (ImageView) findViewById(R.id.favicon);
+        View star = findViewById(R.id.star);
+        star.setVisibility(View.GONE);
+    }
+
+    /**
+     *  Copy this BookmarkItem to item.
+     *  @param item BookmarkItem to receive the info from this BookmarkItem.
+     */
+    /* package */ void copyTo(BookmarkItem item) {
+        item.mTextView.setText(mTextView.getText());
+        item.mUrlText.setText(mUrlText.getText());
+        item.mImageView.setImageDrawable(mImageView.getDrawable());
+    }
+
+    /**
+     * Return the name assigned to this bookmark item.
+     */
+    /* package */ String getName() {
+        return mTextView.getText().toString();
+    }
+
+    /**
+     * Return the TextView which holds the name of this bookmark item.
+     */
+    /* package */ TextView getNameTextView() {
+        return mTextView;
+    }
+
+    /* package */ String getUrl() {
+        return mUrl;
+    }
+
+    /**
+     *  Set the favicon for this item.
+     *
+     *  @param b    The new bitmap for this item.
+     *              If it is null, will use the default.
+     */
+    /* package */ void setFavicon(Bitmap b) {
+        if (b != null) {
+            mImageView.setImageBitmap(b);
+        } else {
+            mImageView.setImageResource(R.drawable.app_web_browser_sm);
+        }
+    }
+
+    /**
+     *  Set the new name for the bookmark item.
+     *
+     *  @param name The new name for the bookmark item.
+     */
+    /* package */ void setName(String name) {
+        mTextView.setText(name);
+    }
+    
+    /**
+     *  Set the new url for the bookmark item.
+     *  @param url  The new url for the bookmark item.
+     */
+    /* package */ void setUrl(String url) {
+        mUrlText.setText(url);
+        mUrl = url;
+    }
+}
diff --git a/src/com/android/browser/Browser.java b/src/com/android/browser/Browser.java
new file mode 100644
index 0000000..32cee67
--- /dev/null
+++ b/src/com/android/browser/Browser.java
@@ -0,0 +1,59 @@
+/*
+ * 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;
+
+import android.util.Config;
+import android.util.Log;
+
+import android.app.Application;
+import android.content.Intent;
+import android.webkit.CookieManager;
+import android.webkit.CookieSyncManager;
+
+import dalvik.system.VMRuntime;
+
+public class Browser extends Application { 
+
+    private final static String LOGTAG = "browser";
+
+    /**
+     * Specifies a heap utilization ratio that works better
+     * for the browser than the default ratio does.
+     */
+    private final static float TARGET_HEAP_UTILIZATION = 0.75f;
+
+    public Browser() {
+    }
+
+    public void onCreate() {
+        if (Config.LOGV)
+            Log.v(LOGTAG, "Browser.onCreate: this=" + this);
+        // Fix heap utilization for better heap size characteristics.
+        VMRuntime.getRuntime().setTargetHeapUtilization(
+                TARGET_HEAP_UTILIZATION);
+        // create CookieSyncManager with current Context
+        CookieSyncManager.createInstance(this);
+        // remove all expired cookies
+        CookieManager.getInstance().removeExpiredCookie();
+    }
+
+    static Intent createBrowserViewIntent() {
+        Intent intent = new Intent(Intent.ACTION_WEB_SEARCH);
+        return intent;
+    }
+}
+
diff --git a/src/com/android/browser/BrowserActivity.java b/src/com/android/browser/BrowserActivity.java
new file mode 100644
index 0000000..53640e5
--- /dev/null
+++ b/src/com/android/browser/BrowserActivity.java
@@ -0,0 +1,4567 @@
+/*
+ * 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;
+
+import com.google.android.googleapps.IGoogleLoginService;
+import com.google.android.googlelogin.GoogleLoginServiceConstants;
+
+import android.app.Activity;
+import android.app.ActivityManager;
+import android.app.AlertDialog;
+import android.app.ProgressDialog;
+import android.app.SearchManager;
+import android.content.ActivityNotFoundException;
+import android.content.BroadcastReceiver;
+import android.content.ComponentName;
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.ServiceConnection;
+import android.content.DialogInterface.OnCancelListener;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.content.res.AssetManager;
+import android.content.res.Configuration;
+import android.content.res.Resources;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteException;
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.DrawFilter;
+import android.graphics.Paint;
+import android.graphics.PaintFlagsDrawFilter;
+import android.graphics.Picture;
+import android.graphics.drawable.BitmapDrawable;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.LayerDrawable;
+import android.graphics.drawable.PaintDrawable;
+import android.hardware.SensorListener;
+import android.hardware.SensorManager;
+import android.net.ConnectivityManager;
+import android.net.Uri;
+import android.net.WebAddress;
+import android.net.http.EventHandler;
+import android.net.http.SslCertificate;
+import android.net.http.SslError;
+import android.os.AsyncTask;
+import android.os.Bundle;
+import android.os.Debug;
+import android.os.Environment;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.Message;
+import android.os.PowerManager;
+import android.os.Process;
+import android.os.RemoteException;
+import android.os.ServiceManager;
+import android.os.SystemClock;
+import android.os.SystemProperties;
+import android.preference.PreferenceManager;
+import android.provider.Browser;
+import android.provider.Contacts;
+import android.provider.Downloads;
+import android.provider.MediaStore;
+import android.provider.Contacts.Intents.Insert;
+import android.text.IClipboard;
+import android.text.TextUtils;
+import android.text.format.DateFormat;
+import android.text.util.Regex;
+import android.util.Config;
+import android.util.Log;
+import android.view.ContextMenu;
+import android.view.Gravity;
+import android.view.KeyEvent;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.Window;
+import android.view.WindowManager;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.view.MenuItem.OnMenuItemClickListener;
+import android.view.animation.AlphaAnimation;
+import android.view.animation.Animation;
+import android.view.animation.AnimationSet;
+import android.view.animation.DecelerateInterpolator;
+import android.view.animation.ScaleAnimation;
+import android.view.animation.TranslateAnimation;
+import android.webkit.CookieManager;
+import android.webkit.CookieSyncManager;
+import android.webkit.DownloadListener;
+import android.webkit.HttpAuthHandler;
+import android.webkit.SslErrorHandler;
+import android.webkit.URLUtil;
+import android.webkit.WebChromeClient;
+import android.webkit.WebHistoryItem;
+import android.webkit.WebIconDatabase;
+import android.webkit.WebView;
+import android.webkit.WebViewClient;
+import android.widget.EditText;
+import android.widget.FrameLayout;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.MalformedURLException;
+import java.net.URI;
+import java.net.URL;
+import java.net.URLEncoder;
+import java.text.ParseException;
+import java.util.Date;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Vector;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+public class BrowserActivity extends Activity
+    implements KeyTracker.OnKeyTracker,
+        View.OnCreateContextMenuListener,
+        DownloadListener {
+
+    private IGoogleLoginService mGls = null;
+    private ServiceConnection mGlsConnection = null;
+
+    private SensorManager mSensorManager = null;
+
+    /* Whitelisted webpages
+    private static HashSet<String> sWhiteList;
+
+    static {
+        sWhiteList = new HashSet<String>();
+        sWhiteList.add("cnn.com/");
+        sWhiteList.add("espn.go.com/");
+        sWhiteList.add("nytimes.com/");
+        sWhiteList.add("engadget.com/");
+        sWhiteList.add("yahoo.com/");
+        sWhiteList.add("msn.com/");
+        sWhiteList.add("amazon.com/");
+        sWhiteList.add("consumerist.com/");
+        sWhiteList.add("google.com/m/news");
+    }
+    */
+
+    private void setupHomePage() {
+        final Runnable getAccount = new Runnable() {
+            public void run() {
+                // Lower priority
+                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
+                // get the default home page
+                String homepage = mSettings.getHomePage();
+
+                try {
+                    if (mGls == null) return;
+
+                    String hostedUser = mGls.getAccount(GoogleLoginServiceConstants.PREFER_HOSTED);
+                    String googleUser = mGls.getAccount(GoogleLoginServiceConstants.REQUIRE_GOOGLE);
+
+                    // three cases:
+                    //
+                    //   hostedUser == googleUser
+                    //      The device has only a google account
+                    //
+                    //   hostedUser != googleUser
+                    //      The device has a hosted account and a google account
+                    //
+                    //   hostedUser != null, googleUser == null
+                    //      The device has only a hosted account (so far)
+
+                    // developers might have no accounts at all
+                    if (hostedUser == null) return;
+
+                    if (googleUser == null || !hostedUser.equals(googleUser)) {
+                        String domain = hostedUser.substring(hostedUser.lastIndexOf('@')+1);
+                        homepage = "http://www.google.com/m/a/" + domain + "?client=ms-" +
+                            SystemProperties.get("persist.sys.com.google.clientid", "unknown");
+                    }
+                } catch (RemoteException ignore) {
+                    // Login service died; carry on
+                } catch (RuntimeException ignore) {
+                    // Login service died; carry on
+                } finally {
+                    finish(homepage);
+                }
+            }
+
+            private void finish(final String homepage) {
+                mHandler.post(new Runnable() {
+                    public void run() {
+                        mSettings.setHomePage(BrowserActivity.this, homepage);
+                        resumeAfterCredentials();
+
+                        // as this is running in a separate thread,
+                        // BrowserActivity's onDestroy() may have been called,
+                        // which also calls unbindService().
+                        if (mGlsConnection != null) {
+                            // we no longer need to keep GLS open
+                            unbindService(mGlsConnection);
+                            mGlsConnection = null;
+                        }
+                    } });
+            } };
+
+        final boolean[] done = { false };
+
+        // Open a connection to the Google Login Service.  The first
+        // time the connection is established, set up the homepage depending on
+        // the account in a background thread.
+        mGlsConnection = new ServiceConnection() {
+            public void onServiceConnected(ComponentName className, IBinder service) {
+                mGls = IGoogleLoginService.Stub.asInterface(service);
+                if (done[0] == false) {
+                    done[0] = true;
+                    Thread account = new Thread(getAccount);
+                    account.setName("GLSAccount");
+                    account.start();
+                }
+            }
+            public void onServiceDisconnected(ComponentName className) {
+                mGls = null;
+            }
+        };
+
+        bindService(GoogleLoginServiceConstants.SERVICE_INTENT,
+                    mGlsConnection, Context.BIND_AUTO_CREATE);
+    }
+
+    /**
+     * This class is in charge of installing pre-packaged plugins
+     * from the Browser assets directory to the user's data partition.
+     * Plugins are loaded from the "plugins" directory in the assets;
+     * Anything that is in this directory will be copied over to the
+     * user data partition in app_plugins.
+     */
+    private class CopyPlugins implements Runnable {
+        final static String TAG = "PluginsInstaller";
+        final static String ZIP_FILTER = "assets/plugins/";
+        final static String APK_PATH = "/system/app/Browser.apk";
+        final static String PLUGIN_EXTENSION = ".so";
+        final static String TEMPORARY_EXTENSION = "_temp";
+        final static String BUILD_INFOS_FILE = "build.prop";
+        final static String SYSTEM_BUILD_INFOS_FILE = "/system/"
+                              + BUILD_INFOS_FILE;
+        final int BUFSIZE = 4096;
+        boolean mDoOverwrite = false;
+        String pluginsPath;
+        Context mContext;
+        File pluginsDir;
+        AssetManager manager;
+
+        public CopyPlugins (boolean overwrite, Context context) {
+            mDoOverwrite = overwrite;
+            mContext = context;
+        }
+
+        /**
+         * Returned a filtered list of ZipEntry.
+         * We list all the files contained in the zip and
+         * only returns the ones starting with the ZIP_FILTER
+         * path.
+         *
+         * @param zip the zip file used.
+         */
+        public Vector<ZipEntry> pluginsFilesFromZip(ZipFile zip) {
+            Vector<ZipEntry> list = new Vector<ZipEntry>();
+            Enumeration entries = zip.entries();
+            while (entries.hasMoreElements()) {
+                ZipEntry entry = (ZipEntry) entries.nextElement();
+                if (entry.getName().startsWith(ZIP_FILTER)) {
+                  list.add(entry);
+                }
+            }
+            return list;
+        }
+
+        /**
+         * Utility method to copy the content from an inputstream
+         * to a file output stream.
+         */
+        public void copyStreams(InputStream is, FileOutputStream fos) {
+            BufferedOutputStream os = null;
+            try {
+                byte data[] = new byte[BUFSIZE];
+                int count;
+                os = new BufferedOutputStream(fos, BUFSIZE);
+                while ((count = is.read(data, 0, BUFSIZE)) != -1) {
+                    os.write(data, 0, count);
+                }
+                os.flush();
+            } catch (IOException e) {
+                Log.e(TAG, "Exception while copying: " + e);
+            } finally {
+              try {
+                if (os != null) {
+                    os.close();
+                }
+              } catch (IOException e2) {
+                Log.e(TAG, "Exception while closing the stream: " + e2);
+              }
+            }
+        }
+
+        /**
+         * Returns a string containing the contents of a file
+         *
+         * @param file the target file
+         */
+        private String contentsOfFile(File file) {
+          String ret = null;
+          FileInputStream is = null;
+          try {
+            byte[] buffer = new byte[BUFSIZE];
+            int count;
+            is = new FileInputStream(file);
+            StringBuffer out = new StringBuffer();
+
+            while ((count = is.read(buffer, 0, BUFSIZE)) != -1) {
+              out.append(new String(buffer, 0, count));
+            }
+            ret = out.toString();
+          } catch (IOException e) {
+            Log.e(TAG, "Exception getting contents of file " + e);
+          } finally {
+            if (is != null) {
+              try {
+                is.close();
+              } catch (IOException e2) {
+                Log.e(TAG, "Exception while closing the file: " + e2);
+              }
+            }
+          }
+          return ret;
+        }
+
+        /**
+         * Utility method to initialize the user data plugins path.
+         */
+        public void initPluginsPath() {
+            BrowserSettings s = BrowserSettings.getInstance();
+            pluginsPath = s.getPluginsPath();
+            if (pluginsPath == null) {
+                s.loadFromDb(mContext);
+                pluginsPath = s.getPluginsPath();
+            }
+            if (Config.LOGV) {
+                Log.v(TAG, "Plugin path: " + pluginsPath);
+            }
+        }
+
+        /**
+         * Utility method to delete a file or a directory
+         *
+         * @param file the File to delete
+         */
+        public void deleteFile(File file) {
+            File[] files = file.listFiles();
+            if ((files != null) && files.length > 0) {
+              for (int i=0; i< files.length; i++) {
+                deleteFile(files[i]);
+              }
+            }
+            if (!file.delete()) {
+              Log.e(TAG, file.getPath() + " could not get deleted");
+            }
+        }
+
+        /**
+         * Clean the content of the plugins directory.
+         * We delete the directory, then recreate it.
+         */
+        public void cleanPluginsDirectory() {
+          if (Config.LOGV) {
+            Log.v(TAG, "delete plugins directory: " + pluginsPath);
+          }
+          File pluginsDirectory = new File(pluginsPath);
+          deleteFile(pluginsDirectory);
+          pluginsDirectory.mkdir();
+        }
+
+
+        /**
+         * Copy the SYSTEM_BUILD_INFOS_FILE file containing the
+         * informations about the system build to the
+         * BUILD_INFOS_FILE in the plugins directory.
+         */
+        public void copyBuildInfos() {
+          try {
+            if (Config.LOGV) {
+              Log.v(TAG, "Copy build infos to the plugins directory");
+            }
+            File buildInfoFile = new File(SYSTEM_BUILD_INFOS_FILE);
+            File buildInfoPlugins = new File(pluginsPath, BUILD_INFOS_FILE);
+            copyStreams(new FileInputStream(buildInfoFile),
+                        new FileOutputStream(buildInfoPlugins));
+          } catch (IOException e) {
+            Log.e(TAG, "Exception while copying the build infos: " + e);
+          }
+        }
+
+        /**
+         * Returns true if the current system is newer than the
+         * system that installed the plugins.
+         * We determinate this by checking the build number of the system.
+         *
+         * At the end of the plugins copy operation, we copy the
+         * SYSTEM_BUILD_INFOS_FILE to the BUILD_INFOS_FILE.
+         * We then just have to load both and compare them -- if they
+         * are different the current system is newer.
+         *
+         * Loading and comparing the strings should be faster than
+         * creating a hash, the files being rather small. Extracting the
+         * version number would require some parsing which may be more
+         * brittle.
+         */
+        public boolean newSystemImage() {
+          try {
+            File buildInfoFile = new File(SYSTEM_BUILD_INFOS_FILE);
+            File buildInfoPlugins = new File(pluginsPath, BUILD_INFOS_FILE);
+            if (!buildInfoPlugins.exists()) {
+              if (Config.LOGV) {
+                Log.v(TAG, "build.prop in plugins directory " + pluginsPath
+                  + " does not exist, therefore it's a new system image");
+              }
+              return true;
+            } else {
+              String buildInfo = contentsOfFile(buildInfoFile);
+              String buildInfoPlugin = contentsOfFile(buildInfoPlugins);
+              if (buildInfo == null || buildInfoPlugin == null
+                  || buildInfo.compareTo(buildInfoPlugin) != 0) {
+                if (Config.LOGV) {
+                  Log.v(TAG, "build.prop are different, "
+                    + " therefore it's a new system image");
+                }
+                return true;
+              }
+            }
+          } catch (Exception e) {
+            Log.e(TAG, "Exc in newSystemImage(): " + e);
+          }
+          return false;
+        }
+
+        /**
+         * Check if the version of the plugins contained in the
+         * Browser assets is the same as the version of the plugins
+         * in the plugins directory.
+         * We simply iterate on every file in the assets/plugins
+         * and return false if a file listed in the assets does
+         * not exist in the plugins directory.
+         */
+        private boolean checkIsDifferentVersions() {
+          try {
+            ZipFile zip = new ZipFile(APK_PATH);
+            Vector<ZipEntry> files = pluginsFilesFromZip(zip);
+            int zipFilterLength = ZIP_FILTER.length();
+
+            Enumeration entries = files.elements();
+            while (entries.hasMoreElements()) {
+              ZipEntry entry = (ZipEntry) entries.nextElement();
+              String path = entry.getName().substring(zipFilterLength);
+              File outputFile = new File(pluginsPath, path);
+              if (!outputFile.exists()) {
+                if (Config.LOGV) {
+                  Log.v(TAG, "checkIsDifferentVersions(): extracted file "
+                    + path + " does not exist, we have a different version");
+                }
+                return true;
+              }
+            }
+          } catch (IOException e) {
+            Log.e(TAG, "Exception in checkDifferentVersions(): " + e);
+          }
+          return false;
+        }
+
+        /**
+         * Copy every files from the assets/plugins directory
+         * to the app_plugins directory in the data partition.
+         * Once copied, we copy over the SYSTEM_BUILD_INFOS file
+         * in the plugins directory.
+         *
+         * NOTE: we directly access the content from the Browser
+         * package (it's a zip file) and do not use AssetManager
+         * as there is a limit of 1Mb (see Asset.h)
+         */
+        public void run() {
+            // Lower the priority
+            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
+            try {
+                if (pluginsPath == null) {
+                    Log.e(TAG, "No plugins path found!");
+                    return;
+                }
+
+                ZipFile zip = new ZipFile(APK_PATH);
+                Vector<ZipEntry> files = pluginsFilesFromZip(zip);
+                Vector<File> plugins = new Vector<File>();
+                int zipFilterLength = ZIP_FILTER.length();
+
+                Enumeration entries = files.elements();
+                while (entries.hasMoreElements()) {
+                    ZipEntry entry = (ZipEntry) entries.nextElement();
+                    String path = entry.getName().substring(zipFilterLength);
+                    File outputFile = new File(pluginsPath, path);
+                    outputFile.getParentFile().mkdirs();
+
+                    if (outputFile.exists() && !mDoOverwrite) {
+                        if (Config.LOGV) {
+                            Log.v(TAG, path + " already extracted.");
+                        }
+                    } else {
+                        if (path.endsWith(PLUGIN_EXTENSION)) {
+                            // We rename plugins to be sure a half-copied
+                            // plugin is not loaded by the browser.
+                            plugins.add(outputFile);
+                            outputFile = new File(pluginsPath,
+                                path + TEMPORARY_EXTENSION);
+                        }
+                        FileOutputStream fos = new FileOutputStream(outputFile);
+                        if (Config.LOGV) {
+                            Log.v(TAG, "copy " + entry + " to "
+                                + pluginsPath + "/" + path);
+                        }
+                        copyStreams(zip.getInputStream(entry), fos);
+                    }
+                }
+
+                // We now rename the .so we copied, once all their resources
+                // are safely copied over to the user data partition.
+                Enumeration elems = plugins.elements();
+                while (elems.hasMoreElements()) {
+                    File renamedFile = (File) elems.nextElement();
+                    File sourceFile = new File(renamedFile.getPath()
+                        + TEMPORARY_EXTENSION);
+                    if (Config.LOGV) {
+                        Log.v(TAG, "rename " + sourceFile.getPath()
+                            + " to " + renamedFile.getPath());
+                    }
+                    sourceFile.renameTo(renamedFile);
+                }
+
+                copyBuildInfos();
+
+                // Refresh the plugin list.
+                if (mTabControl.getCurrentWebView() != null) {
+                    mTabControl.getCurrentWebView().refreshPlugins(false);
+                }
+            } catch (IOException e) {
+                Log.e(TAG, "IO Exception: " + e);
+            }
+        }
+    };
+
+    /**
+     * Copy the content of assets/plugins/ to the app_plugins directory
+     * in the data partition.
+     *
+     * This function is called every time the browser is started.
+     * We first check if the system image is newer than the one that
+     * copied the plugins (if there's plugins in the data partition).
+     * If this is the case, we then check if the versions are different.
+     * If they are different, we clean the plugins directory in the
+     * data partition, then start a thread to copy the plugins while
+     * the browser continue to load.
+     *
+     * @param overwrite if true overwrite the files even if they are
+     * already present (to let the user "reset" the plugins if needed).
+     */
+    private void copyPlugins(boolean overwrite) {
+        CopyPlugins copyPluginsFromAssets = new CopyPlugins(overwrite, this);
+        copyPluginsFromAssets.initPluginsPath();
+        if (copyPluginsFromAssets.newSystemImage())  {
+          if (copyPluginsFromAssets.checkIsDifferentVersions()) {
+            copyPluginsFromAssets.cleanPluginsDirectory();
+            Thread copyplugins = new Thread(copyPluginsFromAssets);
+            copyplugins.setName("CopyPlugins");
+            copyplugins.start();
+          }
+        }
+    }
+
+    private class ClearThumbnails extends AsyncTask<File, Void, Void> {
+        @Override
+        public Void doInBackground(File... files) {
+            if (files != null) {
+                for (File f : files) {
+                    f.delete();
+                }
+            }
+            return null;
+        }
+    }
+
+    @Override public void onCreate(Bundle icicle) {
+        if (Config.LOGV) {
+            Log.v(LOGTAG, this + " onStart");
+        }
+        super.onCreate(icicle);
+        this.requestWindowFeature(Window.FEATURE_LEFT_ICON);
+        this.requestWindowFeature(Window.FEATURE_RIGHT_ICON);
+        this.requestWindowFeature(Window.FEATURE_PROGRESS);
+        this.requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
+
+        // test the browser in OpenGL
+        // requestWindowFeature(Window.FEATURE_OPENGL);
+
+        setDefaultKeyMode(DEFAULT_KEYS_SEARCH_LOCAL);
+
+        mResolver = getContentResolver();
+
+        setBaseSearchUrl(PreferenceManager.getDefaultSharedPreferences(this)
+                .getString("search_url", ""));
+
+        //
+        // start MASF proxy service
+        //
+        //Intent proxyServiceIntent = new Intent();
+        //proxyServiceIntent.setComponent
+        //    (new ComponentName(
+        //        "com.android.masfproxyservice",
+        //        "com.android.masfproxyservice.MasfProxyService"));
+        //startService(proxyServiceIntent, null);
+
+        mSecLockIcon = Resources.getSystem().getDrawable(
+                android.R.drawable.ic_secure);
+        mMixLockIcon = Resources.getSystem().getDrawable(
+                android.R.drawable.ic_partial_secure);
+        mGenericFavicon = getResources().getDrawable(
+                R.drawable.app_web_browser_sm);
+
+        mContentView = (FrameLayout) getWindow().getDecorView().findViewById(
+                com.android.internal.R.id.content);
+
+        // Create the tab control and our initial tab
+        mTabControl = new TabControl(this);
+
+        // Open the icon database and retain all the bookmark urls for favicons
+        retainIconsOnStartup();
+
+        // Keep a settings instance handy.
+        mSettings = BrowserSettings.getInstance();
+        mSettings.setTabControl(mTabControl);
+        mSettings.loadFromDb(this);
+
+        PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
+        mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "Browser");
+
+        if (!mTabControl.restoreState(icicle)) {
+            // clear up the thumbnail directory if we can't restore the state as
+            // none of the files in the directory are referenced any more.
+            new ClearThumbnails().execute(
+                    mTabControl.getThumbnailDir().listFiles());
+            final Intent intent = getIntent();
+            final Bundle extra = intent.getExtras();
+            // Create an initial tab.
+            // If the intent is ACTION_VIEW and data is not null, the Browser is
+            // invoked to view the content by another application. In this case,
+            // the tab will be close when exit.
+            final TabControl.Tab t = mTabControl.createNewTab(
+                    Intent.ACTION_VIEW.equals(intent.getAction()) &&
+                    intent.getData() != null);
+            mTabControl.setCurrentTab(t);
+            // This is one of the only places we call attachTabToContentView
+            // without animating from the tab picker.
+            attachTabToContentView(t);
+            WebView webView = t.getWebView();
+            if (extra != null) {
+                int scale = extra.getInt(Browser.INITIAL_ZOOM_LEVEL, 0);
+                if (scale > 0 && scale <= 1000) {
+                    webView.setInitialScale(scale);
+                }
+            }
+            // If we are not restoring from an icicle, then there is a high
+            // likely hood this is the first run. So, check to see if the
+            // homepage needs to be configured and copy any plugins from our
+            // asset directory to the data partition.
+            if ((extra == null || !extra.getBoolean("testing"))
+                    && !mSettings.isLoginInitialized()) {
+                setupHomePage();
+            }
+            copyPlugins(true);
+
+            String url = getUrlFromIntent(intent);
+            if (url == null || url.length() == 0) {
+                if (mSettings.isLoginInitialized()) {
+                    webView.loadUrl(mSettings.getHomePage());
+                } else {
+                    waitForCredentials();
+                }
+            } else {
+                webView.loadUrl(url);
+            }
+        } else {
+            // TabControl.restoreState() will create a new tab even if
+            // restoring the state fails. Attach it to the view here since we
+            // are not animating from the tab picker.
+            attachTabToContentView(mTabControl.getCurrentTab());
+        }
+
+        /* enables registration for changes in network status from
+           http stack */
+        mNetworkStateChangedFilter = new IntentFilter();
+        mNetworkStateChangedFilter.addAction(
+                ConnectivityManager.CONNECTIVITY_ACTION);
+        mNetworkStateIntentReceiver = new BroadcastReceiver() {
+                @Override
+                public void onReceive(Context context, Intent intent) {
+                    if (intent.getAction().equals(
+                            ConnectivityManager.CONNECTIVITY_ACTION)) {
+                        boolean down = intent.getBooleanExtra(
+                                ConnectivityManager.EXTRA_NO_CONNECTIVITY, false);
+                        onNetworkToggle(!down);
+                    }
+                }
+            };
+    }
+
+    @Override
+    protected void onNewIntent(Intent intent) {
+        TabControl.Tab current = mTabControl.getCurrentTab();
+        // When a tab is closed on exit, the current tab index is set to -1.
+        // Reset before proceed as Browser requires the current tab to be set.
+        if (current == null) {
+            // Try to reset the tab in case the index was incorrect.
+            current = mTabControl.getTab(0);
+            if (current == null) {
+                // No tabs at all so just ignore this intent.
+                return;
+            }
+            mTabControl.setCurrentTab(current);
+            attachTabToContentView(current);
+            resetTitleAndIcon(current.getWebView());
+        }
+        final String action = intent.getAction();
+        final int flags = intent.getFlags();
+        if (Intent.ACTION_MAIN.equals(action) ||
+                (flags & Intent.FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY) != 0) {
+            // just resume the browser
+            return;
+        }
+        if (Intent.ACTION_VIEW.equals(action)
+                || Intent.ACTION_SEARCH.equals(action)
+                || MediaStore.INTENT_ACTION_MEDIA_SEARCH.equals(action)
+                || Intent.ACTION_WEB_SEARCH.equals(action)) {
+            String url = getUrlFromIntent(intent);
+            if (url == null || url.length() == 0) {
+                url = mSettings.getHomePage();
+            }
+            if (Intent.ACTION_VIEW.equals(action) &&
+                    (flags & Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT) != 0) {
+                // if FLAG_ACTIVITY_BROUGHT_TO_FRONT flag is on, the url will be
+                // opened in a new tab unless we have reached MAX_TABS. Then the
+                // url will be opened in the current tab. If a new tab is
+                // created, it will have "true" for exit on close.
+                openTabAndShow(url, null, true);
+            } else {
+                if ("about:debug".equals(url)) {
+                    mSettings.toggleDebugSettings();
+                    return;
+                }
+                // If the Window overview is up and we are not in the midst of
+                // an animation, animate away from the Window overview.
+                if (mTabOverview != null && mAnimationCount == 0) {
+                    sendAnimateFromOverview(current, false, url,
+                            TAB_OVERVIEW_DELAY, null);
+                } else {
+                    // Get rid of the subwindow if it exists
+                    dismissSubWindow(current);
+                    current.getWebView().loadUrl(url);
+                }
+            }
+        }
+    }
+
+    private String getUrlFromIntent(Intent intent) {
+        String url = null;
+        if (intent != null) {
+            final String action = intent.getAction();
+            if (Intent.ACTION_VIEW.equals(action)) {
+                url = smartUrlFilter(intent.getData());
+                if (url != null && url.startsWith("content:")) {
+                    /* Append mimetype so webview knows how to display */
+                    String mimeType = intent.resolveType(getContentResolver());
+                    if (mimeType != null) {
+                        url += "?" + mimeType;
+                    }
+                }
+            } else if (Intent.ACTION_SEARCH.equals(action)
+                    || MediaStore.INTENT_ACTION_MEDIA_SEARCH.equals(action)
+                    || Intent.ACTION_WEB_SEARCH.equals(action)) {
+                url = intent.getStringExtra(SearchManager.QUERY);
+                if (url != null) {
+                    mLastEnteredUrl = url;
+                    // Don't add Urls, just search terms.
+                    // Urls will get added when the page is loaded.
+                    if (!Regex.WEB_URL_PATTERN.matcher(url).matches()) {
+                        Browser.updateVisitedHistory(mResolver, url, false);
+                    }
+                    // In general, we shouldn't modify URL from Intent.
+                    // But currently, we get the user-typed URL from search box as well.
+                    url = fixUrl(url);
+                    url = smartUrlFilter(url);
+                    String searchSource = "&source=android-" + GOOGLE_SEARCH_SOURCE_SUGGEST + "&";
+                    if (url.contains(searchSource)) {
+                        String source = null;
+                        final Bundle appData = intent.getBundleExtra(SearchManager.APP_DATA);
+                        if (appData != null) {
+                            source = appData.getString(SearchManager.SOURCE);
+                        }
+                        if (TextUtils.isEmpty(source)) {
+                            source = GOOGLE_SEARCH_SOURCE_UNKNOWN;
+                        }
+                        url = url.replace(searchSource, "&source=android-"+source+"&");
+                    }
+                }
+            }
+        }
+        return url;
+    }
+
+    /* package */ static String fixUrl(String inUrl) {
+        if (inUrl.startsWith("http://") || inUrl.startsWith("https://"))
+            return inUrl;
+        if (inUrl.startsWith("http:") ||
+                inUrl.startsWith("https:")) {
+            if (inUrl.startsWith("http:/") || inUrl.startsWith("https:/")) {
+                inUrl = inUrl.replaceFirst("/", "//");
+            } else inUrl = inUrl.replaceFirst(":", "://");
+        }
+        return inUrl;
+    }
+
+    /**
+     * Looking for the pattern like this
+     *
+     *          *
+     *         * *
+     *      ***   *     *******
+     *             *   *
+     *              * *
+     *               *
+     */
+    private final SensorListener mSensorListener = new SensorListener() {
+        private long mLastGestureTime;
+        private float[] mPrev = new float[3];
+        private float[] mPrevDiff = new float[3];
+        private float[] mDiff = new float[3];
+        private float[] mRevertDiff = new float[3];
+
+        public void onSensorChanged(int sensor, float[] values) {
+            boolean show = false;
+            float[] diff = new float[3];
+
+            for (int i = 0; i < 3; i++) {
+                diff[i] = values[i] - mPrev[i];
+                if (Math.abs(diff[i]) > 1) {
+                    show = true;
+                }
+                if ((diff[i] > 1.0 && mDiff[i] < 0.2)
+                        || (diff[i] < -1.0 && mDiff[i] > -0.2)) {
+                    // start track when there is a big move, or revert
+                    mRevertDiff[i] = mDiff[i];
+                    mDiff[i] = 0;
+                } else if (diff[i] > -0.2 && diff[i] < 0.2) {
+                    // reset when it is flat
+                    mDiff[i] = mRevertDiff[i]  = 0;
+                }
+                mDiff[i] += diff[i];
+                mPrevDiff[i] = diff[i];
+                mPrev[i] = values[i];
+            }
+
+            if (false) {
+                // only shows if we think the delta is big enough, in an attempt
+                // to detect "serious" moves left/right or up/down
+                Log.d("BrowserSensorHack", "sensorChanged " + sensor + " ("
+                        + values[0] + ", " + values[1] + ", " + values[2] + ")"
+                        + " diff(" + diff[0] + " " + diff[1] + " " + diff[2]
+                        + ")");
+                Log.d("BrowserSensorHack", "      mDiff(" + mDiff[0] + " "
+                        + mDiff[1] + " " + mDiff[2] + ")" + " mRevertDiff("
+                        + mRevertDiff[0] + " " + mRevertDiff[1] + " "
+                        + mRevertDiff[2] + ")");
+            }
+
+            long now = android.os.SystemClock.uptimeMillis();
+            if (now - mLastGestureTime > 1000) {
+                mLastGestureTime = 0;
+
+                float y = mDiff[1];
+                float z = mDiff[2];
+                float ay = Math.abs(y);
+                float az = Math.abs(z);
+                float ry = mRevertDiff[1];
+                float rz = mRevertDiff[2];
+                float ary = Math.abs(ry);
+                float arz = Math.abs(rz);
+                boolean gestY = ay > 2.5f && ary > 1.0f && ay > ary;
+                boolean gestZ = az > 3.5f && arz > 1.0f && az > arz;
+
+                if ((gestY || gestZ) && !(gestY && gestZ)) {
+                    WebView view = mTabControl.getCurrentWebView();
+
+                    if (view != null) {
+                        if (gestZ) {
+                            if (z < 0) {
+                                view.zoomOut();
+                            } else {
+                                view.zoomIn();
+                            }
+                        } else {
+                            view.flingScroll(0, Math.round(y * 100));
+                        }
+                    }
+                    mLastGestureTime = now;
+                }
+            }
+        }
+
+        public void onAccuracyChanged(int sensor, int accuracy) {
+            // TODO Auto-generated method stub
+
+        }
+    };
+
+    @Override protected void onResume() {
+        super.onResume();
+        if (Config.LOGV) {
+            Log.v(LOGTAG, "BrowserActivity.onResume: this=" + this);
+        }
+
+        if (!mActivityInPause) {
+            Log.e(LOGTAG, "BrowserActivity is already resumed.");
+            return;
+        }
+
+        mActivityInPause = false;
+        resumeWebView();
+
+        if (mWakeLock.isHeld()) {
+            mHandler.removeMessages(RELEASE_WAKELOCK);
+            mWakeLock.release();
+        }
+
+        if (mCredsDlg != null) {
+            if (!mHandler.hasMessages(CANCEL_CREDS_REQUEST)) {
+             // In case credential request never comes back
+                mHandler.sendEmptyMessageDelayed(CANCEL_CREDS_REQUEST, 6000);
+            }
+        }
+
+        registerReceiver(mNetworkStateIntentReceiver,
+                         mNetworkStateChangedFilter);
+        WebView.enablePlatformNotifications();
+
+        if (mSettings.doFlick()) {
+            if (mSensorManager == null) {
+                mSensorManager = (SensorManager) getSystemService(
+                        Context.SENSOR_SERVICE);
+            }
+            mSensorManager.registerListener(mSensorListener,
+                    SensorManager.SENSOR_ACCELEROMETER,
+                    SensorManager.SENSOR_DELAY_FASTEST);
+        } else {
+            mSensorManager = null;
+        }
+    }
+
+    /**
+     *  onSaveInstanceState(Bundle map)
+     *  onSaveInstanceState is called right before onStop(). The map contains
+     *  the saved state.
+     */
+    @Override protected void onSaveInstanceState(Bundle outState) {
+        if (Config.LOGV) {
+            Log.v(LOGTAG, "BrowserActivity.onSaveInstanceState: this=" + this);
+        }
+        // the default implementation requires each view to have an id. As the
+        // browser handles the state itself and it doesn't use id for the views,
+        // don't call the default implementation. Otherwise it will trigger the
+        // warning like this, "couldn't save which view has focus because the
+        // focused view XXX has no id".
+
+        // Save all the tabs
+        mTabControl.saveState(outState);
+    }
+
+    @Override protected void onPause() {
+        super.onPause();
+
+        if (mActivityInPause) {
+            Log.e(LOGTAG, "BrowserActivity is already paused.");
+            return;
+        }
+
+        mActivityInPause = true;
+        if (mTabControl.getCurrentIndex() >= 0 && !pauseWebView()) {
+            mWakeLock.acquire();
+            mHandler.sendMessageDelayed(mHandler
+                    .obtainMessage(RELEASE_WAKELOCK), WAKELOCK_TIMEOUT);
+        }
+
+        // Clear the credentials toast if it is up
+        if (mCredsDlg != null && mCredsDlg.isShowing()) {
+            mCredsDlg.dismiss();
+        }
+        mCredsDlg = null;
+
+        cancelStopToast();
+
+        // unregister network state listener
+        unregisterReceiver(mNetworkStateIntentReceiver);
+        WebView.disablePlatformNotifications();
+
+        if (mSensorManager != null) {
+            mSensorManager.unregisterListener(mSensorListener);
+        }
+    }
+
+    @Override protected void onDestroy() {
+        if (Config.LOGV) {
+            Log.v(LOGTAG, "BrowserActivity.onDestroy: this=" + this);
+        }
+        super.onDestroy();
+        // Remove the current tab and sub window
+        TabControl.Tab t = mTabControl.getCurrentTab();
+        dismissSubWindow(t);
+        removeTabFromContentView(t);
+        // Destroy all the tabs
+        mTabControl.destroy();
+        WebIconDatabase.getInstance().close();
+        if (mGlsConnection != null) {
+            unbindService(mGlsConnection);
+            mGlsConnection = null;
+        }
+
+        //
+        // stop MASF proxy service
+        //
+        //Intent proxyServiceIntent = new Intent();
+        //proxyServiceIntent.setComponent
+        //   (new ComponentName(
+        //        "com.android.masfproxyservice",
+        //        "com.android.masfproxyservice.MasfProxyService"));
+        //stopService(proxyServiceIntent);
+    }
+
+    @Override
+    public void onConfigurationChanged(Configuration newConfig) {
+        super.onConfigurationChanged(newConfig);
+
+        if (mPageInfoDialog != null) {
+            mPageInfoDialog.dismiss();
+            showPageInfo(
+                mPageInfoView,
+                mPageInfoFromShowSSLCertificateOnError.booleanValue());
+        }
+        if (mSSLCertificateDialog != null) {
+            mSSLCertificateDialog.dismiss();
+            showSSLCertificate(
+                mSSLCertificateView);
+        }
+        if (mSSLCertificateOnErrorDialog != null) {
+            mSSLCertificateOnErrorDialog.dismiss();
+            showSSLCertificateOnError(
+                mSSLCertificateOnErrorView,
+                mSSLCertificateOnErrorHandler,
+                mSSLCertificateOnErrorError);
+        }
+        if (mHttpAuthenticationDialog != null) {
+            String title = ((TextView) mHttpAuthenticationDialog
+                    .findViewById(com.android.internal.R.id.alertTitle)).getText()
+                    .toString();
+            String name = ((TextView) mHttpAuthenticationDialog
+                    .findViewById(R.id.username_edit)).getText().toString();
+            String password = ((TextView) mHttpAuthenticationDialog
+                    .findViewById(R.id.password_edit)).getText().toString();
+            int focusId = mHttpAuthenticationDialog.getCurrentFocus()
+                    .getId();
+            mHttpAuthenticationDialog.dismiss();
+            showHttpAuthentication(mHttpAuthHandler, null, null, title,
+                    name, password, focusId);
+        }
+        if (mFindDialog != null && mFindDialog.isShowing()) {
+            mFindDialog.onConfigurationChanged(newConfig);
+        }
+    }
+
+    @Override public void onLowMemory() {
+        super.onLowMemory();
+        mTabControl.freeMemory();
+    }
+
+    private boolean resumeWebView() {
+        if ((!mActivityInPause && !mPageStarted) ||
+                (mActivityInPause && mPageStarted)) {
+            CookieSyncManager.getInstance().startSync();
+            WebView w = mTabControl.getCurrentWebView();
+            if (w != null) {
+                w.resumeTimers();
+            }
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    private boolean pauseWebView() {
+        if (mActivityInPause && !mPageStarted) {
+            CookieSyncManager.getInstance().stopSync();
+            WebView w = mTabControl.getCurrentWebView();
+            if (w != null) {
+                w.pauseTimers();
+            }
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /*
+     * This function is called when we are launching for the first time. We
+     * are waiting for the login credentials before loading Google home
+     * pages. This way the user will be logged in straight away.
+     */
+    private void waitForCredentials() {
+        // Show a toast
+        mCredsDlg = new ProgressDialog(this);
+        mCredsDlg.setIndeterminate(true);
+        mCredsDlg.setMessage(getText(R.string.retrieving_creds_dlg_msg));
+        // If the user cancels the operation, then cancel the Google
+        // Credentials request.
+        mCredsDlg.setCancelMessage(mHandler.obtainMessage(CANCEL_CREDS_REQUEST));
+        mCredsDlg.show();
+
+        // We set a timeout for the retrieval of credentials in onResume()
+        // as that is when we have freed up some CPU time to get
+        // the login credentials.
+    }
+
+    /*
+     * If we have received the credentials or we have timed out and we are
+     * showing the credentials dialog, then it is time to move on.
+     */
+    private void resumeAfterCredentials() {
+        if (mCredsDlg == null) {
+            return;
+        }
+
+        // Clear the toast
+        if (mCredsDlg.isShowing()) {
+            mCredsDlg.dismiss();
+        }
+        mCredsDlg = null;
+
+        // Clear any pending timeout
+        mHandler.removeMessages(CANCEL_CREDS_REQUEST);
+
+        // Load the page
+        WebView w = mTabControl.getCurrentWebView();
+        if (w != null) {
+            w.loadUrl(mSettings.getHomePage());
+        }
+
+        // Update the settings, need to do this last as it can take a moment
+        // to persist the settings. In the mean time we could be loading
+        // content.
+        mSettings.setLoginInitialized(this);
+    }
+
+    // Open the icon database and retain all the icons for visited sites.
+    private void retainIconsOnStartup() {
+        final WebIconDatabase db = WebIconDatabase.getInstance();
+        db.open(getDir("icons", 0).getPath());
+        try {
+            Cursor c = Browser.getAllBookmarks(mResolver);
+            if (!c.moveToFirst()) {
+                c.deactivate();
+                return;
+            }
+            int urlIndex = c.getColumnIndex(Browser.BookmarkColumns.URL);
+            do {
+                String url = c.getString(urlIndex);
+                db.retainIconForPageUrl(url);
+            } while (c.moveToNext());
+            c.deactivate();
+        } catch (IllegalStateException e) {
+            Log.e(LOGTAG, "retainIconsOnStartup", e);
+        }
+    }
+
+    // Helper method for getting the top window.
+    WebView getTopWindow() {
+        return mTabControl.getCurrentTopWebView();
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        super.onCreateOptionsMenu(menu);
+
+        MenuInflater inflater = getMenuInflater();
+        inflater.inflate(R.menu.browser, menu);
+        mMenu = menu;
+        updateInLoadMenuItems();
+        return true;
+    }
+
+    /**
+     * As the menu can be open when loading state changes
+     * we must manually update the state of the stop/reload menu
+     * item
+     */
+    private void updateInLoadMenuItems() {
+        if (mMenu == null) {
+            return;
+        }
+        MenuItem src = mInLoad ?
+                mMenu.findItem(R.id.stop_menu_id):
+                    mMenu.findItem(R.id.reload_menu_id);
+        MenuItem dest = mMenu.findItem(R.id.stop_reload_menu_id);
+        dest.setIcon(src.getIcon());
+        dest.setTitle(src.getTitle());
+    }
+
+    @Override
+    public boolean onContextItemSelected(MenuItem item) {
+        // chording is not an issue with context menus, but we use the same
+        // options selector, so set mCanChord to true so we can access them.
+        mCanChord = true;
+        int id = item.getItemId();
+        final WebView webView = getTopWindow();
+        final HashMap hrefMap = new HashMap();
+        hrefMap.put("webview", webView);
+        final Message msg = mHandler.obtainMessage(
+                FOCUS_NODE_HREF, id, 0, hrefMap);
+        switch (id) {
+            // -- Browser context menu
+            case R.id.open_context_menu_id:
+            case R.id.open_newtab_context_menu_id:
+            case R.id.bookmark_context_menu_id:
+            case R.id.save_link_context_menu_id:
+            case R.id.share_link_context_menu_id:
+            case R.id.copy_link_context_menu_id:
+                webView.requestFocusNodeHref(msg);
+                break;
+
+            default:
+                // For other context menus
+                return onOptionsItemSelected(item);
+        }
+        mCanChord = false;
+        return true;
+    }
+
+    private Bundle createGoogleSearchSourceBundle(String source) {
+        Bundle bundle = new Bundle();
+        bundle.putString(SearchManager.SOURCE, source);
+        return bundle;
+    }
+
+    /**
+     * Overriding this forces the search key to launch global search.  The difference
+     * is the final "true" which requests global search.
+     */
+    @Override
+    public boolean onSearchRequested() {
+        startSearch(null, false,
+                createGoogleSearchSourceBundle(GOOGLE_SEARCH_SOURCE_SEARCHKEY), true);
+        return true;
+    }
+
+    @Override
+    public void startSearch(String initialQuery, boolean selectInitialQuery,
+            Bundle appSearchData, boolean globalSearch) {
+        if (appSearchData == null) {
+            appSearchData = createGoogleSearchSourceBundle(GOOGLE_SEARCH_SOURCE_TYPE);
+        }
+        super.startSearch(initialQuery, selectInitialQuery, appSearchData, globalSearch);
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        if (!mCanChord) {
+            // The user has already fired a shortcut with this hold down of the
+            // menu key.
+            return false;
+        }
+        switch (item.getItemId()) {
+            // -- Main menu
+            case R.id.goto_menu_id: {
+                String url = getTopWindow().getUrl();
+                startSearch(mSettings.getHomePage().equals(url) ? null : url, true,
+                        createGoogleSearchSourceBundle(GOOGLE_SEARCH_SOURCE_GOTO), false);
+                }
+                break;
+
+            case R.id.bookmarks_menu_id:
+                bookmarksOrHistoryPicker(false);
+                break;
+
+            case R.id.windows_menu_id:
+                if (mTabControl.getTabCount() == 1) {
+                    openTabAndShow(mSettings.getHomePage(), null, false);
+                } else {
+                    tabPicker(true, mTabControl.getCurrentIndex(), false);
+                }
+                break;
+
+            case R.id.stop_reload_menu_id:
+                if (mInLoad) {
+                    stopLoading();
+                } else {
+                    getTopWindow().reload();
+                }
+                break;
+
+            case R.id.back_menu_id:
+                getTopWindow().goBack();
+                break;
+
+            case R.id.forward_menu_id:
+                getTopWindow().goForward();
+                break;
+
+            case R.id.close_menu_id:
+                // Close the subwindow if it exists.
+                if (mTabControl.getCurrentSubWindow() != null) {
+                    dismissSubWindow(mTabControl.getCurrentTab());
+                    break;
+                }
+                final int currentIndex = mTabControl.getCurrentIndex();
+                final TabControl.Tab parent =
+                        mTabControl.getCurrentTab().getParentTab();
+                int indexToShow = -1;
+                if (parent != null) {
+                    indexToShow = mTabControl.getTabIndex(parent);
+                } else {
+                    // Get the last tab in the list. If it is the current tab,
+                    // subtract 1 more.
+                    indexToShow = mTabControl.getTabCount() - 1;
+                    if (currentIndex == indexToShow) {
+                        indexToShow--;
+                    }
+                }
+                switchTabs(currentIndex, indexToShow, true);
+                break;
+
+            case R.id.homepage_menu_id:
+                TabControl.Tab current = mTabControl.getCurrentTab();
+                if (current != null) {
+                    dismissSubWindow(current);
+                    current.getWebView().loadUrl(mSettings.getHomePage());
+                }
+                break;
+
+            case R.id.preferences_menu_id:
+                Intent intent = new Intent(this,
+                        BrowserPreferencesPage.class);
+                startActivityForResult(intent, PREFERENCES_PAGE);
+                break;
+
+            case R.id.find_menu_id:
+                if (null == mFindDialog) {
+                    mFindDialog = new FindDialog(this);
+                }
+                mFindDialog.setWebView(getTopWindow());
+                mFindDialog.show();
+                mMenuState = EMPTY_MENU;
+                break;
+
+            case R.id.select_text_id:
+                getTopWindow().emulateShiftHeld();
+                break;
+            case R.id.page_info_menu_id:
+                showPageInfo(mTabControl.getCurrentTab(), false);
+                break;
+
+            case R.id.classic_history_menu_id:
+                bookmarksOrHistoryPicker(true);
+                break;
+
+            case R.id.share_page_menu_id:
+                Browser.sendString(this, getTopWindow().getUrl());
+                break;
+
+            case R.id.dump_nav_menu_id:
+                getTopWindow().debugDump();
+                break;
+
+            case R.id.zoom_in_menu_id:
+                getTopWindow().zoomIn();
+                break;
+
+            case R.id.zoom_out_menu_id:
+                getTopWindow().zoomOut();
+                break;
+
+            case R.id.view_downloads_menu_id:
+                viewDownloads(null);
+                break;
+
+            // -- Tab menu
+            case R.id.view_tab_menu_id:
+                if (mTabListener != null && mTabOverview != null) {
+                    int pos = mTabOverview.getContextMenuPosition(item);
+                    mTabOverview.setCurrentIndex(pos);
+                    mTabListener.onClick(pos);
+                }
+                break;
+
+            case R.id.remove_tab_menu_id:
+                if (mTabListener != null && mTabOverview != null) {
+                    int pos = mTabOverview.getContextMenuPosition(item);
+                    mTabListener.remove(pos);
+                }
+                break;
+
+            case R.id.new_tab_menu_id:
+                // No need to check for mTabOverview here since we are not
+                // dependent on it for a position.
+                if (mTabListener != null) {
+                    // If the overview happens to be non-null, make the "New
+                    // Tab" cell visible.
+                    if (mTabOverview != null) {
+                        mTabOverview.setCurrentIndex(ImageGrid.NEW_TAB);
+                    }
+                    mTabListener.onClick(ImageGrid.NEW_TAB);
+                }
+                break;
+
+            case R.id.bookmark_tab_menu_id:
+                if (mTabListener != null && mTabOverview != null) {
+                    int pos = mTabOverview.getContextMenuPosition(item);
+                    TabControl.Tab t = mTabControl.getTab(pos);
+                    // Since we called populatePickerData for all of the
+                    // tabs, getTitle and getUrl will return appropriate
+                    // values.
+                    Browser.saveBookmark(BrowserActivity.this, t.getTitle(),
+                            t.getUrl());
+                }
+                break;
+
+            case R.id.history_tab_menu_id:
+                bookmarksOrHistoryPicker(true);
+                break;
+
+            case R.id.bookmarks_tab_menu_id:
+                bookmarksOrHistoryPicker(false);
+                break;
+
+            case R.id.properties_tab_menu_id:
+                if (mTabListener != null && mTabOverview != null) {
+                    int pos = mTabOverview.getContextMenuPosition(item);
+                    showPageInfo(mTabControl.getTab(pos), false);
+                }
+                break;
+
+            case R.id.window_one_menu_id:
+            case R.id.window_two_menu_id:
+            case R.id.window_three_menu_id:
+            case R.id.window_four_menu_id:
+            case R.id.window_five_menu_id:
+            case R.id.window_six_menu_id:
+            case R.id.window_seven_menu_id:
+            case R.id.window_eight_menu_id:
+                {
+                    int menuid = item.getItemId();
+                    for (int id = 0; id < WINDOW_SHORTCUT_ID_ARRAY.length; id++) {
+                        if (WINDOW_SHORTCUT_ID_ARRAY[id] == menuid) {
+                            TabControl.Tab desiredTab = mTabControl.getTab(id);
+                            if (desiredTab != null &&
+                                    desiredTab != mTabControl.getCurrentTab()) {
+                                switchTabs(mTabControl.getCurrentIndex(), id, false);
+                            }
+                            break;
+                        }
+                    }
+                }
+                break;
+
+            default:
+                if (!super.onOptionsItemSelected(item)) {
+                    return false;
+                }
+                // Otherwise fall through.
+        }
+        mCanChord = false;
+        return true;
+    }
+
+    public void closeFind() {
+        mMenuState = R.id.MAIN_MENU;
+    }
+
+    @Override public boolean onPrepareOptionsMenu(Menu menu)
+    {
+        // This happens when the user begins to hold down the menu key, so
+        // allow them to chord to get a shortcut.
+        mCanChord = true;
+        // Note: setVisible will decide whether an item is visible; while
+        // setEnabled() will decide whether an item is enabled, which also means
+        // whether the matching shortcut key will function.
+        super.onPrepareOptionsMenu(menu);
+        switch (mMenuState) {
+            case R.id.TAB_MENU:
+                if (mCurrentMenuState != mMenuState) {
+                    menu.setGroupVisible(R.id.MAIN_MENU, false);
+                    menu.setGroupEnabled(R.id.MAIN_MENU, false);
+                    menu.setGroupEnabled(R.id.MAIN_SHORTCUT_MENU, false);
+                    menu.setGroupVisible(R.id.TAB_MENU, true);
+                    menu.setGroupEnabled(R.id.TAB_MENU, true);
+                }
+                boolean newT = mTabControl.getTabCount() < TabControl.MAX_TABS;
+                final MenuItem tab = menu.findItem(R.id.new_tab_menu_id);
+                tab.setVisible(newT);
+                tab.setEnabled(newT);
+                break;
+            case EMPTY_MENU:
+                if (mCurrentMenuState != mMenuState) {
+                    menu.setGroupVisible(R.id.MAIN_MENU, false);
+                    menu.setGroupEnabled(R.id.MAIN_MENU, false);
+                    menu.setGroupEnabled(R.id.MAIN_SHORTCUT_MENU, false);
+                    menu.setGroupVisible(R.id.TAB_MENU, false);
+                    menu.setGroupEnabled(R.id.TAB_MENU, false);
+                }
+                break;
+            default:
+                if (mCurrentMenuState != mMenuState) {
+                    menu.setGroupVisible(R.id.MAIN_MENU, true);
+                    menu.setGroupEnabled(R.id.MAIN_MENU, true);
+                    menu.setGroupEnabled(R.id.MAIN_SHORTCUT_MENU, true);
+                    menu.setGroupVisible(R.id.TAB_MENU, false);
+                    menu.setGroupEnabled(R.id.TAB_MENU, false);
+                }
+                final WebView w = getTopWindow();
+                boolean canGoBack = false;
+                boolean canGoForward = false;
+                boolean isHome = false;
+                if (w != null) {
+                    canGoBack = w.canGoBack();
+                    canGoForward = w.canGoForward();
+                    isHome = mSettings.getHomePage().equals(w.getUrl());
+                }
+                final MenuItem back = menu.findItem(R.id.back_menu_id);
+                back.setEnabled(canGoBack);
+
+                final MenuItem home = menu.findItem(R.id.homepage_menu_id);
+                home.setEnabled(!isHome);
+
+                menu.findItem(R.id.forward_menu_id)
+                        .setEnabled(canGoForward);
+
+                // decide whether to show the share link option
+                PackageManager pm = getPackageManager();
+                Intent send = new Intent(Intent.ACTION_SEND);
+                send.setType("text/plain");
+                ResolveInfo ri = pm.resolveActivity(send, PackageManager.MATCH_DEFAULT_ONLY);
+                menu.findItem(R.id.share_page_menu_id).setVisible(ri != null);
+
+                // If there is only 1 window, the text will be "New window"
+                final MenuItem windows = menu.findItem(R.id.windows_menu_id);
+                windows.setTitleCondensed(mTabControl.getTabCount() > 1 ?
+                        getString(R.string.view_tabs_condensed) :
+                        getString(R.string.tab_picker_new_tab));
+
+                boolean isNavDump = mSettings.isNavDump();
+                final MenuItem nav = menu.findItem(R.id.dump_nav_menu_id);
+                nav.setVisible(isNavDump);
+                nav.setEnabled(isNavDump);
+                break;
+        }
+        mCurrentMenuState = mMenuState;
+        return true;
+    }
+
+    @Override
+    public void onCreateContextMenu(ContextMenu menu, View v,
+            ContextMenuInfo menuInfo) {
+        WebView webview = (WebView) v;
+        WebView.HitTestResult result = webview.getHitTestResult();
+        if (result == null) {
+            return;
+        }
+
+        int type = result.getType();
+        if (type == WebView.HitTestResult.UNKNOWN_TYPE) {
+            Log.w(LOGTAG,
+                    "We should not show context menu when nothing is touched");
+            return;
+        }
+        if (type == WebView.HitTestResult.EDIT_TEXT_TYPE) {
+            // let TextView handles context menu
+            return;
+        }
+
+        // Note, http://b/issue?id=1106666 is requesting that
+        // an inflated menu can be used again. This is not available
+        // yet, so inflate each time (yuk!)
+        MenuInflater inflater = getMenuInflater();
+        inflater.inflate(R.menu.browsercontext, menu);
+
+        // Show the correct menu group
+        String extra = result.getExtra();
+        menu.setGroupVisible(R.id.PHONE_MENU,
+                type == WebView.HitTestResult.PHONE_TYPE);
+        menu.setGroupVisible(R.id.EMAIL_MENU,
+                type == WebView.HitTestResult.EMAIL_TYPE);
+        menu.setGroupVisible(R.id.GEO_MENU,
+                type == WebView.HitTestResult.GEO_TYPE);
+        menu.setGroupVisible(R.id.IMAGE_MENU,
+                type == WebView.HitTestResult.IMAGE_TYPE
+                || type == WebView.HitTestResult.SRC_IMAGE_ANCHOR_TYPE);
+        menu.setGroupVisible(R.id.ANCHOR_MENU,
+                type == WebView.HitTestResult.SRC_ANCHOR_TYPE
+                || type == WebView.HitTestResult.SRC_IMAGE_ANCHOR_TYPE);
+
+        // Setup custom handling depending on the type
+        switch (type) {
+            case WebView.HitTestResult.PHONE_TYPE:
+                menu.setHeaderTitle(Uri.decode(extra));
+                menu.findItem(R.id.dial_context_menu_id).setIntent(
+                        new Intent(Intent.ACTION_VIEW, Uri
+                                .parse(WebView.SCHEME_TEL + extra)));
+                Intent addIntent = new Intent(Intent.ACTION_INSERT_OR_EDIT);
+                addIntent.putExtra(Insert.PHONE, Uri.decode(extra));
+                addIntent.setType(Contacts.People.CONTENT_ITEM_TYPE);
+                menu.findItem(R.id.add_contact_context_menu_id).setIntent(
+                        addIntent);
+                menu.findItem(R.id.copy_phone_context_menu_id).setOnMenuItemClickListener(
+                        new Copy(extra));
+                break;
+
+            case WebView.HitTestResult.EMAIL_TYPE:
+                menu.setHeaderTitle(extra);
+                menu.findItem(R.id.email_context_menu_id).setIntent(
+                        new Intent(Intent.ACTION_VIEW, Uri
+                                .parse(WebView.SCHEME_MAILTO + extra)));
+                menu.findItem(R.id.copy_mail_context_menu_id).setOnMenuItemClickListener(
+                        new Copy(extra));
+                break;
+
+            case WebView.HitTestResult.GEO_TYPE:
+                menu.setHeaderTitle(extra);
+                menu.findItem(R.id.map_context_menu_id).setIntent(
+                        new Intent(Intent.ACTION_VIEW, Uri
+                                .parse(WebView.SCHEME_GEO
+                                        + URLEncoder.encode(extra))));
+                menu.findItem(R.id.copy_geo_context_menu_id).setOnMenuItemClickListener(
+                        new Copy(extra));
+                break;
+
+            case WebView.HitTestResult.SRC_ANCHOR_TYPE:
+            case WebView.HitTestResult.SRC_IMAGE_ANCHOR_TYPE:
+                TextView titleView = (TextView) LayoutInflater.from(this)
+                        .inflate(android.R.layout.browser_link_context_header,
+                        null);
+                titleView.setText(extra);
+                menu.setHeaderView(titleView);
+                // decide whether to show the open link in new tab option
+                menu.findItem(R.id.open_newtab_context_menu_id).setVisible(
+                        mTabControl.getTabCount() < TabControl.MAX_TABS);
+                PackageManager pm = getPackageManager();
+                Intent send = new Intent(Intent.ACTION_SEND);
+                send.setType("text/plain");
+                ResolveInfo ri = pm.resolveActivity(send, PackageManager.MATCH_DEFAULT_ONLY);
+                menu.findItem(R.id.share_link_context_menu_id).setVisible(ri != null);
+                if (type == WebView.HitTestResult.SRC_ANCHOR_TYPE) {
+                    break;
+                }
+                // otherwise fall through to handle image part
+            case WebView.HitTestResult.IMAGE_TYPE:
+                if (type == WebView.HitTestResult.IMAGE_TYPE) {
+                    menu.setHeaderTitle(extra);
+                }
+                menu.findItem(R.id.view_image_context_menu_id).setIntent(
+                        new Intent(Intent.ACTION_VIEW, Uri.parse(extra)));
+                menu.findItem(R.id.download_context_menu_id).
+                        setOnMenuItemClickListener(new Download(extra));
+                break;
+
+            default:
+                Log.w(LOGTAG, "We should not get here.");
+                break;
+        }
+    }
+
+    // Used by attachTabToContentView for the WebView's ZoomControl widget.
+    private static final FrameLayout.LayoutParams ZOOM_PARAMS =
+            new FrameLayout.LayoutParams(
+                    ViewGroup.LayoutParams.FILL_PARENT,
+                    ViewGroup.LayoutParams.WRAP_CONTENT,
+                    Gravity.BOTTOM);
+
+    // Attach the given tab to the content view.
+    private void attachTabToContentView(TabControl.Tab t) {
+        final WebView main = t.getWebView();
+        // Attach the main WebView.
+        mContentView.addView(main, COVER_SCREEN_PARAMS);
+        // Attach the Zoom control widget and hide it.
+        final View zoom = main.getZoomControls();
+        mContentView.addView(zoom, ZOOM_PARAMS);
+        zoom.setVisibility(View.GONE);
+        // Attach the sub window if necessary
+        attachSubWindow(t);
+        // Request focus on the top window.
+        t.getTopWindow().requestFocus();
+    }
+
+    // Attach a sub window to the main WebView of the given tab.
+    private void attachSubWindow(TabControl.Tab t) {
+        // If a sub window exists, attach it to the content view.
+        final WebView subView = t.getSubWebView();
+        if (subView != null) {
+            final View container = t.getSubWebViewContainer();
+            mContentView.addView(container, COVER_SCREEN_PARAMS);
+            subView.requestFocus();
+        }
+    }
+
+    // Remove the given tab from the content view.
+    private void removeTabFromContentView(TabControl.Tab t) {
+        // Remove the Zoom widget and the main WebView.
+        mContentView.removeView(t.getWebView().getZoomControls());
+        mContentView.removeView(t.getWebView());
+        // Remove the sub window if it exists.
+        if (t.getSubWebView() != null) {
+            mContentView.removeView(t.getSubWebViewContainer());
+        }
+    }
+
+    // Remove the sub window if it exists. Also called by TabControl when the
+    // user clicks the 'X' to dismiss a sub window.
+    /* package */ void dismissSubWindow(TabControl.Tab t) {
+        final WebView mainView = t.getWebView();
+        if (t.getSubWebView() != null) {
+            // Remove the container view and request focus on the main WebView.
+            mContentView.removeView(t.getSubWebViewContainer());
+            mainView.requestFocus();
+            // Tell the TabControl to dismiss the subwindow. This will destroy
+            // the WebView.
+            mTabControl.dismissSubWindow(t);
+        }
+    }
+
+    // Send the ANIMTE_FROM_OVERVIEW message after changing the current tab.
+    private void sendAnimateFromOverview(final TabControl.Tab tab,
+            final boolean newTab, final String url, final int delay,
+            final Message msg) {
+        // Set the current tab.
+        mTabControl.setCurrentTab(tab);
+        // Attach the WebView so it will layout.
+        attachTabToContentView(tab);
+        // Set the view to invisibile for now.
+        tab.getWebView().setVisibility(View.INVISIBLE);
+        // If there is a sub window, make it invisible too.
+        if (tab.getSubWebView() != null) {
+            tab.getSubWebViewContainer().setVisibility(View.INVISIBLE);
+        }
+        // Create our fake animating view.
+        final AnimatingView view = new AnimatingView(this, tab);
+        // Attach it to the view system and make in invisible so it will
+        // layout but not flash white on the screen.
+        mContentView.addView(view, COVER_SCREEN_PARAMS);
+        view.setVisibility(View.INVISIBLE);
+        // Send the animate message.
+        final HashMap map = new HashMap();
+        map.put("view", view);
+        // Load the url after the AnimatingView has captured the picture. This
+        // prevents any bad layout or bad scale from being used during
+        // animation.
+        if (url != null) {
+            dismissSubWindow(tab);
+            tab.getWebView().loadUrl(url);
+        }
+        map.put("msg", msg);
+        mHandler.sendMessageDelayed(mHandler.obtainMessage(
+                ANIMATE_FROM_OVERVIEW, newTab ? 1 : 0, 0, map), delay);
+        // Increment the count to indicate that we are in an animation.
+        mAnimationCount++;
+        // Remove the listener so we don't get any more tab changes.
+        mTabOverview.setListener(null);
+        mTabListener = null;
+        // Make the menu empty until the animation completes.
+        mMenuState = EMPTY_MENU;
+
+    }
+
+    // 500ms animation with 800ms delay
+    private static final int TAB_ANIMATION_DURATION = 500;
+    private static final int TAB_OVERVIEW_DELAY     = 800;
+
+    // Called by TabControl when a tab is requesting focus
+    /* package */ void showTab(TabControl.Tab t) {
+        // Disallow focus change during a tab animation.
+        if (mAnimationCount > 0) {
+            return;
+        }
+        int delay = 0;
+        if (mTabOverview == null) {
+            // Add a delay so the tab overview can be shown before the second
+            // animation begins.
+            delay = TAB_ANIMATION_DURATION + TAB_OVERVIEW_DELAY;
+            tabPicker(false, mTabControl.getTabIndex(t), false);
+        }
+        sendAnimateFromOverview(t, false, null, delay, null);
+    }
+
+    // This method does a ton of stuff. It will attempt to create a new tab
+    // if we haven't reached MAX_TABS. Otherwise it uses the current tab. If
+    // url isn't null, it will load the given url. If the tab overview is not
+    // showing, it will animate to the tab overview, create a new tab and
+    // animate away from it. After the animation completes, it will dispatch
+    // the given Message. If the tab overview is already showing (i.e. this
+    // method is called from TabListener.onClick(), the method will animate
+    // away from the tab overview.
+    private void openTabAndShow(String url, final Message msg,
+            boolean closeOnExit) {
+        final boolean newTab = mTabControl.getTabCount() != TabControl.MAX_TABS;
+        final TabControl.Tab currentTab = mTabControl.getCurrentTab();
+        if (newTab) {
+            int delay = 0;
+            // If the tab overview is up and there are animations, just load
+            // the url.
+            if (mTabOverview != null && mAnimationCount > 0) {
+                if (url != null) {
+                    // We should not have a msg here since onCreateWindow
+                    // checks the animation count and every other caller passes
+                    // null.
+                    assert msg == null;
+                    // just dismiss the subwindow and load the given url.
+                    dismissSubWindow(currentTab);
+                    currentTab.getWebView().loadUrl(url);
+                }
+            } else {
+                // show mTabOverview if it is not there.
+                if (mTabOverview == null) {
+                    // We have to delay the animation from the tab picker by the
+                    // length of the tab animation. Add a delay so the tab
+                    // overview can be shown before the second animation begins.
+                    delay = TAB_ANIMATION_DURATION + TAB_OVERVIEW_DELAY;
+                    tabPicker(false, ImageGrid.NEW_TAB, false);
+                }
+                // Animate from the Tab overview after any animations have
+                // finished.
+                sendAnimateFromOverview(mTabControl.createNewTab(closeOnExit),
+                        true, url, delay, msg);
+            }
+        } else if (url != null) {
+            // We should not have a msg here.
+            assert msg == null;
+            if (mTabOverview != null && mAnimationCount == 0) {
+                sendAnimateFromOverview(currentTab, false, url,
+                        TAB_OVERVIEW_DELAY, null);
+            } else {
+                // Get rid of the subwindow if it exists
+                dismissSubWindow(currentTab);
+                // Load the given url.
+                currentTab.getWebView().loadUrl(url);
+            }
+        }
+    }
+
+    private Animation createTabAnimation(final AnimatingView view,
+            final View cell, boolean scaleDown) {
+        final AnimationSet set = new AnimationSet(true);
+        final float scaleX = (float) cell.getWidth() / view.getWidth();
+        final float scaleY = (float) cell.getHeight() / view.getHeight();
+        if (scaleDown) {
+            set.addAnimation(new ScaleAnimation(1.0f, scaleX, 1.0f, scaleY));
+            set.addAnimation(new TranslateAnimation(0, cell.getLeft(), 0,
+                    cell.getTop()));
+        } else {
+            set.addAnimation(new ScaleAnimation(scaleX, 1.0f, scaleY, 1.0f));
+            set.addAnimation(new TranslateAnimation(cell.getLeft(), 0,
+                    cell.getTop(), 0));
+        }
+        set.setDuration(TAB_ANIMATION_DURATION);
+        set.setInterpolator(new DecelerateInterpolator());
+        return set;
+    }
+
+    // Animate to the tab overview. currentIndex tells us which position to
+    // animate to and newIndex is the position that should be selected after
+    // the animation completes.
+    // If remove is true, after the animation stops, a confirmation dialog will
+    // be displayed to the user.
+    private void animateToTabOverview(final int newIndex, final boolean remove,
+            final AnimatingView view) {
+        // Find the view in the ImageGrid allowing for the "New Tab" cell.
+        int position = mTabControl.getTabIndex(view.mTab);
+        if (!((ImageAdapter) mTabOverview.getAdapter()).maxedOut()) {
+            position++;
+        }
+
+        // Offset the tab position with the first visible position to get a
+        // number between 0 and 3.
+        position -= mTabOverview.getFirstVisiblePosition();
+
+        // Grab the view that we are going to animate to.
+        final View v = mTabOverview.getChildAt(position);
+
+        final Animation.AnimationListener l =
+                new Animation.AnimationListener() {
+                    public void onAnimationStart(Animation a) {
+                        mTabOverview.requestFocus();
+                        // Clear the listener so we don't trigger a tab
+                        // selection.
+                        mTabOverview.setListener(null);
+                    }
+                    public void onAnimationRepeat(Animation a) {}
+                    public void onAnimationEnd(Animation a) {
+                        // We are no longer animating so decrement the count.
+                        mAnimationCount--;
+                        // Make the view GONE so that it will not draw between
+                        // now and when the Runnable is handled.
+                        view.setVisibility(View.GONE);
+                        // Post a runnable since we can't modify the view
+                        // hierarchy during this callback.
+                        mHandler.post(new Runnable() {
+                            public void run() {
+                                // Remove the AnimatingView.
+                                mContentView.removeView(view);
+                                if (mTabOverview != null) {
+                                    // Make newIndex visible.
+                                    mTabOverview.setCurrentIndex(newIndex);
+                                    // Restore the listener.
+                                    mTabOverview.setListener(mTabListener);
+                                    // Change the menu to TAB_MENU if the
+                                    // ImageGrid is interactive.
+                                    if (mTabOverview.isLive()) {
+                                        mMenuState = R.id.TAB_MENU;
+                                        mTabOverview.requestFocus();
+                                    }
+                                }
+                                // If a remove was requested, remove the tab.
+                                if (remove) {
+                                    // During a remove, the current tab has
+                                    // already changed. Remember the current one
+                                    // here.
+                                    final TabControl.Tab currentTab =
+                                            mTabControl.getCurrentTab();
+                                    // Remove the tab at newIndex from
+                                    // TabControl and the tab overview.
+                                    final TabControl.Tab tab =
+                                            mTabControl.getTab(newIndex);
+                                    mTabControl.removeTab(tab);
+                                    // Restore the current tab.
+                                    if (currentTab != tab) {
+                                        mTabControl.setCurrentTab(currentTab);
+                                    }
+                                    if (mTabOverview != null) {
+                                        mTabOverview.remove(newIndex);
+                                        // Make the current tab visible.
+                                        mTabOverview.setCurrentIndex(
+                                                mTabControl.getCurrentIndex());
+                                    }
+                                }
+                            }
+                        });
+                    }
+                };
+
+        // Do an animation if there is a view to animate to.
+        if (v != null) {
+            // Create our animation
+            final Animation anim = createTabAnimation(view, v, true);
+            anim.setAnimationListener(l);
+            // Start animating
+            view.startAnimation(anim);
+        } else {
+            // If something goes wrong and we didn't find a view to animate to,
+            // just do everything here.
+            l.onAnimationStart(null);
+            l.onAnimationEnd(null);
+        }
+    }
+
+    // Animate from the tab picker. The index supplied is the index to animate
+    // from.
+    private void animateFromTabOverview(final AnimatingView view,
+            final boolean newTab, final Message msg) {
+        // firstVisible is the first visible tab on the screen.  This helps
+        // to know which corner of the screen the selected tab is.
+        int firstVisible = mTabOverview.getFirstVisiblePosition();
+        // tabPosition is the 0-based index of of the tab being opened
+        int tabPosition = mTabControl.getTabIndex(view.mTab);
+        if (!((ImageAdapter) mTabOverview.getAdapter()).maxedOut()) {
+            // Add one to make room for the "New Tab" cell.
+            tabPosition++;
+        }
+        // If this is a new tab, animate from the "New Tab" cell.
+        if (newTab) {
+            tabPosition = 0;
+        }
+        // Location corresponds to the four corners of the screen.
+        // A new tab or 0 is upper left, 0 for an old tab is upper
+        // right, 1 is lower left, and 2 is lower right
+        int location = tabPosition - firstVisible;
+
+        // Find the view at this location.
+        final View v = mTabOverview.getChildAt(location);
+
+        // Wait until the animation completes to replace the AnimatingView.
+        final Animation.AnimationListener l =
+                new Animation.AnimationListener() {
+                    public void onAnimationStart(Animation a) {}
+                    public void onAnimationRepeat(Animation a) {}
+                    public void onAnimationEnd(Animation a) {
+                        mHandler.post(new Runnable() {
+                            public void run() {
+                                mContentView.removeView(view);
+                                // Dismiss the tab overview. If the cell at the
+                                // given location is null, set the fade
+                                // parameter to true.
+                                dismissTabOverview(v == null);
+                                TabControl.Tab t =
+                                        mTabControl.getCurrentTab();
+                                mMenuState = R.id.MAIN_MENU;
+                                // Resume regular updates.
+                                t.getWebView().resumeTimers();
+                                // Dispatch the message after the animation
+                                // completes.
+                                if (msg != null) {
+                                    msg.sendToTarget();
+                                }
+                                // The animation is done and the tab overview is
+                                // gone so allow key events and other animations
+                                // to begin.
+                                mAnimationCount--;
+                                // Reset all the title bar info.
+                                resetTitle();
+                            }
+                        });
+                    }
+                };
+
+        if (v != null) {
+            final Animation anim = createTabAnimation(view, v, false);
+            // Set the listener and start animating
+            anim.setAnimationListener(l);
+            view.startAnimation(anim);
+            // Make the view VISIBLE during the animation.
+            view.setVisibility(View.VISIBLE);
+        } else {
+            // Go ahead and do all the cleanup.
+            l.onAnimationEnd(null);
+        }
+    }
+
+    // Dismiss the tab overview applying a fade if needed.
+    private void dismissTabOverview(final boolean fade) {
+        if (fade) {
+            AlphaAnimation anim = new AlphaAnimation(1.0f, 0.0f);
+            anim.setDuration(500);
+            anim.startNow();
+            mTabOverview.startAnimation(anim);
+        }
+        // Just in case there was a problem with animating away from the tab
+        // overview
+        WebView current = mTabControl.getCurrentWebView();
+        if (current != null) {
+            current.setVisibility(View.VISIBLE);
+        } else {
+            Log.e(LOGTAG, "No current WebView in dismissTabOverview");
+        }
+        // Make the sub window container visible.
+        if (mTabControl.getCurrentSubWindow() != null) {
+            mTabControl.getCurrentTab().getSubWebViewContainer()
+                    .setVisibility(View.VISIBLE);
+        }
+        mContentView.removeView(mTabOverview);
+        mTabOverview.clear();
+        mTabOverview = null;
+        mTabListener = null;
+    }
+
+    private void openTab(String url) {
+        if (mSettings.openInBackground()) {
+            TabControl.Tab t = mTabControl.createNewTab(false);
+            if (t != null) {
+                t.getWebView().loadUrl(url);
+            }
+        } else {
+            openTabAndShow(url, null, false);
+        }
+    }
+
+    private class Copy implements OnMenuItemClickListener {
+        private CharSequence mText;
+
+        public boolean onMenuItemClick(MenuItem item) {
+            copy(mText);
+            return true;
+        }
+
+        public Copy(CharSequence toCopy) {
+            mText = toCopy;
+        }
+    }
+
+    private class Download implements OnMenuItemClickListener {
+        private String mText;
+
+        public boolean onMenuItemClick(MenuItem item) {
+            onDownloadStartNoStream(mText, null, null, null, -1);
+            return true;
+        }
+
+        public Download(String toDownload) {
+            mText = toDownload;
+        }
+    }
+
+    private void copy(CharSequence text) {
+        try {
+            IClipboard clip = IClipboard.Stub.asInterface(ServiceManager.getService("clipboard"));
+            if (clip != null) {
+                clip.setClipboardText(text);
+            }
+        } catch (android.os.RemoteException e) {
+            Log.e(LOGTAG, "Copy failed", e);
+        }
+    }
+
+    /**
+     * Resets the browser title-view to whatever it must be (for example, if we
+     * load a page from history).
+     */
+    private void resetTitle() {
+        resetLockIcon();
+        resetTitleIconAndProgress();
+    }
+
+    /**
+     * Resets the browser title-view to whatever it must be
+     * (for example, if we had a loading error)
+     * When we have a new page, we call resetTitle, when we
+     * have to reset the titlebar to whatever it used to be
+     * (for example, if the user chose to stop loading), we
+     * call resetTitleAndRevertLockIcon.
+     */
+    /* package */ void resetTitleAndRevertLockIcon() {
+        revertLockIcon();
+        resetTitleIconAndProgress();
+    }
+
+    /**
+     * Reset the title, favicon, and progress.
+     */
+    private void resetTitleIconAndProgress() {
+        WebView current = mTabControl.getCurrentWebView();
+        if (current == null) {
+            return;
+        }
+        resetTitleAndIcon(current);
+        int progress = current.getProgress();
+        mInLoad = (progress != 100);
+        updateInLoadMenuItems();
+        mWebChromeClient.onProgressChanged(current, progress);
+    }
+
+    // Reset the title and the icon based on the given item.
+    private void resetTitleAndIcon(WebView view) {
+        WebHistoryItem item = view.copyBackForwardList().getCurrentItem();
+        if (item != null) {
+            setUrlTitle(item.getUrl(), item.getTitle());
+            setFavicon(item.getFavicon());
+        } else {
+            setUrlTitle(null, null);
+            setFavicon(null);
+        }
+    }
+
+    /**
+     * Sets a title composed of the URL and the title string.
+     * @param url The URL of the site being loaded.
+     * @param title The title of the site being loaded.
+     */
+    private void setUrlTitle(String url, String title) {
+        mUrl = url;
+        mTitle = title;
+
+        // While the tab overview is animating or being shown, block changes
+        // to the title.
+        if (mAnimationCount == 0 && mTabOverview == null) {
+            setTitle(buildUrlTitle(url, title));
+        }
+    }
+
+    /**
+     * Builds and returns the page title, which is some
+     * combination of the page URL and title.
+     * @param url The URL of the site being loaded.
+     * @param title The title of the site being loaded.
+     * @return The page title.
+     */
+    private String buildUrlTitle(String url, String title) {
+        String urlTitle = "";
+
+        if (url != null) {
+            String titleUrl = buildTitleUrl(url);
+
+            if (title != null && 0 < title.length()) {
+                if (titleUrl != null && 0 < titleUrl.length()) {
+                    urlTitle = titleUrl + ": " + title;
+                } else {
+                    urlTitle = title;
+                }
+            } else {
+                if (titleUrl != null) {
+                    urlTitle = titleUrl;
+                }
+            }
+        }
+
+        return urlTitle;
+    }
+
+    /**
+     * @param url The URL to build a title version of the URL from.
+     * @return The title version of the URL or null if fails.
+     * The title version of the URL can be either the URL hostname,
+     * or the hostname with an "https://" prefix (for secure URLs),
+     * or an empty string if, for example, the URL in question is a
+     * file:// URL with no hostname.
+     */
+    private static String buildTitleUrl(String url) {
+        String titleUrl = null;
+
+        if (url != null) {
+            try {
+                // parse the url string
+                URL urlObj = new URL(url);
+                if (urlObj != null) {
+                    titleUrl = "";
+
+                    String protocol = urlObj.getProtocol();
+                    String host = urlObj.getHost();
+
+                    if (host != null && 0 < host.length()) {
+                        titleUrl = host;
+                        if (protocol != null) {
+                            // if a secure site, add an "https://" prefix!
+                            if (protocol.equalsIgnoreCase("https")) {
+                                titleUrl = protocol + "://" + host;
+                            }
+                        }
+                    }
+                }
+            } catch (MalformedURLException e) {}
+        }
+
+        return titleUrl;
+    }
+
+    // Set the favicon in the title bar.
+    private void setFavicon(Bitmap icon) {
+        // While the tab overview is animating or being shown, block changes to
+        // the favicon.
+        if (mAnimationCount > 0 || mTabOverview != null) {
+            return;
+        }
+        Drawable[] array = new Drawable[2];
+        PaintDrawable p = new PaintDrawable(Color.WHITE);
+        p.setCornerRadius(3f);
+        array[0] = p;
+        if (icon == null) {
+            array[1] = mGenericFavicon;
+        } else {
+            array[1] = new BitmapDrawable(icon);
+        }
+        LayerDrawable d = new LayerDrawable(array);
+        d.setLayerInset(1, 2, 2, 2, 2);
+        getWindow().setFeatureDrawable(Window.FEATURE_LEFT_ICON, d);
+    }
+
+    /**
+     * Saves the current lock-icon state before resetting
+     * the lock icon. If we have an error, we may need to
+     * roll back to the previous state.
+     */
+    private void saveLockIcon() {
+        mPrevLockType = mLockIconType;
+    }
+
+    /**
+     * Reverts the lock-icon state to the last saved state,
+     * for example, if we had an error, and need to cancel
+     * the load.
+     */
+    private void revertLockIcon() {
+        mLockIconType = mPrevLockType;
+
+        if (Config.LOGV) {
+            Log.v(LOGTAG, "BrowserActivity.revertLockIcon:" +
+                  " revert lock icon to " + mLockIconType);
+        }
+
+        updateLockIconImage(mLockIconType);
+    }
+
+    private void switchTabs(int indexFrom, int indexToShow, boolean remove) {
+        int delay = TAB_ANIMATION_DURATION + TAB_OVERVIEW_DELAY;
+        // Animate to the tab picker, remove the current tab, then
+        // animate away from the tab picker to the parent WebView.
+        tabPicker(false, indexFrom, remove);
+        // Change to the parent tab
+        final TabControl.Tab tab = mTabControl.getTab(indexToShow);
+        if (tab != null) {
+            sendAnimateFromOverview(tab, false, null, delay, null);
+        } else {
+            // Increment this here so that no other animations can happen in
+            // between the end of the tab picker transition and the beginning
+            // of openTabAndShow. This has a matching decrement in the handler
+            // of OPEN_TAB_AND_SHOW.
+            mAnimationCount++;
+            // Send a message to open a new tab.
+            mHandler.sendMessageDelayed(
+                    mHandler.obtainMessage(OPEN_TAB_AND_SHOW,
+                        mSettings.getHomePage()), delay);
+        }
+    }
+
+    private void goBackOnePageOrQuit() {
+        TabControl.Tab current = mTabControl.getCurrentTab();
+        if (current == null) {
+            /*
+             * Instead of finishing the activity, simply push this to the back
+             * of the stack and let ActivityManager to choose the foreground
+             * activity. As BrowserActivity is singleTask, it will be always the
+             * root of the task. So we can use either true or false for
+             * moveTaskToBack().
+             */
+            moveTaskToBack(true);
+        }
+        WebView w = current.getWebView();
+        if (w.canGoBack()) {
+            w.goBack();
+        } else {
+            // Check to see if we are closing a window that was created by
+            // another window. If so, we switch back to that window.
+            TabControl.Tab parent = current.getParentTab();
+            if (parent != null) {
+                switchTabs(mTabControl.getCurrentIndex(),
+                        mTabControl.getTabIndex(parent), true);
+            } else {
+                if (current.closeOnExit()) {
+                    if (mTabControl.getTabCount() == 1) {
+                        finish();
+                        return;
+                    }
+                    // call pauseWebView() now, we won't be able to call it in
+                    // onPause() as the WebView won't be valid.
+                    pauseWebView();
+                    removeTabFromContentView(current);
+                    mTabControl.removeTab(current);
+                }
+                /*
+                 * Instead of finishing the activity, simply push this to the back
+                 * of the stack and let ActivityManager to choose the foreground
+                 * activity. As BrowserActivity is singleTask, it will be always the
+                 * root of the task. So we can use either true or false for
+                 * moveTaskToBack().
+                 */
+                moveTaskToBack(true);
+            }
+        }
+    }
+
+    public KeyTracker.State onKeyTracker(int keyCode,
+                                         KeyEvent event,
+                                         KeyTracker.Stage stage,
+                                         int duration) {
+        // if onKeyTracker() is called after activity onStop()
+        // because of accumulated key events,
+        // we should ignore it as browser is not active any more.
+        WebView topWindow = getTopWindow();
+        if (topWindow == null)
+            return KeyTracker.State.NOT_TRACKING;
+
+        if (keyCode == KeyEvent.KEYCODE_BACK) {
+            // During animations, block the back key so that other animations
+            // are not triggered and so that we don't end up destroying all the
+            // WebViews before finishing the animation.
+            if (mAnimationCount > 0) {
+                return KeyTracker.State.DONE_TRACKING;
+            }
+            if (stage == KeyTracker.Stage.LONG_REPEAT) {
+                bookmarksOrHistoryPicker(true);
+                return KeyTracker.State.DONE_TRACKING;
+            } else if (stage == KeyTracker.Stage.UP) {
+                // FIXME: Currently, we do not have a notion of the
+                // history picker for the subwindow, but maybe we
+                // should?
+                WebView subwindow = mTabControl.getCurrentSubWindow();
+                if (subwindow != null) {
+                    if (subwindow.canGoBack()) {
+                        subwindow.goBack();
+                    } else {
+                        dismissSubWindow(mTabControl.getCurrentTab());
+                    }
+                } else {
+                    goBackOnePageOrQuit();
+                }
+                return KeyTracker.State.DONE_TRACKING;
+            }
+            return KeyTracker.State.KEEP_TRACKING;
+        }
+        return KeyTracker.State.NOT_TRACKING;
+    }
+
+    @Override public boolean onKeyDown(int keyCode, KeyEvent event) {
+        if (keyCode == KeyEvent.KEYCODE_MENU) {
+            mMenuIsDown = true;
+        }
+        boolean handled =  mKeyTracker.doKeyDown(keyCode, event);
+        if (!handled) {
+            switch (keyCode) {
+                case KeyEvent.KEYCODE_SPACE:
+                    if (event.isShiftPressed()) {
+                        getTopWindow().pageUp(false);
+                    } else {
+                        getTopWindow().pageDown(false);
+                    }
+                    handled = true;
+                    break;
+
+                default:
+                    break;
+            }
+        }
+        return handled || super.onKeyDown(keyCode, event);
+    }
+
+    @Override public boolean onKeyUp(int keyCode, KeyEvent event) {
+        if (keyCode == KeyEvent.KEYCODE_MENU) {
+            mMenuIsDown = false;
+        }
+        return mKeyTracker.doKeyUp(keyCode, event) || super.onKeyUp(keyCode, event);
+    }
+
+    private void stopLoading() {
+        resetTitleAndRevertLockIcon();
+        WebView w = getTopWindow();
+        w.stopLoading();
+        mWebViewClient.onPageFinished(w, w.getUrl());
+
+        cancelStopToast();
+        mStopToast = Toast
+                .makeText(this, R.string.stopping, Toast.LENGTH_SHORT);
+        mStopToast.show();
+    }
+
+    private void cancelStopToast() {
+        if (mStopToast != null) {
+            mStopToast.cancel();
+            mStopToast = null;
+        }
+    }
+
+    // called by a non-UI thread to post the message
+    public void postMessage(int what, int arg1, int arg2, Object obj) {
+        mHandler.sendMessage(mHandler.obtainMessage(what, arg1, arg2, obj));
+    }
+
+    // public message ids
+    public final static int LOAD_URL                = 1001;
+    public final static int STOP_LOAD               = 1002;
+
+    // Message Ids
+    private static final int FOCUS_NODE_HREF         = 102;
+    private static final int CANCEL_CREDS_REQUEST    = 103;
+    private static final int ANIMATE_FROM_OVERVIEW   = 104;
+    private static final int ANIMATE_TO_OVERVIEW     = 105;
+    private static final int OPEN_TAB_AND_SHOW       = 106;
+    private static final int CHECK_MEMORY            = 107;
+    private static final int RELEASE_WAKELOCK        = 108;
+
+    // Private handler for handling javascript and saving passwords
+    private Handler mHandler = new Handler() {
+
+        public void handleMessage(Message msg) {
+            switch (msg.what) {
+                case ANIMATE_FROM_OVERVIEW:
+                    final HashMap map = (HashMap) msg.obj;
+                    animateFromTabOverview((AnimatingView) map.get("view"),
+                            msg.arg1 == 1, (Message) map.get("msg"));
+                    break;
+
+                case ANIMATE_TO_OVERVIEW:
+                    animateToTabOverview(msg.arg1, msg.arg2 == 1,
+                            (AnimatingView) msg.obj);
+                    break;
+
+                case OPEN_TAB_AND_SHOW:
+                    // Decrement mAnimationCount before openTabAndShow because
+                    // the method relies on the value being 0 to start the next
+                    // animation.
+                    mAnimationCount--;
+                    openTabAndShow((String) msg.obj, null, false);
+                    break;
+
+                case FOCUS_NODE_HREF:
+                    String url = (String) msg.getData().get("url");
+                    if (url == null || url.length() == 0) {
+                        break;
+                    }
+                    HashMap focusNodeMap = (HashMap) msg.obj;
+                    WebView view = (WebView) focusNodeMap.get("webview");
+                    // Only apply the action if the top window did not change.
+                    if (getTopWindow() != view) {
+                        break;
+                    }
+                    switch (msg.arg1) {
+                        case R.id.open_context_menu_id:
+                        case R.id.view_image_context_menu_id:
+                            loadURL(getTopWindow(), url);
+                            break;
+                        case R.id.open_newtab_context_menu_id:
+                            openTab(url);
+                            break;
+                        case R.id.bookmark_context_menu_id:
+                            Intent intent = new Intent(BrowserActivity.this,
+                                    AddBookmarkPage.class);
+                            intent.putExtra("url", url);
+                            startActivity(intent);
+                            break;
+                        case R.id.share_link_context_menu_id:
+                            Browser.sendString(BrowserActivity.this, url);
+                            break;
+                        case R.id.copy_link_context_menu_id:
+                            copy(url);
+                            break;
+                        case R.id.save_link_context_menu_id:
+                        case R.id.download_context_menu_id:
+                            onDownloadStartNoStream(url, null, null, null, -1);
+                            break;
+                    }
+                    break;
+
+                case LOAD_URL:
+                    loadURL(getTopWindow(), (String) msg.obj);
+                    break;
+
+                case STOP_LOAD:
+                    stopLoading();
+                    break;
+
+                case CANCEL_CREDS_REQUEST:
+                    resumeAfterCredentials();
+                    break;
+
+                case CHECK_MEMORY:
+                    // reschedule to check memory condition
+                    mHandler.removeMessages(CHECK_MEMORY);
+                    mHandler.sendMessageDelayed(mHandler.obtainMessage
+                            (CHECK_MEMORY), CHECK_MEMORY_INTERVAL);
+                    checkMemory();
+                    break;
+
+                case RELEASE_WAKELOCK:
+                    if (mWakeLock.isHeld()) {
+                        mWakeLock.release();
+                    }
+                    break;
+            }
+        }
+    };
+
+    // -------------------------------------------------------------------------
+    // WebViewClient implementation.
+    //-------------------------------------------------------------------------
+
+    // Use in overrideUrlLoading
+    /* package */ final static String SCHEME_WTAI = "wtai://wp/";
+    /* package */ final static String SCHEME_WTAI_MC = "wtai://wp/mc;";
+    /* package */ final static String SCHEME_WTAI_SD = "wtai://wp/sd;";
+    /* package */ final static String SCHEME_WTAI_AP = "wtai://wp/ap;";
+
+    /* package */ WebViewClient getWebViewClient() {
+        return mWebViewClient;
+    }
+
+    private void updateIcon(String url, Bitmap icon) {
+        if (icon != null) {
+            BrowserBookmarksAdapter.updateBookmarkFavicon(mResolver,
+                    url, icon);
+        }
+        setFavicon(icon);
+    }
+
+    private final WebViewClient mWebViewClient = new WebViewClient() {
+        @Override
+        public void onPageStarted(WebView view, String url, Bitmap favicon) {
+            resetLockIcon(url);
+            setUrlTitle(url, null);
+            // Call updateIcon instead of setFavicon so the bookmark
+            // database can be updated.
+            updateIcon(url, favicon);
+
+            if (mSettings.isTracing() == true) {
+                // FIXME: we should save the trace file somewhere other than data.
+                // I can't use "/tmp" as it competes for system memory.
+                File file = getDir("browserTrace", 0);
+                String baseDir = file.getPath();
+                if (!baseDir.endsWith(File.separator)) baseDir += File.separator;
+                String host;
+                try {
+                    WebAddress uri = new WebAddress(url);
+                    host = uri.mHost;
+                } catch (android.net.ParseException ex) {
+                    host = "unknown_host";
+                }
+                host = host.replace('.', '_');
+                baseDir = baseDir + host;
+                file = new File(baseDir+".data");
+                if (file.exists() == true) {
+                    file.delete();
+                }
+                file = new File(baseDir+".key");
+                if (file.exists() == true) {
+                    file.delete();
+                }
+                mInTrace = true;
+                Debug.startMethodTracing(baseDir, 8 * 1024 * 1024);
+            }
+
+            // Performance probe
+            if (false) {
+                mStart = SystemClock.uptimeMillis();
+                mProcessStart = Process.getElapsedCpuTime();
+                long[] sysCpu = new long[7];
+                if (Process.readProcFile("/proc/stat", SYSTEM_CPU_FORMAT, null,
+                        sysCpu, null)) {
+                    mUserStart = sysCpu[0] + sysCpu[1];
+                    mSystemStart = sysCpu[2];
+                    mIdleStart = sysCpu[3];
+                    mIrqStart = sysCpu[4] + sysCpu[5] + sysCpu[6];
+                }
+                mUiStart = SystemClock.currentThreadTimeMillis();
+            }
+
+            if (!mPageStarted) {
+                mPageStarted = true;
+                // if onResume() has been called, resumeWebView() does nothing.
+                resumeWebView();
+            }
+
+            // reset sync timer to avoid sync starts during loading a page
+            CookieSyncManager.getInstance().resetSync();
+
+            mInLoad = true;
+            updateInLoadMenuItems();
+            if (!mIsNetworkUp) {
+                if ( mAlertDialog == null) {
+                    mAlertDialog = new AlertDialog.Builder(BrowserActivity.this)
+                        .setTitle(R.string.loadSuspendedTitle)
+                        .setMessage(R.string.loadSuspended)
+                        .setPositiveButton(R.string.ok, null)
+                        .show();
+                }
+                if (view != null) {
+                    view.setNetworkAvailable(false);
+                }
+            }
+
+            // schedule to check memory condition
+            mHandler.sendMessageDelayed(mHandler.obtainMessage(CHECK_MEMORY),
+                    CHECK_MEMORY_INTERVAL);
+        }
+
+        @Override
+        public void onPageFinished(WebView view, String url) {
+            // Reset the title and icon in case we stopped a provisional
+            // load.
+            resetTitleAndIcon(view);
+
+            // Update the lock icon image only once we are done loading
+            updateLockIconImage(mLockIconType);
+
+            // Performance probe
+             if (false) {
+                long[] sysCpu = new long[7];
+                if (Process.readProcFile("/proc/stat", SYSTEM_CPU_FORMAT, null,
+                        sysCpu, null)) {
+                    String uiInfo = "UI thread used "
+                            + (SystemClock.currentThreadTimeMillis() - mUiStart)
+                            + " ms";
+                    if (Config.LOGD) {
+                        Log.d(LOGTAG, uiInfo);
+                    }
+                    //The string that gets written to the log
+                    String performanceString = "It took total "
+                            + (SystemClock.uptimeMillis() - mStart)
+                            + " ms clock time to load the page."
+                            + "\nbrowser process used "
+                            + (Process.getElapsedCpuTime() - mProcessStart)
+                            + " ms, user processes used "
+                            + (sysCpu[0] + sysCpu[1] - mUserStart) * 10
+                            + " ms, kernel used "
+                            + (sysCpu[2] - mSystemStart) * 10
+                            + " ms, idle took " + (sysCpu[3] - mIdleStart) * 10
+                            + " ms and irq took "
+                            + (sysCpu[4] + sysCpu[5] + sysCpu[6] - mIrqStart)
+                            * 10 + " ms, " + uiInfo;
+                    if (Config.LOGD) {
+                        Log.d(LOGTAG, performanceString + "\nWebpage: " + url);
+                    }
+                    if (url != null) {
+                        // strip the url to maintain consistency
+                        String newUrl = new String(url);
+                        if (newUrl.startsWith("http://www.")) {
+                            newUrl = newUrl.substring(11);
+                        } else if (newUrl.startsWith("http://")) {
+                            newUrl = newUrl.substring(7);
+                        } else if (newUrl.startsWith("https://www.")) {
+                            newUrl = newUrl.substring(12);
+                        } else if (newUrl.startsWith("https://")) {
+                            newUrl = newUrl.substring(8);
+                        }
+                        if (Config.LOGD) {
+                            Log.d(LOGTAG, newUrl + " loaded");
+                        }
+                        /*
+                        if (sWhiteList.contains(newUrl)) {
+                            // The string that gets pushed to the statistcs
+                            // service
+                            performanceString = performanceString
+                                    + "\nWebpage: "
+                                    + newUrl
+                                    + "\nCarrier: "
+                                    + android.os.SystemProperties
+                                            .get("gsm.sim.operator.alpha");
+                            if (mWebView != null
+                                    && mWebView.getContext() != null
+                                    && mWebView.getContext().getSystemService(
+                                    Context.CONNECTIVITY_SERVICE) != null) {
+                                ConnectivityManager cManager =
+                                        (ConnectivityManager) mWebView
+                                        .getContext().getSystemService(
+                                        Context.CONNECTIVITY_SERVICE);
+                                NetworkInfo nInfo = cManager
+                                        .getActiveNetworkInfo();
+                                if (nInfo != null) {
+                                    performanceString = performanceString
+                                            + "\nNetwork Type: "
+                                            + nInfo.getType().toString();
+                                }
+                            }
+                            Checkin.logEvent(mResolver,
+                                    Checkin.Events.Tag.WEBPAGE_LOAD,
+                                    performanceString);
+                            Log.w(LOGTAG, "pushed to the statistics service");
+                        }
+                        */
+                    }
+                }
+             }
+
+            if (mInTrace) {
+                mInTrace = false;
+                Debug.stopMethodTracing();
+            }
+
+            if (mPageStarted) {
+                mPageStarted = false;
+                // pauseWebView() will do nothing and return false if onPause()
+                // is not called yet.
+                if (pauseWebView()) {
+                    if (mWakeLock.isHeld()) {
+                        mHandler.removeMessages(RELEASE_WAKELOCK);
+                        mWakeLock.release();
+                    }
+                }
+            }
+
+            if (mInLoad) {
+                mInLoad = false;
+                updateInLoadMenuItems();
+            }
+
+            mHandler.removeMessages(CHECK_MEMORY);
+            checkMemory();
+        }
+
+        // return true if want to hijack the url to let another app to handle it
+        @Override
+        public boolean shouldOverrideUrlLoading(WebView view, String url) {
+            if (url.startsWith(SCHEME_WTAI)) {
+                // wtai://wp/mc;number
+                // number=string(phone-number)
+                if (url.startsWith(SCHEME_WTAI_MC)) {
+                    Intent intent = new Intent(Intent.ACTION_VIEW,
+                            Uri.parse(WebView.SCHEME_TEL +
+                            url.substring(SCHEME_WTAI_MC.length())));
+                    startActivity(intent);
+                    return true;
+                }
+                // wtai://wp/sd;dtmf
+                // dtmf=string(dialstring)
+                if (url.startsWith(SCHEME_WTAI_SD)) {
+                    // TODO
+                    // only send when there is active voice connection
+                    return false;
+                }
+                // wtai://wp/ap;number;name
+                // number=string(phone-number)
+                // name=string
+                if (url.startsWith(SCHEME_WTAI_AP)) {
+                    // TODO
+                    return false;
+                }
+            }
+
+            Uri uri;
+            try {
+                uri = Uri.parse(url);
+            } catch (IllegalArgumentException ex) {
+                return false;
+            }
+
+            // check whether other activities want to handle this url
+            Intent intent = new Intent(Intent.ACTION_VIEW, uri);
+            intent.addCategory(Intent.CATEGORY_BROWSABLE);
+            try {
+                if (startActivityIfNeeded(intent, -1)) {
+                    return true;
+                }
+            } catch (ActivityNotFoundException ex) {
+                // ignore the error. If no application can handle the URL,
+                // eg about:blank, assume the browser can handle it.
+            }
+
+            if (mMenuIsDown) {
+                openTab(url);
+                closeOptionsMenu();
+                return true;
+            }
+
+            return false;
+        }
+
+        /**
+         * Updates the lock icon. This method is called when we discover another
+         * resource to be loaded for this page (for example, javascript). While
+         * we update the icon type, we do not update the lock icon itself until
+         * we are done loading, it is slightly more secure this way.
+         */
+        @Override
+        public void onLoadResource(WebView view, String url) {
+            if (url != null && url.length() > 0) {
+                // It is only if the page claims to be secure
+                // that we may have to update the lock:
+                if (mLockIconType == LOCK_ICON_SECURE) {
+                    // If NOT a 'safe' url, change the lock to mixed content!
+                    if (!(URLUtil.isHttpsUrl(url) || URLUtil.isDataUrl(url) || URLUtil.isAboutUrl(url))) {
+                        mLockIconType = LOCK_ICON_MIXED;
+                        if (Config.LOGV) {
+                            Log.v(LOGTAG, "BrowserActivity.updateLockIcon:" +
+                                  " updated lock icon to " + mLockIconType + " due to " + url);
+                        }
+                    }
+                }
+            }
+        }
+
+        /**
+         * Show the dialog, asking the user if they would like to continue after
+         * an excessive number of HTTP redirects.
+         */
+        @Override
+        public void onTooManyRedirects(WebView view, final Message cancelMsg,
+                final Message continueMsg) {
+            new AlertDialog.Builder(BrowserActivity.this)
+                .setTitle(R.string.browserFrameRedirect)
+                .setMessage(R.string.browserFrame307Post)
+                .setPositiveButton(R.string.ok, new DialogInterface.OnClickListener() {
+                    public void onClick(DialogInterface dialog, int which) {
+                        continueMsg.sendToTarget();
+                    }})
+                .setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() {
+                    public void onClick(DialogInterface dialog, int which) {
+                        cancelMsg.sendToTarget();
+                    }})
+                .setOnCancelListener(new OnCancelListener() {
+                    public void onCancel(DialogInterface dialog) {
+                        cancelMsg.sendToTarget();
+                    }})
+                .show();
+        }
+
+        /**
+         * Show a dialog informing the user of the network error reported by
+         * WebCore.
+         */
+        @Override
+        public void onReceivedError(WebView view, int errorCode,
+                String description, String failingUrl) {
+            if (errorCode != EventHandler.ERROR_LOOKUP &&
+                    errorCode != EventHandler.ERROR_CONNECT &&
+                    errorCode != EventHandler.ERROR_BAD_URL &&
+                    errorCode != EventHandler.ERROR_UNSUPPORTED_SCHEME &&
+                    errorCode != EventHandler.FILE_ERROR) {
+                new AlertDialog.Builder(BrowserActivity.this)
+                        .setTitle((errorCode == EventHandler.FILE_NOT_FOUND_ERROR) ?
+                                         R.string.browserFrameFileErrorLabel :
+                                         R.string.browserFrameNetworkErrorLabel)
+                        .setMessage(description)
+                        .setPositiveButton(R.string.ok, null)
+                        .show();
+            }
+            Log.e(LOGTAG, "onReceivedError code:"+errorCode+" "+description);
+
+            // We need to reset the title after an error.
+            resetTitleAndRevertLockIcon();
+        }
+
+        /**
+         * Check with the user if it is ok to resend POST data as the page they
+         * are trying to navigate to is the result of a POST.
+         */
+        @Override
+        public void onFormResubmission(WebView view, final Message dontResend,
+                                       final Message resend) {
+            new AlertDialog.Builder(BrowserActivity.this)
+                .setTitle(R.string.browserFrameFormResubmitLabel)
+                .setMessage(R.string.browserFrameFormResubmitMessage)
+                .setPositiveButton(R.string.ok, new DialogInterface.OnClickListener() {
+                    public void onClick(DialogInterface dialog, int which) {
+                        resend.sendToTarget();
+                    }})
+                .setNegativeButton(R.string.cancel, new DialogInterface.OnClickListener() {
+                    public void onClick(DialogInterface dialog, int which) {
+                        dontResend.sendToTarget();
+                    }})
+                .setOnCancelListener(new OnCancelListener() {
+                    public void onCancel(DialogInterface dialog) {
+                        dontResend.sendToTarget();
+                    }})
+                .show();
+        }
+
+        /**
+         * Insert the url into the visited history database.
+         * @param url The url to be inserted.
+         * @param isReload True if this url is being reloaded.
+         * FIXME: Not sure what to do when reloading the page.
+         */
+        @Override
+        public void doUpdateVisitedHistory(WebView view, String url,
+                boolean isReload) {
+            if (url.regionMatches(true, 0, "about:", 0, 6)) {
+                return;
+            }
+            Browser.updateVisitedHistory(mResolver, url, true);
+            WebIconDatabase.getInstance().retainIconForPageUrl(url);
+        }
+
+        /**
+         * Displays SSL error(s) dialog to the user.
+         */
+        @Override
+        public void onReceivedSslError(
+            final WebView view, final SslErrorHandler handler, final SslError error) {
+
+            if (mSettings.showSecurityWarnings()) {
+                final LayoutInflater factory =
+                    LayoutInflater.from(BrowserActivity.this);
+                final View warningsView =
+                    factory.inflate(R.layout.ssl_warnings, null);
+                final LinearLayout placeholder =
+                    (LinearLayout)warningsView.findViewById(R.id.placeholder);
+
+                if (error.hasError(SslError.SSL_UNTRUSTED)) {
+                    LinearLayout ll = (LinearLayout)factory
+                        .inflate(R.layout.ssl_warning, null);
+                    ((TextView)ll.findViewById(R.id.warning))
+                        .setText(R.string.ssl_untrusted);
+                    placeholder.addView(ll);
+                }
+
+                if (error.hasError(SslError.SSL_IDMISMATCH)) {
+                    LinearLayout ll = (LinearLayout)factory
+                        .inflate(R.layout.ssl_warning, null);
+                    ((TextView)ll.findViewById(R.id.warning))
+                        .setText(R.string.ssl_mismatch);
+                    placeholder.addView(ll);
+                }
+
+                if (error.hasError(SslError.SSL_EXPIRED)) {
+                    LinearLayout ll = (LinearLayout)factory
+                        .inflate(R.layout.ssl_warning, null);
+                    ((TextView)ll.findViewById(R.id.warning))
+                        .setText(R.string.ssl_expired);
+                    placeholder.addView(ll);
+                }
+
+                if (error.hasError(SslError.SSL_NOTYETVALID)) {
+                    LinearLayout ll = (LinearLayout)factory
+                        .inflate(R.layout.ssl_warning, null);
+                    ((TextView)ll.findViewById(R.id.warning))
+                        .setText(R.string.ssl_not_yet_valid);
+                    placeholder.addView(ll);
+                }
+
+                new AlertDialog.Builder(BrowserActivity.this)
+                    .setTitle(R.string.security_warning)
+                    .setIcon(android.R.drawable.ic_dialog_alert)
+                    .setView(warningsView)
+                    .setPositiveButton(R.string.ssl_continue,
+                            new DialogInterface.OnClickListener() {
+                                public void onClick(DialogInterface dialog, int whichButton) {
+                                    handler.proceed();
+                                }
+                            })
+                    .setNeutralButton(R.string.view_certificate,
+                            new DialogInterface.OnClickListener() {
+                                public void onClick(DialogInterface dialog, int whichButton) {
+                                    showSSLCertificateOnError(view, handler, error);
+                                }
+                            })
+                    .setNegativeButton(R.string.cancel,
+                            new DialogInterface.OnClickListener() {
+                                public void onClick(DialogInterface dialog, int whichButton) {
+                                    handler.cancel();
+                                    BrowserActivity.this.resetTitleAndRevertLockIcon();
+                                }
+                            })
+                    .setOnCancelListener(
+                            new DialogInterface.OnCancelListener() {
+                                public void onCancel(DialogInterface dialog) {
+                                    handler.cancel();
+                                    BrowserActivity.this.resetTitleAndRevertLockIcon();
+                                }
+                            })
+                    .show();
+            } else {
+                handler.proceed();
+            }
+        }
+
+        /**
+         * Handles an HTTP authentication request.
+         *
+         * @param handler The authentication handler
+         * @param host The host
+         * @param realm The realm
+         */
+        @Override
+        public void onReceivedHttpAuthRequest(WebView view,
+                final HttpAuthHandler handler, final String host, final String realm) {
+            String username = null;
+            String password = null;
+
+            boolean reuseHttpAuthUsernamePassword =
+                handler.useHttpAuthUsernamePassword();
+
+            if (reuseHttpAuthUsernamePassword &&
+                    (mTabControl.getCurrentWebView() != null)) {
+                String[] credentials =
+                        mTabControl.getCurrentWebView()
+                                .getHttpAuthUsernamePassword(host, realm);
+                if (credentials != null && credentials.length == 2) {
+                    username = credentials[0];
+                    password = credentials[1];
+                }
+            }
+
+            if (username != null && password != null) {
+                handler.proceed(username, password);
+            } else {
+                showHttpAuthentication(handler, host, realm, null, null, null, 0);
+            }
+        }
+
+        @Override
+        public boolean shouldOverrideKeyEvent(WebView view, KeyEvent event) {
+            if (mMenuIsDown) {
+                // only check shortcut key when MENU is held
+                return getWindow().isShortcutKey(event.getKeyCode(), event);
+            } else {
+                return false;
+            }
+        }
+
+        @Override
+        public void onUnhandledKeyEvent(WebView view, KeyEvent event) {
+            if (view != mTabControl.getCurrentTopWebView()) {
+                return;
+            }
+            if (event.isDown()) {
+                BrowserActivity.this.onKeyDown(event.getKeyCode(), event);
+            } else {
+                BrowserActivity.this.onKeyUp(event.getKeyCode(), event);
+            }
+        }
+    };
+
+    //--------------------------------------------------------------------------
+    // WebChromeClient implementation
+    //--------------------------------------------------------------------------
+
+    /* package */ WebChromeClient getWebChromeClient() {
+        return mWebChromeClient;
+    }
+
+    private final WebChromeClient mWebChromeClient = new WebChromeClient() {
+        // Helper method to create a new tab or sub window.
+        private void createWindow(final boolean dialog, final Message msg) {
+            if (dialog) {
+                mTabControl.createSubWindow();
+                final TabControl.Tab t = mTabControl.getCurrentTab();
+                attachSubWindow(t);
+                WebView.WebViewTransport transport =
+                        (WebView.WebViewTransport) msg.obj;
+                transport.setWebView(t.getSubWebView());
+                msg.sendToTarget();
+            } else {
+                final TabControl.Tab parent = mTabControl.getCurrentTab();
+                // openTabAndShow will dispatch the message after creating the
+                // new WebView. This will prevent another request from coming
+                // in during the animation.
+                openTabAndShow(null, msg, false);
+                parent.addChildTab(mTabControl.getCurrentTab());
+                WebView.WebViewTransport transport =
+                        (WebView.WebViewTransport) msg.obj;
+                transport.setWebView(mTabControl.getCurrentWebView());
+            }
+        }
+
+        @Override
+        public boolean onCreateWindow(WebView view, final boolean dialog,
+                final boolean userGesture, final Message resultMsg) {
+            // Ignore these requests during tab animations or if the tab
+            // overview is showing.
+            if (mAnimationCount > 0 || mTabOverview != null) {
+                return false;
+            }
+            // Short-circuit if we can't create any more tabs or sub windows.
+            if (dialog && mTabControl.getCurrentSubWindow() != null) {
+                new AlertDialog.Builder(BrowserActivity.this)
+                        .setTitle(R.string.too_many_subwindows_dialog_title)
+                        .setIcon(android.R.drawable.ic_dialog_alert)
+                        .setMessage(R.string.too_many_subwindows_dialog_message)
+                        .setPositiveButton(R.string.ok, null)
+                        .show();
+                return false;
+            } else if (mTabControl.getTabCount() >= TabControl.MAX_TABS) {
+                new AlertDialog.Builder(BrowserActivity.this)
+                        .setTitle(R.string.too_many_windows_dialog_title)
+                        .setIcon(android.R.drawable.ic_dialog_alert)
+                        .setMessage(R.string.too_many_windows_dialog_message)
+                        .setPositiveButton(R.string.ok, null)
+                        .show();
+                return false;
+            }
+
+            // Short-circuit if this was a user gesture.
+            if (userGesture) {
+                // createWindow will call openTabAndShow for new Windows and
+                // that will call tabPicker which will increment
+                // mAnimationCount.
+                createWindow(dialog, resultMsg);
+                return true;
+            }
+
+            // Allow the popup and create the appropriate window.
+            final AlertDialog.OnClickListener allowListener =
+                    new AlertDialog.OnClickListener() {
+                        public void onClick(DialogInterface d,
+                                int which) {
+                            // Same comment as above for setting
+                            // mAnimationCount.
+                            createWindow(dialog, resultMsg);
+                            // Since we incremented mAnimationCount while the
+                            // dialog was up, we have to decrement it here.
+                            mAnimationCount--;
+                        }
+                    };
+
+            // Block the popup by returning a null WebView.
+            final AlertDialog.OnClickListener blockListener =
+                    new AlertDialog.OnClickListener() {
+                        public void onClick(DialogInterface d, int which) {
+                            resultMsg.sendToTarget();
+                            // We are not going to trigger an animation so
+                            // unblock keys and animation requests.
+                            mAnimationCount--;
+                        }
+                    };
+
+            // Build a confirmation dialog to display to the user.
+            final AlertDialog d =
+                    new AlertDialog.Builder(BrowserActivity.this)
+                    .setTitle(R.string.attention)
+                    .setIcon(android.R.drawable.ic_dialog_alert)
+                    .setMessage(R.string.popup_window_attempt)
+                    .setPositiveButton(R.string.allow, allowListener)
+                    .setNegativeButton(R.string.block, blockListener)
+                    .setCancelable(false)
+                    .create();
+
+            // Show the confirmation dialog.
+            d.show();
+            // We want to increment mAnimationCount here to prevent a
+            // potential race condition. If the user allows a pop-up from a
+            // site and that pop-up then triggers another pop-up, it is
+            // possible to get the BACK key between here and when the dialog
+            // appears.
+            mAnimationCount++;
+            return true;
+        }
+
+        @Override
+        public void onCloseWindow(WebView window) {
+            final int currentIndex = mTabControl.getCurrentIndex();
+            final TabControl.Tab parent =
+                    mTabControl.getCurrentTab().getParentTab();
+            if (parent != null) {
+                // JavaScript can only close popup window.
+                switchTabs(currentIndex, mTabControl.getTabIndex(parent), true);
+            }
+        }
+
+        @Override
+        public void onProgressChanged(WebView view, int newProgress) {
+            // Block progress updates to the title bar while the tab overview
+            // is animating or being displayed.
+            if (mAnimationCount == 0 && mTabOverview == null) {
+                getWindow().setFeatureInt(Window.FEATURE_PROGRESS,
+                        newProgress * 100);
+            }
+
+            if (newProgress == 100) {
+                // onProgressChanged() is called for sub-frame too while
+                // onPageFinished() is only called for the main frame. sync
+                // cookie and cache promptly here.
+                CookieSyncManager.getInstance().sync();
+            }
+        }
+
+        @Override
+        public void onReceivedTitle(WebView view, String title) {
+            String url = view.getOriginalUrl();
+
+            // here, if url is null, we want to reset the title
+            setUrlTitle(url, title);
+
+            if (url == null ||
+                url.length() >= SQLiteDatabase.SQLITE_MAX_LIKE_PATTERN_LENGTH) {
+                return;
+            }
+            if (url.startsWith("http://www.")) {
+                url = url.substring(11);
+            } else if (url.startsWith("http://")) {
+                url = url.substring(4);
+            }
+            try {
+                url = "%" + url;
+                String [] selArgs = new String[] { url };
+
+                String where = Browser.BookmarkColumns.URL + " LIKE ? AND "
+                        + Browser.BookmarkColumns.BOOKMARK + " = 0";
+                Cursor c = mResolver.query(Browser.BOOKMARKS_URI,
+                    Browser.HISTORY_PROJECTION, where, selArgs, null);
+                if (c.moveToFirst()) {
+                    if (Config.LOGV) {
+                        Log.v(LOGTAG, "updating cursor");
+                    }
+                    // Current implementation of database only has one entry per
+                    // url.
+                    int titleIndex =
+                            c.getColumnIndex(Browser.BookmarkColumns.TITLE);
+                    c.updateString(titleIndex, title);
+                    c.commitUpdates();
+                }
+                c.close();
+            } catch (IllegalStateException e) {
+                Log.e(LOGTAG, "BrowserActivity onReceived title", e);
+            } catch (SQLiteException ex) {
+                Log.e(LOGTAG, "onReceivedTitle() caught SQLiteException: ", ex);
+            }
+        }
+
+        @Override
+        public void onReceivedIcon(WebView view, Bitmap icon) {
+            updateIcon(view.getUrl(), icon);
+        }
+    };
+
+    /**
+     * Notify the host application a download should be done, or that
+     * the data should be streamed if a streaming viewer is available.
+     * @param url The full url to the content that should be downloaded
+     * @param contentDisposition Content-disposition http header, if
+     *                           present.
+     * @param mimetype The mimetype of the content reported by the server
+     * @param contentLength The file size reported by the server
+     */
+    public void onDownloadStart(String url, String userAgent,
+            String contentDisposition, String mimetype, long contentLength) {
+        // if we're dealing wih A/V content that's not explicitly marked
+        //     for download, check if it's streamable.
+        if (contentDisposition == null
+                        || !contentDisposition.regionMatches(true, 0, "attachment", 0, 10)) {
+            // query the package manager to see if there's a registered handler
+            //     that matches.
+            Intent intent = new Intent(Intent.ACTION_VIEW);
+            intent.setDataAndType(Uri.parse(url), mimetype);
+            if (getPackageManager().resolveActivity(intent,
+                        PackageManager.MATCH_DEFAULT_ONLY) != null) {
+                // someone knows how to handle this mime type with this scheme, don't download.
+                try {
+                    startActivity(intent);
+                    return;
+                } catch (ActivityNotFoundException ex) {
+                    if (Config.LOGD) {
+                        Log.d(LOGTAG, "activity not found for " + mimetype
+                                + " over " + Uri.parse(url).getScheme(), ex);
+                    }
+                    // Best behavior is to fall back to a download in this case
+                }
+            }
+        }
+        onDownloadStartNoStream(url, userAgent, contentDisposition, mimetype, contentLength);
+    }
+
+    /**
+     * Notify the host application a download should be done, even if there
+     * is a streaming viewer available for thise type.
+     * @param url The full url to the content that should be downloaded
+     * @param contentDisposition Content-disposition http header, if
+     *                           present.
+     * @param mimetype The mimetype of the content reported by the server
+     * @param contentLength The file size reported by the server
+     */
+    /*package */ void onDownloadStartNoStream(String url, String userAgent,
+            String contentDisposition, String mimetype, long contentLength) {
+
+        String filename = URLUtil.guessFileName(url,
+                contentDisposition, mimetype);
+
+        // Check to see if we have an SDCard
+        String status = Environment.getExternalStorageState();
+        if (!status.equals(Environment.MEDIA_MOUNTED)) {
+            int title;
+            String msg;
+
+            // Check to see if the SDCard is busy, same as the music app
+            if (status.equals(Environment.MEDIA_SHARED)) {
+                msg = getString(R.string.download_sdcard_busy_dlg_msg);
+                title = R.string.download_sdcard_busy_dlg_title;
+            } else {
+                msg = getString(R.string.download_no_sdcard_dlg_msg, filename);
+                title = R.string.download_no_sdcard_dlg_title;
+            }
+
+            new AlertDialog.Builder(this)
+                .setTitle(title)
+                .setIcon(android.R.drawable.ic_dialog_alert)
+                .setMessage(msg)
+                .setPositiveButton(R.string.ok, null)
+                .show();
+            return;
+        }
+
+        // java.net.URI is a lot stricter than KURL so we have to undo
+        // KURL's percent-encoding and redo the encoding using java.net.URI.
+        URI uri = null;
+        try {
+            // Undo the percent-encoding that KURL may have done.
+            String newUrl = new String(URLUtil.decode(url.getBytes()));
+            // Parse the url into pieces
+            WebAddress w = new WebAddress(newUrl);
+            String frag = null;
+            String query = null;
+            String path = w.mPath;
+            // Break the path into path, query, and fragment
+            if (path.length() > 0) {
+                // Strip the fragment
+                int idx = path.lastIndexOf('#');
+                if (idx != -1) {
+                    frag = path.substring(idx + 1);
+                    path = path.substring(0, idx);
+                }
+                idx = path.lastIndexOf('?');
+                if (idx != -1) {
+                    query = path.substring(idx + 1);
+                    path = path.substring(0, idx);
+                }
+            }
+            uri = new URI(w.mScheme, w.mAuthInfo, w.mHost, w.mPort, path,
+                    query, frag);
+        } catch (Exception e) {
+            Log.e(LOGTAG, "Could not parse url for download: " + url, e);
+            return;
+        }
+
+        // XXX: Have to use the old url since the cookies were stored using the
+        // old percent-encoded url.
+        String cookies = CookieManager.getInstance().getCookie(url);
+
+        ContentValues values = new ContentValues();
+        values.put(Downloads.URI, uri.toString());
+        values.put(Downloads.COOKIE_DATA, cookies);
+        values.put(Downloads.USER_AGENT, userAgent);
+        values.put(Downloads.NOTIFICATION_PACKAGE,
+                getPackageName());
+        values.put(Downloads.NOTIFICATION_CLASS,
+                BrowserDownloadPage.class.getCanonicalName());
+        values.put(Downloads.VISIBILITY, Downloads.VISIBILITY_VISIBLE_NOTIFY_COMPLETED);
+        values.put(Downloads.MIMETYPE, mimetype);
+        values.put(Downloads.FILENAME_HINT, filename);
+        values.put(Downloads.DESCRIPTION, uri.getHost());
+        if (contentLength > 0) {
+            values.put(Downloads.TOTAL_BYTES, contentLength);
+        }
+        if (mimetype == null) {
+            // We must have long pressed on a link or image to download it. We
+            // are not sure of the mimetype in this case, so do a head request
+            new FetchUrlMimeType(this).execute(values);
+        } else {
+            final Uri contentUri =
+                    getContentResolver().insert(Downloads.CONTENT_URI, values);
+            viewDownloads(contentUri);
+        }
+
+    }
+
+    /**
+     * Resets the lock icon. This method is called when we start a new load and
+     * know the url to be loaded.
+     */
+    private void resetLockIcon(String url) {
+        // Save the lock-icon state (we revert to it if the load gets cancelled)
+        saveLockIcon();
+
+        mLockIconType = LOCK_ICON_UNSECURE;
+        if (URLUtil.isHttpsUrl(url)) {
+            mLockIconType = LOCK_ICON_SECURE;
+            if (Config.LOGV) {
+                Log.v(LOGTAG, "BrowserActivity.resetLockIcon:" +
+                      " reset lock icon to " + mLockIconType);
+            }
+        }
+
+        updateLockIconImage(LOCK_ICON_UNSECURE);
+    }
+
+    /**
+     * Resets the lock icon.  This method is called when the icon needs to be
+     * reset but we do not know whether we are loading a secure or not secure
+     * page.
+     */
+    private void resetLockIcon() {
+        // Save the lock-icon state (we revert to it if the load gets cancelled)
+        saveLockIcon();
+
+        mLockIconType = LOCK_ICON_UNSECURE;
+
+        if (Config.LOGV) {
+          Log.v(LOGTAG, "BrowserActivity.resetLockIcon:" +
+                " reset lock icon to " + mLockIconType);
+        }
+
+        updateLockIconImage(LOCK_ICON_UNSECURE);
+    }
+
+    /**
+     * Updates the lock-icon image in the title-bar.
+     */
+    private void updateLockIconImage(int lockIconType) {
+        Drawable d = null;
+        if (lockIconType == LOCK_ICON_SECURE) {
+            d = mSecLockIcon;
+        } else if (lockIconType == LOCK_ICON_MIXED) {
+            d = mMixLockIcon;
+        }
+        // If the tab overview is animating or being shown, do not update the
+        // lock icon.
+        if (mAnimationCount == 0 && mTabOverview == null) {
+            getWindow().setFeatureDrawable(Window.FEATURE_RIGHT_ICON, d);
+        }
+    }
+
+    /**
+     * Displays a page-info dialog.
+     * @param tab The tab to show info about
+     * @param fromShowSSLCertificateOnError The flag that indicates whether
+     * this dialog was opened from the SSL-certificate-on-error dialog or
+     * not. This is important, since we need to know whether to return to
+     * the parent dialog or simply dismiss.
+     */
+    private void showPageInfo(final TabControl.Tab tab,
+                              final boolean fromShowSSLCertificateOnError) {
+        final LayoutInflater factory = LayoutInflater
+                .from(this);
+
+        final View pageInfoView = factory.inflate(R.layout.page_info, null);
+
+        final WebView view = tab.getWebView();
+
+        String url = null;
+        String title = null;
+
+        if (view == null) {
+            url = tab.getUrl();
+            title = tab.getTitle();
+        } else if (view == mTabControl.getCurrentWebView()) {
+             // Use the cached title and url if this is the current WebView
+            url = mUrl;
+            title = mTitle;
+        } else {
+            url = view.getUrl();
+            title = view.getTitle();
+        }
+
+        if (url == null) {
+            url = "";
+        }
+        if (title == null) {
+            title = "";
+        }
+
+        ((TextView) pageInfoView.findViewById(R.id.address)).setText(url);
+        ((TextView) pageInfoView.findViewById(R.id.title)).setText(title);
+
+        mPageInfoView = tab;
+        mPageInfoFromShowSSLCertificateOnError = new Boolean(fromShowSSLCertificateOnError);
+
+        AlertDialog.Builder alertDialogBuilder =
+            new AlertDialog.Builder(this)
+            .setTitle(R.string.page_info).setIcon(android.R.drawable.ic_dialog_info)
+            .setView(pageInfoView)
+            .setPositiveButton(
+                R.string.ok,
+                new DialogInterface.OnClickListener() {
+                    public void onClick(DialogInterface dialog,
+                                        int whichButton) {
+                        mPageInfoDialog = null;
+                        mPageInfoView = null;
+                        mPageInfoFromShowSSLCertificateOnError = null;
+
+                        // if we came here from the SSL error dialog
+                        if (fromShowSSLCertificateOnError) {
+                            // go back to the SSL error dialog
+                            showSSLCertificateOnError(
+                                mSSLCertificateOnErrorView,
+                                mSSLCertificateOnErrorHandler,
+                                mSSLCertificateOnErrorError);
+                        }
+                    }
+                })
+            .setOnCancelListener(
+                new DialogInterface.OnCancelListener() {
+                    public void onCancel(DialogInterface dialog) {
+                        mPageInfoDialog = null;
+                        mPageInfoView = null;
+                        mPageInfoFromShowSSLCertificateOnError = null;
+
+                        // if we came here from the SSL error dialog
+                        if (fromShowSSLCertificateOnError) {
+                            // go back to the SSL error dialog
+                            showSSLCertificateOnError(
+                                mSSLCertificateOnErrorView,
+                                mSSLCertificateOnErrorHandler,
+                                mSSLCertificateOnErrorError);
+                        }
+                    }
+                });
+
+        // if we have a main top-level page SSL certificate set or a certificate
+        // error
+        if (fromShowSSLCertificateOnError ||
+                (view != null && view.getCertificate() != null)) {
+            // add a 'View Certificate' button
+            alertDialogBuilder.setNeutralButton(
+                R.string.view_certificate,
+                new DialogInterface.OnClickListener() {
+                    public void onClick(DialogInterface dialog,
+                                        int whichButton) {
+                        mPageInfoDialog = null;
+                        mPageInfoView = null;
+                        mPageInfoFromShowSSLCertificateOnError = null;
+
+                        // if we came here from the SSL error dialog
+                        if (fromShowSSLCertificateOnError) {
+                            // go back to the SSL error dialog
+                            showSSLCertificateOnError(
+                                mSSLCertificateOnErrorView,
+                                mSSLCertificateOnErrorHandler,
+                                mSSLCertificateOnErrorError);
+                        } else {
+                            // otherwise, display the top-most certificate from
+                            // the chain
+                            if (view.getCertificate() != null) {
+                                showSSLCertificate(tab);
+                            }
+                        }
+                    }
+                });
+        }
+
+        mPageInfoDialog = alertDialogBuilder.show();
+    }
+
+       /**
+     * Displays the main top-level page SSL certificate dialog
+     * (accessible from the Page-Info dialog).
+     * @param tab The tab to show certificate for.
+     */
+    private void showSSLCertificate(final TabControl.Tab tab) {
+        final View certificateView =
+                inflateCertificateView(tab.getWebView().getCertificate());
+        if (certificateView == null) {
+            return;
+        }
+
+        LayoutInflater factory = LayoutInflater.from(this);
+
+        final LinearLayout placeholder =
+                (LinearLayout)certificateView.findViewById(R.id.placeholder);
+
+        LinearLayout ll = (LinearLayout) factory.inflate(
+            R.layout.ssl_success, placeholder);
+        ((TextView)ll.findViewById(R.id.success))
+            .setText(R.string.ssl_certificate_is_valid);
+
+        mSSLCertificateView = tab;
+        mSSLCertificateDialog =
+            new AlertDialog.Builder(this)
+                .setTitle(R.string.ssl_certificate).setIcon(
+                    R.drawable.ic_dialog_browser_certificate_secure)
+                .setView(certificateView)
+                .setPositiveButton(R.string.ok,
+                        new DialogInterface.OnClickListener() {
+                            public void onClick(DialogInterface dialog,
+                                    int whichButton) {
+                                mSSLCertificateDialog = null;
+                                mSSLCertificateView = null;
+
+                                showPageInfo(tab, false);
+                            }
+                        })
+                .setOnCancelListener(
+                        new DialogInterface.OnCancelListener() {
+                            public void onCancel(DialogInterface dialog) {
+                                mSSLCertificateDialog = null;
+                                mSSLCertificateView = null;
+
+                                showPageInfo(tab, false);
+                            }
+                        })
+                .show();
+    }
+
+    /**
+     * Displays the SSL error certificate dialog.
+     * @param view The target web-view.
+     * @param handler The SSL error handler responsible for cancelling the
+     * connection that resulted in an SSL error or proceeding per user request.
+     * @param error The SSL error object.
+     */
+    private void showSSLCertificateOnError(
+        final WebView view, final SslErrorHandler handler, final SslError error) {
+
+        final View certificateView =
+            inflateCertificateView(error.getCertificate());
+        if (certificateView == null) {
+            return;
+        }
+
+        LayoutInflater factory = LayoutInflater.from(this);
+
+        final LinearLayout placeholder =
+                (LinearLayout)certificateView.findViewById(R.id.placeholder);
+
+        if (error.hasError(SslError.SSL_UNTRUSTED)) {
+            LinearLayout ll = (LinearLayout)factory
+                .inflate(R.layout.ssl_warning, placeholder);
+            ((TextView)ll.findViewById(R.id.warning))
+                .setText(R.string.ssl_untrusted);
+        }
+
+        if (error.hasError(SslError.SSL_IDMISMATCH)) {
+            LinearLayout ll = (LinearLayout)factory
+                .inflate(R.layout.ssl_warning, placeholder);
+            ((TextView)ll.findViewById(R.id.warning))
+                .setText(R.string.ssl_mismatch);
+        }
+
+        if (error.hasError(SslError.SSL_EXPIRED)) {
+            LinearLayout ll = (LinearLayout)factory
+                .inflate(R.layout.ssl_warning, placeholder);
+            ((TextView)ll.findViewById(R.id.warning))
+                .setText(R.string.ssl_expired);
+        }
+
+        if (error.hasError(SslError.SSL_NOTYETVALID)) {
+            LinearLayout ll = (LinearLayout)factory
+                .inflate(R.layout.ssl_warning, placeholder);
+            ((TextView)ll.findViewById(R.id.warning))
+                .setText(R.string.ssl_not_yet_valid);
+        }
+
+        mSSLCertificateOnErrorHandler = handler;
+        mSSLCertificateOnErrorView = view;
+        mSSLCertificateOnErrorError = error;
+        mSSLCertificateOnErrorDialog =
+            new AlertDialog.Builder(this)
+                .setTitle(R.string.ssl_certificate).setIcon(
+                    R.drawable.ic_dialog_browser_certificate_partially_secure)
+                .setView(certificateView)
+                .setPositiveButton(R.string.ok,
+                        new DialogInterface.OnClickListener() {
+                            public void onClick(DialogInterface dialog,
+                                    int whichButton) {
+                                mSSLCertificateOnErrorDialog = null;
+                                mSSLCertificateOnErrorView = null;
+                                mSSLCertificateOnErrorHandler = null;
+                                mSSLCertificateOnErrorError = null;
+
+                                mWebViewClient.onReceivedSslError(
+                                    view, handler, error);
+                            }
+                        })
+                 .setNeutralButton(R.string.page_info_view,
+                        new DialogInterface.OnClickListener() {
+                            public void onClick(DialogInterface dialog,
+                                    int whichButton) {
+                                mSSLCertificateOnErrorDialog = null;
+
+                                // do not clear the dialog state: we will
+                                // need to show the dialog again once the
+                                // user is done exploring the page-info details
+
+                                showPageInfo(mTabControl.getTabFromView(view),
+                                        true);
+                            }
+                        })
+                .setOnCancelListener(
+                        new DialogInterface.OnCancelListener() {
+                            public void onCancel(DialogInterface dialog) {
+                                mSSLCertificateOnErrorDialog = null;
+                                mSSLCertificateOnErrorView = null;
+                                mSSLCertificateOnErrorHandler = null;
+                                mSSLCertificateOnErrorError = null;
+
+                                mWebViewClient.onReceivedSslError(
+                                    view, handler, error);
+                            }
+                        })
+                .show();
+    }
+
+    /**
+     * Inflates the SSL certificate view (helper method).
+     * @param certificate The SSL certificate.
+     * @return The resultant certificate view with issued-to, issued-by,
+     * issued-on, expires-on, and possibly other fields set.
+     * If the input certificate is null, returns null.
+     */
+    private View inflateCertificateView(SslCertificate certificate) {
+        if (certificate == null) {
+            return null;
+        }
+
+        LayoutInflater factory = LayoutInflater.from(this);
+
+        View certificateView = factory.inflate(
+            R.layout.ssl_certificate, null);
+
+        // issued to:
+        SslCertificate.DName issuedTo = certificate.getIssuedTo();
+        if (issuedTo != null) {
+            ((TextView) certificateView.findViewById(R.id.to_common))
+                .setText(issuedTo.getCName());
+            ((TextView) certificateView.findViewById(R.id.to_org))
+                .setText(issuedTo.getOName());
+            ((TextView) certificateView.findViewById(R.id.to_org_unit))
+                .setText(issuedTo.getUName());
+        }
+
+        // issued by:
+        SslCertificate.DName issuedBy = certificate.getIssuedBy();
+        if (issuedBy != null) {
+            ((TextView) certificateView.findViewById(R.id.by_common))
+                .setText(issuedBy.getCName());
+            ((TextView) certificateView.findViewById(R.id.by_org))
+                .setText(issuedBy.getOName());
+            ((TextView) certificateView.findViewById(R.id.by_org_unit))
+                .setText(issuedBy.getUName());
+        }
+
+        // issued on:
+        String issuedOn = reformatCertificateDate(
+            certificate.getValidNotBefore());
+        ((TextView) certificateView.findViewById(R.id.issued_on))
+            .setText(issuedOn);
+
+        // expires on:
+        String expiresOn = reformatCertificateDate(
+            certificate.getValidNotAfter());
+        ((TextView) certificateView.findViewById(R.id.expires_on))
+            .setText(expiresOn);
+
+        return certificateView;
+    }
+
+    /**
+     * Re-formats the certificate date (Date.toString()) string to
+     * a properly localized date string.
+     * @return Properly localized version of the certificate date string and
+     * the original certificate date string if fails to localize.
+     * If the original string is null, returns an empty string "".
+     */
+    private String reformatCertificateDate(String certificateDate) {
+      String reformattedDate = null;
+
+      if (certificateDate != null) {
+          Date date = null;
+          try {
+              date = java.text.DateFormat.getInstance().parse(certificateDate);
+          } catch (ParseException e) {
+              date = null;
+          }
+
+          if (date != null) {
+              reformattedDate =
+                  DateFormat.getDateFormat(this).format(date);
+          }
+      }
+
+      return reformattedDate != null ? reformattedDate :
+          (certificateDate != null ? certificateDate : "");
+    }
+
+    /**
+     * Displays an http-authentication dialog.
+     */
+    private void showHttpAuthentication(final HttpAuthHandler handler,
+            final String host, final String realm, final String title,
+            final String name, final String password, int focusId) {
+        LayoutInflater factory = LayoutInflater.from(this);
+        final View v = factory
+                .inflate(R.layout.http_authentication, null);
+        if (name != null) {
+            ((EditText) v.findViewById(R.id.username_edit)).setText(name);
+        }
+        if (password != null) {
+            ((EditText) v.findViewById(R.id.password_edit)).setText(password);
+        }
+
+        String titleText = title;
+        if (titleText == null) {
+            titleText = getText(R.string.sign_in_to).toString().replace(
+                    "%s1", host).replace("%s2", realm);
+        }
+
+        mHttpAuthHandler = handler;
+        AlertDialog dialog = new AlertDialog.Builder(this)
+                .setTitle(titleText)
+                .setIcon(android.R.drawable.ic_dialog_alert)
+                .setView(v)
+                .setPositiveButton(R.string.action,
+                        new DialogInterface.OnClickListener() {
+                             public void onClick(DialogInterface dialog,
+                                     int whichButton) {
+                                String nm = ((EditText) v
+                                        .findViewById(R.id.username_edit))
+                                        .getText().toString();
+                                String pw = ((EditText) v
+                                        .findViewById(R.id.password_edit))
+                                        .getText().toString();
+                                BrowserActivity.this.setHttpAuthUsernamePassword
+                                        (host, realm, nm, pw);
+                                handler.proceed(nm, pw);
+                                mHttpAuthenticationDialog = null;
+                                mHttpAuthHandler = null;
+                            }})
+                .setNegativeButton(R.string.cancel,
+                        new DialogInterface.OnClickListener() {
+                            public void onClick(DialogInterface dialog,
+                                    int whichButton) {
+                                handler.cancel();
+                                BrowserActivity.this.resetTitleAndRevertLockIcon();
+                                mHttpAuthenticationDialog = null;
+                                mHttpAuthHandler = null;
+                            }})
+                .setOnCancelListener(new DialogInterface.OnCancelListener() {
+                        public void onCancel(DialogInterface dialog) {
+                            handler.cancel();
+                            BrowserActivity.this.resetTitleAndRevertLockIcon();
+                            mHttpAuthenticationDialog = null;
+                            mHttpAuthHandler = null;
+                        }})
+                .create();
+        // Make the IME appear when the dialog is displayed if applicable.
+        dialog.getWindow().setSoftInputMode(
+                WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
+        dialog.show();
+        if (focusId != 0) {
+            dialog.findViewById(focusId).requestFocus();
+        } else {
+            v.findViewById(R.id.username_edit).requestFocus();
+        }
+        mHttpAuthenticationDialog = dialog;
+    }
+
+    public int getProgress() {
+        WebView w = mTabControl.getCurrentWebView();
+        if (w != null) {
+            return w.getProgress();
+        } else {
+            return 100;
+        }
+    }
+
+    /**
+     * Set HTTP authentication password.
+     *
+     * @param host The host for the password
+     * @param realm The realm for the password
+     * @param username The username for the password. If it is null, it means
+     *            password can't be saved.
+     * @param password The password
+     */
+    public void setHttpAuthUsernamePassword(String host, String realm,
+                                            String username,
+                                            String password) {
+        WebView w = mTabControl.getCurrentWebView();
+        if (w != null) {
+            w.setHttpAuthUsernamePassword(host, realm, username, password);
+        }
+    }
+
+    /**
+     * connectivity manager says net has come or gone... inform the user
+     * @param up true if net has come up, false if net has gone down
+     */
+    public void onNetworkToggle(boolean up) {
+        if (up == mIsNetworkUp) {
+            return;
+        } else if (up) {
+            mIsNetworkUp = true;
+            if (mAlertDialog != null) {
+                mAlertDialog.cancel();
+                mAlertDialog = null;
+            }
+        } else {
+            mIsNetworkUp = false;
+            if (mInLoad && mAlertDialog == null) {
+                mAlertDialog = new AlertDialog.Builder(this)
+                        .setTitle(R.string.loadSuspendedTitle)
+                        .setMessage(R.string.loadSuspended)
+                        .setPositiveButton(R.string.ok, null)
+                        .show();
+            }
+        }
+        WebView w = mTabControl.getCurrentWebView();
+        if (w != null) {
+            w.setNetworkAvailable(up);
+        }
+    }
+
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode,
+                                    Intent intent) {
+        switch (requestCode) {
+            case COMBO_PAGE:
+                if (resultCode == RESULT_OK && intent != null) {
+                    String data = intent.getAction();
+                    Bundle extras = intent.getExtras();
+                    if (extras != null && extras.getBoolean("new_window", false)) {
+                        openTab(data);
+                    } else {
+                        final TabControl.Tab currentTab =
+                                mTabControl.getCurrentTab();
+                        // If the Window overview is up and we are not in the
+                        // middle of an animation, animate away from it to the
+                        // current tab.
+                        if (mTabOverview != null && mAnimationCount == 0) {
+                            sendAnimateFromOverview(currentTab, false, data,
+                                    TAB_OVERVIEW_DELAY, null);
+                        } else {
+                            dismissSubWindow(currentTab);
+                            if (data != null && data.length() != 0) {
+                                getTopWindow().loadUrl(data);
+                            }
+                        }
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+        getTopWindow().requestFocus();
+    }
+
+    /*
+     * This method is called as a result of the user selecting the options
+     * menu to see the download window, or when a download changes state. It
+     * shows the download window ontop of the current window.
+     */
+    /* package */ void viewDownloads(Uri downloadRecord) {
+        Intent intent = new Intent(this,
+                BrowserDownloadPage.class);
+        intent.setData(downloadRecord);
+        startActivityForResult(intent, this.DOWNLOAD_PAGE);
+
+    }
+
+    /**
+     * Handle results from Tab Switcher mTabOverview tool
+     */
+    private class TabListener implements ImageGrid.Listener {
+        public void remove(int position) {
+            // Note: Remove is not enabled if we have only one tab.
+            if (Config.DEBUG && mTabControl.getTabCount() == 1) {
+                throw new AssertionError();
+            }
+
+            // Remember the current tab.
+            TabControl.Tab current = mTabControl.getCurrentTab();
+            final TabControl.Tab remove = mTabControl.getTab(position);
+            mTabControl.removeTab(remove);
+            // If we removed the current tab, use the tab at position - 1 if
+            // possible.
+            if (current == remove) {
+                // If the user removes the last tab, act like the New Tab item
+                // was clicked on.
+                if (mTabControl.getTabCount() == 0) {
+                    current = mTabControl.createNewTab(false);
+                    sendAnimateFromOverview(current, true,
+                            mSettings.getHomePage(), TAB_OVERVIEW_DELAY, null);
+                } else {
+                    final int index = position > 0 ? (position - 1) : 0;
+                    current = mTabControl.getTab(index);
+                }
+            }
+
+            // The tab overview could have been dismissed before this method is
+            // called.
+            if (mTabOverview != null) {
+                // Remove the tab and change the index.
+                mTabOverview.remove(position);
+                mTabOverview.setCurrentIndex(mTabControl.getTabIndex(current));
+            }
+
+            // Only the current tab ensures its WebView is non-null. This
+            // implies that we are reloading the freed tab.
+            mTabControl.setCurrentTab(current);
+        }
+        public void onClick(int index) {
+            // Change the tab if necessary.
+            // Index equals ImageGrid.CANCEL when pressing back from the tab
+            // overview.
+            if (index == ImageGrid.CANCEL) {
+                index = mTabControl.getCurrentIndex();
+                // The current index is -1 if the current tab was removed.
+                if (index == -1) {
+                    // Take the last tab as a fallback.
+                    index = mTabControl.getTabCount() - 1;
+                }
+            }
+
+            // Clear all the data for tab picker so next time it will be
+            // recreated.
+            mTabControl.wipeAllPickerData();
+
+            // NEW_TAB means that the "New Tab" cell was clicked on.
+            if (index == ImageGrid.NEW_TAB) {
+                openTabAndShow(mSettings.getHomePage(), null, false);
+            } else {
+                sendAnimateFromOverview(mTabControl.getTab(index),
+                        false, null, 0, null);
+            }
+        }
+    }
+
+    // A fake View that draws the WebView's picture with a fast zoom filter.
+    // The View is used in case the tab is freed during the animation because
+    // of low memory.
+    private static class AnimatingView extends View {
+        private static final int ZOOM_BITS = Paint.FILTER_BITMAP_FLAG |
+                Paint.DITHER_FLAG | Paint.SUBPIXEL_TEXT_FLAG;
+        private static final DrawFilter sZoomFilter =
+                new PaintFlagsDrawFilter(ZOOM_BITS, Paint.LINEAR_TEXT_FLAG);
+        private final Picture mPicture;
+        private final float   mScale;
+        private final int     mScrollX;
+        private final int     mScrollY;
+        final TabControl.Tab  mTab;
+
+        AnimatingView(Context ctxt, TabControl.Tab t) {
+            super(ctxt);
+            mTab = t;
+            // Use the top window in the animation since the tab overview will
+            // display the top window in each cell.
+            final WebView w = t.getTopWindow();
+            mPicture = w.capturePicture();
+            mScale = w.getScale() / w.getWidth();
+            mScrollX = w.getScrollX();
+            mScrollY = w.getScrollY();
+        }
+
+        @Override
+        protected void onDraw(Canvas canvas) {
+            canvas.save();
+            canvas.drawColor(Color.WHITE);
+            if (mPicture != null) {
+                canvas.setDrawFilter(sZoomFilter);
+                float scale = getWidth() * mScale;
+                canvas.scale(scale, scale);
+                canvas.translate(-mScrollX, -mScrollY);
+                canvas.drawPicture(mPicture);
+            }
+            canvas.restore();
+        }
+    }
+
+    /**
+     *  Open the tab picker. This function will always use the current tab in
+     *  its animation.
+     *  @param stay boolean stating whether the tab picker is to remain open
+     *          (in which case it needs a listener and its menu) or not.
+     *  @param index The index of the tab to show as the selection in the tab
+     *               overview.
+     *  @param remove If true, the tab at index will be removed after the
+     *                animation completes.
+     */
+    private void tabPicker(final boolean stay, final int index,
+            final boolean remove) {
+        if (mTabOverview != null) {
+            return;
+        }
+
+        int size = mTabControl.getTabCount();
+
+        TabListener l = null;
+        if (stay) {
+            l = mTabListener = new TabListener();
+        }
+        mTabOverview = new ImageGrid(this, stay, l);
+
+        for (int i = 0; i < size; i++) {
+            final TabControl.Tab t = mTabControl.getTab(i);
+            mTabControl.populatePickerData(t);
+            mTabOverview.add(t);
+        }
+
+        // Tell the tab overview to show the current tab, the tab overview will
+        // handle the "New Tab" case.
+        int currentIndex = mTabControl.getCurrentIndex();
+        mTabOverview.setCurrentIndex(currentIndex);
+
+        // Attach the tab overview.
+        mContentView.addView(mTabOverview, COVER_SCREEN_PARAMS);
+
+        // Create a fake AnimatingView to animate the WebView's picture.
+        final TabControl.Tab current = mTabControl.getCurrentTab();
+        final AnimatingView v = new AnimatingView(this, current);
+        mContentView.addView(v, COVER_SCREEN_PARAMS);
+        removeTabFromContentView(current);
+        // Pause timers to get the animation smoother.
+        current.getWebView().pauseTimers();
+
+        // Send a message so the tab picker has a chance to layout and get
+        // positions for all the cells.
+        mHandler.sendMessage(mHandler.obtainMessage(ANIMATE_TO_OVERVIEW,
+                index, remove ? 1 : 0, v));
+        // Setting this will indicate that we are animating to the overview. We
+        // set it here to prevent another request to animate from coming in
+        // between now and when ANIMATE_TO_OVERVIEW is handled.
+        mAnimationCount++;
+        // Always change the title bar to the window overview title while
+        // animating.
+        getWindow().setFeatureDrawable(Window.FEATURE_LEFT_ICON, null);
+        getWindow().setFeatureDrawable(Window.FEATURE_RIGHT_ICON, null);
+        getWindow().setFeatureInt(Window.FEATURE_PROGRESS,
+                Window.PROGRESS_VISIBILITY_OFF);
+        setTitle(R.string.tab_picker_title);
+        // Make the menu empty until the animation completes.
+        mMenuState = EMPTY_MENU;
+    }
+
+    private void bookmarksOrHistoryPicker(boolean startWithHistory) {
+        WebView current = mTabControl.getCurrentWebView();
+        if (current == null) {
+            return;
+        }
+        Intent intent = new Intent(this,
+                CombinedBookmarkHistoryActivity.class);
+        String title = current.getTitle();
+        String url = current.getUrl();
+        // Just in case the user opens bookmarks before a page finishes loading
+        // so the current history item, and therefore the page, is null.
+        if (null == url) {
+            url = mLastEnteredUrl;
+            // This can happen.
+            if (null == url) {
+                url = mSettings.getHomePage();
+            }
+        }
+        // In case the web page has not yet received its associated title.
+        if (title == null) {
+            title = url;
+        }
+        intent.putExtra("title", title);
+        intent.putExtra("url", url);
+        intent.putExtra("maxTabsOpen",
+                mTabControl.getTabCount() >= TabControl.MAX_TABS);
+        if (startWithHistory) {
+            intent.putExtra(CombinedBookmarkHistoryActivity.STARTING_TAB,
+                    CombinedBookmarkHistoryActivity.HISTORY_TAB);
+        }
+        startActivityForResult(intent, COMBO_PAGE);
+    }
+
+    // Called when loading from context menu or LOAD_URL message
+    private void loadURL(WebView view, String url) {
+        // In case the user enters nothing.
+        if (url != null && url.length() != 0 && view != null) {
+            url = smartUrlFilter(url);
+            if (!mWebViewClient.shouldOverrideUrlLoading(view, url)) {
+                view.loadUrl(url);
+            }
+        }
+    }
+
+    private void checkMemory() {
+        ActivityManager.MemoryInfo mi = new ActivityManager.MemoryInfo();
+        ((ActivityManager) getSystemService(ACTIVITY_SERVICE))
+                .getMemoryInfo(mi);
+        // FIXME: mi.lowMemory is too aggressive, use (mi.availMem <
+        // mi.threshold) for now
+        //        if (mi.lowMemory) {
+        if (mi.availMem < mi.threshold) {
+            Log.w(LOGTAG, "Browser is freeing memory now because: available="
+                            + (mi.availMem / 1024) + "K threshold="
+                            + (mi.threshold / 1024) + "K");
+            mTabControl.freeMemory();
+        }
+    }
+
+    private String smartUrlFilter(Uri inUri) {
+        if (inUri != null) {
+            return smartUrlFilter(inUri.toString());
+        }
+        return null;
+    }
+
+
+    // get window count
+
+    int getWindowCount(){
+      if(mTabControl != null){
+        return mTabControl.getTabCount();
+      }
+      return 0;
+    }
+
+    static final Pattern ACCEPTED_URI_SCHEMA = Pattern.compile(
+            "(?i)" + // switch on case insensitive matching
+            "(" +    // begin group for schema
+            "(?:http|https|file):\\/\\/" +
+            "|(?:data|about|content|javascript):" +
+            ")" +
+            "(.*)" );
+
+    /**
+     * Attempts to determine whether user input is a URL or search
+     * terms.  Anything with a space is passed to search.
+     *
+     * Converts to lowercase any mistakenly uppercased schema (i.e.,
+     * "Http://" converts to "http://"
+     *
+     * @return Original or modified URL
+     *
+     */
+    String smartUrlFilter(String url) {
+
+        String inUrl = url.trim();
+        boolean hasSpace = inUrl.indexOf(' ') != -1;
+
+        Matcher matcher = ACCEPTED_URI_SCHEMA.matcher(inUrl);
+        if (matcher.matches()) {
+            if (hasSpace) {
+                inUrl = inUrl.replace(" ", "%20");
+            }
+            // force scheme to lowercase
+            String scheme = matcher.group(1);
+            String lcScheme = scheme.toLowerCase();
+            if (!lcScheme.equals(scheme)) {
+                return lcScheme + matcher.group(2);
+            }
+            return inUrl;
+        }
+        if (hasSpace) {
+            // FIXME: quick search, need to be customized by setting
+            if (inUrl.length() > 2 && inUrl.charAt(1) == ' ') {
+                // FIXME: Is this the correct place to add to searches?
+                // what if someone else calls this function?
+                char char0 = inUrl.charAt(0);
+
+                if (char0 == 'g') {
+                    Browser.addSearchUrl(mResolver, inUrl);
+                    return composeSearchUrl(inUrl.substring(2));
+
+                } else if (char0 == 'w') {
+                    Browser.addSearchUrl(mResolver, inUrl);
+                    return URLUtil.composeSearchUrl(inUrl.substring(2),
+                            QuickSearch_W,
+                            QUERY_PLACE_HOLDER);
+
+                } else if (char0 == 'd') {
+                    Browser.addSearchUrl(mResolver, inUrl);
+                    return URLUtil.composeSearchUrl(inUrl.substring(2),
+                            QuickSearch_D,
+                            QUERY_PLACE_HOLDER);
+
+                } else if (char0 == 'l') {
+                    Browser.addSearchUrl(mResolver, inUrl);
+                    // FIXME: we need location in this case
+                    return URLUtil.composeSearchUrl(inUrl.substring(2),
+                            QuickSearch_L,
+                            QUERY_PLACE_HOLDER);
+                }
+            }
+        } else {
+            if (Regex.WEB_URL_PATTERN.matcher(inUrl).matches()) {
+                return URLUtil.guessUrl(inUrl);
+            }
+        }
+
+        Browser.addSearchUrl(mResolver, inUrl);
+        return composeSearchUrl(inUrl);
+    }
+
+    /* package */ String composeSearchUrl(String search) {
+        return URLUtil.composeSearchUrl(search, QuickSearch_G,
+                QUERY_PLACE_HOLDER);
+    }
+
+    /* package */void setBaseSearchUrl(String url) {
+        if (url == null || url.length() == 0) {
+            /*
+             * get the google search url based on the SIM. Default is US. NOTE:
+             * This code uses resources to optionally select the search Uri,
+             * based on the MCC value from the SIM. The default string will most
+             * likely be fine. It is parameterized to accept info from the
+             * Locale, the language code is the first parameter (%1$s) and the
+             * country code is the second (%2$s). This code must function in the
+             * same way as a similar lookup in
+             * com.android.googlesearch.SuggestionProvider#onCreate(). If you
+             * change either of these functions, change them both. (The same is
+             * true for the underlying resource strings, which are stored in
+             * mcc-specific xml files.)
+             */
+            Locale l = Locale.getDefault();
+            QuickSearch_G = getResources().getString(
+                    R.string.google_search_base, l.getLanguage(),
+                    l.getCountry().toLowerCase())
+                    + "client=ms-"
+                    + SystemProperties.get("persist.sys.com.google.clientid", "unknown")
+                    + "&source=android-" + GOOGLE_SEARCH_SOURCE_SUGGEST + "&q=%s";
+        } else {
+            QuickSearch_G = url;
+        }
+    }
+
+    private final static int LOCK_ICON_UNSECURE = 0;
+    private final static int LOCK_ICON_SECURE   = 1;
+    private final static int LOCK_ICON_MIXED    = 2;
+
+    private int mLockIconType = LOCK_ICON_UNSECURE;
+    private int mPrevLockType = LOCK_ICON_UNSECURE;
+
+    private BrowserSettings mSettings;
+    private TabControl      mTabControl;
+    private ContentResolver mResolver;
+    private FrameLayout     mContentView;
+    private ImageGrid       mTabOverview;
+
+    // FIXME, temp address onPrepareMenu performance problem. When we move everything out of
+    // view, we should rewrite this.
+    private int mCurrentMenuState = 0;
+    private int mMenuState = R.id.MAIN_MENU;
+    private static final int EMPTY_MENU = -1;
+    private Menu mMenu;
+
+    private FindDialog mFindDialog;
+    // Used to prevent chording to result in firing two shortcuts immediately
+    // one after another.  Fixes bug 1211714.
+    boolean mCanChord;
+
+    private boolean mInLoad;
+    private boolean mIsNetworkUp;
+
+    private boolean mPageStarted;
+    private boolean mActivityInPause = true;
+
+    private boolean mMenuIsDown;
+
+    private final KeyTracker mKeyTracker = new KeyTracker(this);
+
+    // As trackball doesn't send repeat down, we have to track it ourselves
+    private boolean mTrackTrackball;
+
+    private static boolean mInTrace;
+
+    // Performance probe
+    private static final int[] SYSTEM_CPU_FORMAT = new int[] {
+            Process.PROC_SPACE_TERM | Process.PROC_COMBINE,
+            Process.PROC_SPACE_TERM | Process.PROC_OUT_LONG, // 1: user time
+            Process.PROC_SPACE_TERM | Process.PROC_OUT_LONG, // 2: nice time
+            Process.PROC_SPACE_TERM | Process.PROC_OUT_LONG, // 3: sys time
+            Process.PROC_SPACE_TERM | Process.PROC_OUT_LONG, // 4: idle time
+            Process.PROC_SPACE_TERM | Process.PROC_OUT_LONG, // 5: iowait time
+            Process.PROC_SPACE_TERM | Process.PROC_OUT_LONG, // 6: irq time
+            Process.PROC_SPACE_TERM | Process.PROC_OUT_LONG  // 7: softirq time
+    };
+
+    private long mStart;
+    private long mProcessStart;
+    private long mUserStart;
+    private long mSystemStart;
+    private long mIdleStart;
+    private long mIrqStart;
+
+    private long mUiStart;
+
+    private Drawable    mMixLockIcon;
+    private Drawable    mSecLockIcon;
+    private Drawable    mGenericFavicon;
+
+    /* hold a ref so we can auto-cancel if necessary */
+    private AlertDialog mAlertDialog;
+
+    // Wait for credentials before loading google.com
+    private ProgressDialog mCredsDlg;
+
+    // The up-to-date URL and title (these can be different from those stored
+    // in WebView, since it takes some time for the information in WebView to
+    // get updated)
+    private String mUrl;
+    private String mTitle;
+
+    // As PageInfo has different style for landscape / portrait, we have
+    // to re-open it when configuration changed
+    private AlertDialog mPageInfoDialog;
+    private TabControl.Tab mPageInfoView;
+    // If the Page-Info dialog is launched from the SSL-certificate-on-error
+    // dialog, we should not just dismiss it, but should get back to the
+    // SSL-certificate-on-error dialog. This flag is used to store this state
+    private Boolean mPageInfoFromShowSSLCertificateOnError;
+
+    // as SSLCertificateOnError has different style for landscape / portrait,
+    // we have to re-open it when configuration changed
+    private AlertDialog mSSLCertificateOnErrorDialog;
+    private WebView mSSLCertificateOnErrorView;
+    private SslErrorHandler mSSLCertificateOnErrorHandler;
+    private SslError mSSLCertificateOnErrorError;
+
+    // as SSLCertificate has different style for landscape / portrait, we
+    // have to re-open it when configuration changed
+    private AlertDialog mSSLCertificateDialog;
+    private TabControl.Tab mSSLCertificateView;
+
+    // as HttpAuthentication has different style for landscape / portrait, we
+    // have to re-open it when configuration changed
+    private AlertDialog mHttpAuthenticationDialog;
+    private HttpAuthHandler mHttpAuthHandler;
+
+    /*package*/ static final FrameLayout.LayoutParams COVER_SCREEN_PARAMS =
+                                            new FrameLayout.LayoutParams(
+                                            ViewGroup.LayoutParams.FILL_PARENT,
+                                            ViewGroup.LayoutParams.FILL_PARENT);
+    // We may provide UI to customize these
+    // Google search from the browser
+    static String QuickSearch_G;
+    // Wikipedia search
+    final static String QuickSearch_W = "http://en.wikipedia.org/w/index.php?search=%s&go=Go";
+    // Dictionary search
+    final static String QuickSearch_D = "http://dictionary.reference.com/search?q=%s";
+    // Google Mobile Local search
+    final static String QuickSearch_L = "http://www.google.com/m/search?site=local&q=%s&near=mountain+view";
+
+    final static String QUERY_PLACE_HOLDER = "%s";
+
+    // "source" parameter for Google search through search key
+    final static String GOOGLE_SEARCH_SOURCE_SEARCHKEY = "browser-key";
+    // "source" parameter for Google search through goto menu
+    final static String GOOGLE_SEARCH_SOURCE_GOTO = "browser-goto";
+    // "source" parameter for Google search through simplily type
+    final static String GOOGLE_SEARCH_SOURCE_TYPE = "browser-type";
+    // "source" parameter for Google search suggested by the browser
+    final static String GOOGLE_SEARCH_SOURCE_SUGGEST = "browser-suggest";
+    // "source" parameter for Google search from unknown source
+    final static String GOOGLE_SEARCH_SOURCE_UNKNOWN = "unknown";
+
+    private final static String LOGTAG = "browser";
+
+    private TabListener mTabListener;
+
+    private String mLastEnteredUrl;
+
+    private PowerManager.WakeLock mWakeLock;
+    private final static int WAKELOCK_TIMEOUT = 5 * 60 * 1000; // 5 minutes
+
+    private Toast mStopToast;
+
+    // Used during animations to prevent other animations from being triggered.
+    // A count is used since the animation to and from the Window overview can
+    // overlap. A count of 0 means no animation where a count of > 0 means
+    // there are animations in progress.
+    private int mAnimationCount;
+
+    // As the ids are dynamically created, we can't guarantee that they will
+    // be in sequence, so this static array maps ids to a window number.
+    final static private int[] WINDOW_SHORTCUT_ID_ARRAY =
+    { R.id.window_one_menu_id, R.id.window_two_menu_id, R.id.window_three_menu_id,
+      R.id.window_four_menu_id, R.id.window_five_menu_id, R.id.window_six_menu_id,
+      R.id.window_seven_menu_id, R.id.window_eight_menu_id };
+
+    // monitor platform changes
+    private IntentFilter mNetworkStateChangedFilter;
+    private BroadcastReceiver mNetworkStateIntentReceiver;
+
+    // activity requestCode
+    final static int COMBO_PAGE             = 1;
+    final static int DOWNLOAD_PAGE          = 2;
+    final static int PREFERENCES_PAGE       = 3;
+
+    // the frenquency of checking whether system memory is low
+    final static int CHECK_MEMORY_INTERVAL = 30000;     // 30 seconds
+}
diff --git a/src/com/android/browser/BrowserBookmarksAdapter.java b/src/com/android/browser/BrowserBookmarksAdapter.java
new file mode 100644
index 0000000..479dc0e
--- /dev/null
+++ b/src/com/android/browser/BrowserBookmarksAdapter.java
@@ -0,0 +1,535 @@
+/*
+ * 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;
+
+import android.content.ContentResolver;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.database.ContentObserver;
+import android.database.Cursor;
+import android.database.DataSetObserver;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.Handler;
+import android.provider.Browser;
+import android.provider.Browser.BookmarkColumns;
+import android.view.KeyEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.webkit.WebIconDatabase;
+import android.webkit.WebIconDatabase.IconListener;
+import android.widget.BaseAdapter;
+
+import java.io.ByteArrayOutputStream;
+
+class BrowserBookmarksAdapter extends BaseAdapter {
+
+    private final String            LOGTAG = "Bookmarks";
+
+    private String                  mCurrentPage;
+    private Cursor                  mCursor;
+    private int                     mCount;
+    private String                  mLastWhereClause;
+    private String[]                mLastSelectionArgs;
+    private String                  mLastOrderBy;
+    private BrowserBookmarksPage    mBookmarksPage;
+    private ContentResolver         mContentResolver;
+    private ChangeObserver          mChangeObserver;
+    private DataSetObserver         mDataSetObserver;
+    private boolean                 mDataValid;
+
+    // When true, this adapter is used to pick a bookmark to create a shortcut
+    private boolean mCreateShortcut;
+    private int mExtraOffset;
+
+    // Implementation of WebIconDatabase.IconListener
+    private class IconReceiver implements IconListener {
+        public void onReceivedIcon(String url, Bitmap icon) {
+            updateBookmarkFavicon(mContentResolver, url, icon);
+        }
+    }
+
+    // Instance of IconReceiver
+    private final IconReceiver mIconReceiver = new IconReceiver();
+
+    /**
+     *  Create a new BrowserBookmarksAdapter.
+     *  @param b        BrowserBookmarksPage that instantiated this.  
+     *                  Necessary so it will adjust its focus
+     *                  appropriately after a search.
+     */
+    public BrowserBookmarksAdapter(BrowserBookmarksPage b, String curPage) {
+        this(b, curPage, false);
+    }
+
+    /**
+     *  Create a new BrowserBookmarksAdapter.
+     *  @param b        BrowserBookmarksPage that instantiated this.
+     *                  Necessary so it will adjust its focus
+     *                  appropriately after a search.
+     */
+    public BrowserBookmarksAdapter(BrowserBookmarksPage b, String curPage,
+            boolean createShortcut) {
+        mDataValid = false;
+        mCreateShortcut = createShortcut;
+        mExtraOffset = createShortcut ? 0 : 1;
+        mBookmarksPage = b;
+        mCurrentPage = b.getResources().getString(R.string.current_page) + 
+                curPage;
+        mContentResolver = b.getContentResolver();
+        mLastOrderBy = Browser.BookmarkColumns.CREATED + " DESC";
+        mChangeObserver = new ChangeObserver();
+        mDataSetObserver = new MyDataSetObserver();
+        // FIXME: Should have a default sort order that the user selects.
+        search(null);
+        // FIXME: This requires another query of the database after the
+        // initial search(null). Can we optimize this?
+        Browser.requestAllIcons(mContentResolver,
+                Browser.BookmarkColumns.FAVICON + " is NULL AND " +
+                Browser.BookmarkColumns.BOOKMARK + " == 1", mIconReceiver);
+    }
+    
+    /**
+     *  Return a hashmap with one row's Title, Url, and favicon.
+     *  @param position  Position in the list.
+     *  @return Bundle  Stores title, url of row position, favicon, and id
+     *                   for the url.  Return a blank map if position is out of
+     *                   range.
+     */
+    public Bundle getRow(int position) {
+        Bundle map = new Bundle();
+        if (position < mExtraOffset || position >= mCount) {
+            return map;
+        }
+        mCursor.moveToPosition(position- mExtraOffset);
+        String url = mCursor.getString(Browser.HISTORY_PROJECTION_URL_INDEX);
+        map.putString(Browser.BookmarkColumns.TITLE, 
+                mCursor.getString(Browser.HISTORY_PROJECTION_TITLE_INDEX));
+        map.putString(Browser.BookmarkColumns.URL, url);
+        byte[] data = mCursor.getBlob(Browser.HISTORY_PROJECTION_FAVICON_INDEX);
+        if (data != null) {
+            map.putParcelable(Browser.BookmarkColumns.FAVICON,
+                    BitmapFactory.decodeByteArray(data, 0, data.length));
+        }
+        map.putInt("id", mCursor.getInt(Browser.HISTORY_PROJECTION_ID_INDEX));
+        return map;
+    }
+
+    /**
+     *  Update a row in the database with new information. 
+     *  Requeries the database if the information has changed.
+     *  @param map  Bundle storing id, title and url of new information
+     */
+    public void updateRow(Bundle map) {
+
+        // Find the record
+        int id = map.getInt("id");
+        int position = -1;
+        for (mCursor.moveToFirst(); !mCursor.isAfterLast(); mCursor.moveToNext()) {
+            if (mCursor.getInt(Browser.HISTORY_PROJECTION_ID_INDEX) == id) {
+                position = mCursor.getPosition();
+                break;
+            }
+        }
+        if (position < 0) {
+            return;
+        }
+
+        mCursor.moveToPosition(position);
+        ContentValues values = new ContentValues();
+        String title = map.getString(Browser.BookmarkColumns.TITLE);
+        if (!title.equals(mCursor
+                .getString(Browser.HISTORY_PROJECTION_TITLE_INDEX))) {
+            values.put(Browser.BookmarkColumns.TITLE, title);
+        }
+        String url = map.getString(Browser.BookmarkColumns.URL);
+        if (!url.equals(mCursor.
+                getString(Browser.HISTORY_PROJECTION_URL_INDEX))) {
+            values.put(Browser.BookmarkColumns.URL, url);
+        }
+        if (values.size() > 0
+                && mContentResolver.update(Browser.BOOKMARKS_URI, values,
+                        "_id = " + id, null) != -1) {
+            refreshList();
+        }
+    }
+
+    /**
+     *  Delete a row from the database.  Requeries the database.  
+     *  Does nothing if the provided position is out of range.
+     *  @param position Position in the list.
+     */
+    public void deleteRow(int position) {
+        if (position < mExtraOffset || position >= getCount()) {
+            return;
+        }
+        mCursor.moveToPosition(position- mExtraOffset);
+        String url = mCursor.getString(Browser.HISTORY_PROJECTION_URL_INDEX);
+        WebIconDatabase.getInstance().releaseIconForPageUrl(url);
+        Uri uri = ContentUris.withAppendedId(Browser.BOOKMARKS_URI, mCursor
+                .getInt(Browser.HISTORY_PROJECTION_ID_INDEX));
+        int numVisits = mCursor.getInt(Browser.HISTORY_PROJECTION_VISITS_INDEX);
+        if (0 == numVisits) {
+            mContentResolver.delete(uri, null, null);
+        } else {
+            // It is no longer a bookmark, but it is still a visited site.
+            ContentValues values = new ContentValues();
+            values.put(Browser.BookmarkColumns.BOOKMARK, 0);
+            mContentResolver.update(uri, values, null, null);
+        }
+        refreshList();
+    }
+    
+    /**
+     *  Delete all bookmarks from the db. Requeries the database.  
+     *  All bookmarks with become visited URLs or if never visited 
+     *  are removed
+     */
+    public void deleteAllRows() {
+        StringBuilder deleteIds = null;
+        StringBuilder convertIds = null;
+        
+        for (mCursor.moveToFirst(); !mCursor.isAfterLast(); mCursor.moveToNext()) {
+            String url = mCursor.getString(Browser.HISTORY_PROJECTION_URL_INDEX);
+            WebIconDatabase.getInstance().releaseIconForPageUrl(url);
+            int id = mCursor.getInt(Browser.HISTORY_PROJECTION_ID_INDEX);
+            int numVisits = mCursor.getInt(Browser.HISTORY_PROJECTION_VISITS_INDEX);
+            if (0 == numVisits) {
+                if (deleteIds == null) {
+                    deleteIds = new StringBuilder();
+                    deleteIds.append("( ");
+                } else {
+                    deleteIds.append(" OR ( ");
+                }
+                deleteIds.append(BookmarkColumns._ID);
+                deleteIds.append(" = ");
+                deleteIds.append(id);
+                deleteIds.append(" )");
+            } else {
+                // It is no longer a bookmark, but it is still a visited site.
+                if (convertIds == null) {
+                    convertIds = new StringBuilder();
+                    convertIds.append("( ");
+                } else {
+                    convertIds.append(" OR ( ");
+                }
+                convertIds.append(BookmarkColumns._ID);
+                convertIds.append(" = ");
+                convertIds.append(id);
+                convertIds.append(" )");
+            }
+        }
+        
+        if (deleteIds != null) {
+            mContentResolver.delete(Browser.BOOKMARKS_URI, deleteIds.toString(), 
+                null);
+        }
+        if (convertIds != null) {
+            ContentValues values = new ContentValues();
+            values.put(Browser.BookmarkColumns.BOOKMARK, 0);
+            mContentResolver.update(Browser.BOOKMARKS_URI, values, 
+                    convertIds.toString(), null);
+        }
+        refreshList();
+    }
+
+    /**
+     *  Refresh list to recognize a change in the database.
+     */
+    public void refreshList() {
+        // FIXME: consider using requery().
+        // Need to do more work to get it to function though.
+        searchInternal(mLastWhereClause, mLastSelectionArgs, mLastOrderBy);
+    }
+
+    /**
+     *  Search the database for bookmarks that match the input string.
+     *  @param like String to use to search the database.  Strings with spaces 
+     *              are treated as having multiple search terms using the
+     *              OR operator.  Search both the title and url.
+     */
+    public void search(String like) {
+        String whereClause = Browser.BookmarkColumns.BOOKMARK + " == 1";
+        String[] selectionArgs = null;
+        if (like != null) {
+            String[] likes = like.split(" ");
+            int count = 0;
+            boolean firstTerm = true;
+            StringBuilder andClause = new StringBuilder(256);
+            for (int j = 0; j < likes.length; j++) {
+                if (likes[j].length() > 0) {
+                    if (firstTerm) {
+                        firstTerm = false;
+                    } else {
+                        andClause.append(" OR ");
+                    }
+                    andClause.append(Browser.BookmarkColumns.TITLE
+                            + " LIKE ? OR " + Browser.BookmarkColumns.URL
+                            + " LIKE ? ");
+                    count += 2;
+                }
+            }
+            if (count > 0) {
+                selectionArgs = new String[count];
+                count = 0;
+                for (int j = 0; j < likes.length; j++) {
+                    if (likes[j].length() > 0) {
+                        like = "%" + likes[j] + "%";
+                        selectionArgs[count++] = like;
+                        selectionArgs[count++] = like;
+                    }
+                }
+                whereClause += " AND (" + andClause + ")";
+            }
+        }
+        searchInternal(whereClause, selectionArgs, mLastOrderBy);
+    }
+
+    /**
+     * Update the bookmark's favicon.
+     * @param cr The ContentResolver to use.
+     * @param url The url of the bookmark to update.
+     * @param favicon The favicon bitmap to write to the db.
+     */
+    /* package */ static void updateBookmarkFavicon(ContentResolver cr,
+            String url, Bitmap favicon) {
+        if (url == null || favicon == null) {
+            return;
+        }
+        // Strip the query.
+        int query = url.indexOf('?');
+        String noQuery = url;
+        if (query != -1) {
+            noQuery = url.substring(0, query);
+        }
+        url = noQuery + '?';
+        // Use noQuery to search for the base url (i.e. if the url is
+        // http://www.yahoo.com/?rs=1, search for http://www.yahoo.com)
+        // Use url to match the base url with other queries (i.e. if the url is
+        // http://www.google.com/m, search for
+        // http://www.google.com/m?some_query)
+        final String[] selArgs = new String[] { noQuery, url };
+        final String where = "(" + Browser.BookmarkColumns.URL + " == ? OR "
+                + Browser.BookmarkColumns.URL + " GLOB ? || '*') AND "
+                + Browser.BookmarkColumns.BOOKMARK + " == 1";
+        final String[] projection = new String[] { Browser.BookmarkColumns._ID };
+        final Cursor c = cr.query(Browser.BOOKMARKS_URI, projection, where,
+                selArgs, null);
+        boolean succeed = c.moveToFirst();
+        ContentValues values = null;
+        while (succeed) {
+            if (values == null) {
+                final ByteArrayOutputStream os = new ByteArrayOutputStream();
+                favicon.compress(Bitmap.CompressFormat.PNG, 100, os);
+                values = new ContentValues();
+                values.put(Browser.BookmarkColumns.FAVICON, os.toByteArray());
+            }
+            cr.update(ContentUris.withAppendedId(Browser.BOOKMARKS_URI, c
+                    .getInt(0)), values, null, null);
+            succeed = c.moveToNext();
+        }
+        c.close();
+    }
+
+    /**
+     *  This sorts alphabetically, with non-capitalized titles before 
+     *  capitalized.
+     */
+    public void sortAlphabetical() {
+        searchInternal(mLastWhereClause, mLastSelectionArgs,
+                Browser.BookmarkColumns.TITLE + " COLLATE UNICODE ASC");
+    }
+
+    /**
+     *  Internal function used in search, sort, and refreshList.
+     */
+    private void searchInternal(String whereClause, String[] selectionArgs,
+            String orderBy) {
+        if (mCursor != null) {
+            mCursor.unregisterContentObserver(mChangeObserver);
+            mCursor.unregisterDataSetObserver(mDataSetObserver);
+            mBookmarksPage.stopManagingCursor(mCursor);
+            mCursor.deactivate();
+        }
+
+        mLastWhereClause = whereClause;
+        mLastSelectionArgs = selectionArgs;
+        mLastOrderBy = orderBy;
+        mCursor = mContentResolver.query(
+            Browser.BOOKMARKS_URI,
+            Browser.HISTORY_PROJECTION,
+            whereClause,
+            selectionArgs, 
+            orderBy);
+        mCursor.registerContentObserver(mChangeObserver);
+        mCursor.registerDataSetObserver(mDataSetObserver);
+        mBookmarksPage.startManagingCursor(mCursor);
+
+        mDataValid = true;
+        notifyDataSetChanged();
+
+        mCount = mCursor.getCount() + mExtraOffset;
+    }
+
+    /**
+     * How many items should be displayed in the list.
+     * @return Count of items.
+     */
+    public int getCount() {
+        if (mDataValid) {
+            return mCount;
+        } else {
+            return 0;
+        }
+    }
+
+    public boolean areAllItemsEnabled() {
+        return true;
+    }
+
+    public boolean isEnabled(int position) {
+        return true;
+    }
+
+    /**
+     * Get the data associated with the specified position in the list.
+     * @param position Index of the item whose data we want.
+     * @return The data at the specified position.
+     */
+    public Object getItem(int position) {
+        return null;
+    }
+
+    /**
+     * Get the row id associated with the specified position in the list.
+     * @param position Index of the item whose row id we want.
+     * @return The id of the item at the specified position.
+     */
+    public long getItemId(int position) {
+        return position;
+    }
+
+    /**
+     * Get a View that displays the data at the specified position
+     * in the list.
+     * @param position Index of the item whose view we want.
+     * @return A View corresponding to the data at the specified position.
+     */
+    public View getView(int position, View convertView, ViewGroup parent) {
+        if (!mDataValid) {
+            throw new IllegalStateException(
+                    "this should only be called when the cursor is valid");
+        }
+        if (position < 0 || position > mCount) {
+            throw new AssertionError(
+                    "BrowserBookmarksAdapter tried to get a view out of range");
+        }
+        if (position == 0 && !mCreateShortcut) {
+            AddNewBookmark b;
+            if (convertView instanceof AddNewBookmark) {
+                b = (AddNewBookmark) convertView;
+            } else {
+                b = new AddNewBookmark(mBookmarksPage);
+            }
+            b.setUrl(mCurrentPage);
+            return b;
+        }
+        if (convertView == null || convertView instanceof AddNewBookmark) {
+            convertView = new BookmarkItem(mBookmarksPage);
+        }
+        bind((BookmarkItem)convertView, position);
+        return convertView;
+    }
+
+    /**
+     *  Return the title for this item in the list.
+     */
+    public String getTitle(int position) {
+        return getString(Browser.HISTORY_PROJECTION_TITLE_INDEX, position);
+    }
+
+    /**
+     *  Return the Url for this item in the list.
+     */
+    public String getUrl(int position) {
+        return getString(Browser.HISTORY_PROJECTION_URL_INDEX, position);
+    }
+
+    /**
+     * Private helper function to return the title or url.
+     */
+    private String getString(int cursorIndex, int position) {
+        if (position < mExtraOffset || position > mCount) {
+            return "";
+        }
+        mCursor.moveToPosition(position- mExtraOffset);
+        return mCursor.getString(cursorIndex);
+    }
+
+    private void bind(BookmarkItem b, int position) {
+        mCursor.moveToPosition(position- mExtraOffset);
+
+        String title = mCursor.getString(Browser.HISTORY_PROJECTION_TITLE_INDEX);
+        if (title.length() > BrowserSettings.MAX_TEXTVIEW_LEN) {
+            title = title.substring(0, BrowserSettings.MAX_TEXTVIEW_LEN);
+        }
+        b.setName(title);
+        String url = mCursor.getString(Browser.HISTORY_PROJECTION_URL_INDEX);
+        if (url.length() > BrowserSettings.MAX_TEXTVIEW_LEN) {
+            url = url.substring(0, BrowserSettings.MAX_TEXTVIEW_LEN);
+        }
+        b.setUrl(url);
+        byte[] data = mCursor.getBlob(Browser.HISTORY_PROJECTION_FAVICON_INDEX);
+        if (data != null) {
+            b.setFavicon(BitmapFactory.decodeByteArray(data, 0, data.length));
+        } else {
+            b.setFavicon(null);
+        }
+    }
+
+    private class ChangeObserver extends ContentObserver {
+        public ChangeObserver() {
+            super(new Handler());
+        }
+
+        @Override
+        public boolean deliverSelfNotifications() {
+            return true;
+        }
+
+        @Override
+        public void onChange(boolean selfChange) {
+            refreshList();
+        }
+    }
+    
+    private class MyDataSetObserver extends DataSetObserver {
+        @Override
+        public void onChanged() {
+            mDataValid = true;
+            notifyDataSetChanged();
+        }
+
+        @Override
+        public void onInvalidated() {
+            mDataValid = false;
+            notifyDataSetInvalidated();
+        }
+    }
+}
diff --git a/src/com/android/browser/BrowserBookmarksPage.java b/src/com/android/browser/BrowserBookmarksPage.java
new file mode 100644
index 0000000..7708e8b
--- /dev/null
+++ b/src/com/android/browser/BrowserBookmarksPage.java
@@ -0,0 +1,385 @@
+/*
+ * 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;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.graphics.Bitmap;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Message;
+import android.os.ServiceManager;
+import android.provider.Browser;
+import android.text.IClipboard;
+import android.util.Log;
+import android.view.ContextMenu;
+import android.view.KeyEvent;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.widget.AdapterView;
+import android.widget.ListView;
+
+/**
+ *  View showing the user's bookmarks in the browser.
+ */
+public class BrowserBookmarksPage extends Activity implements 
+        View.OnCreateContextMenuListener {
+
+    private BrowserBookmarksAdapter mBookmarksAdapter;
+    private static final int        BOOKMARKS_SAVE = 1;
+    private boolean                 mMaxTabsOpen;
+    private BookmarkItem            mContextHeader;
+    private AddNewBookmark          mAddHeader;
+    private boolean                 mCanceled = false;
+    private boolean                 mCreateShortcut;
+    // XXX: There is no public string defining this intent so if Home changes
+    // the value, we have to update this string.
+    private static final String     INSTALL_SHORTCUT =
+            "com.android.launcher.action.INSTALL_SHORTCUT";
+    
+    private final static String LOGTAG = "browser";
+
+
+    @Override
+    public boolean onContextItemSelected(MenuItem item) {
+        // It is possible that the view has been canceled when we get to
+        // this point as back has a higher priority 
+        if (mCanceled) {
+            return true;
+        }
+        AdapterView.AdapterContextMenuInfo i = 
+            (AdapterView.AdapterContextMenuInfo)item.getMenuInfo();
+        // If we have no menu info, we can't tell which item was selected.
+        if (i == null) {
+            return true;
+        }
+        
+        switch (item.getItemId()) {
+        case R.id.new_context_menu_id:
+            saveCurrentPage();
+            break;
+        case R.id.open_context_menu_id:
+            loadUrl(i.position);
+            break;
+        case R.id.edit_context_menu_id:
+            editBookmark(i.position);
+            break;
+        case R.id.shortcut_context_menu_id:
+            final Intent send = createShortcutIntent(getUrl(i.position),
+                    getBookmarkTitle(i.position));
+            send.setAction(INSTALL_SHORTCUT);
+            sendBroadcast(send);
+            break;
+        case R.id.delete_context_menu_id:
+            displayRemoveBookmarkDialog(i.position);
+            break;
+        case R.id.new_window_context_menu_id:
+            openInNewWindow(i.position);
+            break;
+        case R.id.send_context_menu_id:
+            Browser.sendString(BrowserBookmarksPage.this, getUrl(i.position));
+            break;
+        case R.id.copy_url_context_menu_id:
+            copy(getUrl(i.position));
+            
+        default:
+            return super.onContextItemSelected(item);
+        }
+        return true;
+    }
+
+    @Override
+    public void onCreateContextMenu(ContextMenu menu, View v,
+                ContextMenuInfo menuInfo) {
+            AdapterView.AdapterContextMenuInfo i = 
+                    (AdapterView.AdapterContextMenuInfo) menuInfo;
+
+            MenuInflater inflater = getMenuInflater();
+            inflater.inflate(R.menu.bookmarkscontext, menu);
+
+            if (0 == i.position) {
+                menu.setGroupVisible(R.id.CONTEXT_MENU, false);
+                if (mAddHeader == null) {
+                    mAddHeader = new AddNewBookmark(BrowserBookmarksPage.this);
+                } else if (mAddHeader.getParent() != null) {
+                    ((ViewGroup) mAddHeader.getParent()).
+                            removeView(mAddHeader);
+                }
+                ((AddNewBookmark) i.targetView).copyTo(mAddHeader);
+                menu.setHeaderView(mAddHeader);
+                return;
+            }
+            menu.setGroupVisible(R.id.ADD_MENU, false);
+            BookmarkItem b = (BookmarkItem) i.targetView;
+            if (mContextHeader == null) {
+                mContextHeader = new BookmarkItem(BrowserBookmarksPage.this);
+            } else if (mContextHeader.getParent() != null) {
+                ((ViewGroup) mContextHeader.getParent()).
+                        removeView(mContextHeader);
+            }
+            b.copyTo(mContextHeader);
+            menu.setHeaderView(mContextHeader);
+
+            if (mMaxTabsOpen) {
+                menu.findItem(R.id.new_window_context_menu_id).setVisible(
+                        false);
+            }
+        }
+
+    /**
+     *  Create a new BrowserBookmarksPage.
+     */  
+    @Override
+    protected void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+
+        setContentView(R.layout.browser_bookmarks_page);
+        setTitle(R.string.browser_bookmarks_page_bookmarks_text);
+
+        if (Intent.ACTION_CREATE_SHORTCUT.equals(getIntent().getAction())) {
+            mCreateShortcut = true;
+        }
+
+        mBookmarksAdapter = new BrowserBookmarksAdapter(this, 
+                getIntent().getStringExtra("url"), mCreateShortcut);
+        mMaxTabsOpen = getIntent().getBooleanExtra("maxTabsOpen", false);
+
+        ListView listView = (ListView) findViewById(R.id.list);
+        listView.setAdapter(mBookmarksAdapter);
+        listView.setDrawSelectorOnTop(false);
+        listView.setVerticalScrollBarEnabled(true);
+        listView.setOnItemClickListener(mListener);
+
+        if (!mCreateShortcut) {
+            listView.setOnCreateContextMenuListener(this);
+        }
+    }
+
+    private static final int SAVE_CURRENT_PAGE = 1000;
+    private final Handler mHandler = new Handler() {
+        @Override
+        public void handleMessage(Message msg) {
+            if (msg.what == SAVE_CURRENT_PAGE) {
+                saveCurrentPage();
+            }
+        }
+    };
+
+    private AdapterView.OnItemClickListener mListener = new AdapterView.OnItemClickListener() {
+        public void onItemClick(AdapterView parent, View v, int position, long id) {
+            // It is possible that the view has been canceled when we get to
+            // this point as back has a higher priority 
+            if (mCanceled) {
+                android.util.Log.e("browser", "item clicked when dismising");
+                return;
+            }
+            if (!mCreateShortcut) {
+                if (0 == position) {
+                    // XXX: Work-around for a framework issue.
+                    mHandler.sendEmptyMessage(SAVE_CURRENT_PAGE);
+                } else {
+                    loadUrl(position);
+                }
+            } else {
+                final Intent intent = createShortcutIntent(getUrl(position),
+                        getBookmarkTitle(position));
+                setResultToParent(RESULT_OK, intent);
+                finish();
+            }
+        }
+    };
+
+    private Intent createShortcutIntent(String url, String title) {
+        final Intent i = new Intent();
+        i.putExtra(Intent.EXTRA_SHORTCUT_INTENT, new Intent(Intent.ACTION_VIEW,
+                    Uri.parse(url)));
+        i.putExtra(Intent.EXTRA_SHORTCUT_NAME, title);
+        i.putExtra(Intent.EXTRA_SHORTCUT_ICON_RESOURCE,
+                Intent.ShortcutIconResource.fromContext(BrowserBookmarksPage.this,
+                        R.drawable.ic_launcher_browser));
+        // Do not allow duplicate items
+        i.putExtra("duplicate", false);
+        return i;
+    }
+
+    private void saveCurrentPage() {
+        Intent i = new Intent(BrowserBookmarksPage.this,
+                AddBookmarkPage.class);
+        i.putExtras(getIntent());
+        startActivityForResult(i, BOOKMARKS_SAVE);
+    }
+
+    private void loadUrl(int position) {
+        Intent intent = (new Intent()).setAction(getUrl(position));
+        setResultToParent(RESULT_OK, intent);
+        finish();
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        boolean result = super.onCreateOptionsMenu(menu);
+        if (!mCreateShortcut) {
+            MenuInflater inflater = getMenuInflater();
+            inflater.inflate(R.menu.bookmarks, menu);
+            return true;
+        }
+        return result;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        switch (item.getItemId()) {
+            case R.id.new_context_menu_id:
+                saveCurrentPage();
+                break;
+                
+            default:
+                return super.onOptionsItemSelected(item);
+        }
+        return true;
+    }
+
+    private void openInNewWindow(int position) {
+        Bundle b = new Bundle();
+        b.putBoolean("new_window", true);
+        setResultToParent(RESULT_OK,
+                (new Intent()).setAction(getUrl(position)).putExtras(b));
+
+        finish();
+    }
+    
+
+    private void editBookmark(int position) {
+        Intent intent = new Intent(BrowserBookmarksPage.this, 
+            AddBookmarkPage.class);
+        intent.putExtra("bookmark", getRow(position));
+        startActivityForResult(intent, BOOKMARKS_SAVE);
+    }
+
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode,
+                                    Intent data) {
+        switch(requestCode) {
+            case BOOKMARKS_SAVE:
+                if (resultCode == RESULT_OK) {
+                    Bundle extras;
+                    if (data != null && (extras = data.getExtras()) != null) {
+                        // If there are extras, then we need to save
+                        // the edited bookmark. This is done in updateRow()
+                        String title = extras.getString("title");
+                        String url = extras.getString("url");
+                        if (title != null && url != null) {
+                            mBookmarksAdapter.updateRow(extras);
+                        }
+                    } else {
+                        // extras == null then a new bookmark was added to
+                        // the database.
+                        refreshList();
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    
+    private void displayRemoveBookmarkDialog(int position) {
+        // Put up a dialog asking if the user really wants to
+        // delete the bookmark
+        final int deletePos = position;
+        new AlertDialog.Builder(this)
+                .setTitle(R.string.delete_bookmark)
+                .setIcon(android.R.drawable.ic_dialog_alert)
+                .setMessage(getText(R.string.delete_bookmark_warning).toString().replace(
+                        "%s", getBookmarkTitle(deletePos)))
+                .setPositiveButton(R.string.ok, 
+                        new DialogInterface.OnClickListener() {
+                            public void onClick(DialogInterface dialog, int whichButton) {
+                                deleteBookmark(deletePos);
+                            }
+                        })
+                .setNegativeButton(R.string.cancel, null)
+                .show();
+    }
+
+    /**
+     *  Refresh the shown list after the database has changed.
+     */
+    public void refreshList() {
+        mBookmarksAdapter.refreshList();
+    }
+    
+    /**
+     *  Return a hashmap representing the currently highlighted row.
+     */
+    public Bundle getRow(int position) {
+        return mBookmarksAdapter.getRow(position);
+    }
+
+    /**
+     *  Return the url of the currently highlighted row.
+     */
+    public String getUrl(int position) {
+        return mBookmarksAdapter.getUrl(position);
+    }
+
+    private void copy(CharSequence text) {
+        try {
+            IClipboard clip = IClipboard.Stub.asInterface(ServiceManager.getService("clipboard"));
+            if (clip != null) {
+                clip.setClipboardText(text);
+            }
+        } catch (android.os.RemoteException e) {
+            Log.e(LOGTAG, "Copy failed", e);
+        }
+    }
+    
+    public String getBookmarkTitle(int position) {
+        return mBookmarksAdapter.getTitle(position);
+    }
+
+    /**
+     *  Delete the currently highlighted row.
+     */
+    public void deleteBookmark(int position) {
+        mBookmarksAdapter.deleteRow(position);
+    }
+    
+    public boolean dispatchKeyEvent(KeyEvent event) {    
+        if (event.getKeyCode() ==  KeyEvent.KEYCODE_BACK && event.isDown()) {
+            setResultToParent(RESULT_CANCELED, null);
+            mCanceled = true;
+        }
+        return super.dispatchKeyEvent(event);
+    }
+
+    // This Activity is generally a sub-Activity of CombinedHistoryActivity. In
+    // that situation, we need to pass our result code up to our parent.
+    // However, if someone calls this Activity directly, then this has no
+    // parent, and it needs to set it on itself.
+    private void setResultToParent(int resultCode, Intent data) {
+        Activity a = getParent() == null ? this : getParent();
+        a.setResult(resultCode, data);
+    }
+}
diff --git a/src/com/android/browser/BrowserDownloadAdapter.java b/src/com/android/browser/BrowserDownloadAdapter.java
new file mode 100644
index 0000000..38b83fe
--- /dev/null
+++ b/src/com/android/browser/BrowserDownloadAdapter.java
@@ -0,0 +1,222 @@
+/*
+ * Copyright (C) 2007 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;
+
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.content.res.Resources;
+import android.database.Cursor;
+import android.drm.mobile1.DrmRawContent;
+import android.graphics.drawable.Drawable;
+import android.net.Uri;
+import android.provider.Downloads;
+import android.text.format.Formatter;
+import android.view.View;
+import android.widget.ImageView;
+import android.widget.ProgressBar;
+import android.widget.ResourceCursorAdapter;
+import android.widget.TextView;
+
+import java.io.File;
+import java.text.DateFormat;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * This class is used to represent the data for the download list box. The only 
+ * real work done by this class is to construct a custom view for the line
+ * items.
+ */
+public class BrowserDownloadAdapter extends ResourceCursorAdapter {
+    
+    private int mFilenameColumnId;
+    private int mTitleColumnId;
+    private int mDescColumnId;
+    private int mStatusColumnId;
+    private int mTotalBytesColumnId;
+    private int mCurrentBytesColumnId;
+    private int mMimetypeColumnId;
+    private int mDateColumnId;
+
+    public BrowserDownloadAdapter(Context context, int layout, Cursor c) {
+        super(context, layout, c);
+        mFilenameColumnId = c.getColumnIndexOrThrow(Downloads._DATA);
+        mTitleColumnId = c.getColumnIndexOrThrow(Downloads.TITLE);
+        mDescColumnId = c.getColumnIndexOrThrow(Downloads.DESCRIPTION);
+        mStatusColumnId = c.getColumnIndexOrThrow(Downloads.STATUS);
+        mTotalBytesColumnId = c.getColumnIndexOrThrow(Downloads.TOTAL_BYTES);
+        mCurrentBytesColumnId = 
+            c.getColumnIndexOrThrow(Downloads.CURRENT_BYTES);
+        mMimetypeColumnId = c.getColumnIndexOrThrow(Downloads.MIMETYPE);
+        mDateColumnId = c.getColumnIndexOrThrow(Downloads.LAST_MODIFICATION);
+    }
+
+    @Override
+    public void bindView(View view, Context context, Cursor cursor) {
+        Resources r = context.getResources();
+        
+        // Retrieve the icon for this download
+        String mimeType = cursor.getString(mMimetypeColumnId);
+        ImageView iv = (ImageView) view.findViewById(R.id.download_icon);
+        if (DrmRawContent.DRM_MIMETYPE_MESSAGE_STRING.equalsIgnoreCase(mimeType)) {
+            iv.setImageResource(R.drawable.ic_launcher_drm_file);
+        } else if (mimeType == null) {
+            iv.setVisibility(View.INVISIBLE);
+        } else {
+            Intent intent = new Intent(Intent.ACTION_VIEW);
+            intent.setDataAndType(Uri.fromParts("file", "", null), mimeType);
+            PackageManager pm = context.getPackageManager();
+            List<ResolveInfo> list = pm.queryIntentActivities(intent,
+                    PackageManager.MATCH_DEFAULT_ONLY);
+            if (list.size() > 0) {
+                Drawable icon = list.get(0).activityInfo.loadIcon(pm);
+                iv.setImageDrawable(icon);
+                iv.setVisibility(View.VISIBLE);
+            } else {
+                iv.setVisibility(View.INVISIBLE);
+            }
+        }
+        
+        TextView tv = (TextView) view.findViewById(R.id.download_title);
+        String title = cursor.getString(mTitleColumnId);
+        if (title == null) {
+            String fullFilename = cursor.getString(mFilenameColumnId);
+            if (fullFilename == null) {
+                title = r.getString(R.string.download_unknown_filename);
+            } else {
+                // We have a filename, so we can build a title from that
+                title = new File(fullFilename).getName();
+                ContentValues values = new ContentValues();
+                values.put(Downloads.TITLE, title);
+                // assume "_id" is the first column for the cursor 
+                context.getContentResolver().update(
+                        ContentUris.withAppendedId(Downloads.CONTENT_URI,
+                        cursor.getLong(0)), values, null, null);
+            }
+        }
+        tv.setText(title);
+        
+        tv = (TextView) view.findViewById(R.id.domain);
+        tv.setText(cursor.getString(mDescColumnId));
+        
+        long totalBytes = cursor.getLong(mTotalBytesColumnId);
+        
+        int status = cursor.getInt(mStatusColumnId);
+        if (Downloads.isStatusCompleted(status)) { // Download stopped
+            View v = view.findViewById(R.id.progress_text);
+            v.setVisibility(View.GONE);
+
+            v = view.findViewById(R.id.download_progress);
+            v.setVisibility(View.GONE);
+
+            tv = (TextView) view.findViewById(R.id.complete_text);
+            tv.setVisibility(View.VISIBLE);
+            if (Downloads.isStatusError(status)) {
+                tv.setText(getErrorText(status));
+            } else {
+                tv.setText(r.getString(R.string.download_success, 
+                        Formatter.formatFileSize(mContext, totalBytes)));
+            }
+            
+            long time = cursor.getLong(mDateColumnId);
+            Date d = new Date(time);
+            DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);
+            tv = (TextView) view.findViewById(R.id.complete_date);
+            tv.setVisibility(View.VISIBLE);
+            tv.setText(df.format(d));
+            
+        } else { // Download is still running
+            tv = (TextView) view.findViewById(R.id.progress_text);
+            tv.setVisibility(View.VISIBLE);
+
+            View progress = view.findViewById(R.id.download_progress);
+            progress.setVisibility(View.VISIBLE);
+            
+            View v = view.findViewById(R.id.complete_date);
+            v.setVisibility(View.GONE);
+
+            v = view.findViewById(R.id.complete_text);
+            v.setVisibility(View.GONE);
+            
+            if (status == Downloads.STATUS_PENDING) {
+                tv.setText(r.getText(R.string.download_pending));
+            } else if (status == Downloads.STATUS_PENDING_PAUSED) {
+                tv.setText(r.getText(R.string.download_pending_network));
+            } else {
+                ProgressBar pb = (ProgressBar) progress;
+
+                StringBuilder sb = new StringBuilder();
+                if (status == Downloads.STATUS_RUNNING) {
+                    sb.append(r.getText(R.string.download_running));
+                } else {
+                    sb.append(r.getText(R.string.download_running_paused));
+                }
+                if (totalBytes > 0) {
+                    long currentBytes = cursor.getLong(mCurrentBytesColumnId); 
+                    int progressAmount = (int)(currentBytes * 100 / totalBytes);
+                    sb.append(' ');
+                    sb.append(progressAmount);
+                    sb.append("% (");
+                    sb.append(Formatter.formatFileSize(mContext, currentBytes));
+                    sb.append("/");
+                    sb.append(Formatter.formatFileSize(mContext, totalBytes));
+                    sb.append(")");
+                    pb.setIndeterminate(false);
+                    pb.setProgress(progressAmount);
+                } else {
+                    pb.setIndeterminate(true);
+                }
+                tv.setText(sb.toString()); 
+            }
+        }
+        
+    }
+    
+    /**
+     * Provide the resource id for the error string.
+     * @param status status of the download item
+     * @return resource id for the error string.
+     */
+    public static int getErrorText(int status) {
+        switch (status) {
+            case Downloads.STATUS_NOT_ACCEPTABLE:
+                return R.string.download_not_acceptable;
+                
+            case Downloads.STATUS_LENGTH_REQUIRED:
+                return R.string.download_length_required;
+                
+            case Downloads.STATUS_PRECONDITION_FAILED:
+                return R.string.download_precondition_failed;
+                
+            case Downloads.STATUS_CANCELED:
+                return R.string.download_canceled;
+
+            case Downloads.STATUS_FILE_ERROR:
+                return R.string.download_file_error;
+                
+            case Downloads.STATUS_BAD_REQUEST:
+            case Downloads.STATUS_UNKNOWN_ERROR:
+            default:
+                return R.string.download_error;
+        }
+    }
+}
diff --git a/src/com/android/browser/BrowserDownloadPage.java b/src/com/android/browser/BrowserDownloadPage.java
new file mode 100644
index 0000000..4397337
--- /dev/null
+++ b/src/com/android/browser/BrowserDownloadPage.java
@@ -0,0 +1,468 @@
+/*
+ * Copyright (C) 2007 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;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.ActivityNotFoundException;
+import android.content.ContentValues;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.ContentUris;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.database.Cursor;
+import android.net.Uri;
+import android.os.Bundle;
+import android.provider.Downloads;
+import android.view.ContextMenu;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.MenuInflater;
+import android.view.View;
+import android.view.ViewGroup.LayoutParams;
+import android.widget.AdapterView;
+import android.widget.ListView;
+import android.widget.AdapterView.OnItemClickListener;
+
+import java.io.File;
+import java.util.List;
+
+/**
+ *  View showing the user's current browser downloads
+ */
+public class BrowserDownloadPage extends Activity 
+        implements View.OnCreateContextMenuListener, OnItemClickListener {
+    
+    private ListView                mListView;
+    private Cursor                  mDownloadCursor;
+    private BrowserDownloadAdapter  mDownloadAdapter;
+    private int                     mStatusColumnId;
+    private int                     mIdColumnId;
+    private int                     mTitleColumnId;
+    private int                     mContextMenuPosition;
+    
+    @Override 
+    public void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+        setContentView(R.layout.browser_downloads_page);
+        
+        setTitle(getText(R.string.download_title));
+
+        mListView = (ListView) findViewById(R.id.list);
+        LayoutInflater factory = LayoutInflater.from(this);
+        View v = factory.inflate(R.layout.no_downloads, null);
+        addContentView(v, new LayoutParams(LayoutParams.FILL_PARENT,
+                LayoutParams.FILL_PARENT));
+        mListView.setEmptyView(v);
+        
+        mDownloadCursor = managedQuery(Downloads.CONTENT_URI, 
+                new String [] {"_id", Downloads.TITLE, Downloads.STATUS,
+                Downloads.TOTAL_BYTES, Downloads.CURRENT_BYTES, 
+                Downloads._DATA, Downloads.DESCRIPTION, 
+                Downloads.MIMETYPE, Downloads.LAST_MODIFICATION,
+                Downloads.VISIBILITY}, 
+                null, null);
+        
+        // only attach everything to the listbox if we can access
+        // the download database. Otherwise, just show it empty
+        if (mDownloadCursor != null) {
+            mStatusColumnId = 
+                    mDownloadCursor.getColumnIndexOrThrow(Downloads.STATUS);
+            mIdColumnId =
+                    mDownloadCursor.getColumnIndexOrThrow(Downloads._ID);
+            mTitleColumnId = 
+                    mDownloadCursor.getColumnIndexOrThrow(Downloads.TITLE);
+            
+            // Create a list "controller" for the data
+            mDownloadAdapter = new BrowserDownloadAdapter(this, 
+                    R.layout.browser_download_item, mDownloadCursor);
+            
+            mListView.setAdapter(mDownloadAdapter);
+            mListView.setScrollBarStyle(View.SCROLLBARS_INSIDE_INSET);
+            mListView.setOnCreateContextMenuListener(this);
+            mListView.setOnItemClickListener(this);
+            
+            Intent intent = getIntent();
+            if (intent != null && intent.getData() != null) {
+                int position = checkStatus(
+                        ContentUris.parseId(intent.getData()));
+                if (position >= 0) {
+                    mListView.setSelection(position);
+                }
+            }
+        }
+    }
+        
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        if (mDownloadCursor != null) {
+            MenuInflater inflater = getMenuInflater();
+            inflater.inflate(R.menu.downloadhistory, menu);
+        }
+        return true;
+    }
+    
+    @Override
+    public boolean onPrepareOptionsMenu(Menu menu) {
+        boolean showCancel = getCancelableCount() > 0;
+        menu.findItem(R.id.download_menu_cancel_all).setEnabled(showCancel);
+        
+        boolean showClear = getClearableCount() > 0;
+        menu.findItem(R.id.download_menu_clear_all).setEnabled(showClear);
+        return super.onPrepareOptionsMenu(menu);
+    }
+    
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        switch (item.getItemId()) {
+            case R.id.download_menu_cancel_all:
+                promptCancelAll();
+                return true;
+                
+            case R.id.download_menu_clear_all:
+                promptClearList();
+                return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean onContextItemSelected(MenuItem item) {
+        mDownloadCursor.moveToPosition(mContextMenuPosition);
+        switch (item.getItemId()) {
+            case R.id.download_menu_open:
+                hideCompletedDownload();
+                openCurrentDownload();
+                return true;
+                
+            case R.id.download_menu_clear:
+            case R.id.download_menu_cancel:
+                getContentResolver().delete(
+                        ContentUris.withAppendedId(Downloads.CONTENT_URI,
+                        mDownloadCursor.getLong(mIdColumnId)), null, null);
+                return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void onCreateContextMenu(ContextMenu menu, View v,
+            ContextMenuInfo menuInfo) {
+        if (mDownloadCursor != null) {
+            AdapterView.AdapterContextMenuInfo info = 
+                    (AdapterView.AdapterContextMenuInfo) menuInfo;
+            mDownloadCursor.moveToPosition(info.position);
+            mContextMenuPosition = info.position;
+            menu.setHeaderTitle(mDownloadCursor.getString(mTitleColumnId));
+            
+            MenuInflater inflater = getMenuInflater();
+            int status = mDownloadCursor.getInt(mStatusColumnId);
+            if (Downloads.isStatusSuccess(status)) {
+                inflater.inflate(R.menu.downloadhistorycontextfinished, menu);
+            } else if (Downloads.isStatusError(status)) {
+                inflater.inflate(R.menu.downloadhistorycontextfailed, menu);
+            } else {
+                inflater.inflate(R.menu.downloadhistorycontextrunning, menu);
+            }
+        }
+    }
+
+    /**
+     * This function is called to check the status of the download and if it
+     * has an error show an error dialog.
+     * @param id Row id of the download to check
+     * @return position of item
+     */
+    int checkStatus(final long id) {
+        int position = -1;
+        for (mDownloadCursor.moveToFirst(); !mDownloadCursor.isAfterLast(); 
+                mDownloadCursor.moveToNext()) {
+            if (id == mDownloadCursor.getLong(mIdColumnId)) {
+                position = mDownloadCursor.getPosition();
+                break;
+            }
+            
+        }
+        if (!mDownloadCursor.isAfterLast()) {
+            int status = mDownloadCursor.getInt(mStatusColumnId);
+            if (!Downloads.isStatusError(status)) {
+                return position;
+            }
+            
+            if (status == Downloads.STATUS_FILE_ERROR) {
+                String title = mDownloadCursor.getString(mTitleColumnId);
+                if (title == null || title.length() == 0) {
+                    title = getString(R.string.download_unknown_filename);
+                }
+                String msg = getString(R.string.download_file_error_dlg_msg, 
+                        title);
+                new AlertDialog.Builder(this)
+                        .setTitle(R.string.download_file_error_dlg_title)
+                        .setIcon(android.R.drawable.ic_popup_disk_full)
+                        .setMessage(msg)
+                        .setPositiveButton(R.string.ok, null)
+                        .setNegativeButton(R.string.retry, 
+                                new DialogInterface.OnClickListener() {
+                                    public void onClick(DialogInterface dialog, 
+                                            int whichButton) {
+                                        resumeDownload(id);
+                                    }
+                                })
+                        .show();
+            } else {
+                new AlertDialog.Builder(this)
+                        .setTitle(R.string.download_failed_generic_dlg_title)
+                        .setIcon(R.drawable.ssl_icon)
+                        .setMessage(BrowserDownloadAdapter.getErrorText(status))
+                        .setPositiveButton(R.string.ok, null)
+                        .show();
+            }
+        }
+        return position;
+    }
+    
+    /**
+     * Resume a given download
+     * @param id Row id of the download to resume
+     */
+    private void resumeDownload(final long id) {
+        // the relevant functionality doesn't exist in the download manager
+    }
+    
+    /**
+     * Prompt the user if they would like to clear the download history
+     */
+    private void promptClearList() {
+        new AlertDialog.Builder(this)
+               .setTitle(R.string.download_clear_dlg_title)
+               .setIcon(R.drawable.ssl_icon)
+               .setMessage(R.string.download_clear_dlg_msg)
+               .setPositiveButton(R.string.ok, 
+                       new DialogInterface.OnClickListener() {
+                           public void onClick(DialogInterface dialog, 
+                                   int whichButton) {
+                               clearAllDownloads();
+                           }
+                       })
+                .setNegativeButton(R.string.cancel, null)
+                .show();
+    }
+    
+    /**
+     * Return the number of items in the list that can be canceled.
+     * @return count
+     */
+    private int getCancelableCount() {
+        // Count the number of items that will be canceled.
+        int count = 0;
+        if (mDownloadCursor != null) {
+            for (mDownloadCursor.moveToFirst(); !mDownloadCursor.isAfterLast(); 
+                    mDownloadCursor.moveToNext()) {
+                int status = mDownloadCursor.getInt(mStatusColumnId);
+                if (!Downloads.isStatusCompleted(status)) {
+                    count++;
+                }
+            }
+        }
+        
+        return count;
+    }
+    
+    /**
+     * Prompt the user if they would like to clear the download history
+     */
+    private void promptCancelAll() {
+        int count = getCancelableCount();
+        
+        // If there is nothing to do, just return
+        if (count == 0) {
+            return;
+        }
+        
+        // Don't show the dialog if there is only one download
+        if (count == 1) {
+            cancelAllDownloads();
+            return;
+        }
+        String msg = 
+            getString(R.string.download_cancel_dlg_msg, count);
+        new AlertDialog.Builder(this)
+                .setTitle(R.string.download_cancel_dlg_title)
+                .setIcon(R.drawable.ssl_icon)
+                .setMessage(msg)
+                .setPositiveButton(R.string.ok, 
+                        new DialogInterface.OnClickListener() {
+                            public void onClick(DialogInterface dialog, 
+                                    int whichButton) {
+                                cancelAllDownloads();
+                            }
+                        })
+                 .setNegativeButton(R.string.cancel, null)
+                 .show();
+    }
+    
+    /**
+     * Cancel all downloads. As canceled downloads are not
+     * listed, we removed them from the db. Removing a download
+     * record, cancels the download.
+     */
+    private void cancelAllDownloads() {
+        if (mDownloadCursor.moveToFirst()) {
+            StringBuilder where = new StringBuilder();
+            boolean firstTime = true;
+            while (!mDownloadCursor.isAfterLast()) {
+                int status = mDownloadCursor.getInt(mStatusColumnId);
+                if (!Downloads.isStatusCompleted(status)) {
+                    if (firstTime) {
+                        firstTime = false;
+                    } else {
+                        where.append(" OR ");
+                    }
+                    where.append("( ");
+                    where.append(Downloads._ID);
+                    where.append(" = '");
+                    where.append(mDownloadCursor.getLong(mIdColumnId));
+                    where.append("' )");
+                }
+                mDownloadCursor.moveToNext();
+            }
+            if (!firstTime) {
+                getContentResolver().delete(Downloads.CONTENT_URI,
+                        where.toString(), null);
+            }
+        }
+    }
+    
+    private int getClearableCount() {
+        int count = 0;
+        if (mDownloadCursor.moveToFirst()) {
+            while (!mDownloadCursor.isAfterLast()) {
+                int status = mDownloadCursor.getInt(mStatusColumnId);
+                if (Downloads.isStatusCompleted(status)) {
+                    count++;
+                }
+                mDownloadCursor.moveToNext();
+            }
+        }
+        return count;
+    }
+    
+    /**
+     * Clear all stopped downloads, ie canceled (though should not be
+     * there), error and success download items.
+     */
+    private void clearAllDownloads() {
+        if (mDownloadCursor.moveToFirst()) {
+            StringBuilder where = new StringBuilder();
+            boolean firstTime = true;
+            while (!mDownloadCursor.isAfterLast()) {
+                int status = mDownloadCursor.getInt(mStatusColumnId);
+                if (Downloads.isStatusCompleted(status)) {
+                    if (firstTime) {
+                        firstTime = false;
+                    } else {
+                        where.append(" OR ");
+                    }
+                    where.append("( ");
+                    where.append(Downloads._ID);
+                    where.append(" = '");
+                    where.append(mDownloadCursor.getLong(mIdColumnId));
+                    where.append("' )");
+                }
+                mDownloadCursor.moveToNext();
+            }
+            if (!firstTime) {
+                getContentResolver().delete(Downloads.CONTENT_URI,
+                        where.toString(), null);
+            }
+        }
+    }
+    
+    /**
+     * Open the content where the download db cursor currently is
+     */
+    private void openCurrentDownload() {
+        int filenameColumnId = 
+                mDownloadCursor.getColumnIndexOrThrow(Downloads._DATA);
+        String filename = mDownloadCursor.getString(filenameColumnId);
+        int mimetypeColumnId =
+                mDownloadCursor.getColumnIndexOrThrow(Downloads.MIMETYPE);
+        String mimetype = mDownloadCursor.getString(mimetypeColumnId);
+        Uri path = Uri.parse(filename);
+        // If there is no scheme, then it must be a file
+        if (path.getScheme() == null) {
+            path = Uri.fromFile(new File(filename));
+        }
+        Intent intent = new Intent(Intent.ACTION_VIEW);
+        intent.setDataAndType(path, mimetype);
+        intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
+        try {
+            startActivity(intent);
+        } catch (ActivityNotFoundException ex) {
+            new AlertDialog.Builder(this)
+                    .setTitle(R.string.download_failed_generic_dlg_title)
+                    .setIcon(R.drawable.ssl_icon)
+                    .setMessage(R.string.download_no_application)
+                    .setPositiveButton(R.string.ok, null)
+                    .show();
+        }
+    }
+
+    /*
+     * (non-Javadoc)
+     * @see android.widget.AdapterView.OnItemClickListener#onItemClick(android.widget.AdapterView, android.view.View, int, long)
+     */
+    public void onItemClick(AdapterView parent, View view, int position, 
+            long id) {
+        // Open the selected item
+        mDownloadCursor.moveToPosition(position);
+        
+        hideCompletedDownload();
+
+        int status = mDownloadCursor.getInt(mStatusColumnId);
+        if (Downloads.isStatusSuccess(status)) {
+            // Open it if it downloaded successfully
+            openCurrentDownload();
+        } else {
+            // Check to see if there is an error.
+            checkStatus(id);
+        }
+    }
+    
+    /**
+     * hides the notification for the download pointed by mDownloadCursor
+     * if the download has completed.
+     */
+    private void hideCompletedDownload() {
+        int status = mDownloadCursor.getInt(mStatusColumnId);
+
+        int visibilityColumn = mDownloadCursor.getColumnIndexOrThrow(Downloads.VISIBILITY);
+        int visibility = mDownloadCursor.getInt(visibilityColumn);
+
+        if (Downloads.isStatusCompleted(status) &&
+                visibility == Downloads.VISIBILITY_VISIBLE_NOTIFY_COMPLETED) {
+            ContentValues values = new ContentValues();
+            values.put(Downloads.VISIBILITY, Downloads.VISIBILITY_VISIBLE);
+            getContentResolver().update(
+                    ContentUris.withAppendedId(Downloads.CONTENT_URI,
+                    mDownloadCursor.getLong(mIdColumnId)), values, null, null);
+        }
+    }
+}
diff --git a/src/com/android/browser/BrowserHistoryPage.java b/src/com/android/browser/BrowserHistoryPage.java
new file mode 100644
index 0000000..42ca848
--- /dev/null
+++ b/src/com/android/browser/BrowserHistoryPage.java
@@ -0,0 +1,468 @@
+/*
+ * Copyright (C) 2008 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;
+
+import android.app.Activity;
+import android.app.ExpandableListActivity;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.database.ContentObserver;
+import android.database.Cursor;
+import android.database.DataSetObserver;
+import android.graphics.Bitmap;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.ServiceManager;
+import android.provider.Browser;
+import android.text.IClipboard;
+import android.util.Log;
+import android.view.ContextMenu;
+import android.view.KeyEvent;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewGroup.LayoutParams;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.webkit.DateSorter;
+import android.webkit.WebIconDatabase.IconListener;
+import android.widget.AdapterView;
+import android.widget.ExpandableListAdapter;
+import android.widget.ExpandableListView;
+import android.widget.ExpandableListView.ExpandableListContextMenuInfo;
+import android.widget.TextView;
+
+import java.util.List;
+import java.util.Vector;
+
+/**
+ * Activity for displaying the browser's history, divided into
+ * days of viewing.
+ */
+public class BrowserHistoryPage extends ExpandableListActivity {
+    private HistoryAdapter          mAdapter;
+    private DateSorter              mDateSorter;
+    private boolean                 mMaxTabsOpen;
+
+    private final static String LOGTAG = "browser";
+
+    // Implementation of WebIconDatabase.IconListener
+    private class IconReceiver implements IconListener {
+        public void onReceivedIcon(String url, Bitmap icon) {
+            setListAdapter(mAdapter);
+        }
+    }
+    // Instance of IconReceiver
+    private final IconReceiver mIconReceiver = new IconReceiver();
+
+    /**
+     * Report back to the calling activity to load a site.
+     * @param url   Site to load.
+     * @param newWindow True if the URL should be loaded in a new window
+     */
+    private void loadUrl(String url, boolean newWindow) {
+        Intent intent = new Intent().setAction(url);
+        if (newWindow) {
+            Bundle b = new Bundle();
+            b.putBoolean("new_window", true);
+            intent.putExtras(b);
+        }
+        setResultToParent(RESULT_OK, intent);
+        finish();
+    }
+    
+    private void copy(CharSequence text) {
+        try {
+            IClipboard clip = IClipboard.Stub.asInterface(ServiceManager.getService("clipboard"));
+            if (clip != null) {
+                clip.setClipboardText(text);
+            }
+        } catch (android.os.RemoteException e) {
+            Log.e(LOGTAG, "Copy failed", e);
+        }
+    }
+
+    @Override
+    protected void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+        setTitle(R.string.browser_history);
+        
+        mDateSorter = new DateSorter(this);
+
+        mAdapter = new HistoryAdapter();
+        setListAdapter(mAdapter);
+        final ExpandableListView list = getExpandableListView();
+        list.setOnCreateContextMenuListener(this);
+        LayoutInflater factory = LayoutInflater.from(this);
+        View v = factory.inflate(R.layout.empty_history, null);
+        addContentView(v, new LayoutParams(LayoutParams.FILL_PARENT,
+                LayoutParams.FILL_PARENT));
+        list.setEmptyView(v);
+        // Do not post the runnable if there is nothing in the list.
+        if (list.getExpandableListAdapter().getGroupCount() > 0) {
+            list.post(new Runnable() {
+                public void run() {
+                    // In case the history gets cleared before this event
+                    // happens.
+                    if (list.getExpandableListAdapter().getGroupCount() > 0) {
+                        list.expandGroup(0);
+                    }
+                }
+            });
+        }
+        mMaxTabsOpen = getIntent().getBooleanExtra("maxTabsOpen", false);
+        CombinedBookmarkHistoryActivity.getIconListenerSet(getContentResolver())
+                .addListener(mIconReceiver);
+        
+        // initialize the result to canceled, so that if the user just presses
+        // back then it will have the correct result
+        setResultToParent(RESULT_CANCELED, null);
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        super.onCreateOptionsMenu(menu);
+        MenuInflater inflater = getMenuInflater();
+        inflater.inflate(R.menu.history, menu);
+        return true;
+    }
+
+    @Override
+    public boolean onPrepareOptionsMenu(Menu menu) {
+        menu.findItem(R.id.clear_history_menu_id).setVisible(Browser.canClearHistory(this.getContentResolver()));
+        return true;
+    }
+    
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        switch (item.getItemId()) {
+            case R.id.clear_history_menu_id:
+                // FIXME: Need to clear the tab control in browserActivity 
+                // as well
+                Browser.clearHistory(getContentResolver());
+                mAdapter.refreshData();
+                return true;
+                
+            default:
+                break;
+        }  
+        return super.onOptionsItemSelected(item);
+    }
+    
+    @Override
+    public void onCreateContextMenu(ContextMenu menu, View v,
+            ContextMenuInfo menuInfo) {
+        ExpandableListContextMenuInfo i = 
+            (ExpandableListContextMenuInfo) menuInfo;
+        // Do not allow a context menu to come up from the group views.
+        if (!(i.targetView instanceof HistoryItem)) {
+            return;
+        }
+
+        // Inflate the menu
+        MenuInflater inflater = getMenuInflater();
+        inflater.inflate(R.menu.historycontext, menu);
+
+        // Setup the header
+        menu.setHeaderTitle(((HistoryItem)i.targetView).getUrl());
+
+        // Only show open in new tab if we have not maxed out available tabs
+        menu.findItem(R.id.new_window_context_menu_id).setVisible(!mMaxTabsOpen);
+        
+        // decide whether to show the share link option
+        PackageManager pm = getPackageManager();
+        Intent send = new Intent(Intent.ACTION_SEND);
+        send.setType("text/plain");
+        ResolveInfo ri = pm.resolveActivity(send, PackageManager.MATCH_DEFAULT_ONLY);
+        menu.findItem(R.id.share_link_context_menu_id).setVisible(ri != null);
+        
+        super.onCreateContextMenu(menu, v, menuInfo);
+    }
+    
+    @Override
+    public boolean onContextItemSelected(MenuItem item) {
+        ExpandableListContextMenuInfo i = 
+            (ExpandableListContextMenuInfo) item.getMenuInfo();
+        String url = ((HistoryItem)i.targetView).getUrl();
+        String title = ((HistoryItem)i.targetView).getName();
+        switch (item.getItemId()) {
+            case R.id.open_context_menu_id:
+                loadUrl(url, false);
+                return true;
+            case R.id.new_window_context_menu_id:
+                loadUrl(url, true);
+                return true;
+            case R.id.save_to_bookmarks_menu_id:
+                Browser.saveBookmark(this, title, url);
+                return true;
+            case R.id.share_link_context_menu_id:
+                Browser.sendString(this, url);
+                return true;
+            case R.id.copy_context_menu_id:
+                copy(url);
+                return true;
+            case R.id.delete_context_menu_id:
+                Browser.deleteFromHistory(getContentResolver(), url);
+                mAdapter.refreshData();
+                return true;
+            default:
+                break;
+        }
+        return super.onContextItemSelected(item);
+    }
+    
+    @Override
+    public boolean onChildClick(ExpandableListView parent, View v,
+            int groupPosition, int childPosition, long id) {
+        if (v instanceof HistoryItem) {
+            loadUrl(((HistoryItem) v).getUrl(), false);
+            return true;
+        }
+        return false;
+    }
+
+    // This Activity is generally a sub-Activity of CombinedHistoryActivity. In
+    // that situation, we need to pass our result code up to our parent.
+    // However, if someone calls this Activity directly, then this has no
+    // parent, and it needs to set it on itself.
+    private void setResultToParent(int resultCode, Intent data) {
+        Activity a = getParent() == null ? this : getParent();
+        a.setResult(resultCode, data);
+    }
+
+    private class ChangeObserver extends ContentObserver {
+        public ChangeObserver() {
+            super(new Handler());
+        }
+
+        @Override
+        public boolean deliverSelfNotifications() {
+            return true;
+        }
+
+        @Override
+        public void onChange(boolean selfChange) {
+            mAdapter.refreshData();
+        }
+    }
+    
+    private class HistoryAdapter implements ExpandableListAdapter {
+        
+        // Array for each of our bins.  Each entry represents how many items are
+        // in that bin.
+        int mItemMap[];
+        // This is our GroupCount.  We will have at most DateSorter.DAY_COUNT
+        // bins, less if the user has no items in one or more bins.
+        int mNumberOfBins;
+        Vector<DataSetObserver> mObservers;
+        Cursor mCursor;
+        
+        HistoryAdapter() {
+            mObservers = new Vector<DataSetObserver>();
+            
+            String whereClause = Browser.BookmarkColumns.VISITS + " > 0 ";
+            String orderBy = Browser.BookmarkColumns.DATE + " DESC";
+           
+            mCursor = managedQuery(
+                    Browser.BOOKMARKS_URI,
+                    Browser.HISTORY_PROJECTION,
+                    whereClause, null, orderBy);
+            
+            buildMap();
+            mCursor.registerContentObserver(new ChangeObserver());
+        }
+        
+        void refreshData() {
+            mCursor.requery();
+            buildMap();
+            for (DataSetObserver o : mObservers) {
+                o.onChanged();
+            }
+        }
+        
+        private void buildMap() {
+            // The cursor is sorted by date
+            // The ItemMap will store the number of items in each bin.
+            int array[] = new int[DateSorter.DAY_COUNT];
+            // Zero out the array.
+            for (int j = 0; j < DateSorter.DAY_COUNT; j++) {
+                array[j] = 0;
+            }
+            mNumberOfBins = 0;
+            int dateIndex = -1;
+            if (mCursor.moveToFirst() && mCursor.getCount() > 0) {
+                while (!mCursor.isAfterLast()) {
+                    long date = mCursor.getLong(Browser.HISTORY_PROJECTION_DATE_INDEX);
+                    int index = mDateSorter.getIndex(date);
+                    if (index > dateIndex) {
+                        mNumberOfBins++;
+                        if (index == DateSorter.DAY_COUNT - 1) {
+                            // We are already in the last bin, so it will
+                            // include all the remaining items
+                            array[index] = mCursor.getCount()
+                                    - mCursor.getPosition();
+                            break;
+                        }
+                        dateIndex = index;
+                    }
+                    array[dateIndex]++;
+                    mCursor.moveToNext();
+                }
+            }
+            mItemMap = array;
+        }
+
+        // This translates from a group position in the Adapter to a position in
+        // our array.  This is necessary because some positions in the array
+        // have no history items, so we simply do not present those positions
+        // to the Adapter.
+        private int groupPositionToArrayPosition(int groupPosition) {
+            if (groupPosition < 0 || groupPosition >= DateSorter.DAY_COUNT) {
+                throw new AssertionError("group position out of range");
+            }
+            if (DateSorter.DAY_COUNT == mNumberOfBins || 0 == mNumberOfBins) {
+                // In the first case, we have exactly the same number of bins
+                // as our maximum possible, so there is no need to do a
+                // conversion
+                // The second statement is in case this method gets called when
+                // the array is empty, in which case the provided groupPosition
+                // will do fine.
+                return groupPosition;
+            }
+            int arrayPosition = -1;
+            while (groupPosition > -1) {
+                arrayPosition++;
+                if (mItemMap[arrayPosition] != 0) {
+                    groupPosition--;
+                }
+            }
+            return arrayPosition;
+        }
+
+        public View getChildView(int groupPosition, int childPosition, boolean isLastChild,
+                View convertView, ViewGroup parent) {
+            groupPosition = groupPositionToArrayPosition(groupPosition);
+            HistoryItem item;
+            if (null == convertView || !(convertView instanceof HistoryItem)) {
+                item = new HistoryItem(BrowserHistoryPage.this);
+                // Add padding on the left so it will be indented from the
+                // arrows on the group views.
+                item.setPadding(item.getPaddingLeft() + 10,
+                        item.getPaddingTop(),
+                        item.getPaddingRight(),
+                        item.getPaddingBottom());
+            } else {
+                item = (HistoryItem) convertView;
+            }
+            int index = childPosition;
+            for (int i = 0; i < groupPosition; i++) {
+                index += mItemMap[i];
+            }
+            mCursor.moveToPosition(index);
+            item.setName(mCursor.getString(Browser.HISTORY_PROJECTION_TITLE_INDEX));
+            String url = mCursor.getString(Browser.HISTORY_PROJECTION_URL_INDEX);
+            item.setUrl(url);
+            item.setFavicon(CombinedBookmarkHistoryActivity.getIconListenerSet(
+                    getContentResolver()).getFavicon(url));
+            item.setIsBookmark(1 ==
+                    mCursor.getInt(Browser.HISTORY_PROJECTION_BOOKMARK_INDEX));
+            return item;
+        }
+        
+        public View getGroupView(int groupPosition, boolean isExpanded, View convertView, ViewGroup parent) {
+            groupPosition = groupPositionToArrayPosition(groupPosition);
+            TextView item;
+            if (null == convertView || !(convertView instanceof TextView)) {
+                LayoutInflater factory = 
+                        LayoutInflater.from(BrowserHistoryPage.this);
+                item = (TextView) 
+                        factory.inflate(R.layout.history_header, null);
+            } else {
+                item = (TextView) convertView;
+            }
+            item.setText(mDateSorter.getLabel(groupPosition));
+            return item;
+        }
+
+        public boolean areAllItemsEnabled() {
+            return true;
+        }
+
+        public boolean isChildSelectable(int groupPosition, int childPosition) {
+            return true;
+        }
+
+        public int getGroupCount() {
+            return mNumberOfBins;
+        }
+
+        public int getChildrenCount(int groupPosition) {
+            return mItemMap[groupPositionToArrayPosition(groupPosition)];
+        }
+
+        public Object getGroup(int groupPosition) {
+            return null;
+        }
+
+        public Object getChild(int groupPosition, int childPosition) {
+            return null;
+        }
+
+        public long getGroupId(int groupPosition) {
+            return groupPosition;
+        }
+
+        public long getChildId(int groupPosition, int childPosition) {
+            return (childPosition << 3) + groupPosition;
+        }
+
+        public boolean hasStableIds() {
+            return true;
+        }
+
+        public void registerDataSetObserver(DataSetObserver observer) {
+            mObservers.add(observer);
+        }
+
+        public void unregisterDataSetObserver(DataSetObserver observer) {
+            mObservers.remove(observer);
+        }
+
+        public void onGroupExpanded(int groupPosition) {
+        
+        }
+
+        public void onGroupCollapsed(int groupPosition) {
+        
+        }
+
+        public long getCombinedChildId(long groupId, long childId) {
+            return childId;
+        }
+
+        public long getCombinedGroupId(long groupId) {
+            return groupId;
+        }
+
+        public boolean isEmpty() {
+            return mCursor.getCount() == 0;
+        }
+    }
+}
diff --git a/src/com/android/browser/BrowserHomepagePreference.java b/src/com/android/browser/BrowserHomepagePreference.java
new file mode 100644
index 0000000..d4708c3
--- /dev/null
+++ b/src/com/android/browser/BrowserHomepagePreference.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2008 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;
+
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.preference.EditTextPreference;
+import android.text.Editable;
+import android.text.TextWatcher;
+import android.text.util.Regex;
+import android.util.AttributeSet;
+
+public class BrowserHomepagePreference extends EditTextPreference implements
+        TextWatcher {
+
+    public BrowserHomepagePreference(Context context, AttributeSet attrs,
+            int defStyle) {
+        super(context, attrs, defStyle);
+        getEditText().addTextChangedListener(this);
+    }
+
+    public BrowserHomepagePreference(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        getEditText().addTextChangedListener(this);
+    }
+
+    public BrowserHomepagePreference(Context context) {
+        super(context);
+        getEditText().addTextChangedListener(this);
+    }
+
+    public void afterTextChanged(Editable s) {
+        AlertDialog dialog = (AlertDialog) getDialog();
+        // This callback is called before the dialog has been fully constructed
+        if (dialog != null) {
+            String url = s.toString();
+            dialog.getButton(DialogInterface.BUTTON_POSITIVE).setEnabled(
+                    url.length() == 0 || url.equals("about:blank") ||
+                    Regex.WEB_URL_PATTERN.matcher(url).matches());
+        }
+    }
+
+    public void beforeTextChanged(CharSequence s, int start, int count,
+            int after) {
+    }
+
+    public void onTextChanged(CharSequence s, int start, int before, int count) {
+    }
+}
diff --git a/src/com/android/browser/BrowserPluginList.java b/src/com/android/browser/BrowserPluginList.java
new file mode 100644
index 0000000..6689b0e
--- /dev/null
+++ b/src/com/android/browser/BrowserPluginList.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2008 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;
+
+import android.app.ListActivity;
+import android.os.Bundle;
+import android.view.View;
+import android.view.ViewGroup;
+import android.webkit.Plugin;
+import android.webkit.PluginList;
+import android.webkit.WebView;
+import android.widget.ArrayAdapter;
+import android.widget.LinearLayout;
+import android.widget.LinearLayout.LayoutParams;
+import android.widget.ListView;
+import android.widget.TextView;
+import java.util.ArrayList;
+import java.util.List;
+
+// Manages the list of installed (and loaded) plugins.
+public class BrowserPluginList extends ListActivity {
+    @Override
+    public void onCreate(Bundle icicle) {
+        super.onCreate(icicle);
+        // The list of plugins can change under us, as the plugins are
+        // loaded and unloaded in a different thread. We make a copy
+        // of the list here.
+        List loadedPlugins = WebView.getPluginList().getList();
+        ArrayList localLoadedPluginList = new ArrayList();
+        synchronized (loadedPlugins) {
+            localLoadedPluginList.addAll(loadedPlugins);
+        }
+        setListAdapter(new ArrayAdapter(this,
+                                        android.R.layout.simple_list_item_1,
+                                        localLoadedPluginList));
+        setTitle(R.string.pref_plugin_installed);
+        // Add a text view to this ListActivity. This text view
+        // will be displayed when the list of plugins is empty.
+        TextView textView = new TextView(this);
+        textView.setId(android.R.id.empty);
+        textView.setText(R.string.pref_plugin_installed_empty_list);
+        addContentView(textView, new LinearLayout.LayoutParams(
+                               ViewGroup.LayoutParams.FILL_PARENT,
+                               ViewGroup.LayoutParams.WRAP_CONTENT));
+
+    }
+
+    @Override
+    public void onListItemClick(ListView l, View v, int position, long id) {
+        WebView.getPluginList().pluginClicked(this, position);
+    }
+}
diff --git a/src/com/android/browser/BrowserPreferencesPage.java b/src/com/android/browser/BrowserPreferencesPage.java
new file mode 100644
index 0000000..5d6795b
--- /dev/null
+++ b/src/com/android/browser/BrowserPreferencesPage.java
@@ -0,0 +1,149 @@
+/*
+ * Copyright (C) 2008 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;
+
+import java.util.List;
+
+import android.net.Uri;
+import android.os.Bundle;
+import android.preference.EditTextPreference;
+import android.preference.Preference;
+import android.preference.PreferenceActivity;
+import android.webkit.WebView;
+import android.webkit.Plugin;
+
+public class BrowserPreferencesPage extends PreferenceActivity
+        implements Preference.OnPreferenceChangeListener, 
+        Preference.OnPreferenceClickListener {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        // Load the XML preferences file
+        addPreferencesFromResource(R.xml.browser_preferences);
+
+        Preference e = findPreference(BrowserSettings.PREF_HOMEPAGE);
+        e.setOnPreferenceChangeListener(this);
+        e.setSummary(getPreferenceScreen().getSharedPreferences()
+                .getString(BrowserSettings.PREF_HOMEPAGE, null));
+        
+        e = findPreference(BrowserSettings.PREF_EXTRAS_RESET_DEFAULTS);
+        e.setOnPreferenceChangeListener(this);
+        
+        e = findPreference(BrowserSettings.PREF_TEXT_SIZE);
+        e.setOnPreferenceChangeListener(this);
+        e.setSummary(getVisualTextSizeName(
+                getPreferenceScreen().getSharedPreferences()
+                .getString(BrowserSettings.PREF_TEXT_SIZE, null)) );
+        
+        e = findPreference(BrowserSettings.PREF_DEFAULT_TEXT_ENCODING);
+        e.setOnPreferenceChangeListener(this);
+        
+        if (BrowserSettings.getInstance().showDebugSettings()) {
+            addPreferencesFromResource(R.xml.debug_preferences);
+        }
+        
+        e = findPreference(BrowserSettings.PREF_GEARS_SETTINGS);
+        e.setOnPreferenceClickListener(this);
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause();
+
+        // sync the shared preferences back to BrowserSettings
+        BrowserSettings.getInstance().syncSharedPreferences(
+                getPreferenceScreen().getSharedPreferences());
+    }
+
+    public boolean onPreferenceChange(Preference pref, Object objValue) {
+        if (pref.getKey().equals(BrowserSettings.PREF_EXTRAS_RESET_DEFAULTS)) {
+            Boolean value = (Boolean) objValue;
+            if (value.booleanValue() == true) {
+                finish();
+            }
+        } else if (pref.getKey().equals(BrowserSettings.PREF_HOMEPAGE)) {
+            String value = (String) objValue;
+            boolean needUpdate = value.indexOf(' ') != -1;
+            if (needUpdate) {
+                value = value.trim().replace(" ", "%20");
+            }
+            if (value.length() != 0 && Uri.parse(value).getScheme() == null) {
+                value = "http://" + value;
+                needUpdate = true;
+            }
+            // Set the summary value.
+            pref.setSummary(value);
+            if (needUpdate) {
+                // Update through the EditText control as it has a cached copy
+                // of the string and it will handle persisting the value
+                ((EditTextPreference) pref).setText(value);
+
+                // as we update the value above, we need to return false
+                // here so that setText() is not called by EditTextPref
+                // with the old value.
+                return false;
+            } else {
+                return true;
+            }
+        } else if (pref.getKey().equals(BrowserSettings.PREF_TEXT_SIZE)) {
+            pref.setSummary(getVisualTextSizeName((String) objValue));
+            return true;
+        } else if (pref.getKey().equals(
+                BrowserSettings.PREF_DEFAULT_TEXT_ENCODING)) {
+            pref.setSummary((String) objValue);
+            return true;
+        }
+        
+        return false;
+    }
+    
+    public boolean onPreferenceClick(Preference pref) {
+        if (pref.getKey().equals(BrowserSettings.PREF_GEARS_SETTINGS)) {
+            List<Plugin> loadedPlugins = WebView.getPluginList().getList();
+            for(Plugin p : loadedPlugins) {
+                if (p.getName().equals("gears")) {
+                    p.dispatchClickEvent(this);
+                    return true;
+                }
+            }
+            
+        }
+        return true;
+    }
+    
+    private CharSequence getVisualTextSizeName(String enumName) {
+        CharSequence[] visualNames = 
+                getResources().getTextArray(R.array.pref_text_size_choices);
+        CharSequence[] enumNames = 
+                getResources().getTextArray(R.array.pref_text_size_values);
+        
+        // Sanity check
+        if (visualNames.length != enumNames.length) {
+            return "";
+        }
+        
+        for (int i = 0; i < enumNames.length; i++) {
+            if (enumNames[i].equals(enumName)) {
+                return visualNames[i];
+            }
+        }
+        
+        return "";
+    }
+}
diff --git a/src/com/android/browser/BrowserProvider.java b/src/com/android/browser/BrowserProvider.java
new file mode 100644
index 0000000..0c930c6
--- /dev/null
+++ b/src/com/android/browser/BrowserProvider.java
@@ -0,0 +1,654 @@
+/*
+ * 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;
+
+import android.app.ISearchManager;
+import android.app.SearchManager;
+import android.content.ComponentName;
+import android.content.ContentProvider;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.Intent;
+import android.content.UriMatcher;
+import android.database.AbstractCursor;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.database.sqlite.SQLiteDatabase;
+import android.net.Uri;
+import android.os.RemoteException;
+import android.os.ServiceManager;
+import android.os.SystemProperties;
+import android.provider.Browser;
+import android.util.Log;
+import android.server.search.SearchableInfo;
+import android.text.util.Regex;
+
+public class BrowserProvider extends ContentProvider {
+
+    private SQLiteOpenHelper mOpenHelper;
+    private 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[] TABLE_NAMES = new String[] {
+        "bookmarks", "searches"
+    };
+    private static final String[] SUGGEST_PROJECTION = new String[] {
+            "_id", "url", "title", "bookmark"
+    };
+    private static final String SUGGEST_SELECTION = 
+            "url LIKE ? OR url LIKE ? OR url LIKE ? OR url LIKE ?";
+    private String[] SUGGEST_ARGS = new String[4];
+
+    // 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_ICON_1_ID = 5;
+    private static final int SUGGEST_COLUMN_ICON_2_ID = 6;
+    private static final int SUGGEST_COLUMN_QUERY_ID = 7;
+
+    // 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_ICON_1,
+            SearchManager.SUGGEST_COLUMN_ICON_2,
+            SearchManager.SUGGEST_COLUMN_QUERY};
+
+    private static final int MAX_SUGGESTION_SHORT_ENTRIES = 3;
+    private static final int MAX_SUGGESTION_LONG_ENTRIES = 6;
+
+    // make sure that these match the index of TABLE_NAMES
+    private 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 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);
+    }
+
+    // 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
+    private static final int DATABASE_VERSION = 19;
+
+    public BrowserProvider() {
+    }
+  
+
+    private static CharSequence replaceSystemPropertyInString(CharSequence srcString) {
+        StringBuffer sb = new StringBuffer();
+        int lastCharLoc = 0;
+        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();
+                        // See if the propertyKeyValue specifies a default value
+                        int defaultOffset = propertyKeyValue.indexOf(':');
+                        if (defaultOffset == -1) {
+                            sb.append(SystemProperties.get(propertyKeyValue));
+                        } else {
+                            String propertyKey = propertyKeyValue.substring(0, defaultOffset);
+                            String defaultValue = 
+                                    propertyKeyValue.substring(defaultOffset + 1, 
+                                                               propertyKeyValue.length());
+                            sb.append(SystemProperties.get(propertyKey, defaultValue));
+                        }
+                        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;
+    }
+
+    private 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," +
+                    "visits INTEGER," +
+                    "date LONG," +
+                    "created LONG," +
+                    "description TEXT," +
+                    "bookmark INTEGER," +
+                    "favicon BLOB DEFAULT NULL" +
+                    ");");
+
+            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(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 + ", which will destroy all old data");
+            if (oldVersion == 18) {
+                db.execSQL("DROP TABLE IF EXISTS labels");
+            } else {
+                db.execSQL("DROP TABLE IF EXISTS bookmarks");
+                db.execSQL("DROP TABLE IF EXISTS searches");
+                onCreate(db);
+            }
+        }
+    }
+
+    @Override
+    public boolean onCreate() {
+        mOpenHelper = new DatabaseHelper(getContext());
+        return true;
+    }
+
+    /*
+     * Subclass AbstractCursor so we can combine multiple Cursors and add
+     * "Google Search".
+     * Here are the rules.
+     * 1. We only have MAX_SUGGESTION_LONG_ENTRIES in the list plus 
+     *      "Google Search";
+     * 2. If bookmark/history entries are less than 
+     *      (MAX_SUGGESTION_SHORT_ENTRIES -1), we include Google suggest.
+     */
+    private class MySuggestionCursor extends AbstractCursor {
+        private Cursor  mHistoryCursor;
+        private Cursor  mSuggestCursor;
+        private int     mHistoryCount;
+        private int     mSuggestionCount;
+        private boolean mBeyondCursor;
+        private String  mString;
+
+        public MySuggestionCursor(Cursor hc, Cursor sc, String string) {
+            mHistoryCursor = hc;
+            mSuggestCursor = sc;
+            mHistoryCount = hc.getCount();
+            mSuggestionCount = sc != null ? sc.getCount() : 0;
+            if (mSuggestionCount > (MAX_SUGGESTION_LONG_ENTRIES - mHistoryCount)) {
+                mSuggestionCount = MAX_SUGGESTION_LONG_ENTRIES - mHistoryCount;
+            }
+            mString = string;
+            mBeyondCursor = false;
+        }
+
+        @Override
+        public boolean onMove(int oldPosition, int newPosition) {
+            if (mHistoryCursor == null) {
+                return false;
+            }
+            if (mHistoryCount > newPosition) {
+                mHistoryCursor.moveToPosition(newPosition);
+                mBeyondCursor = false;
+            } else if (mHistoryCount + mSuggestionCount > newPosition) {
+                mSuggestCursor.moveToPosition(newPosition - mHistoryCount);
+                mBeyondCursor = false;
+            } else {
+                mBeyondCursor = true;
+            }
+            return true;
+        }
+
+        @Override
+        public int getCount() {
+            if (mString.length() > 0) {
+                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)) {
+                switch(columnIndex) {
+                    case SUGGEST_COLUMN_INTENT_ACTION_ID:
+                        if (mHistoryCount > mPos) {
+                            return Intent.ACTION_VIEW;
+                        } else {
+                            return Intent.ACTION_SEARCH;
+                        }
+
+                    case SUGGEST_COLUMN_INTENT_DATA_ID:
+                        if (mHistoryCount > mPos) {
+                            return mHistoryCursor.getString(1);
+                        } else {
+                            return null;
+                        }
+
+                    case SUGGEST_COLUMN_TEXT_1_ID:
+                        if (mHistoryCount > mPos) {
+                            return mHistoryCursor.getString(1);
+                        } else if (!mBeyondCursor) {
+                            return mSuggestCursor.getString(1);
+                        } else {
+                            return mString;
+                        }
+
+                    case SUGGEST_COLUMN_TEXT_2_ID:
+                        if (mHistoryCount > mPos) {
+                            return mHistoryCursor.getString(2);
+                        } else if (!mBeyondCursor) {
+                            return mSuggestCursor.getString(2);
+                        } else {
+                            return getContext().getString(R.string.search_google);
+                        }
+
+                    case SUGGEST_COLUMN_ICON_1_ID:
+                        if (mHistoryCount > mPos) {
+                            if (mHistoryCursor.getInt(3) == 1) {
+                                return new Integer(
+                                        R.drawable.ic_search_category_bookmark)
+                                        .toString();
+                            } else {
+                                return new Integer(
+                                        R.drawable.ic_search_category_history)
+                                        .toString();
+                            }
+                        } else {
+                            return new Integer(
+                                    R.drawable.ic_search_category_suggest)
+                                    .toString();
+                        }
+
+                    case SUGGEST_COLUMN_ICON_2_ID:
+                        return new String("0");
+
+                    case SUGGEST_COLUMN_QUERY_ID:
+                        if (mHistoryCount > mPos) {
+                            return null;
+                        } else if (!mBeyondCursor) {
+                            return mSuggestCursor.getString(3);
+                        } else {
+                            return mString;
+                        }
+                }
+            }
+            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
+        public void deactivate() {
+            if (mHistoryCursor != null) {
+                mHistoryCursor.deactivate();
+            }
+            if (mSuggestCursor != null) {
+                mSuggestCursor.deactivate();
+            }
+            super.deactivate();
+        }
+
+        public boolean requery() {
+            return (mHistoryCursor != null ? mHistoryCursor.requery() : false) |
+                    (mSuggestCursor != null ? mSuggestCursor.requery() : false);
+        }
+
+        // TODO Temporary change, finalize after jq's changes go in
+        public void close() {
+            super.close();
+            if (mHistoryCursor != null) {
+                mHistoryCursor.close();
+                mHistoryCursor = null;
+            }
+            if (mSuggestCursor != null) {
+                mSuggestCursor.close();
+                mSuggestCursor = null;
+            }
+        }
+    }
+
+    @Override
+    public Cursor query(Uri url, String[] projectionIn, String selection,
+            String[] selectionArgs, String sortOrder) 
+            throws IllegalStateException {
+        SQLiteDatabase db = mOpenHelper.getReadableDatabase();
+
+        int match = URI_MATCHER.match(url);
+        if (match == -1) {
+            throw new IllegalArgumentException("Unknown URL");
+        }
+
+        if (match == URI_MATCH_SUGGEST) {
+            String suggestSelection;
+            String [] myArgs;
+            if (selectionArgs[0] == null || selectionArgs[0].equals("")) {
+                suggestSelection = null;
+                myArgs = null;
+            } else {
+                String like = selectionArgs[0] + "%";
+                if (selectionArgs[0].startsWith("http")) {
+                    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;
+                    myArgs = SUGGEST_ARGS;
+                    suggestSelection = SUGGEST_SELECTION;
+                }
+            }
+
+            Cursor c = db.query(TABLE_NAMES[URI_MATCH_BOOKMARKS],
+                    SUGGEST_PROJECTION, suggestSelection, myArgs, null, null,
+                    ORDER_BY,
+                    (new Integer(MAX_SUGGESTION_LONG_ENTRIES)).toString());
+
+            if (Regex.WEB_URL_PATTERN.matcher(selectionArgs[0]).matches()) {
+                return new MySuggestionCursor(c, null, "");
+            } else {
+                // get Google suggest if there is still space in the list
+                if (myArgs != null && myArgs.length > 1
+                        && c.getCount() < (MAX_SUGGESTION_SHORT_ENTRIES - 1)) {
+                    ISearchManager sm = ISearchManager.Stub
+                            .asInterface(ServiceManager
+                                    .getService(Context.SEARCH_SERVICE));
+                    SearchableInfo si = null;
+                    try {
+                        // use the global search to get Google suggest provider
+                        si = sm.getSearchableInfo(new ComponentName(
+                                getContext(), "com.android.browser"), true);
+
+                        // similar to the getSuggestions() in SearchDialog.java
+                        StringBuilder uriStr = new StringBuilder("content://");
+                        uriStr.append(si.getSuggestAuthority());
+                        // if content path provided, insert it now
+                        final String contentPath = si.getSuggestPath();
+                        if (contentPath != null) {
+                            uriStr.append('/');
+                            uriStr.append(contentPath);
+                        }
+                        // append standard suggestion query path 
+                        uriStr.append('/' + SearchManager.SUGGEST_URI_PATH_QUERY);
+                        // inject query, either as selection args or inline
+                        String[] selArgs = null;
+                        if (si.getSuggestSelection() != null) {
+                            selArgs = new String[] {selectionArgs[0]};
+                        } else {
+                            uriStr.append('/');
+                            uriStr.append(Uri.encode(selectionArgs[0]));
+                        }
+
+                        // finally, make the query
+                        Cursor sc = getContext().getContentResolver().query(
+                                Uri.parse(uriStr.toString()), null,
+                                si.getSuggestSelection(), selArgs, null);
+
+                        return new MySuggestionCursor(c, sc, selectionArgs[0]);
+                    } catch (RemoteException e) {
+                    }
+                }
+                return new MySuggestionCursor(c, null, selectionArgs[0]);
+            }
+        }
+
+        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";
+        }
+
+        StringBuilder whereClause = new StringBuilder(256);
+        if (match == URI_MATCH_BOOKMARKS_ID || match == URI_MATCH_SEARCHES_ID) {
+            whereClause.append("(_id = ").append(url.getPathSegments().get(1))
+                    .append(")");
+        }
+
+        // Tack on the user's selection, if present
+        if (selection != null && selection.length() > 0) {
+            if (whereClause.length() > 0) {
+                whereClause.append(" AND ");
+            }
+
+            whereClause.append('(');
+            whereClause.append(selection);
+            whereClause.append(')');
+        }
+        Cursor c = db.query(TABLE_NAMES[match % 10], projection,
+                whereClause.toString(), selectionArgs, null, null, sortOrder,
+                null);
+        c.setNotificationUri(getContext().getContentResolver(), url);
+        return c;
+    }
+
+    @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) {
+        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);
+                }
+                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);
+        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");
+        }
+
+        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 ");
+            }
+            sb.append("_id = ");
+            sb.append(url.getPathSegments().get(1));
+            where = sb.toString();
+        }
+
+        int count = db.delete(TABLE_NAMES[match % 10], where, whereArgs);
+        getContext().getContentResolver().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 ");
+            }
+            sb.append("_id = ");
+            sb.append(url.getPathSegments().get(1));
+            where = sb.toString();
+        }
+
+        int ret = db.update(TABLE_NAMES[match % 10], values, where, whereArgs);
+        getContext().getContentResolver().notifyChange(url, null);
+        return ret;
+    }
+}
diff --git a/src/com/android/browser/BrowserSearchpagePreference.java b/src/com/android/browser/BrowserSearchpagePreference.java
new file mode 100644
index 0000000..09e8993
--- /dev/null
+++ b/src/com/android/browser/BrowserSearchpagePreference.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2008 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;
+
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.preference.EditTextPreference;
+import android.text.Editable;
+import android.text.TextWatcher;
+import android.text.util.Regex;
+import android.util.AttributeSet;
+
+public class BrowserSearchpagePreference extends EditTextPreference implements
+        TextWatcher {
+
+    public BrowserSearchpagePreference(Context context, AttributeSet attrs,
+            int defStyle) {
+        super(context, attrs, defStyle);
+        getEditText().addTextChangedListener(this);
+    }
+
+    public BrowserSearchpagePreference(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        getEditText().addTextChangedListener(this);
+    }
+
+    public BrowserSearchpagePreference(Context context) {
+        super(context);
+        getEditText().addTextChangedListener(this);
+    }
+
+    public void afterTextChanged(Editable s) {
+        AlertDialog dialog = (AlertDialog) getDialog();
+        // This callback is called before the dialog has been fully constructed
+        if (dialog != null) {
+            String string = s.toString();
+            int length = string.length();
+            int first = length > 0 ? string
+                    .indexOf(BrowserActivity.QUERY_PLACE_HOLDER) : -1;
+            int last = length > 0 ? string
+                    .lastIndexOf(BrowserActivity.QUERY_PLACE_HOLDER) : -1;
+            dialog.getButton(DialogInterface.BUTTON_POSITIVE).setEnabled(
+                    length == 0 || (first > 0 && first == last));
+        }
+    }
+
+    public void beforeTextChanged(CharSequence s, int start, int count,
+            int after) {
+    }
+
+    public void onTextChanged(CharSequence s, int start, int before, int count) {
+    }
+}
diff --git a/src/com/android/browser/BrowserSettings.java b/src/com/android/browser/BrowserSettings.java
new file mode 100644
index 0000000..d8c5186
--- /dev/null
+++ b/src/com/android/browser/BrowserSettings.java
@@ -0,0 +1,442 @@
+/*
+ * Copyright (C) 2007 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;
+
+import android.app.Activity;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.pm.ActivityInfo;
+import android.content.SharedPreferences;
+import android.content.SharedPreferences.Editor;
+import android.os.SystemProperties;
+import android.view.WindowManager;
+import android.webkit.CacheManager;
+import android.webkit.CookieManager;
+import android.webkit.WebView;
+import android.webkit.WebViewDatabase;
+import android.webkit.WebIconDatabase;
+import android.webkit.WebSettings;
+import android.preference.PreferenceManager;
+import android.provider.Browser;
+
+import java.util.HashMap;
+import java.util.Observable;
+
+/*
+ * Package level class for storing various WebView and Browser settings. To use
+ * this class:
+ * BrowserSettings s = BrowserSettings.getInstance();
+ * s.addObserver(webView.getSettings());
+ * s.loadFromDb(context); // Only needed on app startup
+ * s.javaScriptEnabled = true;
+ * ... // set any other settings
+ * s.update(); // this will update all the observers
+ *
+ * To remove an observer:
+ * s.deleteObserver(webView.getSettings());
+ */
+class BrowserSettings extends Observable {
+
+    // Public variables for settings
+    // NOTE: these defaults need to be kept in sync with the XML
+    // until the performance of PreferenceManager.setDefaultValues()
+    // is improved.
+    private boolean loadsImagesAutomatically = true;
+    private boolean javaScriptEnabled = true;
+    private boolean pluginsEnabled = true;
+    private String pluginsPath;  // default value set in loadFromDb().
+    private boolean javaScriptCanOpenWindowsAutomatically = false;
+    private boolean showSecurityWarnings = true;
+    private boolean rememberPasswords = true;
+    private boolean saveFormData = true;
+    private boolean openInBackground = false;
+    private String defaultTextEncodingName;
+    private String homeUrl = "http://www.google.com/m?client=ms-" +
+        SystemProperties.get("persist.sys.com.google.clientid", "unknown");
+    private boolean loginInitialized = false;
+    private boolean autoFitPage = true;
+    private boolean showDebugSettings = false;
+
+    // Development settings
+    public WebSettings.LayoutAlgorithm layoutAlgorithm =
+        WebSettings.LayoutAlgorithm.NARROW_COLUMNS;
+    private boolean useWideViewPort = true;
+    private int userAgent = 0;
+    private boolean tracing = false;
+    private boolean lightTouch = false;
+    private boolean navDump = false;
+    // Browser only settings
+    private boolean doFlick = false;
+
+    // Private preconfigured values
+    private static int minimumFontSize = 8;
+    private static int minimumLogicalFontSize = 8;
+    private static int defaultFontSize = 16;
+    private static int defaultFixedFontSize = 13;
+    private static WebSettings.TextSize textSize =
+        WebSettings.TextSize.NORMAL;
+
+    // Preference keys that are used outside this class
+    public final static String PREF_CLEAR_CACHE = "privacy_clear_cache";
+    public final static String PREF_CLEAR_COOKIES = "privacy_clear_cookies";
+    public final static String PREF_CLEAR_HISTORY = "privacy_clear_history";
+    public final static String PREF_HOMEPAGE = "homepage";
+    public final static String PREF_CLEAR_FORM_DATA =
+            "privacy_clear_form_data";
+    public final static String PREF_CLEAR_PASSWORDS =
+            "privacy_clear_passwords";
+    public final static String PREF_EXTRAS_RESET_DEFAULTS =
+            "reset_default_preferences";
+    public final static String PREF_DEBUG_SETTINGS = "debug_menu";
+    public final static String PREF_GEARS_SETTINGS = "gears_settings";
+    public final static String PREF_TEXT_SIZE = "text_size";
+    public final static String PREF_DEFAULT_TEXT_ENCODING =
+            "default_text_encoding";
+
+    private static final String DESKTOP_USERAGENT = "Mozilla/5.0 (Macintosh; " +
+            "U; Intel Mac OS X 10_5_5; en-us) AppleWebKit/525.18 (KHTML, " +
+            "like Gecko) Version/3.1.2 Safari/525.20.1";
+
+    private static final String IPHONE_USERAGENT = "Mozilla/5.0 (iPhone; U; " +
+            "CPU iPhone OS 2_2 like Mac OS X; en-us) AppleWebKit/525.18.1 " +
+            "(KHTML, like Gecko) Version/3.1.1 Mobile/5G77 Safari/525.20";
+
+    // Value to truncate strings when adding them to a TextView within
+    // a ListView
+    public final static int MAX_TEXTVIEW_LEN = 80;
+
+    private TabControl mTabControl;
+
+    // Single instance of the BrowserSettings for use in the Browser app.
+    private static BrowserSettings sSingleton;
+
+    // Private map of WebSettings to Observer objects used when deleting an
+    // observer.
+    private HashMap<WebSettings,Observer> mWebSettingsToObservers =
+        new HashMap<WebSettings,Observer>();
+
+    /*
+     * An observer wrapper for updating a WebSettings object with the new
+     * settings after a call to BrowserSettings.update().
+     */
+    static class Observer implements java.util.Observer {
+        // Private WebSettings object that will be updated.
+        private WebSettings mSettings;
+
+        Observer(WebSettings w) {
+            mSettings = w;
+        }
+
+        public void update(Observable o, Object arg) {
+            BrowserSettings b = (BrowserSettings)o;
+            WebSettings s = mSettings;
+
+            s.setLayoutAlgorithm(b.layoutAlgorithm);
+            if (b.userAgent == 0) {
+                // use the default ua string
+                s.setUserAgentString(null);
+            } else if (b.userAgent == 1) {
+                s.setUserAgentString(DESKTOP_USERAGENT);
+            } else if (b.userAgent == 2) {
+                s.setUserAgentString(IPHONE_USERAGENT);
+            }
+            s.setUseWideViewPort(b.useWideViewPort);
+            s.setLoadsImagesAutomatically(b.loadsImagesAutomatically);
+            s.setJavaScriptEnabled(b.javaScriptEnabled);
+            s.setPluginsEnabled(b.pluginsEnabled);
+            s.setPluginsPath(b.pluginsPath);
+            s.setJavaScriptCanOpenWindowsAutomatically(
+                    b.javaScriptCanOpenWindowsAutomatically);
+            s.setDefaultTextEncodingName(b.defaultTextEncodingName);
+            s.setMinimumFontSize(b.minimumFontSize);
+            s.setMinimumLogicalFontSize(b.minimumLogicalFontSize);
+            s.setDefaultFontSize(b.defaultFontSize);
+            s.setDefaultFixedFontSize(b.defaultFixedFontSize);
+            s.setNavDump(b.navDump);
+            s.setTextSize(b.textSize);
+            s.setLightTouchEnabled(b.lightTouch);
+            s.setSaveFormData(b.saveFormData);
+            s.setSavePassword(b.rememberPasswords);
+
+            // WebView inside Browser doesn't want initial focus to be set.
+            s.setNeedInitialFocus(false);
+            // Browser supports multiple windows
+            s.setSupportMultipleWindows(true);
+            // Turn off file access
+            s.setAllowFileAccess(false);
+        }
+    }
+
+    /**
+     * Load settings from the browser app's database.
+     * NOTE: Strings used for the preferences must match those specified
+     * in the browser_preferences.xml
+     * @param ctx A Context object used to query the browser's settings
+     *            database. If the database exists, the saved settings will be
+     *            stored in this BrowserSettings object. This will update all
+     *            observers of this object.
+     */
+    public void loadFromDb(Context ctx) {
+        SharedPreferences p =
+                PreferenceManager.getDefaultSharedPreferences(ctx);
+
+        // Set the default value for the plugins path to the application's
+        // local directory.
+        pluginsPath = ctx.getDir("plugins", 0).getPath();
+
+        // Load the defaults from the xml
+        // This call is TOO SLOW, need to manually keep the defaults
+        // in sync
+        //PreferenceManager.setDefaultValues(ctx, R.xml.browser_preferences);
+        syncSharedPreferences(p);
+    }
+
+    /* package */ void syncSharedPreferences(SharedPreferences p) {
+        homeUrl =
+            p.getString(PREF_HOMEPAGE, homeUrl);
+        loadsImagesAutomatically = p.getBoolean("load_images",
+                loadsImagesAutomatically);
+        javaScriptEnabled = p.getBoolean("enable_javascript",
+                javaScriptEnabled);
+        pluginsEnabled = p.getBoolean("enable_plugins",
+                pluginsEnabled);
+        pluginsPath = p.getString("plugins_path", pluginsPath);
+        javaScriptCanOpenWindowsAutomatically = !p.getBoolean(
+            "block_popup_windows",
+            !javaScriptCanOpenWindowsAutomatically);
+        showSecurityWarnings = p.getBoolean("show_security_warnings",
+                showSecurityWarnings);
+        rememberPasswords = p.getBoolean("remember_passwords",
+                rememberPasswords);
+        saveFormData = p.getBoolean("save_formdata",
+                saveFormData);
+        boolean accept_cookies = p.getBoolean("accept_cookies",
+                CookieManager.getInstance().acceptCookie());
+        CookieManager.getInstance().setAcceptCookie(accept_cookies);
+        openInBackground = p.getBoolean("open_in_background", openInBackground);
+        loginInitialized = p.getBoolean("login_initialized", loginInitialized);
+        textSize = WebSettings.TextSize.valueOf(
+                p.getString(PREF_TEXT_SIZE, textSize.name()));
+        autoFitPage = p.getBoolean("autofit_pages", autoFitPage);
+        useWideViewPort = true; // use wide view port for either setting
+        if (autoFitPage) {
+            layoutAlgorithm = WebSettings.LayoutAlgorithm.NARROW_COLUMNS;
+        } else {
+            layoutAlgorithm = WebSettings.LayoutAlgorithm.NORMAL;
+        }
+        defaultTextEncodingName =
+                p.getString(PREF_DEFAULT_TEXT_ENCODING,
+                        defaultTextEncodingName);
+
+        showDebugSettings =
+                p.getBoolean(PREF_DEBUG_SETTINGS, showDebugSettings);
+        // Debug menu items have precidence if the menu is visible
+        if (showDebugSettings) {
+            boolean small_screen = p.getBoolean("small_screen",
+                    layoutAlgorithm ==
+                    WebSettings.LayoutAlgorithm.SINGLE_COLUMN);
+            if (small_screen) {
+                layoutAlgorithm = WebSettings.LayoutAlgorithm.SINGLE_COLUMN;
+            } else {
+                boolean normal_layout = p.getBoolean("normal_layout",
+                        layoutAlgorithm == WebSettings.LayoutAlgorithm.NORMAL);
+                if (normal_layout) {
+                    layoutAlgorithm = WebSettings.LayoutAlgorithm.NORMAL;
+                } else {
+                    layoutAlgorithm =
+                            WebSettings.LayoutAlgorithm.NARROW_COLUMNS;
+                }
+            }
+            useWideViewPort = p.getBoolean("wide_viewport", useWideViewPort);
+            tracing = p.getBoolean("enable_tracing", tracing);
+            lightTouch = p.getBoolean("enable_light_touch", lightTouch);
+            navDump = p.getBoolean("enable_nav_dump", navDump);
+            doFlick = p.getBoolean("enable_flick", doFlick);
+            userAgent = Integer.parseInt(p.getString("user_agent", "0"));
+            mTabControl.getBrowserActivity().setBaseSearchUrl(
+                    p.getString("search_url", ""));
+        }
+        update();
+    }
+
+    public String getPluginsPath() {
+        return pluginsPath;
+    }
+
+    public String getHomePage() {
+        return homeUrl;
+    }
+
+    public void setHomePage(Context context, String url) {
+        Editor ed = PreferenceManager.
+                getDefaultSharedPreferences(context).edit();
+        ed.putString(PREF_HOMEPAGE, url);
+        ed.commit();
+        homeUrl = url;
+    }
+
+    public boolean isLoginInitialized() {
+        return loginInitialized;
+    }
+
+    public void setLoginInitialized(Context context) {
+        loginInitialized = true;
+        Editor ed = PreferenceManager.
+                getDefaultSharedPreferences(context).edit();
+        ed.putBoolean("login_initialized", loginInitialized);
+        ed.commit();
+    }
+
+    public WebSettings.TextSize getTextSize() {
+        return textSize;
+    }
+
+    public boolean openInBackground() {
+        return openInBackground;
+    }
+
+    public boolean showSecurityWarnings() {
+        return showSecurityWarnings;
+    }
+
+    public boolean isTracing() {
+        return tracing;
+    }
+
+    public boolean isLightTouch() {
+        return lightTouch;
+    }
+
+    public boolean isNavDump() {
+        return navDump;
+    }
+
+    public boolean doFlick() {
+        return doFlick;
+    }
+
+    public boolean showDebugSettings() {
+        return showDebugSettings;
+    }
+
+    public void toggleDebugSettings() {
+        showDebugSettings = !showDebugSettings;
+        navDump = showDebugSettings;
+        update();
+    }
+
+    /**
+     * Add a WebSettings object to the list of observers that will be updated
+     * when update() is called.
+     *
+     * @param s A WebSettings object that is strictly tied to the life of a
+     *            WebView.
+     */
+    public Observer addObserver(WebSettings s) {
+        Observer old = mWebSettingsToObservers.get(s);
+        if (old != null) {
+            super.deleteObserver(old);
+        }
+        Observer o = new Observer(s);
+        mWebSettingsToObservers.put(s, o);
+        super.addObserver(o);
+        return o;
+    }
+
+    /**
+     * Delete the given WebSettings observer from the list of observers.
+     * @param s The WebSettings object to be deleted.
+     */
+    public void deleteObserver(WebSettings s) {
+        Observer o = mWebSettingsToObservers.get(s);
+        if (o != null) {
+            mWebSettingsToObservers.remove(s);
+            super.deleteObserver(o);
+        }
+    }
+
+    /*
+     * Package level method for obtaining a single app instance of the
+     * BrowserSettings.
+     */
+    /*package*/ static BrowserSettings getInstance() {
+        if (sSingleton == null ) {
+            sSingleton = new BrowserSettings();
+        }
+        return sSingleton;
+    }
+
+    /*
+     * Package level method for associating the BrowserSettings with TabControl
+     */
+    /* package */void setTabControl(TabControl tabControl) {
+        mTabControl = tabControl;
+    }
+
+    /*
+     * Update all the observers of the object.
+     */
+    /*package*/ void update() {
+        setChanged();
+        notifyObservers();
+    }
+
+    /*package*/ void clearCache(Context context) {
+        WebIconDatabase.getInstance().removeAllIcons();
+        if (mTabControl != null) {
+            WebView current = mTabControl.getCurrentWebView();
+            if (current != null) {
+                current.clearCache(true);
+            }
+        }
+    }
+
+    /*package*/ void clearCookies(Context context) {
+        CookieManager.getInstance().removeAllCookie();
+    }
+
+    /* package */void clearHistory(Context context) {
+        ContentResolver resolver = context.getContentResolver();
+        Browser.clearHistory(resolver);
+        Browser.clearSearches(resolver);
+    }
+
+    /* package */ void clearFormData(Context context) {
+        WebViewDatabase.getInstance(context).clearFormData();
+        if (mTabControl != null) {
+            mTabControl.getCurrentTopWebView().clearFormData();
+        }
+    }
+
+    /*package*/ void clearPasswords(Context context) {
+        WebViewDatabase db = WebViewDatabase.getInstance(context);
+        db.clearUsernamePassword();
+        db.clearHttpAuthUsernamePassword();
+    }
+
+    /*package*/ void resetDefaultPreferences(Context context) {
+        SharedPreferences p =
+            PreferenceManager.getDefaultSharedPreferences(context);
+        p.edit().clear().commit();
+        PreferenceManager.setDefaultValues(context, R.xml.browser_preferences,
+                true);
+    }
+
+    // Private constructor that does nothing.
+    private BrowserSettings() {
+    }
+}
diff --git a/src/com/android/browser/BrowserYesNoPreference.java b/src/com/android/browser/BrowserYesNoPreference.java
new file mode 100644
index 0000000..65cde71
--- /dev/null
+++ b/src/com/android/browser/BrowserYesNoPreference.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2008 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;
+
+import com.android.internal.preference.YesNoPreference;
+
+import android.content.Context;
+import android.util.AttributeSet;
+
+class BrowserYesNoPreference extends YesNoPreference {
+
+    // This is the constructor called by the inflater
+    public BrowserYesNoPreference(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    @Override
+    protected void onDialogClosed(boolean positiveResult) {
+        super.onDialogClosed(positiveResult);
+
+        if (positiveResult) {
+            setEnabled(false);
+
+            Context context = getContext();
+            if (BrowserSettings.PREF_CLEAR_CACHE.equals(getKey())) {
+                BrowserSettings.getInstance().clearCache(context);
+            } else if (BrowserSettings.PREF_CLEAR_COOKIES.equals(getKey())) {
+                BrowserSettings.getInstance().clearCookies(context);
+            } else if (BrowserSettings.PREF_CLEAR_HISTORY.equals(getKey())) {
+                BrowserSettings.getInstance().clearHistory(context);
+            } else if (BrowserSettings.PREF_CLEAR_FORM_DATA.equals(getKey())) {
+                BrowserSettings.getInstance().clearFormData(context);
+            } else if (BrowserSettings.PREF_CLEAR_PASSWORDS.equals(getKey())) {
+                BrowserSettings.getInstance().clearPasswords(context);
+            } else if (BrowserSettings.PREF_EXTRAS_RESET_DEFAULTS.equals(
+                    getKey())) {
+                BrowserSettings.getInstance().resetDefaultPreferences(context);
+                setEnabled(true);
+            }
+        }
+    }
+}
diff --git a/src/com/android/browser/CombinedBookmarkHistoryActivity.java b/src/com/android/browser/CombinedBookmarkHistoryActivity.java
new file mode 100644
index 0000000..963f179
--- /dev/null
+++ b/src/com/android/browser/CombinedBookmarkHistoryActivity.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2009 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;
+
+import android.app.Activity;
+import android.app.TabActivity;
+import android.content.ContentResolver;
+import android.content.Intent;
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.os.Bundle;
+import android.provider.Browser;
+import android.webkit.WebIconDatabase.IconListener;
+import android.widget.TabHost;
+import android.widget.TabHost.TabSpec;
+import android.view.Window;
+
+import java.util.HashMap;
+import java.util.Vector;
+
+public class CombinedBookmarkHistoryActivity extends TabActivity
+        implements TabHost.OnTabChangeListener {
+    /* package */ static String BOOKMARKS_TAB = "bookmark";
+    /* package */ static String VISITED_TAB = "visited";
+    /* package */ static String HISTORY_TAB = "history";
+    /* package */ static String STARTING_TAB = "tab";
+
+    static class IconListenerSet implements IconListener {
+        // Used to store favicons as we get them from the database
+        // FIXME: We use a different method to get the Favicons in
+        // BrowserBookmarksAdapter. They should probably be unified.
+        private HashMap<String, Bitmap> mUrlsToIcons;
+        private Vector<IconListener> mListeners;
+
+        public IconListenerSet() {
+            mUrlsToIcons = new HashMap<String, Bitmap>();
+            mListeners = new Vector<IconListener>();
+        }
+        public void onReceivedIcon(String url, Bitmap icon) {
+            mUrlsToIcons.put(url, icon);
+            for (IconListener listener : mListeners) {
+                listener.onReceivedIcon(url, icon);
+            }
+        }
+        public void addListener(IconListener listener) {
+            mListeners.add(listener);
+        }
+        public Bitmap getFavicon(String url) {
+            return (Bitmap) mUrlsToIcons.get(url);
+        }
+    }
+    private static IconListenerSet sIconListenerSet;
+    static IconListenerSet getIconListenerSet(ContentResolver cr) {
+        if (null == sIconListenerSet) {
+            sIconListenerSet = new IconListenerSet();
+            Browser.requestAllIcons(cr, null, sIconListenerSet);
+        }
+        return sIconListenerSet;
+    }
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        requestWindowFeature(Window.FEATURE_NO_TITLE);
+        setContentView(R.layout.tabs);
+        TabHost tabHost = getTabHost();
+        tabHost.setOnTabChangedListener(this);
+
+        Bundle extras = getIntent().getExtras();
+        Resources resources = getResources();
+
+        getIconListenerSet(getContentResolver());
+        Intent bookmarksIntent = new Intent(this, BrowserBookmarksPage.class);
+        bookmarksIntent.putExtras(extras);
+        tabHost.addTab(tabHost.newTabSpec(BOOKMARKS_TAB)
+                .setIndicator(resources.getString(R.string.tab_bookmarks),
+                resources.getDrawable(R.drawable.browser_bookmark_tab))
+                .setContent(bookmarksIntent));
+
+        Intent visitedIntent = new Intent(this, MostVisitedActivity.class);
+        visitedIntent.putExtras(extras);
+        tabHost.addTab(tabHost.newTabSpec(VISITED_TAB)
+                .setIndicator(resources.getString(R.string.tab_most_visited),
+                resources.getDrawable(R.drawable.browser_visited_tab))
+                .setContent(visitedIntent));
+
+        Intent historyIntent = new Intent(this, BrowserHistoryPage.class);
+        historyIntent.putExtras(extras);
+        tabHost.addTab(tabHost.newTabSpec(HISTORY_TAB)
+                .setIndicator(resources.getString(R.string.tab_history),
+                resources.getDrawable(R.drawable.
+                browser_history_tab)).setContent(historyIntent));
+
+        String defaultTab = extras.getString(STARTING_TAB);
+        if (defaultTab != null) {
+            tabHost.setCurrentTab(2);
+        }
+    }
+
+    // Copied from DialTacts Activity
+    /** {@inheritDoc} */
+    public void onTabChanged(String tabId) {
+        Activity activity = getLocalActivityManager().getActivity(tabId);
+        if (activity != null) {
+            activity.onWindowFocusChanged(true);
+        }
+    }
+
+    
+}
diff --git a/src/com/android/browser/Dots.java b/src/com/android/browser/Dots.java
new file mode 100644
index 0000000..eb8d493
--- /dev/null
+++ b/src/com/android/browser/Dots.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2008 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;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.Gravity;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+
+import java.util.Map;
+
+/**
+ * Displays a series of dots.  The selected one is highlighted.
+ * No animations yet.  Nothing fancy.
+ */
+class Dots extends LinearLayout {
+
+    private static final int MAX_DOTS = 8;
+    private int mSelected = -1;
+
+    public Dots(Context context) {
+        this(context, null);
+    }
+
+    public Dots(Context context, AttributeSet attrs) {
+        super(context, attrs);
+
+        setGravity(Gravity.CENTER);
+        setPadding(0, 4, 0, 4);
+
+        LayoutParams lp =
+                new LayoutParams(LayoutParams.WRAP_CONTENT,
+                                 LayoutParams.WRAP_CONTENT);
+
+        for (int i = 0; i < MAX_DOTS; i++) {
+            ImageView dotView = new ImageView(mContext);
+            dotView.setImageResource(R.drawable.page_indicator_unselected2);
+            addView(dotView, lp);
+        }
+    }
+
+    /**
+     * @param dotCount if less than 1 or greater than MAX_DOTS, Dots
+     * disappears
+     */
+    public void setDotCount(int dotCount) {
+        if (dotCount > 1 && dotCount <= MAX_DOTS) {
+            setVisibility(VISIBLE);
+            for (int i = 0; i < MAX_DOTS; i++) {
+                getChildAt(i).setVisibility(i < dotCount? VISIBLE : GONE);
+            }
+        } else {
+            setVisibility(GONE);
+        }
+    }
+
+    public void setSelected(int index) {
+        if (index < 0 || index >= MAX_DOTS) return;
+
+        if (mSelected >= 0) {
+            // Unselect old
+            ((ImageView)getChildAt(mSelected)).setImageResource(
+                    R.drawable.page_indicator_unselected2);
+        }
+        ((ImageView)getChildAt(index)).setImageResource(R.drawable.page_indicator);
+        mSelected = index;
+    }
+}
diff --git a/src/com/android/browser/FakeWebView.java b/src/com/android/browser/FakeWebView.java
new file mode 100644
index 0000000..633b799
--- /dev/null
+++ b/src/com/android/browser/FakeWebView.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2008 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;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Picture;
+import android.util.AttributeSet;
+import android.view.View;
+import android.webkit.WebView;
+import android.widget.ImageView;
+
+import android.util.Log;
+
+/**
+ *  This class is used by ImageAdapter to draw a representation of each tab. It 
+ *  overrides ImageView so it can be used for the new tab image as well.
+ */
+public class FakeWebView extends ImageView {
+    private TabControl.Tab mTab;
+    private Picture        mPicture;
+    private boolean        mUsesResource;
+
+    private class Listener implements WebView.PictureListener {
+        public void onNewPicture(WebView view, Picture p) {
+            FakeWebView.this.mPicture = p;
+            FakeWebView.this.invalidate();
+        }
+    };
+
+    public FakeWebView(Context context) {
+        this(context, null);
+    }
+    
+    public FakeWebView(Context context, AttributeSet attrs) {
+        this(context, attrs, 0);
+    }
+    
+    public FakeWebView(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    @Override
+    protected void onDraw(Canvas canvas) {
+        if (mUsesResource) {
+            super.onDraw(canvas);
+        } else {
+            // Always draw white behind the picture just in case the picture
+            // draws nothing.
+            // FIXME: We used to draw white only when the WebView was null but
+            // sometimes the picture was empty. So now we always draw white. It
+            // would be nice to know if the picture is empty so we can avoid
+            // drawing white.
+            canvas.drawColor(Color.WHITE);
+            if (mTab != null) {
+                final WebView w = mTab.getTopWindow();
+                if (w != null) {
+                    if (mPicture != null) {
+                        canvas.save();
+                        float scale = getWidth() * w.getScale() / w.getWidth();
+                        canvas.scale(scale, scale);
+                        canvas.translate(-w.getScrollX(), -w.getScrollY());
+                        canvas.drawPicture(mPicture);
+                        canvas.restore();
+                    }
+                }
+            }
+        }
+    }
+    
+    @Override
+    public void setImageResource(int resId) {
+        mUsesResource = true;
+        mTab = null;
+        super.setImageResource(resId);
+    }
+
+    /**
+     *  Set a WebView for this FakeWebView to represent.
+     *  @param  v WebView whose picture and other data will be used in onDraw.
+     */
+    public void setTab(TabControl.Tab t) {
+        mUsesResource = false;
+        mTab = t;
+        if (t != null && t.getWebView() != null) {
+            Listener l = new Listener();
+            if (t.getSubWebView() != null) {
+                t.getSubWebView().setPictureListener(l);
+            } else {
+                t.getWebView().setPictureListener(l);
+            }
+            mPicture = mTab.getTopWindow().capturePicture();
+        }
+    }
+}
diff --git a/src/com/android/browser/FetchUrlMimeType.java b/src/com/android/browser/FetchUrlMimeType.java
new file mode 100644
index 0000000..8578643
--- /dev/null
+++ b/src/com/android/browser/FetchUrlMimeType.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright (C) 2008 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;
+
+import android.content.ContentValues;
+import android.net.Uri;
+import android.net.http.AndroidHttpClient;
+
+import org.apache.http.HttpResponse;
+import org.apache.http.Header;
+import org.apache.http.client.methods.HttpHead;
+
+import java.io.IOException;
+
+import android.os.AsyncTask;
+import android.provider.Downloads;
+import android.webkit.MimeTypeMap;
+import android.webkit.URLUtil;
+
+/**
+ * This class is used to pull down the http headers of a given URL so that
+ * we can analyse the mimetype and make any correction needed before we give
+ * the URL to the download manager. The ContentValues class holds the
+ * content that would be provided to the download manager, so that on
+ * completion of checking the mimetype, we can issue the download to
+ * the download manager.
+ * This operation is needed when the user long-clicks on a link or image and
+ * we don't know the mimetype. If the user just clicks on the link, we will
+ * do the same steps of correcting the mimetype down in
+ * android.os.webkit.LoadListener rather than handling it here.
+ *
+ */
+class FetchUrlMimeType extends AsyncTask<ContentValues, String, String> {
+
+    BrowserActivity mActivity;
+    ContentValues mValues;
+
+    public FetchUrlMimeType(BrowserActivity activity) {
+        mActivity = activity;
+    }
+
+    @Override
+    public String doInBackground(ContentValues... values) {
+        mValues = values[0];
+
+        // Check to make sure we have a URI to download
+        String uri = mValues.getAsString(Downloads.URI);
+        if (uri == null || uri.length() == 0) {
+            return null;
+        }
+
+        // User agent is likely to be null, though the AndroidHttpClient
+        // seems ok with that.
+        AndroidHttpClient client = AndroidHttpClient.newInstance(
+                mValues.getAsString(Downloads.USER_AGENT));
+        HttpHead request = new HttpHead(uri);
+
+        String cookie = mValues.getAsString(Downloads.COOKIE_DATA);
+        if (cookie != null && cookie.length() > 0) {
+            request.addHeader("Cookie", cookie);
+        }
+
+        String referer = mValues.getAsString(Downloads.REFERER);
+        if (referer != null && referer.length() > 0) {
+            request.addHeader("Referer", referer);
+        }
+
+        HttpResponse response;
+        Boolean succeeded = true;
+        String mimeType = null;
+        try {
+            response = client.execute(request);
+            // We could get a redirect here, but if we do lets let
+            // the download manager take care of it, and thus trust that
+            // the server sends the right mimetype
+            if (response.getStatusLine().getStatusCode() == 200) {
+                Header header = response.getFirstHeader("Content-Type");
+                if (header != null) {
+                    mimeType = header.getValue();
+                    final int semicolonIndex = mimeType.indexOf(';');
+                    if (semicolonIndex != -1) {
+                        mimeType = mimeType.substring(0, semicolonIndex);
+                    }
+                }
+            }
+        } catch (IllegalArgumentException ex) {
+            request.abort();
+        } catch (IOException ex) {
+            request.abort();
+        } finally {
+            client.close();
+        }
+
+        return mimeType;
+    }
+
+   @Override
+    public void onPostExecute(String mimeType) {
+       if (mimeType != null) {
+           String url = mValues.getAsString(Downloads.URI);
+           if (mimeType.equalsIgnoreCase("text/plain") ||
+                   mimeType.equalsIgnoreCase("application/octet-stream")) {
+               String newMimeType =
+                       MimeTypeMap.getSingleton().getMimeTypeFromExtension(
+                           MimeTypeMap.getFileExtensionFromUrl(url));
+               if (newMimeType != null) {
+                   mValues.put(Downloads.MIMETYPE, newMimeType);
+               }
+           }
+           String filename = URLUtil.guessFileName(url,
+                   null, mimeType);
+           mValues.put(Downloads.FILENAME_HINT, filename);
+       }
+
+       // Start the download
+       final Uri contentUri =
+           mActivity.getContentResolver().insert(Downloads.CONTENT_URI, mValues);
+       mActivity.viewDownloads(contentUri);
+    }
+
+}
diff --git a/src/com/android/browser/FindDialog.java b/src/com/android/browser/FindDialog.java
new file mode 100644
index 0000000..43cd1c4
--- /dev/null
+++ b/src/com/android/browser/FindDialog.java
@@ -0,0 +1,226 @@
+/*
+ * Copyright (C) 2007 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;
+
+import android.app.Dialog;
+import android.content.Context;
+import android.content.res.Configuration;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Message;
+import android.text.Editable;
+import android.text.Spannable;
+import android.text.TextWatcher;
+import android.view.Gravity;
+import android.view.KeyEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.Window;
+import android.view.WindowManager;
+import android.view.inputmethod.InputMethodManager;
+import android.webkit.WebView;
+import android.widget.EditText;
+import android.widget.TextView;
+
+/* package */ class FindDialog extends Dialog implements TextWatcher {
+    private WebView         mWebView;
+    private TextView        mMatches;
+    private BrowserActivity mBrowserActivity;
+    
+    // Views with which the user can interact.
+    private View            mOk;
+    private EditText        mEditText;
+    private View            mNextButton;
+    private View            mPrevButton;
+    private View            mMatchesView;
+
+    private View.OnClickListener mFindListener = new View.OnClickListener() {
+        public void onClick(View v) {
+            findNext();
+        }
+    };
+
+    private View.OnClickListener mFindCancelListener  = 
+            new View.OnClickListener() {
+        public void onClick(View v) {
+            dismiss();
+        }
+    };
+    
+    private View.OnClickListener mFindPreviousListener  = 
+            new View.OnClickListener() {
+        public void onClick(View v) {
+            if (mWebView == null) {
+                throw new AssertionError("No WebView for FindDialog::onClick");
+            }
+            mWebView.findNext(false);
+            hideSoftInput();
+        }
+    };
+
+    /*
+     * Remove the soft keyboard from the screen.
+     */
+    private void hideSoftInput() {
+        InputMethodManager imm = (InputMethodManager)
+                mBrowserActivity.getSystemService(Context.INPUT_METHOD_SERVICE);
+        imm.hideSoftInputFromWindow(mEditText.getWindowToken(), 0);
+    }
+
+    private void disableButtons() {
+        mPrevButton.setEnabled(false);
+        mNextButton.setEnabled(false);
+        mPrevButton.setFocusable(false);
+        mNextButton.setFocusable(false);
+    }
+
+    /* package */ void setWebView(WebView webview) {
+        mWebView = webview;
+    }
+
+    /* package */ FindDialog(BrowserActivity context) {
+        super(context, R.style.FindDialogTheme);
+        mBrowserActivity = context;
+        setCanceledOnTouchOutside(true);
+    }
+
+    /* package */ void onConfigurationChanged(Configuration newConfig) {
+        // FIXME: Would like to call mWebView.findAll again, so that the
+        // matches would refresh, but the new picture has not yet been
+        // created, so it is too soon.
+        mEditText.getText().clear();
+    }
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        Window theWindow = getWindow();
+        theWindow.setGravity(Gravity.BOTTOM|Gravity.FILL_HORIZONTAL);
+
+        setContentView(R.layout.browser_find);
+
+        theWindow.setLayout(ViewGroup.LayoutParams.FILL_PARENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT);
+
+        mEditText = (EditText) findViewById(R.id.edit);
+        
+        View button = findViewById(R.id.next);
+        button.setOnClickListener(mFindListener);
+        mNextButton = button;
+        
+        button = findViewById(R.id.previous);
+        button.setOnClickListener(mFindPreviousListener);
+        mPrevButton = button;
+        
+        button = findViewById(R.id.done);
+        button.setOnClickListener(mFindCancelListener);
+        mOk = button;
+        
+        mMatches = (TextView) findViewById(R.id.matches);
+        mMatchesView = findViewById(R.id.matches_view);
+        disableButtons();
+        theWindow.setSoftInputMode(
+                WindowManager.LayoutParams.SOFT_INPUT_STATE_VISIBLE);
+    }
+    
+    public void dismiss() {
+        super.dismiss();
+        mBrowserActivity.closeFind();
+        mWebView.clearMatches();
+    }
+    
+    @Override
+    public boolean dispatchKeyEvent(KeyEvent event) {
+        int code = event.getKeyCode();
+        boolean up = event.getAction() == KeyEvent.ACTION_UP;
+        switch (code) {
+            case KeyEvent.KEYCODE_DPAD_CENTER:
+            case KeyEvent.KEYCODE_ENTER:
+                if (!mEditText.hasFocus()) {
+                    break;
+                }
+                if (up) {
+                    findNext();
+                }
+                return true;
+            default:
+                break;
+        }
+        return super.dispatchKeyEvent(event);
+    }
+
+    private void findNext() {
+        if (mWebView == null) {
+            throw new AssertionError("No WebView for FindDialog::findNext");
+        }
+        mWebView.findNext(true);
+        hideSoftInput();
+    }
+
+    public void show() {
+        super.show();
+        mEditText.requestFocus();
+        mEditText.setText("");
+        Spannable span = (Spannable) mEditText.getText();
+        span.setSpan(this, 0, span.length(), 
+                     Spannable.SPAN_INCLUSIVE_INCLUSIVE);
+        mMatches.setText(R.string.zero);
+        disableButtons();
+    }
+    
+    // TextWatcher methods
+    public void beforeTextChanged(CharSequence s, 
+                                  int start, 
+                                  int count, 
+                                  int after) {
+    }
+    
+    public void onTextChanged(CharSequence s,  
+                              int start, 
+                              int before, 
+                              int count) {
+        if (mWebView == null) {
+            throw new AssertionError(
+                    "No WebView for FindDialog::onTextChanged");
+        }
+        CharSequence find = mEditText.getText();
+        if (0 == find.length()) {
+            disableButtons();
+            mWebView.clearMatches();
+            mMatchesView.setVisibility(View.INVISIBLE);
+        } else {
+            mMatchesView.setVisibility(View.VISIBLE);
+            int found = mWebView.findAll(find.toString());
+            mMatches.setText(Integer.toString(found));
+            if (found < 2) {
+                disableButtons();
+                if (found == 0) {
+                    mMatches.setText(R.string.zero);
+                }
+            } else {
+                mPrevButton.setFocusable(true);
+                mNextButton.setFocusable(true);
+                mPrevButton.setEnabled(true);
+                mNextButton.setEnabled(true);
+            }
+        }
+    }
+
+    public void afterTextChanged(Editable s) {
+    }
+}
diff --git a/src/com/android/browser/GearsBaseDialog.java b/src/com/android/browser/GearsBaseDialog.java
new file mode 100644
index 0000000..638ba27
--- /dev/null
+++ b/src/com/android/browser/GearsBaseDialog.java
@@ -0,0 +1,474 @@
+/*
+ * Copyright (C) 2008 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;
+
+import android.app.Activity;
+import android.app.Dialog;
+import android.content.Context;
+import android.content.res.Resources;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.os.Handler;
+import android.text.Spannable;
+import android.text.SpannableString;
+import android.text.style.UnderlineSpan;
+import android.util.Log;
+import android.view.InflateException;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Button;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import java.io.InputStream;
+import java.io.IOException;
+import java.lang.ClassCastException;
+import java.net.HttpURLConnection;
+import java.net.MalformedURLException;
+import java.net.URL;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ * Base dialog class for gears
+ */
+class GearsBaseDialog {
+
+  private static final String TAG = "GearsNativeDialog";
+  protected Handler mHandler;
+  protected Activity mActivity;
+  protected String mDialogArguments;
+
+  private Bitmap mIcon;
+  private final int MAX_ICON_SIZE = 64;
+  protected int mChoosenIconSize;
+
+  // Dialog closing types
+  public static final int CANCEL = 0;
+  public static final int ALWAYS_DENY = 1;
+  public static final int ALLOW = 2;
+  public static final int DENY = 3;
+  public static final int NEW_ICON = 4;
+  public static final int UPDATE_ICON = 5;
+  public static final int REQUEST_ICON = 6;
+  public static final int PAUSE_REQUEST_ICON = 7;
+  public static final int CLEAR_REQUEST_ICON = 8;
+
+  protected final String LOCAL_DATA_STRING = "localData";
+  protected final String LOCAL_STORAGE_STRING = "localStorage";
+  protected final String LOCATION_DATA_STRING = "locationData";
+
+  protected String mGearsVersion = "UNDEFINED";
+  protected boolean mDebug = false;
+
+  public GearsBaseDialog(Activity activity, Handler handler, String arguments) {
+    mActivity = activity;
+    mHandler = handler;
+    mDialogArguments = arguments;
+  }
+
+  Resources getResources() {
+    return mActivity.getResources();
+  }
+
+  Object getSystemService(String name) {
+    return mActivity.getSystemService(name);
+  }
+
+  View findViewById(int id) {
+    return mActivity.findViewById(id);
+  }
+
+  private String getString(int id) {
+    return mActivity.getString(id);
+  }
+
+  public void setDebug(boolean debug) {
+    mDebug = debug;
+  }
+
+  public void setGearsVersion(String version) {
+    mGearsVersion = version;
+  }
+
+  public String closeDialog(int closingType) {
+    return null;
+  }
+
+  /*
+   * Utility methods for setting up the dialogs elements
+   */
+
+  /**
+   * Inflate a given layout in a view (which has to be
+   * a ViewGroup, e.g. LinearLayout).
+   * This is used to share the basic dialog outline among
+   * the different dialog types.
+   */
+  void inflate(int layout, int viewID) {
+    LayoutInflater inflater = (LayoutInflater) getSystemService(
+        Context.LAYOUT_INFLATER_SERVICE);
+    View view = findViewById(viewID);
+    if (view != null) {
+      try {
+        ViewGroup viewGroup = (ViewGroup) view;
+        inflater.inflate(layout, viewGroup);
+      } catch (ClassCastException e) {
+        String msg = "exception, the view (" + view + ")";
+        msg += " is not a ViewGroup";
+        Log.e(TAG, msg, e);
+      } catch (InflateException e) {
+        Log.e(TAG, "exception while inflating the layout", e);
+      }
+    } else {
+      String msg = "problem, trying to inflate a non-existent view";
+      msg += " (" + viewID + ")";
+      Log.e(TAG, msg);
+    }
+  }
+
+  /**
+   * Button setup.
+   * Set the button's text and its listener. If the text resource's id
+   * is 0, makes the button invisible.
+   */
+  void setupButton(int buttonRscID,
+                   int rscString,
+                   View.OnClickListener listener,
+                   boolean isLink,
+                   boolean requestFocus) {
+    View view = findViewById(buttonRscID);
+    if (view == null) {
+      return;
+    }
+
+    Button button = (Button) view;
+
+    if (rscString == 0) {
+      button.setVisibility(View.GONE);
+    } else {
+      CharSequence text = getString(rscString);
+      button.setText(text);
+      button.setOnClickListener(listener);
+      if (isLink) {
+        displayAsLink(button);
+      }
+      if (requestFocus) {
+        button.requestFocus();
+      }
+    }
+  }
+
+  /**
+   * Button setup: as the above method, except that 'isLink' and
+   * 'requestFocus' default to false.
+   */
+  void setupButton(int buttonRsc, int rsc,
+                   View.OnClickListener listener) {
+    setupButton(buttonRsc, rsc, listener, false, false);
+  }
+
+  /**
+   * Utility method to setup the three dialog buttons.
+   */
+  void setupButtons(int alwaysDenyRsc, int allowRsc, int denyRsc) {
+    setupButton(R.id.button_alwaysdeny, alwaysDenyRsc,
+                new Button.OnClickListener() {
+                  public void onClick(View v) {
+                    mHandler.sendEmptyMessage(ALWAYS_DENY);
+                  }
+                });
+
+    setupButton(R.id.button_allow, allowRsc,
+                new Button.OnClickListener() {
+                  public void onClick(View v) {
+                    mHandler.sendEmptyMessage(ALLOW);
+                  }
+                });
+
+    setupButton(R.id.button_deny, denyRsc,
+                new Button.OnClickListener() {
+                  public void onClick(View v) {
+                    mHandler.sendEmptyMessage(DENY);
+                  }
+                });
+  }
+
+  /**
+   * Display a button as an HTML link. Remove the background, set the
+   * text color to R.color.dialog_link and draw an underline
+   */
+  void displayAsLink(Button button) {
+    if (button == null) {
+      return;
+    }
+
+    CharSequence text = button.getText();
+    button.setBackgroundDrawable(null);
+    int color = getResources().getColor(R.color.dialog_link);
+    button.setTextColor(color);
+    SpannableString str = new SpannableString(text);
+    str.setSpan(new UnderlineSpan(), 0, str.length(),
+                Spannable.SPAN_INCLUSIVE_INCLUSIVE);
+    button.setText(str);
+    button.setFocusable(false);
+  }
+
+  /**
+   * Utility method to set elements' text indicated in
+   * the dialogs' arguments.
+   */
+  void setLabel(JSONObject json, String name, int rsc) {
+    try {
+      if (json.has(name)) {
+        String text = json.getString(name);
+        View view = findViewById(rsc);
+        if (view != null && text != null) {
+          TextView textView = (TextView) view;
+          textView.setText(text);
+          textView.setVisibility(View.VISIBLE);
+        }
+      }
+    } catch (JSONException e) {
+      Log.e(TAG, "json exception", e);
+    }
+  }
+
+  /**
+   * Utility method to hide a view.
+   */
+  void hideView(View v, int rsc) {
+    if (rsc == 0) {
+      return;
+    }
+    View view;
+    if (v == null) {
+      view = findViewById(rsc);
+    } else {
+      view = v.findViewById(rsc);
+    }
+    if (view != null) {
+      view.setVisibility(View.GONE);
+    }
+  }
+
+  /**
+   * Utility method to show a view.
+   */
+  void showView(View v, int rsc) {
+    if (rsc == 0) {
+      return;
+    }
+    View view;
+    if (v == null) {
+      view = findViewById(rsc);
+    } else {
+      view = v.findViewById(rsc);
+    }
+    if (view != null) {
+      view.setVisibility(View.VISIBLE);
+    }
+  }
+
+  /**
+   * Utility method to set a text.
+   */
+  void setText(View v, int rsc, CharSequence text) {
+    if (rsc == 0) {
+      return;
+    }
+    View view = v.findViewById(rsc);
+    if (view != null) {
+      TextView textView = (TextView) view;
+      textView.setText(text);
+      textView.setVisibility(View.VISIBLE);
+    }
+  }
+
+  /**
+   * Utility method to set a text.
+   */
+  void setText(View v, int rsc, int txtRsc) {
+    if (rsc == 0) {
+      return;
+    }
+    View view = v.findViewById(rsc);
+    if (view != null) {
+      TextView textView = (TextView) view;
+      if (txtRsc == 0) {
+        textView.setVisibility(View.GONE);
+      } else {
+        CharSequence text = getString(txtRsc);
+        textView.setText(text);
+        textView.setVisibility(View.VISIBLE);
+      }
+    }
+  }
+
+  /**
+   * Utility class to download an icon in the background.
+   * Once done ask the UI thread to update the icon.
+   */
+  class IconDownload implements Runnable {
+    private String mUrlString;
+
+    IconDownload(String url) {
+      mUrlString = url;
+    }
+
+    public void run() {
+      if (mUrlString == null) {
+        return;
+      }
+      try {
+        URL url = new URL(mUrlString);
+        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
+        connection.setDoInput(true);
+        connection.connect();
+        int length = connection.getContentLength();
+        InputStream is = connection.getInputStream();
+        Bitmap customIcon = BitmapFactory.decodeStream(is);
+        if (customIcon != null) {
+          mIcon = customIcon;
+          mHandler.sendEmptyMessage(UPDATE_ICON);
+        }
+      } catch (ClassCastException e) {
+        Log.e(TAG, "Class cast exception (" + mUrlString + ")", e);
+      } catch (MalformedURLException e) {
+        Log.e(TAG, "Malformed url (" + mUrlString + ") ", e);
+      } catch (IOException e) {
+        Log.e(TAG, "Exception downloading icon (" + mUrlString + ") ", e);
+      }
+    }
+  }
+
+  /**
+   * Utility method to update the icon.
+   * Called on the UI thread.
+   */
+  public void updateIcon() {
+    if (mIcon == null) {
+      return;
+    }
+    View view = findViewById(R.id.origin_icon);
+    if (view != null) {
+      ImageView imageView = (ImageView) view;
+      imageView.setMaxHeight(MAX_ICON_SIZE);
+      imageView.setMaxWidth(MAX_ICON_SIZE);
+      imageView.setScaleType(ImageView.ScaleType.FIT_XY);
+      imageView.setImageBitmap(mIcon);
+      imageView.setVisibility(View.VISIBLE);
+    }
+  }
+
+  /**
+   * Utility method to download an icon from a url and set
+   * it to the GUI element R.id.origin_icon.
+   * It is used both in the shortcut dialog and the
+   * permission dialog.
+   * The actual download is done in the background via
+   * IconDownload; once the icon is downlowded the UI is updated
+   * via updateIcon().
+   * The icon size is included in the layout with the choosen
+   * size, although not displayed, to limit text reflow once
+   * the icon is received.
+   */
+  void downloadIcon(String url) {
+    if (url == null) {
+      return;
+    }
+    View view = findViewById(R.id.origin_icon);
+    if (view != null) {
+      view.setMinimumWidth(mChoosenIconSize);
+      view.setMinimumHeight(mChoosenIconSize);
+      view.setVisibility(View.INVISIBLE);
+    }
+    Thread thread = new Thread(new IconDownload(url));
+    thread.start();
+  }
+
+  /**
+   * Utility method that get the dialogMessage
+   * and icon and ask the setupDialog(message,icon)
+   * method to set the values.
+   */
+  public void setupDialog() {
+    TextView dialogMessage = null;
+    ImageView icon = null;
+
+    View view = findViewById(R.id.dialog_message);
+    if (view != null) {
+      dialogMessage = (TextView) view;
+    }
+
+    View iconView = findViewById(R.id.icon);
+    if (iconView != null) {
+      icon = (ImageView) iconView;
+    }
+
+    if ((dialogMessage != null) && (icon != null)) {
+      setupDialog(dialogMessage, icon);
+      dialogMessage.setVisibility(View.VISIBLE);
+    }
+  }
+
+  /*
+   * Set the message and icon of the dialog
+   */
+  public void setupDialog(TextView message, ImageView icon) {
+    message.setText(R.string.unrecognized_dialog_message);
+    icon.setImageResource(R.drawable.ic_dialog_menu_generic);
+    message.setVisibility(View.VISIBLE);
+  }
+
+  /**
+   * Setup the dialog
+   * By default, just display a simple message.
+   */
+  public void setup() {
+    setupButtons(0, 0, R.string.default_button);
+    setupDialog();
+  }
+
+  /**
+   * Method called when the back button is pressed,
+   * allowing the dialog to intercept the default behaviour.
+   */
+  public boolean handleBackButton() {
+    return false;
+  }
+
+  /**
+   * Returns the resource string of the notification displayed
+   * after the dialog. By default, does not return one.
+   */
+  public int notification() {
+    return 0;
+  }
+
+  /**
+   * If a secondary dialog (e.g. a confirmation dialog) is created,
+   * GearsNativeDialog will call this method.
+   */
+  public Dialog onCreateDialog(int id) {
+    // This should be redefined by subclasses as needed.
+    return null;
+  }
+
+}
diff --git a/src/com/android/browser/GearsNativeDialog.java b/src/com/android/browser/GearsNativeDialog.java
new file mode 100644
index 0000000..ecf166d
--- /dev/null
+++ b/src/com/android/browser/GearsNativeDialog.java
@@ -0,0 +1,280 @@
+/*
+ * Copyright (C) 2008 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;
+
+import android.app.Activity;
+import android.app.Dialog;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Message;
+import android.util.Config;
+import android.util.Log;
+import android.view.Gravity;
+import android.view.KeyEvent;
+import android.view.Window;
+import android.widget.BaseAdapter;
+import android.widget.Toast;
+
+import android.webkit.gears.NativeDialog;
+
+import com.android.browser.GearsBaseDialog;
+import com.android.browser.GearsPermissionsDialog;
+import com.android.browser.GearsSettingsDialog;
+
+/**
+ * Native dialog Activity used by gears
+ * TODO: rename in GearsNativeDialogActivity
+ * @hide
+ */
+public class GearsNativeDialog extends Activity {
+
+  private static final String TAG = "GearsNativeDialog";
+
+  private String mDialogArguments;
+
+  private String mGearsVersion = null;
+
+  private boolean mDebug = false;
+
+  private int mDialogType;
+  private final int SETTINGS_DIALOG = 1;
+  private final int PERMISSION_DIALOG = 2;
+  private final int LOCATION_DIALOG = 3;
+
+  private final String VERSION_STRING = "version";
+  private final String SETTINGS_DIALOG_STRING = "settings_dialog";
+  private final String PERMISSION_DIALOG_STRING = "permissions_dialog";
+  private final String LOCATION_DIALOG_STRING = "locations_dialog";
+
+  private boolean mDialogDismissed = false;
+
+  GearsBaseDialog dialog;
+
+  // Handler for callbacks to the UI thread
+  final Handler mHandler = new Handler() {
+    public void handleMessage(Message msg) {
+      if (msg.what == GearsBaseDialog.NEW_ICON) {
+        BaseAdapter adapter = (BaseAdapter) msg.obj;
+        adapter.notifyDataSetChanged();
+      } else if (msg.what == GearsBaseDialog.UPDATE_ICON) {
+        dialog.updateIcon();
+      } else if (msg.what == GearsBaseDialog.ALWAYS_DENY) {
+        closeDialog(GearsBaseDialog.ALWAYS_DENY);
+      } else if (msg.what == GearsBaseDialog.ALLOW) {
+        closeDialog(GearsBaseDialog.ALLOW);
+      } else if (msg.what == GearsBaseDialog.DENY) {
+        closeDialog(GearsBaseDialog.DENY);
+      }
+      super.handleMessage(msg);
+    }
+  };
+
+  @Override
+  public void onCreate(Bundle icicle) {
+    getArguments();
+    if (mDialogType == SETTINGS_DIALOG) {
+      setTheme(android.R.style.Theme);
+    }
+    super.onCreate(icicle);
+    if (mDialogType != SETTINGS_DIALOG) {
+      requestWindowFeature(Window.FEATURE_NO_TITLE);
+      setContentView(R.layout.gears_dialog);
+    }
+
+    switch (mDialogType) {
+      case SETTINGS_DIALOG:
+        dialog = new GearsSettingsDialog(this, mHandler, mDialogArguments);
+        dialog.setGearsVersion(mGearsVersion);
+        break;
+      case PERMISSION_DIALOG:
+        dialog = new GearsPermissionsDialog(this, mHandler, mDialogArguments);
+        break;
+      case LOCATION_DIALOG:
+        dialog = new GearsPermissionsDialog(this, mHandler, mDialogArguments);
+        break;
+      default:
+        dialog = new GearsBaseDialog(this, mHandler, mDialogArguments);
+    }
+    dialog.setDebug(mDebug);
+    dialog.setup();
+  }
+
+  /**
+   * Get the arguments for the dialog
+   *
+   * The dialog needs a json string as an argument, as
+   * well as a dialogType. In debug mode the arguments
+   * are mocked.
+   */
+  private void getArguments() {
+    if (mDebug) {
+      mDialogType = LOCATION_DIALOG +1;
+      mockArguments();
+
+      return;
+    }
+
+    Intent intent = getIntent();
+    mDialogArguments = intent.getStringExtra("dialogArguments");
+    String dialogTypeString = intent.getStringExtra("dialogType");
+    if (dialogTypeString == null) {
+      return;
+    }
+
+    if (Config.LOGV) {
+      Log.v(TAG, "dialogtype: " + dialogTypeString);
+    }
+
+    if (dialogTypeString.equalsIgnoreCase(SETTINGS_DIALOG_STRING)) {
+      mDialogType = SETTINGS_DIALOG;
+      mGearsVersion = intent.getStringExtra(VERSION_STRING);
+    } else if (dialogTypeString.equalsIgnoreCase(PERMISSION_DIALOG_STRING)) {
+      mDialogType = PERMISSION_DIALOG;
+    } else if (dialogTypeString.equalsIgnoreCase(LOCATION_DIALOG_STRING)) {
+      mDialogType = LOCATION_DIALOG;
+    }
+  }
+
+  /**
+   * Utility method for debugging the dialog.
+   *
+   * Set mock arguments.
+   */
+  private void mockArguments() {
+
+    String argumentsPermissions = "{ locale: \"en-US\", "
+        + "origin: \"http://www.google.com\", dialogType: \"localData\","
+        + "customIcon: \"http://google-gears.googlecode.com/"
+        + "svn/trunk/gears/test/manual/shortcuts/32.png\","
+        + "customName: \"My Application\","
+        + "customMessage: \"Press the button to enable my "
+        + "application to run offline!\" };";
+
+    String argumentsPermissions2 = "{ locale: \"en-US\", "
+        + "origin: \"http://www.google.com\", dialogType: \"localData\" };";
+
+    String argumentsLocation = "{ locale: \"en-US\", "
+        + "origin: \"http://www.google.com\", dialogType: \"locationData\","
+        + "customIcon: \"http://google-gears.googlecode.com/"
+        + "svn/trunk/gears/test/manual/shortcuts/32.png\","
+        + "customName: \"My Application\","
+        + "customMessage: \"Press the button to enable my "
+        + "application to run offline!\" };";
+
+    String argumentsSettings = "{ locale: \"en-US\", permissions: [ { "
+        + "name: \"http://www.google.com\", "
+        + "localStorage: { permissionState: 0 }, "
+        + "locationData: { permissionState: 1 } }, "
+        + "{ name: \"http://www.aaronboodman.com\", "
+        + "localStorage: { permissionState: 1 }, "
+        + "locationData: { permissionState: 2 } }, "
+        + "{ name: \"http://www.evil.org\", "
+        + "localStorage: { permissionState: 2 }, "
+        + "locationData: { permissionState: 2 } } ] }";
+
+    switch (mDialogType) {
+      case PERMISSION_DIALOG:
+        mDialogArguments = argumentsPermissions;
+        break;
+      case LOCATION_DIALOG:
+        mDialogArguments = argumentsLocation;
+        break;
+      case SETTINGS_DIALOG:
+        mDialogArguments = argumentsSettings;
+        break;
+    }
+  }
+
+  /**
+   * Close the dialog and set the return string value.
+   */
+  private void closeDialog(int closingType) {
+    String ret = dialog.closeDialog(closingType);
+
+    if (mDebug) {
+      Log.v(TAG, "closeDialog ret value: " + ret);
+    }
+
+    NativeDialog.closeDialog(ret);
+    notifyEndOfDialog();
+    finish();
+
+    // If the dialog sets a notification, we display it.
+    int notification = dialog.notification();
+    if (notification != 0) {
+      Toast toast = Toast.makeText(this, notification, Toast.LENGTH_LONG);
+      toast.setGravity(Gravity.BOTTOM, 0, 0);
+      toast.show();
+    }
+  }
+
+  @Override
+  public void onDestroy() {
+    super.onDestroy();
+    // In case we reach this point without
+    // notifying NativeDialog, we do it now.
+    if (!mDialogDismissed) {
+      notifyEndOfDialog();
+    }
+  }
+
+  @Override
+  public void onPause(){
+    super.onPause();
+    if (!mDialogDismissed) {
+      closeDialog(GearsBaseDialog.CANCEL);
+    }
+  }
+
+  /**
+   * Signal to NativeDialog that we are done.
+   */
+  private void notifyEndOfDialog() {
+    NativeDialog.signalFinishedDialog();
+    mDialogDismissed = true;
+  }
+
+  /**
+   * Intercepts the back key to immediately notify
+   * NativeDialog that we are done.
+   */
+  public boolean dispatchKeyEvent(KeyEvent event) {
+    if ((event.getKeyCode() == KeyEvent.KEYCODE_BACK)
+      && (event.getAction() == KeyEvent.ACTION_DOWN)) {
+      if (!dialog.handleBackButton()) {
+        // if the dialog doesn't do anything with the back button
+        closeDialog(GearsBaseDialog.CANCEL);
+      }
+      return true; // event consumed
+    }
+    return super.dispatchKeyEvent(event);
+  }
+
+  /**
+   * If the dialog call showDialog() on ourself, we let
+   * it handle the creation of this secondary dialog.
+   * It is used in GearsSettingsDialog, to create the confirmation
+   * dialog when the user click on "Remove this site from Gears"
+   */
+  @Override
+  protected Dialog onCreateDialog(int id) {
+    return dialog.onCreateDialog(id);
+  }
+
+}
diff --git a/src/com/android/browser/GearsPermissions.java b/src/com/android/browser/GearsPermissions.java
new file mode 100644
index 0000000..e48e045
--- /dev/null
+++ b/src/com/android/browser/GearsPermissions.java
@@ -0,0 +1,196 @@
+/*
+ * Copyright (C) 2008 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;
+
+import android.util.Log;
+
+import java.util.HashMap;
+import java.util.Iterator;
+
+/**
+ * The permission mechanism works the following way:
+ *
+ * PermissionType allows to define a type of permission
+ *   (e.g. localStorage/locationData), storing a name and a set of
+ *   resource ids corresponding to the GUI resources.
+ *
+ * Permission defines an actual permission instance, with a type and a value.
+ *
+ * OriginPermissions holds an origin with a set of Permission objects
+ */
+class GearsPermissions {
+
+  private static final String TAG = "GearsPermissions";
+
+  /**
+   * Defines a type of permission
+   *
+   * Store the permission's name (used in the json result)
+   * Graphically, each permission is a label followed by two radio buttons.
+   * We store the resources ids here.
+   */
+  public static class PermissionType {
+    public static final int PERMISSION_NOT_SET = 0;
+    public static final int PERMISSION_ALLOWED = 1;
+    public static final int PERMISSION_DENIED = 2;
+
+    String mName;
+    int mTitleRsc;
+    int mSubtitleOnRsc;
+    int mSubtitleOffRsc;
+
+    PermissionType(String name) {
+      mName = name;
+    }
+
+    public void setResources(int titleRsc,
+        int subtitleOnRsc, int subtitleOffRsc) {
+      mTitleRsc = titleRsc;
+      mSubtitleOnRsc = subtitleOnRsc;
+      mSubtitleOffRsc = subtitleOffRsc;
+    }
+
+    public String getName() {
+      return mName;
+    }
+
+    public int getTitleRsc() {
+      return mTitleRsc;
+    }
+
+    public int getSubtitleOnRsc() {
+      return mSubtitleOnRsc;
+    }
+
+    public int getSubtitleOffRsc() {
+      return mSubtitleOffRsc;
+    }
+
+  }
+
+  /**
+   * Simple class to store an instance of a permission
+   *
+   * i.e. a permission type and a value
+   * Value can be either PERMISSION_NOT_SET,
+   * PERMISSION_ALLOWED or PERMISSION_DENIED
+   * (defined in PermissionType).
+   */
+  public static class Permission {
+    PermissionType mType;
+    int mValue;
+
+    Permission(PermissionType type, int value) {
+      mType = type;
+      mValue = value;
+    }
+
+    Permission(PermissionType type) {
+      mType = type;
+      mValue = 0;
+    }
+
+    public PermissionType getType() {
+      return mType;
+    }
+
+    public void setValue(int value) {
+      mValue = value;
+    }
+
+    public int getValue() {
+      return mValue;
+    }
+  }
+
+  /**
+   * Interface used by the GearsNativeDialog implementation
+   * to listen to changes in the permissions.
+   */
+  public interface PermissionsChangesListener {
+    public boolean setPermission(PermissionType type, int perm);
+  }
+
+  /**
+   * Holds the model for an origin -- each origin has a set of
+   * permissions.
+   */
+  public static class OriginPermissions {
+    HashMap<PermissionType, Permission> mPermissions;
+    String mOrigin;
+    public static PermissionsChangesListener mListener;
+
+    public static void setListener(PermissionsChangesListener listener) {
+      mListener = listener;
+    }
+
+    OriginPermissions(String anOrigin) {
+      mOrigin = anOrigin;
+      mPermissions = new HashMap<PermissionType, Permission>();
+    }
+
+    OriginPermissions(OriginPermissions perms) {
+      mOrigin = perms.getOrigin();
+      mPermissions = new HashMap<PermissionType, Permission>();
+      HashMap<PermissionType, Permission> permissions = perms.getPermissions();
+      Iterator<PermissionType> iterator = permissions.keySet().iterator();
+      while (iterator.hasNext()) {
+        Permission permission = permissions.get(iterator.next());
+        int value = permission.getValue();
+        setPermission(permission.getType(), value);
+      }
+    }
+
+    public String getOrigin() {
+      return mOrigin;
+    }
+
+    public HashMap<PermissionType, Permission> getPermissions() {
+      return mPermissions;
+    }
+
+    public int getPermission(PermissionType type) {
+      return mPermissions.get(type).getValue();
+    }
+
+    public void setPermission(PermissionType type, int perm) {
+      if (mPermissions.get(type) == null) {
+        Permission permission = new Permission(type, perm);
+        mPermissions.put(type, permission);
+        return;
+      }
+
+      if (mListener != null) {
+        mListener.setPermission(type, perm);
+      }
+
+      mPermissions.get(type).setValue(perm);
+    }
+
+    public void print() {
+      Log.v(TAG, "Permissions for " + mOrigin);
+      Iterator<PermissionType> iterator = mPermissions.keySet().iterator();
+      while (iterator.hasNext()) {
+        Permission permission = mPermissions.get(iterator.next());
+        String name = permission.getType().getName();
+        int value = permission.getValue();
+        Log.v(TAG, "  " + name + ": " + value);
+      }
+    }
+  }
+
+}
diff --git a/src/com/android/browser/GearsPermissionsDialog.java b/src/com/android/browser/GearsPermissionsDialog.java
new file mode 100644
index 0000000..dbec363
--- /dev/null
+++ b/src/com/android/browser/GearsPermissionsDialog.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) 2008 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;
+
+import android.app.Activity;
+import android.os.Handler;
+import android.util.Log;
+import android.view.Gravity;
+import android.view.View;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ * Gears permission dialog
+ */
+class GearsPermissionsDialog extends GearsBaseDialog {
+
+  private static final String TAG = "GearsPermissionsDialog";
+
+  private String mDialogType;
+  private int mNotification = 0;
+
+  public GearsPermissionsDialog(Activity activity,
+                                Handler handler,
+                                String arguments) {
+    super (activity, handler, arguments);
+  }
+
+  public void setup() {
+    inflate(R.layout.gears_dialog_permission, R.id.panel_content);
+    setupButtons(R.string.permission_button_alwaysdeny,
+                 R.string.permission_button_allow,
+                 R.string.permission_button_deny);
+
+    try {
+      JSONObject json = new JSONObject(mDialogArguments);
+
+      if (json.has("dialogType")) {
+        mDialogType = json.getString("dialogType");
+        setupDialog();
+      }
+
+      if (!json.has("customName")) {
+        setLabel(json, "origin", R.id.origin_title);
+        View titleView = findViewById(R.id.origin_title);
+        if (titleView != null) {
+          TextView title = (TextView) titleView;
+          title.setGravity(Gravity.CENTER);
+        }
+      } else {
+        setLabel(json, "customName", R.id.origin_title);
+        setLabel(json, "origin", R.id.origin_subtitle);
+        setLabel(json, "customMessage", R.id.origin_message);
+      }
+
+      if (json.has("customIcon")) {
+        String iconUrl = json.getString("customIcon");
+        mChoosenIconSize = 32;
+        downloadIcon(iconUrl);
+      }
+
+      View msg = findViewById(R.id.permission_dialog_message);
+      if (msg != null) {
+        TextView dialogMessage = (TextView) msg;
+        if (mDialogType.equalsIgnoreCase(LOCAL_DATA_STRING)) {
+          dialogMessage.setText(R.string.query_data_message);
+        } else if (mDialogType.equalsIgnoreCase(LOCATION_DATA_STRING)) {
+          dialogMessage.setText(R.string.location_message);
+        }
+      }
+
+    } catch (JSONException e) {
+      Log.e(TAG, "JSON exception ", e);
+    }
+  }
+
+  public void setupDialog(TextView message, ImageView icon) {
+    if (mDialogType.equalsIgnoreCase(LOCAL_DATA_STRING)) {
+      message.setText(R.string.query_data_prompt);
+      icon.setImageResource(android.R.drawable.ic_popup_disk_full);
+    } else if (mDialogType.equalsIgnoreCase(LOCATION_DATA_STRING)) {
+      message.setText(R.string.location_prompt);
+      icon.setImageResource(R.drawable.ic_dialog_menu_generic);
+    }
+  }
+
+  public String closeDialog(int closingType) {
+    String ret = null;
+    switch (closingType) {
+      case ALWAYS_DENY:
+        ret = "{\"allow\": false, \"permanently\": true }";
+        if (mDialogType.equalsIgnoreCase(LOCAL_DATA_STRING)) {
+          mNotification = R.string.storage_notification_alwaysdeny;
+        } else if (mDialogType.equalsIgnoreCase(LOCATION_DATA_STRING)) {
+          mNotification = R.string.location_notification_alwaysdeny;
+        }
+        break;
+      case ALLOW:
+        ret = "{\"allow\": true, \"permanently\": true }";
+        if (mDialogType.equalsIgnoreCase(LOCAL_DATA_STRING)) {
+          mNotification = R.string.storage_notification;
+        } else if (mDialogType.equalsIgnoreCase(LOCATION_DATA_STRING)) {
+          mNotification = R.string.location_notification;
+        }
+        break;
+      case DENY:
+        ret = "{\"allow\": false, \"permanently\": false }";
+        break;
+    }
+    return ret;
+  }
+
+  public int notification() {
+    return mNotification;
+  }
+}
diff --git a/src/com/android/browser/GearsSettingsDialog.java b/src/com/android/browser/GearsSettingsDialog.java
new file mode 100644
index 0000000..5ea2342
--- /dev/null
+++ b/src/com/android/browser/GearsSettingsDialog.java
@@ -0,0 +1,460 @@
+/*
+ * Copyright (C) 2008 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;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.os.Handler;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ArrayAdapter;
+import android.widget.AdapterView;
+import android.widget.AdapterView.OnItemClickListener;
+import android.widget.BaseAdapter;
+import android.widget.Button;
+import android.widget.CheckBox;
+import android.widget.CompoundButton;
+import android.widget.ImageView;
+import android.widget.ListAdapter;
+import android.widget.ListView;
+import android.widget.RadioButton;
+import android.widget.TextView;
+
+import com.android.browser.GearsPermissions.OriginPermissions;
+import com.android.browser.GearsPermissions.Permission;
+import com.android.browser.GearsPermissions.PermissionsChangesListener;
+import com.android.browser.GearsPermissions.PermissionType;
+
+import java.util.Vector;
+import java.util.List;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ * Gears Settings dialog
+ */
+class GearsSettingsDialog extends GearsBaseDialog
+    implements PermissionsChangesListener {
+
+  private static final String TAG = "GearsPermissionsDialog";
+  private Vector<OriginPermissions> mSitesPermissions = null;
+  private Vector<OriginPermissions> mOriginalPermissions = null;
+  private Vector<OriginPermissions> mCurrentPermissions = null;
+
+  private Vector<PermissionType> mPermissions;
+  private static final int CONFIRMATION_REMOVE_DIALOG = 1;
+
+  // We declare the permissions globally to simplify the code
+  private final PermissionType LOCAL_STORAGE =
+      new PermissionType(LOCAL_STORAGE_STRING);
+  private final PermissionType LOCATION_DATA =
+      new PermissionType(LOCATION_DATA_STRING);
+
+  private boolean mChanges = false;
+
+  SettingsAdapter mListAdapter;
+
+  public GearsSettingsDialog(Activity activity,
+                             Handler handler,
+                             String arguments) {
+    super (activity, handler, arguments);
+    activity.setContentView(R.layout.gears_settings);
+  }
+
+  public void setup() {
+    // First let's add the permissions' resources
+    LOCAL_STORAGE.setResources(R.string.settings_storage_title,
+                               R.string.settings_storage_subtitle_on,
+                               R.string.settings_storage_subtitle_off);
+    LOCATION_DATA.setResources(R.string.settings_location_title,
+                               R.string.settings_location_subtitle_on,
+                               R.string.settings_location_subtitle_off);
+    // add the permissions to the list of permissions.
+    mPermissions = new Vector<PermissionType>();
+    mPermissions.add(LOCAL_STORAGE);
+    mPermissions.add(LOCATION_DATA);
+    OriginPermissions.setListener(this);
+
+
+    setupDialog();
+
+    // We manage the permissions using three vectors, mSitesPermissions,
+    // mOriginalPermissions and mCurrentPermissions.
+    // The dialog's arguments are parsed and a list of permissions is
+    // generated and stored in those three vectors.
+    // mOriginalPermissions is a separate copy and will not be modified;
+    // mSitesPermissions contains the current permissions _only_ --
+    // if an origin is removed, it is also removed from mSitesPermissions.
+    // Finally, mCurrentPermissions contains the current permissions and
+    // is a clone of mSitesPermissions, but removed sites aren't removed,
+    // their permissions are simply set to PERMISSION_NOT_SET. This
+    // allows us to easily generate the final difference between the
+    // original permissions and the final permissions, while directly
+    // using mSitesPermissions for the listView adapter (SettingsAdapter).
+
+    mSitesPermissions = new Vector<OriginPermissions>();
+    mOriginalPermissions = new Vector<OriginPermissions>();
+
+    try {
+      JSONObject json = new JSONObject(mDialogArguments);
+      if (json.has("permissions")) {
+        JSONArray jsonArray = json.getJSONArray("permissions");
+        for (int i = 0; i < jsonArray.length(); i++) {
+          JSONObject infos = jsonArray.getJSONObject(i);
+          String name = null;
+          int localStorage = PermissionType.PERMISSION_NOT_SET;
+          int locationData = PermissionType.PERMISSION_NOT_SET;
+          if (infos.has("name")) {
+            name = infos.getString("name");
+          }
+          if (infos.has(LOCAL_STORAGE_STRING)) {
+            JSONObject perm = infos.getJSONObject(LOCAL_STORAGE_STRING);
+            if (perm.has("permissionState")) {
+              localStorage = perm.getInt("permissionState");
+            }
+          }
+          if (infos.has(LOCATION_DATA_STRING)) {
+            JSONObject perm = infos.getJSONObject(LOCATION_DATA_STRING);
+            if (perm.has("permissionState")) {
+              locationData = perm.getInt("permissionState");
+            }
+          }
+          OriginPermissions perms = new OriginPermissions(name);
+          perms.setPermission(LOCAL_STORAGE, localStorage);
+          perms.setPermission(LOCATION_DATA, locationData);
+
+          mSitesPermissions.add(perms);
+          mOriginalPermissions.add(new OriginPermissions(perms));
+        }
+      }
+    } catch (JSONException e) {
+      Log.e(TAG, "JSON exception ", e);
+    }
+    mCurrentPermissions = (Vector<OriginPermissions>)mSitesPermissions.clone();
+
+    View listView = findViewById(R.id.sites_list);
+    if (listView != null) {
+      ListView list = (ListView) listView;
+      mListAdapter = new SettingsAdapter(mActivity, mSitesPermissions);
+      list.setAdapter(mListAdapter);
+      list.setScrollBarStyle(android.view.View.SCROLLBARS_OUTSIDE_INSET);
+      list.setOnItemClickListener(mListAdapter);
+    }
+    if (mDebug) {
+      printPermissions();
+    }
+  }
+
+  private void setMainTitle() {
+    String windowTitle = mActivity.getString(R.string.pref_extras_gears_settings);
+    mActivity.setTitle(windowTitle);
+  }
+
+  public void setupDialog() {
+    setMainTitle();
+  }
+
+  /**
+   * GearsPermissions.PermissionsChangesListener delegate
+   */
+  public boolean setPermission(PermissionType type, int perm) {
+    if (mChanges == false) {
+      mChanges = true;
+    }
+    return mChanges;
+  }
+
+  public boolean handleBackButton() {
+    return mListAdapter.backButtonPressed();
+  }
+
+  /**
+   * We use this to create a confirmation dialog when the user
+   * clicks on "remove this site from gears"
+   */
+  public Dialog onCreateDialog(int id) {
+    return new AlertDialog.Builder(mActivity)
+        .setTitle(R.string.settings_confirmation_remove_title)
+        .setMessage(R.string.settings_confirmation_remove)
+        .setPositiveButton(android.R.string.ok,
+                           new AlertDialog.OnClickListener() {
+          public void onClick(DialogInterface dlg, int which) {
+            mListAdapter.removeCurrentSite();
+          }
+        })
+        .setNegativeButton(android.R.string.cancel, null)
+        .setIcon(android.R.drawable.ic_dialog_alert)
+        .create();
+  }
+
+  /**
+   * Adapter class for the list view in the settings dialog
+   *
+   * We first display a list of all the origins (sites), or
+   * a message saying that no permission is set if the list is empty.
+   * When the user click on one of the origin, we then display
+   * the list of the permissions existing for that origin.
+   * Each permission can be either allowed or denied by clicking
+   * on the checkbox.
+   * The last row is a special case, allowing to remove the entire origin.
+   */
+  class SettingsAdapter extends BaseAdapter
+      implements AdapterView.OnItemClickListener {
+    private Activity mContext;
+    private List mItems;
+    private OriginPermissions mCurrentSite;
+    private Vector mCurrentPermissions;
+    private int MAX_ROW_HEIGHT = 64;
+
+    SettingsAdapter(Activity context, List items) {
+      mContext = context;
+      mItems = items;
+      mCurrentSite = null;
+    }
+
+    public int getCount() {
+      if (mCurrentSite == null) {
+        int size = mItems.size();
+        if (size == 0) {
+          return 1;
+        } else {
+          return size;
+        }
+      }
+      return mCurrentPermissions.size() + 1;
+    }
+
+    public long getItemId(int position) {
+      return position;
+    }
+
+    private String shortName(String url) {
+        // We remove the http and https prefix
+        if (url.startsWith("http://")) {
+          return url.substring(7);
+        }
+        if (url.startsWith("https://")) {
+          return url.substring(8);
+        }
+        return url;
+    }
+
+    public Object getItem(int position) {
+      if (mCurrentSite == null) {
+        if (mItems.size() == 0) {
+          return null;
+        } else {
+          return mItems.get(position);
+        }
+      }
+      return mCurrentPermissions.get(position);
+    }
+
+    public View getView(int position, View convertView, ViewGroup parent) {
+      View row = convertView;
+      if (row == null) { // no cached view, we create one
+        LayoutInflater inflater = (LayoutInflater) getSystemService(
+            Context.LAYOUT_INFLATER_SERVICE);
+        row = inflater.inflate(R.layout.gears_settings_row, null);
+      }
+      row.setMinimumHeight(MAX_ROW_HEIGHT);
+
+      if (mCurrentSite == null) {
+        if (mItems.size() == 0) {
+          hideView(row, R.id.title);
+          hideView(row, R.id.subtitle);
+          hideView(row, R.id.checkbox);
+          hideView(row, R.id.icon);
+          setText(row, R.id.info, R.string.settings_empty);
+        } else {
+          hideView(row, R.id.subtitle);
+          hideView(row, R.id.info);
+          hideView(row, R.id.checkbox);
+          OriginPermissions perms = (OriginPermissions) mItems.get(position);
+          setText(row, R.id.title, shortName(perms.getOrigin()));
+          showView(row, R.id.icon);
+        }
+      } else {
+        if (position == getCount() - 1) {
+          // last position: "remove this site from gears"
+          hideView(row, R.id.subtitle);
+          hideView(row, R.id.info);
+          hideView(row, R.id.checkbox);
+          hideView(row, R.id.icon);
+          setText(row, R.id.title, R.string.settings_remove_site);
+        } else {
+          hideView(row, R.id.info);
+          hideView(row, R.id.icon);
+          showView(row, R.id.checkbox);
+
+          PermissionType type =
+              (PermissionType) mCurrentPermissions.get(position);
+          setText(row, R.id.title, type.getTitleRsc());
+
+          View checkboxView = row.findViewById(R.id.checkbox);
+          if (checkboxView != null) {
+            CheckBox checkbox = (CheckBox) checkboxView;
+            int perm = mCurrentSite.getPermission(type);
+            if (perm == PermissionType.PERMISSION_DENIED) {
+              setText(row, R.id.subtitle, type.getSubtitleOffRsc());
+              checkbox.setChecked(false);
+            } else {
+              setText(row, R.id.subtitle, type.getSubtitleOnRsc());
+              checkbox.setChecked(true);
+            }
+          }
+        }
+      }
+      return row;
+    }
+
+    public void removeCurrentSite() {
+      mCurrentSite.setPermission(LOCAL_STORAGE,
+                                 PermissionType.PERMISSION_NOT_SET);
+      mCurrentSite.setPermission(LOCATION_DATA,
+                                 PermissionType.PERMISSION_NOT_SET);
+      mSitesPermissions.remove(mCurrentSite);
+      mCurrentSite = null;
+      setMainTitle();
+      notifyDataSetChanged();
+    }
+
+    public void onItemClick(AdapterView<?> parent,
+                            View view,
+                            int position,
+                            long id) {
+      if (mItems.size() == 0) {
+        return;
+      }
+      if (mCurrentSite == null) {
+         mCurrentSite = (OriginPermissions) mItems.get(position);
+         mCurrentPermissions = new Vector();
+         for (int i = 0; i < mPermissions.size(); i++) {
+           PermissionType type = mPermissions.get(i);
+           int perm = mCurrentSite.getPermission(type);
+           if (perm != PermissionType.PERMISSION_NOT_SET) {
+             mCurrentPermissions.add(type);
+           }
+         }
+         mContext.setTitle(shortName(mCurrentSite.getOrigin()));
+      } else {
+        if (position == getCount() - 1) { // last item (remove site)
+          // Ask the user to confirm
+          // If yes, removeCurrentSite() will be called via the dialog callback.
+          mActivity.showDialog(CONFIRMATION_REMOVE_DIALOG);
+        } else {
+          PermissionType type =
+              (PermissionType) mCurrentPermissions.get(position);
+          if (mCurrentSite.getPermission(type) ==
+              PermissionType.PERMISSION_ALLOWED) {
+            mCurrentSite.setPermission(type, PermissionType.PERMISSION_DENIED);
+          } else {
+            mCurrentSite.setPermission(type, PermissionType.PERMISSION_ALLOWED);
+          }
+        }
+      }
+      notifyDataSetChanged();
+    }
+
+    public boolean backButtonPressed() {
+      if (mCurrentSite != null) { // we intercept the back button
+        mCurrentSite = null;
+        setMainTitle();
+        notifyDataSetChanged();
+        return true;
+      }
+      return false;
+    }
+
+  }
+
+  /**
+   * Utility method used in debug mode to print the list of
+   * permissions (original values and current values).
+   */
+  public void printPermissions() {
+    Log.v(TAG, "Original Permissions: ");
+    for (int i = 0; i < mOriginalPermissions.size(); i++) {
+      OriginPermissions p = mOriginalPermissions.get(i);
+      p.print();
+    }
+    Log.v(TAG, "Current Permissions: ");
+    for (int i = 0; i < mSitesPermissions.size(); i++) {
+      OriginPermissions p = mSitesPermissions.get(i);
+      p.print();
+    }
+  }
+
+  /**
+   * Computes the difference between the original permissions and the
+   * current ones. Returns a json-formatted string.
+   * It is used by the Settings dialog.
+   */
+  public String computeDiff(boolean modif) {
+    String ret = null;
+    try {
+      JSONObject results = new JSONObject();
+      JSONArray permissions = new JSONArray();
+
+      for (int i = 0; modif && i < mOriginalPermissions.size(); i++) {
+        OriginPermissions original = mOriginalPermissions.get(i);
+        OriginPermissions current = mCurrentPermissions.get(i);
+        JSONObject permission = new JSONObject();
+        boolean modifications = false;
+
+        for (int j = 0; j < mPermissions.size(); j++) {
+          PermissionType type = mPermissions.get(j);
+
+          if (current.getPermission(type) != original.getPermission(type)) {
+            JSONObject state = new JSONObject();
+            state.put("permissionState", current.getPermission(type));
+            permission.put(type.getName(), state);
+            modifications = true;
+          }
+        }
+
+        if (modifications) {
+          permission.put("name", current.getOrigin());
+          permissions.put(permission);
+        }
+      }
+      results.put("modifiedOrigins", permissions);
+      ret = results.toString();
+    } catch (JSONException e) {
+      Log.e(TAG, "JSON exception ", e);
+    }
+    return ret;
+  }
+
+  public String closeDialog(int closingType) {
+    String ret = computeDiff(mChanges);
+
+    if (mDebug) {
+      printPermissions();
+    }
+
+    return ret;
+  }
+
+}
diff --git a/src/com/android/browser/HistoryItem.java b/src/com/android/browser/HistoryItem.java
new file mode 100644
index 0000000..55e43f0
--- /dev/null
+++ b/src/com/android/browser/HistoryItem.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright (C) 2008 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;
+
+import android.content.ContentResolver;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.graphics.Bitmap;
+import android.net.Uri;
+import android.provider.Browser;
+import android.util.Log;
+import android.view.View;
+import android.webkit.WebIconDatabase;
+import android.widget.CompoundButton;
+import android.widget.ImageView;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import java.util.Date;
+
+/**
+ *  Layout representing a history item in the classic history viewer.
+ */
+/* package */ class HistoryItem extends BookmarkItem {
+
+    private CompoundButton  mStar;      // Star for bookmarking
+    private CompoundButton.OnCheckedChangeListener  mListener;
+    /**
+     *  Create a new HistoryItem.
+     *  @param context  Context for this HistoryItem.
+     */
+    /* package */ HistoryItem(Context context) {
+        super(context);
+
+        mStar = (CompoundButton) findViewById(R.id.star);
+        mStar.setVisibility(View.VISIBLE);
+        mListener = new CompoundButton.OnCheckedChangeListener() {
+            public void onCheckedChanged(CompoundButton buttonView,
+                    boolean isChecked) {
+                ContentResolver cr = mContext.getContentResolver();
+                Cursor cursor = cr.query(
+                        Browser.BOOKMARKS_URI,
+                        Browser.HISTORY_PROJECTION,
+                        "url = ?",
+                        new String[] { mUrl },
+                        null);
+                boolean first = cursor.moveToFirst();
+                // Should be in the database no matter what
+                if (!first) {
+                    throw new AssertionError("URL is not in the database!");
+                }
+                if (isChecked) {
+                    // Add to bookmarks
+                    // FIXME: Share code with AddBookmarkPage.java
+                    ContentValues map = new ContentValues();
+                    map.put(Browser.BookmarkColumns.CREATED,
+                            new Date().getTime());
+                    map.put(Browser.BookmarkColumns.TITLE, getName());
+                    map.put(Browser.BookmarkColumns.BOOKMARK, 1);
+                    try {
+                        cr.update(Browser.BOOKMARKS_URI, map, 
+                                "_id = " + cursor.getInt(0), null);
+                    } catch (IllegalStateException e) {
+                        Log.e("HistoryItem", "no database!");
+                    }
+                    WebIconDatabase.getInstance().retainIconForPageUrl(mUrl);
+                    // catch IllegalStateException?
+                    Toast.makeText(mContext, R.string.added_to_bookmarks,
+                            Toast.LENGTH_LONG).show();
+                } else {
+                    // Remove from bookmarks
+                    // FIXME: This code should be shared with
+                    // BrowserBookmarksAdapter.java
+                    WebIconDatabase.getInstance().releaseIconForPageUrl(mUrl);
+                    Uri uri = ContentUris.withAppendedId(Browser.BOOKMARKS_URI,
+                            cursor.getInt(Browser.HISTORY_PROJECTION_ID_INDEX));
+                    // It is no longer a bookmark, but it is still a visited
+                    // site.
+                    ContentValues values = new ContentValues();
+                    values.put(Browser.BookmarkColumns.BOOKMARK, 0);
+                    try {
+                        cr.update(uri, values, null, null);
+                    } catch (IllegalStateException e) {
+                        Log.e("HistoryItem", "no database!");
+                    }
+                    Toast.makeText(mContext, R.string.removed_from_bookmarks,
+                            Toast.LENGTH_LONG).show();
+                }
+                cursor.deactivate();
+            }
+        };
+    }
+    
+    void copyTo(HistoryItem item) {
+        item.mTextView.setText(mTextView.getText());
+        item.mUrlText.setText(mUrlText.getText());
+        item.setIsBookmark(mStar.isChecked());
+        item.mImageView.setImageDrawable(mImageView.getDrawable());
+    }
+
+    /**
+     *  Set whether or not this represents a bookmark, and make sure the star
+     *  behaves appropriately.
+     */
+    void setIsBookmark(boolean isBookmark) {
+        mStar.setOnCheckedChangeListener(null);
+        mStar.setChecked(isBookmark);
+        mStar.setOnCheckedChangeListener(mListener);
+    }
+}
diff --git a/src/com/android/browser/ImageAdapter.java b/src/com/android/browser/ImageAdapter.java
new file mode 100644
index 0000000..b4c1209
--- /dev/null
+++ b/src/com/android/browser/ImageAdapter.java
@@ -0,0 +1,291 @@
+/*
+ * Copyright (C) 2008 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;
+
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.res.Configuration;
+import android.content.res.Resources;
+import android.database.DataSetObserver;
+import android.graphics.Color;
+import android.view.KeyEvent;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.LayoutInflater;
+import android.webkit.WebView;
+import android.widget.ImageView;
+import android.widget.ListAdapter;
+import android.widget.TextView;
+
+import java.util.ArrayList;
+
+/**
+ * Adapter used by ImageGrid.
+ */
+public class ImageAdapter implements ListAdapter {
+    
+    ArrayList<TabControl.Tab> mItems;  // Items shown in the grid
+    private ArrayList<DataSetObserver> mDataObservers; // Data change listeners
+    private Context mContext;  // Context to use to inflate views
+    private boolean mMaxedOut;
+    private ImageGrid mImageGrid;
+    private boolean mIsLive;
+    private int mTabHeight;
+
+    ImageAdapter(Context context, ImageGrid grid, boolean live) {
+        mContext = context;
+        mIsLive = live;
+        mItems = new ArrayList<TabControl.Tab>();
+        mImageGrid = grid;
+        mDataObservers = new ArrayList<DataSetObserver>();
+    }
+
+    void heightChanged(int newHeight) {
+        mTabHeight = newHeight;
+    }
+
+    /**
+     *  Whether the adapter is at its limit, determined by TabControl.MAX_TABS
+     *
+     *  @return True if the number of Tabs represented in this Adapter is at its
+     *          maximum.
+     */
+    public boolean maxedOut() {
+        return mMaxedOut;
+    }
+
+    /**
+     * Clear the internal WebViews and remove their picture listeners.
+     */
+    public void clear() {
+        for (TabControl.Tab t : mItems) {
+            clearPictureListeners(t);
+        }
+        mItems.clear();
+        notifyObservers();
+    }
+
+    private void clearPictureListeners(TabControl.Tab t) {
+        if (t.getWebView() != null) {
+            t.getWebView().setPictureListener(null);
+            if (t.getSubWebView() != null) {
+                t.getSubWebView().setPictureListener(null);
+            }
+        }
+    }
+
+    /**
+     * Add a new window web page to the grid
+     * 
+     * @param t The tab to display
+     */
+    public void add(TabControl.Tab t) {
+        if (mMaxedOut) {
+            return;
+        }
+        mItems.add(t);
+        notifyObservers();
+        if (mItems.size() == TabControl.MAX_TABS) {
+            mMaxedOut = true;
+        }
+    }
+    
+    /**
+     * Remove a window from the list. At this point, the window
+     * has already gone. It just needs to be removed from the screen
+     * 
+     * @param index window to remove
+     */
+    public void remove(int index) {
+        if (index >= 0 && index < mItems.size()) {
+            clearPictureListeners(mItems.remove(index));
+            notifyObservers();
+            mMaxedOut = false;
+        }
+    }
+
+    /* (non-Javadoc)
+     * @see android.widget.ListAdapter#areAllItemsSelectable()
+     */
+    public boolean areAllItemsEnabled() {
+        return true;
+    }
+
+    /* (non-Javadoc)
+     * @see android.widget.ListAdapter#isSelectable(int)
+     */
+    public boolean isEnabled(int position) {
+        if (position >= 0 && position <= mItems.size()) {
+            return true;
+        }
+        return false;
+    }
+
+    /* (non-Javadoc)
+     * @see android.widget.Adapter#getCount()
+     */
+    public int getCount() {
+        // Include the New Window button if we have not reached the tab limit
+        if (!mMaxedOut) {
+            return mItems.size()+1;
+        }
+        return mItems.size();
+    }
+
+    /* (non-Javadoc)
+     * @see android.widget.Adapter#getItem(int)
+     */
+    public Object getItem(int position) {
+        if (!mMaxedOut) {
+            if (0 == position) {
+                return null;
+            }
+            return mItems.get(position);
+        }
+        return mItems.get(position);
+    }
+
+    /* (non-Javadoc)
+     * @see android.widget.Adapter#getItemId(int)
+     */
+    public long getItemId(int position) {
+        return position;
+    }
+
+    /* (non-Javadoc)
+     * @see android.widget.Adapter#getView(int, android.view.View, 
+     * android.view.ViewGroup)
+     */
+    public View getView(int position, View convertView, ViewGroup parent) {
+        View v = null;
+        if (convertView != null) {
+            v = convertView;
+        } else {
+            LayoutInflater factory = LayoutInflater.from(mContext);
+            v = factory.inflate(R.layout.tabitem, null);
+        }
+        FakeWebView img = (FakeWebView) v.findViewById(R.id.icon);
+        ImageView close = (ImageView) v.findViewById(R.id.close);
+        TextView tv = (TextView) v.findViewById(R.id.label);
+
+        // position needs to be in the range of Tab indices.
+        if (!mMaxedOut) {
+            position--;
+        }
+
+        // Create the View for actual tabs
+        if (position != ImageGrid.NEW_TAB) {
+            TabControl.Tab t = mItems.get(position);
+            img.setTab(t);
+            tv.setText(t.getTitle());
+            // Do not put the 'X' if the tab picker isn't "live" (meaning the
+            // user cannot click on a tab)
+            if (!mIsLive) {
+                close.setVisibility(View.GONE);
+            } else {
+                close.setVisibility(View.VISIBLE);
+                final int pos = position;
+                close.setOnClickListener(new View.OnClickListener() {
+                        public void onClick(View v) {
+                            ImageAdapter.this.confirmClose(pos);
+                        }
+                    });
+            }
+        } else {
+            img.setBackgroundColor(Color.BLACK);
+            img.setImageResource(R.drawable.ic_new_window);
+            img.setScaleType(ImageView.ScaleType.CENTER);
+            img.setPadding(0, 0, 0, 34);
+            tv.setText(R.string.new_window);
+            close.setVisibility(View.GONE);
+        }
+        ViewGroup.LayoutParams lp = img.getLayoutParams();
+        if (lp.height != mTabHeight) {
+            lp.height = mTabHeight;
+            img.requestLayout();
+        }
+        return v;
+    }
+
+    /*
+     * Pop a confirmation dialog to the user asking if they want to close this
+     * tab.
+     */
+    private void confirmClose(final int position) {
+        final ImageGrid.Listener l = mImageGrid.getListener();
+        if (l == null) {
+            return;
+        }
+        DialogInterface.OnClickListener confirm =
+                new DialogInterface.OnClickListener() {
+                    public void onClick(DialogInterface dialog,
+                            int whichButton) {
+                        l.remove(position);
+                    }
+                };
+        new AlertDialog.Builder(mContext)
+                .setTitle(R.string.close)
+                .setIcon(android.R.drawable.ic_dialog_alert)
+                .setMessage(R.string.close_window)
+                .setPositiveButton(R.string.ok, confirm)
+                .setNegativeButton(R.string.cancel, null)
+                .show();
+    }
+
+    /* (non-Javadoc)
+     * @see android.widget.Adapter#registerDataSetObserver(android.database.DataSetObserver)
+     */
+    public void registerDataSetObserver(DataSetObserver observer) {
+        mDataObservers.add(observer);
+    }
+
+    /* (non-Javadoc)
+     * @see android.widget.Adapter#hasStableIds()
+     */
+    public boolean hasStableIds() {
+        return true;
+    }
+
+    /* (non-Javadoc)
+     * @see android.widget.Adapter#unregisterDataSetObserver(android.database.DataSetObserver)
+     */
+    public void unregisterDataSetObserver(DataSetObserver observer) {
+        mDataObservers.remove(observer);
+    }
+
+    /**
+     * Notify all the observers that a change has happened.
+     */
+    void notifyObservers() {
+        for (DataSetObserver observer : mDataObservers) {
+            observer.onChanged();
+        }
+    }
+
+    public int getItemViewType(int position) {
+        return 0;
+    }
+
+    public int getViewTypeCount() {
+        return 1;
+    }
+
+    public boolean isEmpty() {
+        return getCount() == 0;
+    }
+}
diff --git a/src/com/android/browser/ImageGrid.java b/src/com/android/browser/ImageGrid.java
new file mode 100644
index 0000000..9eccb16
--- /dev/null
+++ b/src/com/android/browser/ImageGrid.java
@@ -0,0 +1,233 @@
+/*
+ * Copyright (C) 2008 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;
+
+import android.content.Context;
+import android.util.Config;
+import android.view.ContextMenu;
+import android.view.ContextMenu.ContextMenuInfo;
+import android.view.KeyEvent;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.View.OnCreateContextMenuListener;
+import android.webkit.WebView;
+import android.widget.AdapterView;
+import android.widget.AdapterView.OnItemClickListener;
+import android.widget.GridView;
+
+/**
+ * This class implements a Grid layout of Views for the Tab picker.
+ */
+class ImageGrid extends GridView implements OnItemClickListener, 
+        OnCreateContextMenuListener  {
+    
+    private Listener     mListener;
+    private ImageAdapter mAdapter;
+    private boolean      mIsLive;
+    private static final int SPACING = 10;
+    public static final int CANCEL  = -99;
+    public static final int NEW_TAB = -1;
+
+    /**
+     * Constructor
+     * @param context Context to use when inflating resources.
+     * @param live  TRUE if the view can accept touch or click
+     * @param l     Listener to respond to clicks etc.
+     */
+    public ImageGrid(Context context, boolean live, Listener l) {
+        super(context);
+
+        mIsLive = live;
+        if (live) {
+            setFocusable(true);
+            setFocusableInTouchMode(true);
+            setOnItemClickListener(this);
+            setOnCreateContextMenuListener(this);
+        }
+        mListener = l;
+
+        mAdapter = new ImageAdapter(context, this, live);
+        setAdapter(mAdapter);
+
+        setBackgroundColor(0xFF000000);
+
+        setVerticalSpacing(SPACING);
+        setHorizontalSpacing(SPACING);
+        setNumColumns(2);
+        setStretchMode(GridView.STRETCH_COLUMN_WIDTH);
+        setSelector(android.R.drawable.gallery_thumb);
+    }
+
+    @Override
+    public boolean dispatchKeyEvent(KeyEvent event) {
+        // We always consume the BACK key even if mListener is null or the
+        // ImageGrid is not "live." This prevents crashes during tab animations
+        // if the user presses BACK.
+        if ((event.getAction() == KeyEvent.ACTION_DOWN) &&
+                (event.getKeyCode() == KeyEvent.KEYCODE_BACK)) {
+            if (mListener != null && mIsLive) {
+                mListener.onClick(CANCEL);
+                invalidate();
+            }
+            return true;
+        }
+        return super.dispatchKeyEvent(event);
+    }
+    
+    /**
+     * Called by BrowserActivity to add a new window to the tab picker.
+     * This does not happen dynamically, this only happens during view
+     * setup.
+     * 
+     * @param v Webview of the tab to add
+     * @param name Web page title
+     * @param url URL of the webpage
+     */
+    public void add(TabControl.Tab t) {
+        mAdapter.add(t);
+    }
+
+    /**
+     * Called by BrowserActivity when a window has been removed from the
+     * tab list.
+     * 
+     * @param index Window to remove, from 0 to MAX_TABS-1
+     */
+    public void remove(int index) {
+        if (Config.DEBUG && (index < 0 || index >= TabControl.MAX_TABS)) {
+            throw new AssertionError();
+        }
+        mAdapter.remove(index);
+    }
+
+    /**
+     * Request focus to initially set to a particular tab. 
+     *
+     * @param startingIndex This is a Tab index from 0 - MAX_TABS-1 and does not
+     *                      include the "New Tab" cell.
+     */
+    public void setCurrentIndex(int startingIndex) {
+        if (!mAdapter.maxedOut()) {
+            startingIndex++;
+        }
+        setSelection(startingIndex);
+    }
+
+    public Listener getListener() {
+        return mListener;
+    }
+
+    public void setListener(Listener l) {
+        mListener = l;
+    }
+
+    /**
+     * Return true if the ImageGrid is live. This means that tabs can be chosen
+     * and the menu can be invoked.
+     */
+    public boolean isLive() {
+        return mIsLive;
+    }
+
+    /**
+     * Do some internal cleanup of the ImageGrid's adapter.
+     */
+    public void clear() {
+        mAdapter.clear();
+    }
+
+    /* (non-Javadoc)
+     * @see android.widget.AdapterView.OnItemClickListener#onItemClick(android.widget.AdapterView, android.view.View, int, long)
+     */
+    public void onItemClick(AdapterView parent, View v, int position, long id) {
+        if (!mAdapter.maxedOut()) {
+            position--;
+        }
+        // Position will be -1 for the "New Tab" cell.
+        if (mListener != null) {
+            mListener.onClick(position);
+        }
+    }
+    
+    /* (non-Javadoc)
+     * @see android.view.View.OnCreateContextMenuListener#onCreateContextMenu(android.view.ContextMenu, android.view.View, java.lang.Object)
+     */
+    public void onCreateContextMenu(ContextMenu menu, View v, 
+            ContextMenuInfo menuInfo) {
+        // Do not create the context menu if there is no listener or the Tab
+        // overview is not "live."
+        if (mListener == null || !mIsLive) {
+            return;
+        }
+        AdapterView.AdapterContextMenuInfo info = 
+                (AdapterView.AdapterContextMenuInfo) menuInfo;
+        boolean maxed = mAdapter.maxedOut();
+        if (info.position > 0 || maxed) {
+            MenuInflater inflater = new MenuInflater(mContext);
+            inflater.inflate(R.menu.tabscontext, menu);
+            int position = info.position;
+            if (!maxed) {
+                position--;
+            }
+            menu.setHeaderTitle(mAdapter.mItems.get(position).getTitle());
+        }
+    }
+
+    // convert a context menu position to an actual tab position. Since context
+    // menus are not created for the "New Tab" cell, this will always return a
+    // valid tab position.
+    public int getContextMenuPosition(MenuItem menu) {
+        AdapterView.AdapterContextMenuInfo info =
+                (AdapterView.AdapterContextMenuInfo) menu.getMenuInfo();
+        int pos = info.position;
+        if (!mAdapter.maxedOut()) {
+            pos--;
+        }
+        return pos;
+    }
+    
+    @Override
+    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+        // Called when our orientation changes. Tell the adapter about the new
+        // size. Compute the individual tab height by taking the grid height
+        // and subtracting the SPACING. Then subtract the list padding twice
+        // (once for each tab on screen) and divide the remaining height by 2.
+        int tabHeight = (h - SPACING
+                - 2 * (getListPaddingTop() + getListPaddingBottom())) / 2;
+        mAdapter.heightChanged(tabHeight);
+        super.onSizeChanged(w, h, oldw, oldh);
+    }
+
+    /**
+     * Listener to be notified by behavior of ImageGrid.
+     */
+    public interface Listener {
+        /**
+         * Called when enter is pressed on the list.
+         * @param position  The index of the selected image when
+         *                  enter is pressed.
+         */
+        void onClick(int position);
+
+        /**
+         * Called when remove is called on the grid.
+         */
+        void remove(int position);
+    }
+
+}
diff --git a/src/com/android/browser/KeyTracker.java b/src/com/android/browser/KeyTracker.java
new file mode 100644
index 0000000..344e4f8
--- /dev/null
+++ b/src/com/android/browser/KeyTracker.java
@@ -0,0 +1,107 @@
+/*
+ * 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;
+
+import android.view.KeyEvent;
+import android.view.ViewConfiguration;
+
+class KeyTracker {
+
+    public enum Stage {
+        DOWN,           //!< the key has just been pressed
+        SHORT_REPEAT,   //!< repeated key, but duration is under the long-press threshold
+        LONG_REPEAT,    //!< repeated key, but duration is over the long-press threshold
+        UP              //!< the key is being released
+    }
+    
+    public enum State {
+        KEEP_TRACKING,  //!< return this to continue to track the key
+        DONE_TRACKING,  //!< return this if you handled the key, but need not track it anymore
+        NOT_TRACKING    //!< return this if you will not handle this key
+    }
+    
+    public interface OnKeyTracker {
+
+        /** Called whenever there is a key event [down, short/long repeat, up]
+            @param keyCode  The current keyCode (see KeyEvent class)
+            @param msg      The message associated with the keyCode
+            @maram stage    The state the key press is in [down, short/long repeat, up]
+            @param duration The number of milliseconds since this key was initially pressed
+            @return your state after seeing the key. If you return DONE_TRACKING or NOT_TRACKING,
+                    you will not be called again for the lifetime of this key event.
+        */
+        public State onKeyTracker(int keyCode, KeyEvent event, Stage stage, int duration);
+    }
+    
+    public KeyTracker(OnKeyTracker tracker) {
+        mTracker = tracker;
+    }
+    
+    public boolean doKeyDown(int keyCode, KeyEvent event) {
+        long now = System.currentTimeMillis();
+        Stage stage = null;
+
+        // check if its a new/different key
+        if (mKeyCode != keyCode || event.getRepeatCount() == 0) {
+            mKeyCode = keyCode;
+            mStartMS = now;
+            stage = Stage.DOWN;
+        }
+        else if (mState == State.KEEP_TRACKING) {
+            stage = (now - mStartMS) >= LONG_PRESS_DURATION_MS ? Stage.LONG_REPEAT : Stage.SHORT_REPEAT;
+        }
+
+        if (stage != null) {
+            mEvent = event;        
+            callTracker(stage, now);
+        }
+
+        return mState != State.NOT_TRACKING;
+    }
+    
+    public boolean doKeyUp(int keyCode, KeyEvent event) {
+        boolean handled = false;
+
+        if (mState == State.KEEP_TRACKING && mKeyCode == keyCode) {
+            mEvent = event;
+            callTracker(Stage.UP, System.currentTimeMillis());
+            handled = mState != State.NOT_TRACKING;
+        }
+        mKeyCode = NOT_A_KEYCODE;
+        return handled;
+    }
+    
+    private void callTracker(Stage stage, long now) {
+        mState = mTracker.onKeyTracker(mKeyCode, mEvent, stage, (int)(now - mStartMS));
+    }
+    
+    private void dump() {
+        System.out.println(" key=" + mKeyCode + " dur=" + (System.currentTimeMillis() - mStartMS) +
+                            " state=" + mState);
+    }
+
+    private int             mKeyCode = NOT_A_KEYCODE;
+    private KeyEvent        mEvent;
+    private long            mStartMS;
+    private State           mState;
+    private OnKeyTracker    mTracker;
+
+    private static final int LONG_PRESS_DURATION_MS = 
+            ViewConfiguration.getLongPressTimeout();
+    private static final int NOT_A_KEYCODE = -123456;
+}
+
diff --git a/src/com/android/browser/MostVisitedActivity.java b/src/com/android/browser/MostVisitedActivity.java
new file mode 100644
index 0000000..704ee27
--- /dev/null
+++ b/src/com/android/browser/MostVisitedActivity.java
@@ -0,0 +1,199 @@
+/*
+ * Copyright (C) 2009 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;
+
+import android.app.Activity;
+import android.app.ListActivity;
+import android.content.Intent;
+import android.database.ContentObserver;
+import android.database.Cursor;
+import android.database.DataSetObserver;
+import android.graphics.Bitmap;
+import android.os.Bundle;
+import android.os.Handler;
+import android.provider.Browser;
+import android.webkit.WebIconDatabase.IconListener;
+import android.widget.ListAdapter;
+import android.widget.ListView;
+import android.widget.SimpleCursorAdapter;
+import android.widget.TextView;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewGroup.LayoutParams;
+
+import java.util.Vector;
+
+public class MostVisitedActivity extends ListActivity {
+
+    private MyAdapter   mAdapter;
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        mAdapter = new MyAdapter();
+        CombinedBookmarkHistoryActivity.getIconListenerSet(getContentResolver())
+                .addListener(new IconReceiver());
+        setListAdapter(mAdapter);
+        ListView list = getListView();
+        LayoutInflater factory = LayoutInflater.from(this);
+        View v = factory.inflate(R.layout.empty_history, null);
+        addContentView(v, new LayoutParams(LayoutParams.FILL_PARENT,
+                LayoutParams.FILL_PARENT));
+        list.setEmptyView(v);
+    }
+
+    private class IconReceiver implements IconListener {
+        public void onReceivedIcon(String url, Bitmap icon) {
+            setListAdapter(mAdapter);
+        }
+    }
+
+    protected void onListItemClick(ListView l, View v, int position, long id) {
+        TextView tv = (TextView) v.findViewById(R.id.url);
+        String url = tv.getText().toString();
+        loadUrl(url, false);
+    }
+
+    private void loadUrl(String url, boolean newWindow) {
+        Intent intent = new Intent().setAction(url);
+        if (newWindow) {
+            Bundle b = new Bundle();
+            b.putBoolean("new_window", true);
+            intent.putExtras(b);
+        }
+        setResultToParent(RESULT_OK, intent);
+        finish();
+    }
+
+    private class MyAdapter implements ListAdapter {
+        private Vector<DataSetObserver> mObservers;
+        private Cursor mCursor;
+        // These correspond with projection below.
+        private final int mUrlIndex = 0;
+        private final int mTitleIndex = 1;
+        private final int mBookmarkIndex = 2;
+
+        MyAdapter() {
+            mObservers = new Vector<DataSetObserver>();
+            String[] projection = new String[] {
+                    Browser.BookmarkColumns.URL,
+                    Browser.BookmarkColumns.TITLE,
+                    Browser.BookmarkColumns.BOOKMARK };
+            String whereClause = Browser.BookmarkColumns.VISITS + " != 0";
+            String orderBy = Browser.BookmarkColumns.VISITS + " DESC";
+            mCursor = managedQuery(Browser.BOOKMARKS_URI, projection,
+                    whereClause, null, orderBy);
+            mCursor.registerContentObserver(new ChangeObserver());
+        }
+
+        private class ChangeObserver extends ContentObserver {
+            public ChangeObserver() {
+                super(new Handler());
+            }
+
+            @Override
+            public boolean deliverSelfNotifications() {
+                return true;
+            }
+
+            @Override
+            public void onChange(boolean selfChange) {
+                MyAdapter.this.refreshData();
+            }
+        }
+
+        void refreshData() {
+            mCursor.requery();
+            for (DataSetObserver o : mObservers) {
+                o.onChanged();
+            }
+        }
+
+        public View getView(int position, View convertView, ViewGroup parent) {
+            HistoryItem item;
+            if (null == convertView) {
+                item = new HistoryItem(MostVisitedActivity.this);
+            } else {
+                item = (HistoryItem) convertView;
+            }
+            mCursor.moveToPosition(position);
+            item.setName(mCursor.getString(mTitleIndex));
+            String url = mCursor.getString(mUrlIndex);
+            item.setUrl(url);
+            item.setFavicon(CombinedBookmarkHistoryActivity.getIconListenerSet(
+                    getContentResolver()).getFavicon(url));
+            item.setIsBookmark(1 == mCursor.getInt(mBookmarkIndex));
+            return item;
+        }
+
+        public boolean areAllItemsEnabled() {
+            return true;
+        }
+
+        public boolean isEnabled(int position) {
+            return true;
+        }
+
+        public int getCount() {
+            return mCursor.getCount();
+        }
+
+        public Object getItem(int position) {
+            return null;
+        }
+
+        public long getItemId(int position) {
+            return position;
+        }
+
+        // Always a HistoryItem
+        public int getItemViewType(int position) {
+            return 0;
+        }
+
+        public int getViewTypeCount() {
+            return 1;
+        }
+
+        public boolean hasStableIds() {
+            return true;
+        }
+
+        public void registerDataSetObserver(DataSetObserver observer) {
+            mObservers.add(observer);
+        }
+
+        public void unregisterDataSetObserver(DataSetObserver observer) {
+            mObservers.remove(observer);
+        }
+
+        public boolean isEmpty() {
+            return getCount() == 0;
+        }
+    }
+
+    // This Activity is generally a sub-Activity of CombinedHistoryActivity. In
+    // that situation, we need to pass our result code up to our parent.
+    // However, if someone calls this Activity directly, then this has no
+    // parent, and it needs to set it on itself.
+    private void setResultToParent(int resultCode, Intent data) {
+        Activity a = getParent() == null ? this : getParent();
+        a.setResult(resultCode, data);
+    }
+}
+
diff --git a/src/com/android/browser/TabControl.java b/src/com/android/browser/TabControl.java
new file mode 100644
index 0000000..2f39302
--- /dev/null
+++ b/src/com/android/browser/TabControl.java
@@ -0,0 +1,937 @@
+/*
+ * Copyright (C) 2007 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;
+
+import android.content.Context;
+import android.net.http.SslError;
+import android.os.Bundle;
+import android.os.Message;
+import android.util.Config;
+import android.util.Log;
+import android.view.Gravity;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.View.OnClickListener;
+import android.webkit.HttpAuthHandler;
+import android.webkit.JsPromptResult;
+import android.webkit.JsResult;
+import android.webkit.SslErrorHandler;
+import android.webkit.WebBackForwardList;
+import android.webkit.WebChromeClient;
+import android.webkit.WebHistoryItem;
+import android.webkit.WebView;
+import android.webkit.WebViewClient;
+import android.widget.FrameLayout;
+import android.widget.ImageButton;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Vector;
+
+class TabControl {
+    // Log Tag
+    private static final String LOGTAG = "TabControl";
+    // Maximum number of tabs.
+    static final int MAX_TABS = 8;
+    // Static instance of an empty callback.
+    private static final WebViewClient mEmptyClient =
+            new WebViewClient();
+    // Instance of BackgroundChromeClient for background tabs.
+    private final BackgroundChromeClient mBackgroundChromeClient =
+            new BackgroundChromeClient();
+    // Private array of WebViews that are used as tabs.
+    private ArrayList<Tab> mTabs = new ArrayList<Tab>(MAX_TABS);
+    // Queue of most recently viewed tabs.
+    private ArrayList<Tab> mTabQueue = new ArrayList<Tab>(MAX_TABS);
+    // Current position in mTabs.
+    private int mCurrentTab = -1;
+    // A private instance of BrowserActivity to interface with when adding and
+    // switching between tabs.
+    private final BrowserActivity mActivity;
+    // Inflation service for making subwindows.
+    private final LayoutInflater mInflateService;
+    // Subclass of WebViewClient used in subwindows to notify the main
+    // WebViewClient of certain WebView activities.
+    private class SubWindowClient extends WebViewClient {
+        // The main WebViewClient.
+        private final WebViewClient mClient;
+
+        SubWindowClient(WebViewClient client) {
+            mClient = client;
+        }
+        @Override
+        public void doUpdateVisitedHistory(WebView view, String url,
+                boolean isReload) {
+            mClient.doUpdateVisitedHistory(view, url, isReload);
+        }
+        @Override
+        public boolean shouldOverrideUrlLoading(WebView view, String url) {
+            return mClient.shouldOverrideUrlLoading(view, url);
+        }
+        @Override
+        public void onReceivedSslError(WebView view, SslErrorHandler handler,
+                SslError error) {
+            mClient.onReceivedSslError(view, handler, error);
+        }
+        @Override
+        public void onReceivedHttpAuthRequest(WebView view,
+                HttpAuthHandler handler, String host, String realm) {
+            mClient.onReceivedHttpAuthRequest(view, handler, host, realm);
+        }
+        @Override
+        public void onFormResubmission(WebView view, Message dontResend,
+                Message resend) {
+            mClient.onFormResubmission(view, dontResend, resend);
+        }
+        @Override
+        public void onReceivedError(WebView view, int errorCode,
+                String description, String failingUrl) {
+            mClient.onReceivedError(view, errorCode, description, failingUrl);
+        }
+    }
+    // Subclass of WebChromeClient to display javascript dialogs.
+    private class SubWindowChromeClient extends WebChromeClient {
+        // This subwindow's tab.
+        private final Tab mTab;
+        // The main WebChromeClient.
+        private final WebChromeClient mClient;
+
+        SubWindowChromeClient(Tab t, WebChromeClient client) {
+            mTab = t;
+            mClient = client;
+        }
+        @Override
+        public void onProgressChanged(WebView view, int newProgress) {
+            mClient.onProgressChanged(view, newProgress);
+        }
+        @Override
+        public boolean onCreateWindow(WebView view, boolean dialog,
+                boolean userGesture, android.os.Message resultMsg) {
+            return mClient.onCreateWindow(view, dialog, userGesture, resultMsg);
+        }
+        @Override
+        public void onCloseWindow(WebView window) {
+            if (Config.DEBUG && window != mTab.mSubView) {
+                throw new AssertionError("Can't close the window");
+            }
+            mActivity.dismissSubWindow(mTab);
+        }
+    }
+    // Background WebChromeClient for focusing tabs
+    private class BackgroundChromeClient extends WebChromeClient {
+        @Override
+        public void onRequestFocus(WebView view) {
+            Tab t = getTabFromView(view);
+            if (t != getCurrentTab()) {
+                mActivity.showTab(t);
+            }
+        }
+    }
+
+    /**
+     * Private class for maintaining Tabs with a main WebView and a subwindow.
+     */
+    public class Tab {
+        // Main WebView
+        private WebView mMainView;
+        // Subwindow WebView
+        private WebView mSubView;
+        // Subwindow container
+        private View mSubViewContainer;
+        // Subwindow callback
+        private SubWindowClient mSubViewClient;
+        // Subwindow chrome callback
+        private SubWindowChromeClient mSubViewChromeClient;
+        // Saved bundle for when we are running low on memory. It contains the
+        // information needed to restore the WebView if the user goes back to
+        // the tab.
+        private Bundle mSavedState;
+        // Extra saved information for displaying the tab in the picker.
+        private String mUrl;
+        private String mTitle;
+ 
+        // Parent Tab. This is the Tab that created this Tab, or null
+        // if the Tab was created by the UI
+        private Tab mParentTab;
+        // Tab that constructed by this Tab. This is used when this
+        // Tab is destroyed, it clears all mParentTab values in the 
+        // children.
+        private Vector<Tab> mChildTabs;
+
+        private Boolean mCloseOnExit;
+
+        // Construct a new tab
+        private Tab(WebView w, boolean closeOnExit) {
+            mMainView = w;
+            mCloseOnExit = closeOnExit;
+        }
+
+        /**
+         * Return the top window of this tab; either the subwindow if it is not
+         * null or the main window.
+         * @return The top window of this tab.
+         */
+        public WebView getTopWindow() {
+            if (mSubView != null) {
+                return mSubView;
+            }
+            return mMainView;
+        }
+
+        /**
+         * Return the main window of this tab. Note: if a tab is freed in the
+         * background, this can return null. It is only guaranteed to be 
+         * non-null for the current tab.
+         * @return The main WebView of this tab.
+         */
+        public WebView getWebView() {
+            return mMainView;
+        }
+
+        /**
+         * Return the subwindow of this tab or null if there is no subwindow.
+         * @return The subwindow of this tab or null.
+         */
+        public WebView getSubWebView() {
+            return mSubView;
+        }
+
+        /**
+         * Return the subwindow container of this tab or null if there is no
+         * subwindow.
+         * @return The subwindow's container View.
+         */
+        public View getSubWebViewContainer() {
+            return mSubViewContainer;
+        }
+
+        /**
+         * Get the url of this tab.  Valid after calling populatePickerData, but
+         * before calling wipePickerData, or if the webview has been destroyed.
+         * 
+         * @return The WebView's url or null.
+         */
+        public String getUrl() {
+            return mUrl;
+        }
+
+        /**
+         * Get the title of this tab.  Valid after calling populatePickerData, 
+         * but before calling wipePickerData, or if the webview has been 
+         * destroyed.  If the url has no title, use the url instead.
+         * 
+         * @return The WebView's title (or url) or null.
+         */
+        public String getTitle() {
+            return mTitle;
+        }
+
+        private void setParentTab(Tab parent) {
+            mParentTab = parent;
+            // This tab may have been freed due to low memory. If that is the
+            // case, the parent tab index is already saved. If we are changing
+            // that index (most likely due to removing the parent tab) we must
+            // update the parent tab index in the saved Bundle.
+            if (mSavedState != null) {
+                if (parent == null) {
+                    mSavedState.remove(PARENTTAB);
+                } else {
+                    mSavedState.putInt(PARENTTAB, getTabIndex(parent));
+                }
+            }
+        }
+        
+        /**
+         * When a Tab is created through the content of another Tab, then 
+         * we associate the Tabs. 
+         * @param child the Tab that was created from this Tab
+         */
+        public void addChildTab(Tab child) {
+            if (mChildTabs == null) {
+                mChildTabs = new Vector<Tab>();
+            }
+            mChildTabs.add(child);
+            child.setParentTab(this);
+        }
+        
+        private void removeFromTree() {
+            // detach the children
+            if (mChildTabs != null) {
+                for(Tab t : mChildTabs) {
+                    t.setParentTab(null);
+                }
+            }
+            
+            // Find myself in my parent list
+            if (mParentTab != null) {
+                mParentTab.mChildTabs.remove(this);
+            }
+        }
+        
+        /**
+         * If this Tab was created through another Tab, then this method
+         * returns that Tab.
+         * @return the Tab parent or null
+         */
+        public Tab getParentTab() {
+            return mParentTab;
+        }
+
+        /**
+         * Return whether this tab should be closed when it is backing out of
+         * the first page.
+         * @return TRUE if this tab should be closed when exit.
+         */
+        public boolean closeOnExit() {
+            return mCloseOnExit;
+        }
+    };
+
+    // Directory to store thumbnails for each WebView.
+    private final File mThumbnailDir;
+
+    /**
+     * Construct a new TabControl object that interfaces with the given
+     * BrowserActivity instance.
+     * @param activity A BrowserActivity instance that TabControl will interface
+     *                 with.
+     */
+    TabControl(BrowserActivity activity) {
+        mActivity = activity;
+        mInflateService =
+                ((LayoutInflater) activity.getSystemService(
+                        Context.LAYOUT_INFLATER_SERVICE));
+        mThumbnailDir = activity.getDir("thumbnails", 0);
+    }
+
+    File getThumbnailDir() {
+        return mThumbnailDir;
+    }
+
+    BrowserActivity getBrowserActivity() {
+        return mActivity;
+    }
+
+    /**
+     * Return the current tab's main WebView. This will always return the main
+     * WebView for a given tab and not a subwindow.
+     * @return The current tab's WebView.
+     */
+    WebView getCurrentWebView() {
+        Tab t = getTab(mCurrentTab);
+        if (t == null) {
+            return null;
+        }
+        return t.mMainView;
+    }
+
+    /**
+     * Return the current tab's top-level WebView. This can return a subwindow
+     * if one exists.
+     * @return The top-level WebView of the current tab.
+     */
+    WebView getCurrentTopWebView() {
+        Tab t = getTab(mCurrentTab);
+        if (t == null) {
+            return null;
+        }
+        return t.mSubView != null ? t.mSubView : t.mMainView;
+    }
+
+    /**
+     * Return the current tab's subwindow if it exists.
+     * @return The subwindow of the current tab or null if it doesn't exist.
+     */
+    WebView getCurrentSubWindow() {
+        Tab t = getTab(mCurrentTab);
+        if (t == null) {
+            return null;
+        }
+        return t.mSubView;
+    }
+
+    /**
+     * Return the tab at the specified index.
+     * @return The Tab for the specified index or null if the tab does not
+     *         exist.
+     */
+    Tab getTab(int index) {
+        if (index >= 0 && index < mTabs.size()) {
+            return mTabs.get(index);
+        }
+        return null;
+    }
+
+    /**
+     * Return the current tab.
+     * @return The current tab.
+     */
+    Tab getCurrentTab() {
+        return getTab(mCurrentTab);
+    }
+
+    /**
+     * Return the current tab index.
+     * @return The current tab index
+     */
+    int getCurrentIndex() {
+        return mCurrentTab;
+    }
+    
+    /**
+     * Given a Tab, find it's index
+     * @param Tab to find
+     * @return index of Tab or -1 if not found
+     */
+    int getTabIndex(Tab tab) {
+        return mTabs.indexOf(tab);
+    }
+
+    /**
+     * Create a new tab and display the new tab immediately.
+     * @return The newly createTab or null if we have reached the maximum
+     *         number of open tabs.
+     */
+    Tab createNewTab(boolean closeOnExit) {
+        int size = mTabs.size();
+        // Return false if we have maxed out on tabs
+        if (MAX_TABS == size) {
+            return null;
+        }
+        // Create a new WebView
+        WebView w = new WebView(mActivity);
+        w.setMapTrackballToArrowKeys(false); // use trackball directly
+        // Add this WebView to the settings observer list and update the
+        // settings
+        final BrowserSettings s = BrowserSettings.getInstance();
+        s.addObserver(w.getSettings()).update(s, null);
+        // Create a new tab and add it to the tab list
+        Tab t = new Tab(w, closeOnExit);
+        mTabs.add(t);
+        return t;
+    }
+
+    /**
+     * Remove the tab from the list. If the tab is the current tab shown, the
+     * last created tab will be shown.
+     * @param t The tab to be removed.
+     */
+    boolean removeTab(Tab t) {
+        if (t == null) {
+            return false;
+        }
+        // Only remove the tab if it is the current one.
+        if (getCurrentTab() == t) {
+            putTabInBackground(t);
+        }
+
+        // Only destroy the WebView if it still exists.
+        if (t.mMainView != null) {
+            // Take down the sub window.
+            dismissSubWindow(t);
+            // Remove the WebView's settings from the BrowserSettings list of
+            // observers.
+            BrowserSettings.getInstance().deleteObserver(
+                    t.mMainView.getSettings());
+            // Destroy the main view and subview
+            t.mMainView.destroy();
+            t.mMainView = null;
+        }
+        // clear it's references to parent and children
+        t.removeFromTree();
+        
+        // Remove it from our list of tabs.
+        mTabs.remove(t);
+
+        // The tab indices have shifted, update all the saved state so we point
+        // to the correct index.
+        for (Tab tab : mTabs) {
+            if (tab.mChildTabs != null) {
+                for (Tab child : tab.mChildTabs) {
+                    child.setParentTab(tab);
+                }
+            }
+        }
+
+
+        // This tab may have been pushed in to the background and then closed.
+        // If the saved state contains a picture file, delete the file.
+        if (t.mSavedState != null) {
+            if (t.mSavedState.containsKey("picture")) {
+                new File(t.mSavedState.getString("picture")).delete();
+            }
+        }
+
+        // Remove it from the queue of viewed tabs.
+        mTabQueue.remove(t);
+        mCurrentTab = -1;
+        return true;
+    }
+
+    /**
+     * Clear the back/forward list for all the current tabs.
+     */
+    void clearHistory() {
+        int size = getTabCount();
+        for (int i = 0; i < size; i++) {
+            Tab t = mTabs.get(i);
+            // TODO: if a tab is freed due to low memory, its history is not
+            // cleared here.
+            if (t.mMainView != null) {
+                t.mMainView.clearHistory();
+            }
+            if (t.mSubView != null) {
+                t.mSubView.clearHistory();
+            }
+        }
+    }
+
+    /**
+     * Destroy all the tabs and subwindows
+     */
+    void destroy() {
+        BrowserSettings s = BrowserSettings.getInstance();
+        for (Tab t : mTabs) {
+            if (t.mMainView != null) {
+                dismissSubWindow(t);
+                s.deleteObserver(t.mMainView.getSettings());
+                t.mMainView.destroy();
+                t.mMainView = null;
+            }
+        }
+        mTabs.clear();
+        mTabQueue.clear();
+    }
+
+    /**
+     * Returns the number of tabs created.
+     * @return The number of tabs created.
+     */
+    int getTabCount() {
+        return mTabs.size();
+    }
+
+    // Used for saving and restoring each Tab
+    private static final String WEBVIEW = "webview";
+    private static final String NUMTABS = "numTabs";
+    private static final String CURRTAB = "currentTab";
+    private static final String CURRURL = "currentUrl";
+    private static final String CURRTITLE = "currentTitle";
+    private static final String CLOSEONEXIT = "closeonexit";
+    private static final String PARENTTAB = "parentTab";
+
+    /**
+     * Save the state of all the Tabs.
+     * @param outState The Bundle to save the state to.
+     */
+    void saveState(Bundle outState) {
+        final int numTabs = getTabCount();
+        outState.putInt(NUMTABS, numTabs);
+        final int index = getCurrentIndex();
+        outState.putInt(CURRTAB, (index >= 0 && index < numTabs) ? index : 0);
+        for (int i = 0; i < numTabs; i++) {
+            final Tab t = getTab(i);
+            if (saveState(t)) {
+                outState.putBundle(WEBVIEW + i, t.mSavedState);
+            }
+        }
+    }
+
+    /**
+     * Restore the state of all the tabs.
+     * @param inState The saved state of all the tabs.
+     * @return True if there were previous tabs that were restored. False if
+     *         there was no saved state or restoring the state failed.
+     */
+    boolean restoreState(Bundle inState) {
+        final int numTabs = (inState == null)
+                ? -1 : inState.getInt(NUMTABS, -1);
+        if (numTabs == -1) {
+            return false;
+        } else {
+            final int currentTab = inState.getInt(CURRTAB, -1);
+            for (int i = 0; i < numTabs; i++) {
+                if (i == currentTab) {
+                    Tab t = createNewTab(false);
+                    // Me must set the current tab before restoring the state
+                    // so that all the client classes are set.
+                    setCurrentTab(t);
+                    if (!restoreState(inState.getBundle(WEBVIEW + i), t)) {
+                        Log.w(LOGTAG, "Fail in restoreState, load home page.");
+                        t.mMainView.loadUrl(BrowserSettings.getInstance()
+                                .getHomePage());
+                    }
+                } else {
+                    // Create a new tab and don't restore the state yet, add it
+                    // to the tab list
+                    Tab t = new Tab(null, false);
+                    t.mSavedState = inState.getBundle(WEBVIEW + i);
+                    if (t.mSavedState != null) {
+                        t.mUrl = t.mSavedState.getString(CURRURL);
+                        t.mTitle = t.mSavedState.getString(CURRTITLE);
+                    }
+                    mTabs.add(t);
+                    mTabQueue.add(t);
+                }
+            }
+            // Rebuild the tree of tabs. Do this after all tabs have been
+            // created/restored so that the parent tab exists.
+            for (int i = 0; i < numTabs; i++) {
+                final Bundle b = inState.getBundle(WEBVIEW + i);
+                final Tab t = getTab(i);
+                if (b != null && t != null) {
+                    final int parentIndex = b.getInt(PARENTTAB, -1);
+                    if (parentIndex != -1) {
+                        final Tab parent = getTab(parentIndex);
+                        if (parent != null) {
+                            parent.addChildTab(t);
+                        }
+                    }
+                }
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Free the memory in this order, 1) free the background tab; 2) free the
+     * WebView cache;
+     */
+    void freeMemory() {
+        // free the least frequently used background tab
+        Tab t = getLeastUsedTab();
+        if (t != null) {
+            Log.w(LOGTAG, "Free a tab in the browser");
+            freeTab(t);
+            // force a gc
+            System.gc();
+            return;
+        }
+
+        // free the WebView cache
+        Log.w(LOGTAG, "Free WebView cache");
+        WebView view = getCurrentWebView();
+        if (view != null) {
+            view.clearCache(false);
+        }
+        // force a gc
+        System.gc();
+    }
+
+    private Tab getLeastUsedTab() {
+        // Don't do anything if we only have 1 tab.
+        if (getTabCount() == 1) {
+            return null;
+        }
+
+        // Rip through the queue starting at the beginning and teardown the
+        // next available tab.
+        Tab t = null;
+        int i = 0;
+        final int queueSize = mTabQueue.size();
+        if (queueSize == 0) {
+            return null;
+        }
+        do {
+            t = mTabQueue.get(i++);
+        } while (i < queueSize && t != null && t.mMainView == null);
+
+        // Don't do anything if the last remaining tab is the current one.
+        if (t == getCurrentTab()) {
+            return null;
+        }
+
+        return t;
+    }
+
+    private void freeTab(Tab t) {
+        // Store the WebView's state.
+        saveState(t);
+
+        // Tear down the tab.
+        dismissSubWindow(t);
+        // Remove the WebView's settings from the BrowserSettings list of
+        // observers.
+        BrowserSettings.getInstance().deleteObserver(t.mMainView.getSettings());
+        t.mMainView.destroy();
+        t.mMainView = null;
+    }
+
+    /**
+     * Create a new subwindow unless a subwindow already exists.
+     * @return True if a new subwindow was created. False if one already exists.
+     */
+    void createSubWindow() {
+        Tab t = getTab(mCurrentTab);
+        if (t != null && t.mSubView == null) {
+            final View v = mInflateService.inflate(R.layout.browser_subwindow, null);
+            final WebView w = (WebView) v.findViewById(R.id.webview);
+            w.setMapTrackballToArrowKeys(false); // use trackball directly
+            final SubWindowClient subClient =
+                    new SubWindowClient(mActivity.getWebViewClient());
+            final SubWindowChromeClient subChromeClient =
+                    new SubWindowChromeClient(t,
+                            mActivity.getWebChromeClient());
+            w.setWebViewClient(subClient);
+            w.setWebChromeClient(subChromeClient);
+            w.setDownloadListener(mActivity);
+            w.setOnCreateContextMenuListener(mActivity);
+            final BrowserSettings s = BrowserSettings.getInstance();
+            s.addObserver(w.getSettings()).update(s, null);
+            t.mSubView = w;
+            t.mSubViewClient = subClient;
+            t.mSubViewChromeClient = subChromeClient;
+            // FIXME: I really hate having to know the name of the view
+            // containing the webview.
+            t.mSubViewContainer = v.findViewById(R.id.subwindow_container);
+            final ImageButton cancel =
+                    (ImageButton) v.findViewById(R.id.subwindow_close);
+            cancel.setOnClickListener(new OnClickListener() {
+                    public void onClick(View v) {
+                        subChromeClient.onCloseWindow(w);
+                    }
+                });
+        }
+    }
+
+    /**
+     * Show the tab that contains the given WebView.
+     * @param view The WebView used to find the tab.
+     */
+    Tab getTabFromView(WebView view) {
+        final int size = getTabCount();
+        for (int i = 0; i < size; i++) {
+            final Tab t = getTab(i);
+            if (t.mSubView == view || t.mMainView == view) {
+                return t;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Put the current tab in the background and set newTab as the current tab.
+     * @param newTab The new tab. If newTab is null, the current tab is not
+     *               set.
+     */
+    boolean setCurrentTab(Tab newTab) {
+        Tab current = getTab(mCurrentTab);
+        if (current == newTab) {
+            return true;
+        }
+        if (current != null) {
+            // Remove the current WebView and the container of the subwindow
+            putTabInBackground(current);
+        }
+
+        if (newTab == null) {
+            return false;
+        }
+
+        // Move the newTab to the end of the queue
+        int index = mTabQueue.indexOf(newTab);
+        if (index != -1) {
+            mTabQueue.remove(index);
+        }
+        mTabQueue.add(newTab);
+
+        WebView mainView;
+        WebView subView;
+
+        // Display the new current tab
+        mCurrentTab = mTabs.indexOf(newTab);
+        mainView = newTab.mMainView;
+        boolean needRestore = (mainView == null);
+        if (needRestore) {
+            // Same work as in createNewTab() except don't do new Tab()
+            newTab.mMainView = mainView = new WebView(mActivity);
+            mainView.setMapTrackballToArrowKeys(false); // use t-ball directly
+
+            // Add this WebView to the settings observer list and update the
+            // settings
+            final BrowserSettings s = BrowserSettings.getInstance();
+            s.addObserver(mainView.getSettings()).update(s, null);
+        }
+        mainView.setWebViewClient(mActivity.getWebViewClient());
+        mainView.setWebChromeClient(mActivity.getWebChromeClient());
+        mainView.setOnCreateContextMenuListener(mActivity);
+        mainView.setDownloadListener(mActivity);
+        // Add the subwindow if it exists
+        if (newTab.mSubViewContainer != null) {
+            subView = newTab.mSubView;
+            subView.setWebViewClient(newTab.mSubViewClient);
+            subView.setWebChromeClient(newTab.mSubViewChromeClient);
+            subView.setOnCreateContextMenuListener(mActivity);
+            subView.setDownloadListener(mActivity);
+        }
+        if (needRestore) {
+            // Have to finish setCurrentTab work before calling restoreState
+            if (!restoreState(newTab.mSavedState, newTab)) {
+                mainView.loadUrl(BrowserSettings.getInstance().getHomePage());
+            }
+        }
+        return true;
+    }
+
+    /*
+     * Put the tab in the background using all the empty/background clients.
+     */
+    private void putTabInBackground(Tab t) {
+        WebView mainView = t.mMainView;
+        // Set an empty callback so that default actions are not triggered.
+        mainView.setWebViewClient(mEmptyClient);
+        mainView.setWebChromeClient(mBackgroundChromeClient);
+        mainView.setOnCreateContextMenuListener(null);
+        // Leave the DownloadManager attached so that downloads can start in
+        // a non-active window. This can happen when going to a site that does
+        // a redirect after a period of time. The user could have switched to
+        // another tab while waiting for the download to start.
+        mainView.setDownloadListener(mActivity);
+        WebView subView = t.mSubView;
+        if (subView != null) {
+            // Set an empty callback so that default actions are not triggered.
+            subView.setWebViewClient(mEmptyClient);
+            subView.setWebChromeClient(mBackgroundChromeClient);
+            subView.setOnCreateContextMenuListener(null);
+            subView.setDownloadListener(mActivity);
+        }
+    }
+
+    /*
+     * Dismiss the subwindow for the given tab.
+     */
+    void dismissSubWindow(Tab t) {
+        if (t != null && t.mSubView != null) {
+            BrowserSettings.getInstance().deleteObserver(
+                    t.mSubView.getSettings());
+            t.mSubView.destroy();
+            t.mSubView = null;
+            t.mSubViewContainer = null;
+        }
+    }
+
+    /**
+     * Ensure that Tab t has a title, url, and favicon.
+     * @param  t   Tab to populate.
+     */
+    /* package */ void populatePickerData(Tab t) {
+        if (t == null || t.mMainView == null) {
+            return;
+        }
+        // FIXME: The only place we cared about subwindow was for 
+        // bookmarking (i.e. not when saving state). Was this deliberate?
+        final WebBackForwardList list = t.mMainView.copyBackForwardList();
+        final WebHistoryItem item =
+                list != null ? list.getCurrentItem() : null;
+        populatePickerData(t, item);
+    }
+
+    // Populate the picker data
+    private void populatePickerData(Tab t, WebHistoryItem item) {
+        if (item != null) {
+            t.mUrl = item.getUrl();
+            t.mTitle = item.getTitle();
+            if (t.mTitle == null) {
+                t.mTitle = t.mUrl;
+            }
+        }
+    }
+    
+    /**
+     * Clean up the data for all tabs.
+     */
+    /* package */ void wipeAllPickerData() {
+        int size = getTabCount();
+        for (int i = 0; i < size; i++) {
+            final Tab t = getTab(i);
+            if (t != null && t.mSavedState == null) {
+                t.mUrl = null;
+                t.mTitle = null;
+            }
+        }
+    }
+
+    /*
+     * Save the state for an individual tab.
+     */
+    private boolean saveState(Tab t) {
+        if (t != null) {
+            final WebView w = t.mMainView;
+            // If the WebView is null it means we ran low on memory and we
+            // already stored the saved state in mSavedState.
+            if (w == null) {
+                return true;
+            }
+            final Bundle b = new Bundle();
+            final WebBackForwardList list = w.saveState(b);
+            if (list != null) {
+                final File f = new File(mThumbnailDir, w.hashCode()
+                        + "_pic.save");
+                if (w.savePicture(b, f)) {
+                    b.putString("picture", f.getPath());
+                }
+            }
+
+            // Store some extra info for displaying the tab in the picker.
+            final WebHistoryItem item =
+                    list != null ? list.getCurrentItem() : null;
+            populatePickerData(t, item);
+            if (t.mUrl != null) {
+                b.putString(CURRURL, t.mUrl);
+            }
+            if (t.mTitle != null) {
+                b.putString(CURRTITLE, t.mTitle);
+            }
+            b.putBoolean(CLOSEONEXIT, t.mCloseOnExit);
+
+            // Remember the parent tab so the relationship can be restored.
+            if (t.mParentTab != null) {
+                b.putInt(PARENTTAB, getTabIndex(t.mParentTab));
+            }
+
+            // Remember the saved state.
+            t.mSavedState = b;
+            return true;
+        }
+        return false;
+    }
+
+    /*
+     * Restore the state of the tab.
+     */
+    private boolean restoreState(Bundle b, Tab t) {
+        if (b == null) {
+            return false;
+        }
+        final WebView w = t.mMainView;
+        final WebBackForwardList list = w.restoreState(b);
+        if (list == null) {
+            return false;
+        }
+        if (b.containsKey("picture")) {
+            final File f = new File(b.getString("picture"));
+            w.restorePicture(b, f);
+            f.delete();
+        }
+        t.mSavedState = null;
+        t.mUrl = null;
+        t.mTitle = null;
+        t.mCloseOnExit = b.getBoolean(CLOSEONEXIT);
+        return true;
+    }
+}