Rename EnhancedBookmarks to Bookmarks, part 1.

chrome/android/java/src/org/chromium/chrome/browser/bookmarks/BookmarkManager.java

Index: chrome/android/java/src/org/chromium/chrome/browser/bookmarks/BookmarkManager.java
diff --git a/chrome/android/java/src/org/chromium/chrome/browser/enhancedbookmarks/EnhancedBookmarkManager.java b/chrome/android/java/src/org/chromium/chrome/browser/bookmarks/BookmarkManager.java
similarity index 71%
rename from chrome/android/java/src/org/chromium/chrome/browser/enhancedbookmarks/EnhancedBookmarkManager.java
rename to chrome/android/java/src/org/chromium/chrome/browser/bookmarks/BookmarkManager.java
index cc74a7fddc5c88d86728b3079de8470dd6b5429c..3d604f372bb54b370df2f8d00242cbfd58599117 100644
--- a/chrome/android/java/src/org/chromium/chrome/browser/enhancedbookmarks/EnhancedBookmarkManager.java
+++ b/chrome/android/java/src/org/chromium/chrome/browser/bookmarks/BookmarkManager.java
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-package org.chromium.chrome.browser.enhancedbookmarks;
+package org.chromium.chrome.browser.bookmarks;
 
 import android.app.Activity;
 import android.app.ActivityManager;
@@ -35,25 +35,25 @@ import java.util.Stack;
 /**
  * The new bookmark manager that is planned to replace the existing bookmark manager. It holds all
  * views and shared logics between tablet and phone. For tablet/phone specific logics, see
- * {@link EnhancedBookmarkActivity} (phone) and {@link EnhancedBookmarkPage} (tablet).
+ * {@link BookmarkActivity} (phone) and {@link BookmarkPage} (tablet).
  */
-public class EnhancedBookmarkManager implements EnhancedBookmarkDelegate {
+public class BookmarkManager implements BookmarkDelegate {
     private static final int FAVICON_MAX_CACHE_SIZE_BYTES = 10 * 1024 * 1024; // 10MB
 
     private Activity mActivity;
     private ViewGroup mMainView;
-    private EnhancedBookmarksModel mEnhancedBookmarksModel;
-    private EnhancedBookmarkUndoController mUndoController;
-    private final ObserverList<EnhancedBookmarkUIObserver> mUIObservers =
-            new ObserverList<EnhancedBookmarkUIObserver>();
+    private BookmarkModel mBookmarkModel;
+    private BookmarkUndoController mUndoController;
+    private final ObserverList<BookmarkUIObserver> mUIObservers =
+            new ObserverList<BookmarkUIObserver>();
     private Set<BookmarkId> mSelectedBookmarks = new HashSet<>();
-    private EnhancedBookmarkStateChangeListener mUrlChangeListener;
-    private EnhancedBookmarkContentView mContentView;
-    private EnhancedBookmarkSearchView mSearchView;
+    private BookmarkStateChangeListener mUrlChangeListener;
+    private BookmarkContentView mContentView;
+    private BookmarkSearchView mSearchView;
     private ViewSwitcher mViewSwitcher;
     private DrawerLayout mDrawer;
-    private EnhancedBookmarkDrawerListView mDrawerListView;
-    private final Stack<EnhancedBookmarkUIState> mStateStack = new Stack<>();
+    private BookmarkDrawerListView mDrawerListView;
+    private final Stack<BookmarkUIState> mStateStack = new Stack<>();
     private LargeIconBridge mLargeIconBridge;
     private String mInitialUrl;
     private boolean mIsDialogUi;
@@ -65,9 +65,9 @@ public class EnhancedBookmarkManager implements EnhancedBookmarkDelegate {
                 boolean isDoingExtensiveChanges) {
             // If the folder is removed in folder mode, show the parent folder or falls back to all
             // bookmarks mode.
-            if (getCurrentState() == EnhancedBookmarkUIState.STATE_FOLDER
+            if (getCurrentState() == BookmarkUIState.STATE_FOLDER
                     && node.getId().equals(mStateStack.peek().mFolder)) {
-                if (mEnhancedBookmarksModel.getTopLevelFolderIDs(true, true).contains(
+                if (mBookmarkModel.getTopLevelFolderIDs(true, true).contains(
                         node.getId())) {
                     openAllBookmarks();
                 } else {
@@ -87,7 +87,7 @@ public class EnhancedBookmarkManager implements EnhancedBookmarkDelegate {
         public void bookmarkModelChanged() {
             // If the folder no longer exists in folder mode, we need to fall back. Relying on the
             // default behavior by setting the folder mode again.
-            if (getCurrentState() == EnhancedBookmarkUIState.STATE_FOLDER) {
+            if (getCurrentState() == BookmarkUIState.STATE_FOLDER) {
                 setState(mStateStack.peek());
             }
             clearSelection();
@@ -97,39 +97,39 @@ public class EnhancedBookmarkManager implements EnhancedBookmarkDelegate {
     private final Runnable mModelLoadedRunnable = new Runnable() {
         @Override
         public void run() {
-            mSearchView.onEnhancedBookmarkDelegateInitialized(EnhancedBookmarkManager.this);
-            mDrawerListView.onEnhancedBookmarkDelegateInitialized(EnhancedBookmarkManager.this);
-            mContentView.onEnhancedBookmarkDelegateInitialized(EnhancedBookmarkManager.this);
+            mSearchView.onBookmarkDelegateInitialized(BookmarkManager.this);
+            mDrawerListView.onBookmarkDelegateInitialized(BookmarkManager.this);
+            mContentView.onBookmarkDelegateInitialized(BookmarkManager.this);
             if (!TextUtils.isEmpty(mInitialUrl)) {
-                setState(EnhancedBookmarkUIState.createStateFromUrl(mInitialUrl,
-                        mEnhancedBookmarksModel));
+                setState(BookmarkUIState.createStateFromUrl(mInitialUrl,
+                        mBookmarkModel));
             }
         }
     };
 
     /**
-     * Creates an instance of {@link EnhancedBookmarkManager}. It also initializes resources,
+     * Creates an instance of {@link BookmarkManager}. It also initializes resources,
      * bookmark models and jni bridges.
      * @param activity The activity context to use.
      * @param isDialogUi Whether the main bookmarks UI will be shown in a dialog, not a NativePage.
      */
-    public EnhancedBookmarkManager(Activity activity, boolean isDialogUi) {
+    public BookmarkManager(Activity activity, boolean isDialogUi) {
         mActivity = activity;
         mIsDialogUi = isDialogUi;
 
-        mEnhancedBookmarksModel = new EnhancedBookmarksModel();
+        mBookmarkModel = new BookmarkModel();
         mMainView = (ViewGroup) mActivity.getLayoutInflater().inflate(R.layout.eb_main, null);
         mDrawer = (DrawerLayout) mMainView.findViewById(R.id.eb_drawer_layout);
-        mDrawerListView = (EnhancedBookmarkDrawerListView) mMainView.findViewById(
+        mDrawerListView = (BookmarkDrawerListView) mMainView.findViewById(
                 R.id.eb_drawer_list);
-        mContentView = (EnhancedBookmarkContentView) mMainView.findViewById(R.id.eb_content_view);
+        mContentView = (BookmarkContentView) mMainView.findViewById(R.id.eb_content_view);
         mViewSwitcher = (ViewSwitcher) mMainView.findViewById(R.id.eb_view_switcher);
-        mUndoController = new EnhancedBookmarkUndoController(activity, mEnhancedBookmarksModel,
+        mUndoController = new BookmarkUndoController(activity, mBookmarkModel,
                 ((SnackbarManageable) activity).getSnackbarManager());
-        mSearchView = (EnhancedBookmarkSearchView) getView().findViewById(R.id.eb_search_view);
-        mEnhancedBookmarksModel.addObserver(mBookmarkModelObserver);
+        mSearchView = (BookmarkSearchView) getView().findViewById(R.id.eb_search_view);
+        mBookmarkModel.addObserver(mBookmarkModelObserver);
         initializeToLoadingState();
-        mEnhancedBookmarksModel.runAfterBookmarkModelLoaded(mModelLoadedRunnable);
+        mBookmarkModel.runAfterBookmarkModelLoaded(mModelLoadedRunnable);
 
         // Load partner bookmarks explicitly. We load partner bookmarks in the deferred startup
         // code, but that might be executed much later. Especially on L, showing loading
@@ -148,7 +148,7 @@ public class EnhancedBookmarkManager implements EnhancedBookmarkDelegate {
      * Destroys and cleans up itself. This must be called after done using this class.
      */
     public void destroy() {
-        for (EnhancedBookmarkUIObserver observer : mUIObservers) {
+        for (BookmarkUIObserver observer : mUIObservers) {
             observer.onDestroy();
         }
         assert mUIObservers.size() == 0;
@@ -157,9 +157,9 @@ public class EnhancedBookmarkManager implements EnhancedBookmarkDelegate {
             mUndoController.destroy();
             mUndoController = null;
         }
-        mEnhancedBookmarksModel.removeObserver(mBookmarkModelObserver);
-        mEnhancedBookmarksModel.destroy();
-        mEnhancedBookmarksModel = null;
+        mBookmarkModel.removeObserver(mBookmarkModelObserver);
+        mBookmarkModel.destroy();
+        mBookmarkModel = null;
         mLargeIconBridge.destroy();
         mLargeIconBridge = null;
     }
@@ -195,7 +195,7 @@ public class EnhancedBookmarkManager implements EnhancedBookmarkDelegate {
     /**
      * Sets the listener that reacts upon the change of the UI state of bookmark manager.
      */
-    public void setUrlChangeListener(EnhancedBookmarkStateChangeListener urlListner) {
+    public void setUrlChangeListener(BookmarkStateChangeListener urlListner) {
         mUrlChangeListener = urlListner;
     }
 
@@ -212,16 +212,16 @@ public class EnhancedBookmarkManager implements EnhancedBookmarkDelegate {
     /**
      * Updates UI based on the new URL. If the bookmark model is not loaded yet, cache the url and
      * it will be picked up later when the model is loaded. This method is supposed to align with
-     * {@link EnhancedBookmarkPage#updateForUrl(String)}
+     * {@link BookmarkPage#updateForUrl(String)}
      * <p>
      * @param url The url to navigate to.
      */
     public void updateForUrl(String url) {
         // Bookmark model is null if the manager has been destroyed.
-        if (mEnhancedBookmarksModel == null) return;
+        if (mBookmarkModel == null) return;
 
-        if (mEnhancedBookmarksModel.isBookmarkModelLoaded()) {
-            setState(EnhancedBookmarkUIState.createStateFromUrl(url, mEnhancedBookmarksModel));
+        if (mBookmarkModel.isBookmarkModelLoaded()) {
+            setState(BookmarkUIState.createStateFromUrl(url, mBookmarkModel));
         } else {
             mInitialUrl = url;
         }
@@ -236,7 +236,7 @@ public class EnhancedBookmarkManager implements EnhancedBookmarkDelegate {
         mDrawerListView.showLoadingUi();
         mContentView.showLoadingUi();
         assert mStateStack.isEmpty();
-        setState(EnhancedBookmarkUIState.createLoadingState());
+        setState(BookmarkUIState.createLoadingState());
     }
 
     /**
@@ -252,9 +252,9 @@ public class EnhancedBookmarkManager implements EnhancedBookmarkDelegate {
      * and back button are not controlled by the manager: the tab handles back key and backstack
      * navigation.
      */
-    private void setState(EnhancedBookmarkUIState state) {
-        if (!state.isValid(mEnhancedBookmarksModel)) {
-            state = EnhancedBookmarkUIState.createAllBookmarksState(mEnhancedBookmarksModel);
+    private void setState(BookmarkUIState state) {
+        if (!state.isValid(mBookmarkModel)) {
+            state = BookmarkUIState.createAllBookmarksState(mBookmarkModel);
         }
 
         if (!mStateStack.isEmpty() && mStateStack.peek().equals(state)) return;
@@ -262,15 +262,15 @@ public class EnhancedBookmarkManager implements EnhancedBookmarkDelegate {
         // The loading state is not persisted in history stack and once we have a valid state it
         // shall be removed.
         if (!mStateStack.isEmpty()
-                && mStateStack.peek().mState == EnhancedBookmarkUIState.STATE_LOADING) {
+                && mStateStack.peek().mState == BookmarkUIState.STATE_LOADING) {
             mStateStack.pop();
         }
         mStateStack.push(state);
 
-        if (state.mState != EnhancedBookmarkUIState.STATE_LOADING) {
+        if (state.mState != BookmarkUIState.STATE_LOADING) {
             // Loading state may be pushed to the stack but should never be stored in preferences.
             if (state.mShouldPersist) {
-                EnhancedBookmarkUtils.setLastUsedUrl(mActivity, state.mUrl);
+                BookmarkUtils.setLastUsedUrl(mActivity, state.mUrl);
             }
             // If a loading state is replaced by another loading state, do not notify this change.
             if (mUrlChangeListener != null) {
@@ -280,12 +280,12 @@ public class EnhancedBookmarkManager implements EnhancedBookmarkDelegate {
 
         clearSelection();
 
-        for (EnhancedBookmarkUIObserver observer : mUIObservers) {
+        for (BookmarkUIObserver observer : mUIObservers) {
             notifyStateChange(observer);
         }
     }
 
-    // EnhancedBookmarkDelegate implementations.
+    // BookmarkDelegate implementations.
 
     @Override
     public boolean isDialogUi() {
@@ -295,35 +295,35 @@ public class EnhancedBookmarkManager implements EnhancedBookmarkDelegate {
     @Override
     public void openFolder(BookmarkId folder) {
         closeSearchUI();
-        setState(EnhancedBookmarkUIState.createFolderState(folder, mEnhancedBookmarksModel));
+        setState(BookmarkUIState.createFolderState(folder, mBookmarkModel));
     }
 
     @Override
     public void openAllBookmarks() {
         closeSearchUI();
-        setState(EnhancedBookmarkUIState.createAllBookmarksState(mEnhancedBookmarksModel));
+        setState(BookmarkUIState.createAllBookmarksState(mBookmarkModel));
     }
 
     @Override
-    public void openFilter(EnhancedBookmarkFilter filter) {
-        setState(EnhancedBookmarkUIState.createFilterState(filter, mEnhancedBookmarksModel));
+    public void openFilter(BookmarkFilter filter) {
+        setState(BookmarkUIState.createFilterState(filter, mBookmarkModel));
     }
 
     @Override
     public void clearSelection() {
         mSelectedBookmarks.clear();
-        for (EnhancedBookmarkUIObserver observer : mUIObservers) {
+        for (BookmarkUIObserver observer : mUIObservers) {
             observer.onSelectionStateChange(new ArrayList<BookmarkId>(mSelectedBookmarks));
         }
     }
 
     @Override
     public boolean toggleSelectionForBookmark(BookmarkId bookmark) {
-        if (!mEnhancedBookmarksModel.getBookmarkById(bookmark).isEditable()) return false;
+        if (!mBookmarkModel.getBookmarkById(bookmark).isEditable()) return false;
 
         if (mSelectedBookmarks.contains(bookmark)) mSelectedBookmarks.remove(bookmark);
         else mSelectedBookmarks.add(bookmark);
-        for (EnhancedBookmarkUIObserver observer : mUIObservers) {
+        for (BookmarkUIObserver observer : mUIObservers) {
             observer.onSelectionStateChange(new ArrayList<BookmarkId>(mSelectedBookmarks));
         }
 
@@ -346,21 +346,21 @@ public class EnhancedBookmarkManager implements EnhancedBookmarkDelegate {
     }
 
     @Override
-    public void notifyStateChange(EnhancedBookmarkUIObserver observer) {
+    public void notifyStateChange(BookmarkUIObserver observer) {
         int state = getCurrentState();
         switch (state) {
-            case EnhancedBookmarkUIState.STATE_ALL_BOOKMARKS:
+            case BookmarkUIState.STATE_ALL_BOOKMARKS:
                 observer.onAllBookmarksStateSet();
                 break;
-            case EnhancedBookmarkUIState.STATE_FOLDER:
+            case BookmarkUIState.STATE_FOLDER:
                 observer.onFolderStateSet(mStateStack.peek().mFolder);
                 break;
-            case EnhancedBookmarkUIState.STATE_LOADING:
-                // In loading state, onEnhancedBookmarkDelegateInitialized() is not called for all
+            case BookmarkUIState.STATE_LOADING:
+                // In loading state, onBookmarkDelegateInitialized() is not called for all
                 // UIObservers, which means that there will be no observers at the time. Do nothing.
                 assert mUIObservers.isEmpty();
                 break;
-            case EnhancedBookmarkUIState.STATE_FILTER:
+            case BookmarkUIState.STATE_FILTER:
                 observer.onFilterStateSet(mStateStack.peek().mFilter);
                 break;
             default:
@@ -389,9 +389,9 @@ public class EnhancedBookmarkManager implements EnhancedBookmarkDelegate {
     @Override
     public void openBookmark(BookmarkId bookmark, int launchLocation) {
         clearSelection();
-        if (EnhancedBookmarkUtils.openBookmark(
-                    mEnhancedBookmarksModel, mActivity, bookmark, launchLocation)) {
-            EnhancedBookmarkUtils.finishActivityOnPhone(mActivity);
+        if (BookmarkUtils.openBookmark(
+                    mBookmarkModel, mActivity, bookmark, launchLocation)) {
+            BookmarkUtils.finishActivityOnPhone(mActivity);
         }
     }
 
@@ -408,23 +408,23 @@ public class EnhancedBookmarkManager implements EnhancedBookmarkDelegate {
     }
 
     @Override
-    public void addUIObserver(EnhancedBookmarkUIObserver observer) {
+    public void addUIObserver(BookmarkUIObserver observer) {
         mUIObservers.addObserver(observer);
     }
 
     @Override
-    public void removeUIObserver(EnhancedBookmarkUIObserver observer) {
+    public void removeUIObserver(BookmarkUIObserver observer) {
         mUIObservers.removeObserver(observer);
     }
 
     @Override
-    public EnhancedBookmarksModel getModel() {
-        return mEnhancedBookmarksModel;
+    public BookmarkModel getModel() {
+        return mBookmarkModel;
     }
 
     @Override
     public int getCurrentState() {
-        if (mStateStack.isEmpty()) return EnhancedBookmarkUIState.STATE_LOADING;
+        if (mStateStack.isEmpty()) return BookmarkUIState.STATE_LOADING;
         return mStateStack.peek().mState;
     }