diff --git a/src/com/android/browser/BrowserBookmarksPage.java b/src/com/android/browser/BrowserBookmarksPage.java
index 2c38334..bf96597 100644
--- a/src/com/android/browser/BrowserBookmarksPage.java
+++ b/src/com/android/browser/BrowserBookmarksPage.java
@@ -26,6 +26,7 @@
 import android.content.CursorLoader;
 import android.content.Intent;
 import android.content.Loader;
+import android.content.SharedPreferences;
 import android.content.res.Configuration;
 import android.content.res.Resources;
 import android.database.Cursor;
@@ -57,6 +58,9 @@
 import com.android.browser.view.BookmarkExpandableView;
 import com.android.browser.view.BookmarkExpandableView.BookmarkContextMenuInfo;
 
+import org.json.JSONException;
+import org.json.JSONObject;
+
 import java.util.HashMap;
 
 interface BookmarksPageCallbacks {
@@ -84,6 +88,7 @@
     static final int LOADER_BOOKMARKS = 100;
 
     static final String EXTRA_DISABLE_WINDOW = "disable_new_window";
+    static final String PREF_GROUP_STATE = "bbp_group_state";
 
     static final String ACCOUNT_TYPE = "account_type";
     static final String ACCOUNT_NAME = "account_name";
@@ -100,6 +105,7 @@
     View mHeader;
     HashMap<Integer, BrowserBookmarksAdapter> mBookmarkAdapters = new HashMap<Integer, BrowserBookmarksAdapter>();
     BookmarkDragHandler mDragHandler;
+    JSONObject mState;
 
     @Override
     public Loader<Cursor> onCreateLoader(int id, Bundle args) {
@@ -130,7 +136,12 @@
                 BrowserBookmarksAdapter adapter = new BrowserBookmarksAdapter(
                         getActivity(), VIEW_THUMBNAILS);
                 mBookmarkAdapters.put(id, adapter);
-                mGrid.addAccount(accountName, adapter);
+                boolean expand = true;
+                try {
+                    expand = mState.getBoolean(accountName != null ? accountName
+                            : BookmarkExpandableView.LOCAL_ACCOUNT_NAME);
+                } catch (JSONException e) {} // no state for accountName
+                mGrid.addAccount(accountName, adapter, expand);
                 lm.restartLoader(id, args, this);
                 id++;
             }
@@ -300,6 +311,14 @@
     @Override
     public void onCreate(Bundle icicle) {
         super.onCreate(icicle);
+        SharedPreferences prefs = BrowserSettings.getInstance().getPreferences();
+        try {
+            mState = new JSONObject(prefs.getString(PREF_GROUP_STATE, "{}"));
+        } catch (JSONException e) {
+            // Parse failed, clear preference and start with empty state
+            prefs.edit().remove(PREF_GROUP_STATE).apply();
+            mState = new JSONObject();
+        }
         Bundle args = getArguments();
         mDisableNewWindow = args == null ? false : args.getBoolean(EXTRA_DISABLE_WINDOW, false);
         setHasOptionsMenu(true);
@@ -309,6 +328,21 @@
         }
     }
 
+    @Override
+    public void onPause() {
+        super.onPause();
+        try {
+            mState = mGrid.saveGroupState();
+            // Save state
+            SharedPreferences prefs = BrowserSettings.getInstance().getPreferences();
+            prefs.edit()
+                    .putString(PREF_GROUP_STATE, mState.toString())
+                    .apply();
+        } catch (JSONException e) {
+            // Not critical, ignore
+        }
+    }
+
     private static class CombinedBookmarksCallbackWrapper
             implements BookmarksPageCallbacks {
 
diff --git a/src/com/android/browser/view/BookmarkExpandableView.java b/src/com/android/browser/view/BookmarkExpandableView.java
index baa9172..edc497b 100644
--- a/src/com/android/browser/view/BookmarkExpandableView.java
+++ b/src/com/android/browser/view/BookmarkExpandableView.java
@@ -43,12 +43,17 @@
 import com.android.browser.R;
 import com.android.internal.view.menu.MenuBuilder;
 
+import org.json.JSONException;
+import org.json.JSONObject;
+
 import java.util.ArrayList;
 import java.util.HashMap;
 
 public class BookmarkExpandableView extends ExpandableListView
         implements BreadCrumbView.Controller {
 
+    public static final String LOCAL_ACCOUNT_NAME = "local";
+
     // Experimental drag & drop
     private static final boolean ENABLE_DRAG_DROP = false;
 
@@ -123,7 +128,8 @@
         mAdapter.clear();
     }
 
-    public void addAccount(String accountName, BrowserBookmarksAdapter adapter) {
+    public void addAccount(String accountName, BrowserBookmarksAdapter adapter,
+            boolean expandGroup) {
         // First, check if it already exists
         int indexOf = mAdapter.mGroups.indexOf(accountName);
         if (indexOf >= 0) {
@@ -144,7 +150,9 @@
             adapter.registerDataSetObserver(mAdapter.mObserver);
         }
         mAdapter.notifyDataSetChanged();
-        expandGroup(mAdapter.getGroupCount() - 1);
+        if (expandGroup) {
+            expandGroup(mAdapter.getGroupCount() - 1);
+        }
     }
 
     @Override
@@ -308,6 +316,18 @@
         mAdapter.notifyDataSetChanged();
     }
 
+    public JSONObject saveGroupState() throws JSONException {
+        JSONObject obj = new JSONObject();
+        int count = mAdapter.getGroupCount();
+        for (int i = 0; i < count; i++) {
+            String acctName = mAdapter.mGroups.get(i);
+            if (!isGroupExpanded(i)) {
+                obj.put(acctName != null ? acctName : LOCAL_ACCOUNT_NAME, false);
+            }
+        }
+        return obj;
+    }
+
     class BookmarkAccountAdapter extends BaseExpandableListAdapter {
         ArrayList<BrowserBookmarksAdapter> mChildren;
         ArrayList<String> mGroups;
