Makes the OfflinePageBridge.getAllPages method asynchronous.

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

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // 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.bookmarks;
 
 import android.app.Activity;
 import android.content.Context;
 import android.content.Intent;
 import android.content.SharedPreferences;
@@ skipping 28 matching lines @@
 /**
  * A class holding static util functions for bookmark.
  */
 public class BookmarkUtils {
     private static final String PREF_LAST_USED_URL = "enhanced_bookmark_last_used_url";
     private static final String PREF_LAST_USED_PARENT = "enhanced_bookmark_last_used_parent_folder";
 
     /**
      * If the tab has already been bookmarked, start {@link BookmarkEditActivity} for the
      * bookmark. If not, add the bookmark to bookmarkmodel, and show a snackbar notifying the user.
+     *
+     * Note: Takes ownership of bookmarkModel, and will call |destroy| on it when finished.
+     *
      * @param idToAdd The bookmark ID if the tab has already been bookmarked.
      * @param bookmarkModel The bookmark model.
      * @param tab The tab to add or edit a bookmark.
      * @param snackbarManager The SnackbarManager used to show the snackbar.
      * @param activity Current activity.
      */
     public static void addOrEditBookmark(long idToAdd, BookmarkModel bookmarkModel,
             Tab tab, SnackbarManager snackbarManager, Activity activity) {
         // See if the Tab's contents should be saved or not.
         WebContents webContentsToSave = null;
         if (!shouldSkipSavingTabOffline(tab)) webContentsToSave = tab.getWebContents();
 
         if (idToAdd != Tab.INVALID_BOOKMARK_ID) {
             startEditActivity(activity, new BookmarkId(idToAdd, BookmarkType.NORMAL),
                     webContentsToSave);
+            bookmarkModel.destroy();
             return;
         }
 
         BookmarkId parent = getLastUsedParent(activity);
         if (parent == null || !bookmarkModel.doesBookmarkExist(parent)) {
             parent = bookmarkModel.getDefaultFolder();
         }
 
         // The bookmark model will be destroyed in the created AddBookmarkCallback.
         bookmarkModel.addBookmarkAsync(parent, bookmarkModel.getChildCount(parent), tab.getTitle(),
                 tab.getUrl(), webContentsToSave,
                 createAddBookmarkCallback(bookmarkModel, snackbarManager, activity,
-                        webContentsToSave));
+                                               webContentsToSave));
     }
 
     /**
      * Adds a bookmark with the given title and url to the last used parent folder. Provides
      * no visual feedback that a bookmark has been added.
      *
      * @param title The title of the bookmark.
      * @param url The URL of the new bookmark.
      */
     public static BookmarkId addBookmarkSilently(Context context,
@@ skipping 133 matching lines @@
                 RecordUserAction.record("EnhancedBookmarks.EditAfterCreateButtonClicked");
                 startEditActivity(activity, bookmarkId, (WebContents) actionData);
             }
         };
     }
 
     /**
      * Gets whether bookmark manager should load offline page initially.
      */
     private static boolean shouldShowOfflinePageAtFirst(OfflinePageBridge bridge) {
-        if (bridge == null || bridge.getAllPages().isEmpty() || OfflinePageUtils.isConnected()) {
-            return false;
-        }
-        return true;
+        return !OfflinePageUtils.isConnected() && bridge != null && bridge.hasPages();
     }
 
     /**
      * Shows bookmark main UI.
      */
     public static void showBookmarkManager(Activity activity) {
         String url = getFirstUrlToLoad(activity);
 
         if (DeviceFormFactor.isTablet(activity)) {
             openUrl(activity, url);
         } else {
             Intent intent = new Intent(activity, BookmarkActivity.class);
             intent.setData(Uri.parse(url));
             activity.startActivity(intent);
         }
     }
 
     /**
      * The initial url the bookmark manager shows depends on offline page status and some
      * experiments we run.
      */
     private static String getFirstUrlToLoad(Activity activity) {
         BookmarkModel model = new BookmarkModel();
         OfflinePageBridge bridge = model.getOfflinePageBridge();
-        try {
-            if (shouldShowOfflinePageAtFirst(bridge)) {
-                return BookmarkUIState.createFilterUrl(BookmarkFilter.OFFLINE_PAGES,
-                        false).toString();
-            }
-            String lastUsedUrl = getLastUsedUrl(activity);
-            if (!TextUtils.isEmpty(lastUsedUrl)) return lastUsedUrl;
-            return UrlConstants.BOOKMARKS_URL;
-        } finally {
-            model.destroy();
+        model.destroy();
+
+        if (shouldShowOfflinePageAtFirst(bridge)) {
+            return BookmarkUIState.createFilterUrl(BookmarkFilter.OFFLINE_PAGES, false).toString();
         }
+
+        String lastUsedUrl = getLastUsedUrl(activity);
+        return TextUtils.isEmpty(lastUsedUrl) ? UrlConstants.BOOKMARKS_URL : lastUsedUrl;
     }
 
     /**
      * Saves the last used url to preference. The saved url will be later queried by
      * {@link #getLastUsedUrl(Context)}
      */
     static void setLastUsedUrl(Context context, String url) {
         PreferenceManager.getDefaultSharedPreferences(context).edit()
                 .putString(PREF_LAST_USED_URL, url).apply();
     }
@@ skipping 108 matching lines @@
     }
 
     /**
      * Indicates whether we should skip saving the given tab as an offline page.
      * A tab shouldn't be saved offline if it shows an error page or a sad tab page.
      */
     private static boolean shouldSkipSavingTabOffline(Tab tab) {
         return tab.isShowingErrorPage() || tab.isShowingSadTab();
     }
 }