Makes the OfflinePageBridge.getAllPages method asynchronous.

chrome/android/java/src/org/chromium/chrome/browser/bookmarks/BookmarkItemsAdapter.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.content.Context;
 import android.support.v7.widget.RecyclerView;
 import android.support.v7.widget.RecyclerView.ViewHolder;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
 
+import org.chromium.base.Callback;
 import org.chromium.base.annotations.SuppressFBWarnings;
 import org.chromium.base.metrics.RecordHistogram;
 import org.chromium.chrome.R;
 import org.chromium.chrome.browser.bookmarks.BookmarkBridge.BookmarkItem;
 import org.chromium.chrome.browser.bookmarks.BookmarkBridge.BookmarkModelObserver;
 import org.chromium.chrome.browser.bookmarks.BookmarkPromoHeader.PromoHeaderShowingChangeListener;
 import org.chromium.chrome.browser.offlinepages.ClientId;
 import org.chromium.chrome.browser.offlinepages.OfflinePageBridge;
 import org.chromium.chrome.browser.offlinepages.OfflinePageBridge.OfflinePageModelObserver;
 import org.chromium.chrome.browser.offlinepages.OfflinePageFreeUpSpaceCallback;
 import org.chromium.chrome.browser.offlinepages.OfflinePageFreeUpSpaceDialog;
 import org.chromium.chrome.browser.offlinepages.OfflinePageStorageSpaceHeader;
+import org.chromium.chrome.browser.offlinepages.OfflinePageStorageSpacePolicy;
 import org.chromium.components.bookmarks.BookmarkId;
 
 import java.util.ArrayList;
 import java.util.List;
 
 /**
  * BaseAdapter for {@link BookmarkRecyclerView}. It manages bookmarks to list there.
  */
 class BookmarkItemsAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> implements
         BookmarkUIObserver, PromoHeaderShowingChangeListener {
     private static final int PROMO_HEADER_VIEW = 0;
     private static final int FOLDER_VIEW = 1;
     private static final int DIVIDER_VIEW = 2;
     private static final int BOOKMARK_VIEW = 3;
     private static final int OFFLINE_PAGES_STORAGE_VIEW = 4;
 
+    private boolean mDestroyed = false;
     private BookmarkDelegate mDelegate;
     private Context mContext;
     private BookmarkPromoHeader mPromoHeaderManager;
     private OfflinePageStorageSpaceHeader mOfflineStorageHeader;
 
     private List<List<? extends Object>> mSections;
     private List<Object> mPromoHeaderSection = new ArrayList<>();
     private List<Object> mOfflineStorageSection = new ArrayList<>();
     private List<Object> mFolderDividerSection = new ArrayList<>();
     private List<BookmarkId> mFolderSection = new ArrayList<>();
@@ skipping 215 matching lines @@
     }
 
     // BookmarkUIObserver implementations.
 
     @Override
     public void onBookmarkDelegateInitialized(BookmarkDelegate delegate) {
         mDelegate = delegate;
         mDelegate.addUIObserver(this);
         mDelegate.getModel().addObserver(mBookmarkModelObserver);
         mPromoHeaderManager = new BookmarkPromoHeader(mContext, this);
-        OfflinePageBridge offlinePageBridge = mDelegate.getModel().getOfflinePageBridge();
+        final OfflinePageBridge offlinePageBridge = mDelegate.getModel().getOfflinePageBridge();
         if (offlinePageBridge != null) {
             mOfflinePageModelObserver = new OfflinePageModelObserver() {
                 @Override
                 public void offlinePageModelChanged() {
                     mDelegate.notifyStateChange(BookmarkItemsAdapter.this);
                 }
 
                 @Override
                 public void offlinePageDeleted(long offlineId, ClientId clientId) {
                     if (mDelegate.getCurrentState() == BookmarkUIState.STATE_FILTER) {
                         BookmarkId id = BookmarkModel.getBookmarkIdForOfflineClientId(clientId);
                         int deletedPosition = getPositionForBookmark(id);
                         if (deletedPosition >= 0) {
                             removeItem(deletedPosition);
                         }
                     }
                 }
             };
             offlinePageBridge.addObserver(mOfflinePageModelObserver);
 
-            mOfflineStorageHeader = new OfflinePageStorageSpaceHeader(
-                    mContext, offlinePageBridge, new OfflinePageFreeUpSpaceCallback() {
+            OfflinePageStorageSpacePolicy.create(
+                    offlinePageBridge, new Callback<OfflinePageStorageSpacePolicy>() {
                         @Override
-                        public void onFreeUpSpaceDone() {
-                            refreshOfflinePagesFilterView();
-                            mDelegate.getSnackbarManager().showSnackbar(
-                                    OfflinePageFreeUpSpaceDialog.createStorageClearedSnackbar(
-                                            mContext));
-                        }
-
-                        @Override
-                        public void onFreeUpSpaceCancelled() {
-                            // No need to refresh, as result outcome should be the same here.
+                        public void onResult(OfflinePageStorageSpacePolicy policy) {
+                            if (!mDestroyed) {
+                                setOfflineStorageHeader(offlinePageBridge, policy);
+                            }
                         }
                     });
         }
     }
 
     @Override
     public void onDestroy() {
+        mDestroyed = true;
+
         mDelegate.removeUIObserver(this);
         mDelegate.getModel().removeObserver(mBookmarkModelObserver);
         mPromoHeaderManager.destroy();
 
         OfflinePageBridge offlinePageBridge = mDelegate.getModel().getOfflinePageBridge();
         if (offlinePageBridge != null) {
             offlinePageBridge.removeObserver(mOfflinePageModelObserver);
+        }
+
+        if (mOfflineStorageHeader != null) {
             mOfflineStorageHeader.destroy();
         }
     }
 
     @Override
     public void onAllBookmarksStateSet() {
         List<BookmarkId> bookmarkIds =
                 mDelegate.getModel().getAllBookmarkIDsOrderedByCreationDate();
         RecordHistogram.recordCountHistogram("EnhancedBookmarks.AllBookmarksCount",
                 bookmarkIds.size());
         setBookmarks(null, bookmarkIds);
     }
 
     @Override
     public void onFolderStateSet(BookmarkId folder) {
         setBookmarks(mDelegate.getModel().getChildIDs(folder, true, false),
                 mDelegate.getModel().getChildIDs(folder, false, true));
     }
 
     @Override
     public void onFilterStateSet(BookmarkFilter filter) {
         assert filter == BookmarkFilter.OFFLINE_PAGES;
-        List<BookmarkId> bookmarkIds = mDelegate.getModel().getBookmarkIDsByFilter(filter);
-        RecordHistogram.recordCountHistogram("OfflinePages.OfflinePageCount", bookmarkIds.size());
-        setBookmarks(null, mDelegate.getModel().getBookmarkIDsByFilter(filter));
-        mDelegate.getModel().getOfflinePageBridge().checkOfflinePageMetadata();
+        setBookmarks(null, new ArrayList<BookmarkId>());
+        BookmarkModel bookmarkModel = mDelegate.getModel();
+        bookmarkModel.getOfflinePageBridge().checkOfflinePageMetadata();
+        bookmarkModel.getOfflineBookmarkIds(new BookmarkModel.GetOfflineBookmarkIdsCallback() {

[fgorski, 2016/03/28 17:58:46]

perhaps extract method?

[dewittj, 2016/03/31 18:43:17]

This callback really only calls one method + UMA, so it seems silly to extract
it.

+            @Override
+            public void onGetOfflineBookmarkIdsDone(List<BookmarkId> bookmarkIds) {
+                RecordHistogram.recordCountHistogram(
+                        "OfflinePages.OfflinePageCount", bookmarkIds.size());
+                if (mDestroyed) {
+                    return;
+                }
+
+                setBookmarks(null, bookmarkIds);
+            }
+        });
     }
 
     @Override
     public void onSelectionStateChange(List<BookmarkId> selectedBookmarks) {}
 
     private static class ItemViewHolder extends RecyclerView.ViewHolder {
         private ItemViewHolder(View view) {
             super(view);
         }
     }
 
+    private void setOfflineStorageHeader(
+            OfflinePageBridge offlinePageBridge, OfflinePageStorageSpacePolicy policy) {
+        mOfflineStorageHeader = new OfflinePageStorageSpaceHeader(
+                mContext, offlinePageBridge, policy, new OfflinePageFreeUpSpaceCallback() {
+                    @Override
+                    public void onFreeUpSpaceDone() {
+                        if (!mDestroyed) {
+                            refreshOfflinePagesFilterView();
+                        }
+                        mDelegate.getSnackbarManager().showSnackbar(
+                                OfflinePageFreeUpSpaceDialog.createStorageClearedSnackbar(
+                                        mContext));
+                    }
+
+                    @Override
+                    public void onFreeUpSpaceCancelled() {
+                        // No need to refresh, as result outcome should
+                        // be the same here.
+                    }
+                });
+
+        updateHeader();
+    }
+
     private void updateHeader() {
         int currentUIState = mDelegate.getCurrentState();
         if (currentUIState == BookmarkUIState.STATE_LOADING) return;
 
         mPromoHeaderSection.clear();
         mOfflineStorageSection.clear();
         if (currentUIState == BookmarkUIState.STATE_FILTER) {
             if (mOfflineStorageHeader != null && mOfflineStorageHeader.shouldShow()) {
                 mOfflineStorageSection.add(null);
             }
         } else {
             assert currentUIState == BookmarkUIState.STATE_ALL_BOOKMARKS
                     || currentUIState == BookmarkUIState.STATE_FOLDER
                     : "Unexpected UI state";
             if (mPromoHeaderManager.shouldShow()) {
                 mPromoHeaderSection.add(null);
             }
         }
     }
 
     private void refreshOfflinePagesFilterView() {
         if (mDelegate.getCurrentState() != BookmarkUIState.STATE_FILTER) return;
-        setBookmarks(null,
-                mDelegate.getModel().getBookmarkIDsByFilter(BookmarkFilter.OFFLINE_PAGES));
+        setBookmarks(null, new ArrayList<BookmarkId>());
+        mDelegate.getModel().getOfflineBookmarkIds(
+                new BookmarkModel.GetOfflineBookmarkIdsCallback() {
+                    @Override
+                    public void onGetOfflineBookmarkIdsDone(List<BookmarkId> bookmarkIds) {
+                        if (mDestroyed) {
+                            return;
+                        }
+                        setBookmarks(null, bookmarkIds);
+                    }
+                });
     }
 }