[Offline pages] Adding capability to free up space used by Offline pages

chrome/android/java/src/org/chromium/chrome/browser/enhancedbookmarks/EnhancedBookmarkItemsAdapter.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.enhancedbookmarks;
 
 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.annotations.SuppressFBWarnings;
 import org.chromium.chrome.R;
 import org.chromium.chrome.browser.BookmarksBridge.BookmarkItem;
 import org.chromium.chrome.browser.BookmarksBridge.BookmarkModelObserver;
+import org.chromium.chrome.browser.enhancedbookmarks.EnhancedBookmarkManager.UIState;
 import org.chromium.chrome.browser.enhancedbookmarks.EnhancedBookmarkPromoHeader.PromoHeaderShowingChangeListener;
+import org.chromium.chrome.browser.offline_pages.OfflinePageBridge;
+import org.chromium.chrome.browser.offline_pages.OfflinePageFreeUpSpaceCallback;
+import org.chromium.chrome.browser.offline_pages.OfflinePageStorageSpaceHeader;
 import org.chromium.components.bookmarks.BookmarkId;
 
 import java.util.ArrayList;
 import java.util.List;
 
 /**
  * BaseAdapter for EnhancedBookmarkItemsContainer. It manages bookmarks to list there.
  */
 class EnhancedBookmarkItemsAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> implements
         EnhancedBookmarkUIObserver, 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 EnhancedBookmarkDelegate mDelegate;
     private Context mContext;
     private EnhancedBookmarkPromoHeader 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<>();
     private List<Object> mBookmarkDividerSection = new ArrayList<>();
     private List<BookmarkId> mBookmarkSection = new ArrayList<>();
 
     private BookmarkModelObserver mBookmarkModelObserver = new BookmarkModelObserver() {
         @Override
         public void bookmarkNodeChanged(BookmarkItem node) {
             int position = getPositionForBookmark(node.getId());
             if (position >= 0) notifyItemChanged(position);
@@ skipping 16 matching lines @@
         public void bookmarkModelChanged() {
             mDelegate.notifyStateChange(EnhancedBookmarkItemsAdapter.this);
         }
     };
 
     EnhancedBookmarkItemsAdapter(Context context) {
         mContext = context;
 
         mSections = new ArrayList<>();
         mSections.add(mPromoHeaderSection);
+        mSections.add(mOfflineStorageSection);
         mSections.add(mFolderDividerSection);
         mSections.add(mFolderSection);
         mSections.add(mBookmarkDividerSection);
         mSections.add(mBookmarkSection);
     }
 
     BookmarkId getItem(int position) {
         return (BookmarkId) getSection(position).get(toSectionPosition(position));
     }
 
@@ skipping 37 matching lines @@
      * @param folders This can be null if there is no folders to show.
      */
     private void setBookmarks(List<BookmarkId> folders, List<BookmarkId> bookmarks) {
         if (folders == null) folders = new ArrayList<BookmarkId>();
 
         mFolderSection.clear();
         mFolderSection.addAll(folders);
         mBookmarkSection.clear();
         mBookmarkSection.addAll(bookmarks);
 
+        updateHeader();
         updateDividerSections();
 
         // TODO(kkimlabs): Animation is disabled due to a performance issue on bookmark undo.
         //                 http://crbug.com/484174
         notifyDataSetChanged();
     }
 
     private void updateDividerSections() {
         mFolderDividerSection.clear();
         mBookmarkDividerSection.clear();
-        if (!mPromoHeaderSection.isEmpty() && !mFolderSection.isEmpty()) {
+
+        boolean isHeaderPresent =
+                !mPromoHeaderSection.isEmpty() || !mOfflineStorageSection.isEmpty();
+
+        if (isHeaderPresent && !mFolderSection.isEmpty()) {
             mFolderDividerSection.add(null);
         }
-        if ((!mPromoHeaderSection.isEmpty() || !mFolderSection.isEmpty())
-                && !mBookmarkSection.isEmpty()) {
+        if ((isHeaderPresent || !mFolderSection.isEmpty()) && !mBookmarkSection.isEmpty()) {
             mBookmarkDividerSection.add(null);
         }
     }
 
     private void removeItem(int position) {
         List<?> section = getSection(position);
         assert section == mFolderSection || section == mBookmarkSection;
         section.remove(toSectionPosition(position));
         notifyItemRemoved(position);
     }
 
     // RecyclerView.Adapter implementation.
 
     @Override
     public int getItemCount() {
         int count = 0;
         for (List<?> section : mSections) {
             count += section.size();
         }
         return count;
     }
 
     @Override
     public int getItemViewType(int position) {
         List<?> section = getSection(position);
 
         if (section == mPromoHeaderSection) {
             return PROMO_HEADER_VIEW;
+        } else if (section == mOfflineStorageSection) {
+            return OFFLINE_PAGES_STORAGE_VIEW;
         } else if (section == mFolderDividerSection
                 || section == mBookmarkDividerSection) {
             return DIVIDER_VIEW;
         } else if (section == mFolderSection) {
             return FOLDER_VIEW;
         } else if (section == mBookmarkSection) {
             return BOOKMARK_VIEW;
         }
 
         assert false : "Invalid position requested";
         return -1;
     }
 
     @Override
     public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
         switch (viewType) {
             case PROMO_HEADER_VIEW:
                 return mPromoHeaderManager.createHolder(parent);
+            case OFFLINE_PAGES_STORAGE_VIEW:
+                return mOfflineStorageHeader.createHolder(parent);
             case DIVIDER_VIEW:
                 return new ViewHolder(LayoutInflater.from(parent.getContext()).inflate(
                         R.layout.eb_divider, parent, false)) {};
             case FOLDER_VIEW:
                 EnhancedBookmarkFolderRow folder = (EnhancedBookmarkFolderRow) LayoutInflater
                         .from(parent.getContext()).inflate(R.layout.eb_folder_row, parent, false);
                 folder.onEnhancedBookmarkDelegateInitialized(mDelegate);
                 return new ItemViewHolder(folder);
             case BOOKMARK_VIEW:
                 EnhancedBookmarkBookmarkRow item = (EnhancedBookmarkBookmarkRow) LayoutInflater
                         .from(parent.getContext()).inflate(R.layout.eb_bookmark_row, parent, false);
                 item.onEnhancedBookmarkDelegateInitialized(mDelegate);
                 return new ItemViewHolder(item);
             default:
                 assert false;
                 return null;
         }
     }
 
     @SuppressFBWarnings("BC_UNCONFIRMED_CAST")
     @Override
     public void onBindViewHolder(ViewHolder holder, int position) {
         BookmarkId id = getItem(position);
         switch (getItemViewType(position)) {
             case PROMO_HEADER_VIEW:
+            case OFFLINE_PAGES_STORAGE_VIEW:
             case DIVIDER_VIEW:
                 break;
             case FOLDER_VIEW:
                 ((EnhancedBookmarkRow) holder.itemView).setBookmarkId(id);
                 break;
             case BOOKMARK_VIEW:
                 ((EnhancedBookmarkRow) holder.itemView).setBookmarkId(id);
                 break;
             default:
                 assert false : "View type not supported!";
         }
     }
 
     // PromoHeaderShowingChangeListener implementation.
 
     @Override
     public void onPromoHeaderShowingChanged(boolean isShowing) {
-        mPromoHeaderSection.clear();
-        if (isShowing) mPromoHeaderSection.add(null);
+        if (mDelegate.getCurrentState() != UIState.STATE_ALL_BOOKMARKS
+                && mDelegate.getCurrentState() != UIState.STATE_FOLDER) {
+            return;
+        }
 
+        updateHeader();
         updateDividerSections();
         notifyDataSetChanged();
     }
 
     // EnhancedBookmarkUIObserver implementations.
 
     @Override
     public void onEnhancedBookmarkDelegateInitialized(EnhancedBookmarkDelegate delegate) {
         mDelegate = delegate;
         mDelegate.addUIObserver(this);
         mDelegate.getModel().addObserver(mBookmarkModelObserver);
         mPromoHeaderManager = new EnhancedBookmarkPromoHeader(mContext, this);
-        if (mPromoHeaderManager.shouldShow()) mPromoHeaderSection.add(null);
+        OfflinePageBridge offlinePageBridge = mDelegate.getModel().getOfflinePageBridge();
+        if (offlinePageBridge != null) {
+            mOfflineStorageHeader = new OfflinePageStorageSpaceHeader(
+                    mContext, offlinePageBridge, new OfflinePageFreeUpSpaceCallback() {
+                        @Override
+                        public void onFreeUpSpaceDone() {
+                            refreshOfflinePagesFilterView();
+                        }
 
-        updateDividerSections();
+                        @Override
+                        public void onFreeUpSpaceCancelled() {
+                            // No need to refresh, as result outcome should be the same here.
+                        }
+                    });
+        }
     }
 
     @Override
     public void onDestroy() {
         mDelegate.removeUIObserver(this);
         mDelegate.getModel().removeObserver(mBookmarkModelObserver);
         mPromoHeaderManager.destroy();
     }
 
     @Override
@@ skipping 14 matching lines @@
     }
 
     @Override
     public void onSelectionStateChange(List<BookmarkId> selectedBookmarks) {}
 
     private static class ItemViewHolder extends RecyclerView.ViewHolder {
         private ItemViewHolder(View view) {
             super(view);
         }
     }
+
+    private void updateHeader() {
+        int currentUIState = mDelegate.getCurrentState();
+        if (currentUIState == UIState.STATE_LOADING) return;
+
+        mPromoHeaderSection.clear();
+        mOfflineStorageSection.clear();
+        if (currentUIState == UIState.STATE_FILTER) {
+            if (mOfflineStorageHeader != null && mOfflineStorageHeader.shouldShow()) {
+                mOfflineStorageSection.add(null);
+            }
+        } else {
+            assert currentUIState == UIState.STATE_ALL_BOOKMARKS
+                    || currentUIState == UIState.STATE_FOLDER : "Unexpected UI state";
+            if (mPromoHeaderManager.shouldShow()) {
+                mPromoHeaderSection.add(null);
+            }
+        }
+    }
+
+    private void refreshOfflinePagesFilterView() {
+        if (mDelegate.getCurrentState() != UIState.STATE_FILTER) return;
+        setBookmarks(null,
+                mDelegate.getModel().getBookmarkIDsByFilter(EnhancedBookmarkFilter.OFFLINE_PAGES));
+    }
 }