[Offline pages] Wiring saving and opening offline page

chrome/android/java/src/org/chromium/chrome/browser/enhancedbookmarks/EnhancedBookmarksModel.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.app.ActivityManager;
 import android.content.Context;
 import android.graphics.Bitmap;
 import android.util.LruCache;
 import android.util.Pair;
 
 import org.chromium.base.ApplicationStatus;
 import org.chromium.base.ObserverList;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.chrome.browser.BookmarksBridge;
 import org.chromium.chrome.browser.favicon.LargeIconBridge;
 import org.chromium.chrome.browser.favicon.LargeIconBridge.LargeIconCallback;
 import org.chromium.chrome.browser.offline_pages.OfflinePageBridge;
+import org.chromium.chrome.browser.offline_pages.OfflinePageBridge.OfflinePageModelObserver;
+import org.chromium.chrome.browser.offline_pages.OfflinePageBridge.SavePageCallback;
 import org.chromium.chrome.browser.offline_pages.OfflinePageItem;
 import org.chromium.chrome.browser.profiles.Profile;
 import org.chromium.components.bookmarks.BookmarkId;
 import org.chromium.components.bookmarks.BookmarkType;
 import org.chromium.components.dom_distiller.core.DomDistillerUrlUtils;
+import org.chromium.components.offline_pages.SavePageResult;
+import org.chromium.content_public.browser.WebContents;
 
 import java.util.ArrayList;
 import java.util.List;
 
 /**
  * A class that encapsulates {@link BookmarksBridge} and provides extra features such as undo, large
  * icon fetching, reader mode url redirecting, etc. This class should serve as the single class for
  * the UI to acquire data from the backend.
  */
 public class EnhancedBookmarksModel extends BookmarksBridge {
     private static final int FAVICON_MAX_CACHE_SIZE = 10 * 1024 * 1024; // 10MB
 
     /**
+     * Callback for use with addBookmark.
+     */
+    public interface AddBookmarkCallback {
+        /**
+         * Called when the bookmark has been added.
+         * @param bookmarkId ID of the bookmark that has been added.
+         */
+        void onBookmarkAdded(BookmarkId bookmarkId);
+    }
+
+    /**
      * Observer that listens to delete event. This interface is used by undo controllers to know
      * which bookmarks were deleted. Note this observer only listens to events that go through
      * enhanced bookmark model.
      */
     public interface EnhancedBookmarkDeleteObserver {
 
         /**
          * Callback being triggered immediately before bookmarks are deleted.
          * @param titles All titles of the bookmarks to be deleted.
          * @param isUndoable Whether the deletion is undoable.
          */
         void onDeleteBookmarks(String[] titles, boolean isUndoable);
     }
 
     private LargeIconBridge mLargeIconBridge;
     private ObserverList<EnhancedBookmarkDeleteObserver> mDeleteObservers = new ObserverList<>();
     private LruCache<String, Pair<Bitmap, Integer>> mFaviconCache;
     private OfflinePageBridge mOfflinePageBridge;
+    private boolean mIsOfflinePageModelLoaded;
+    private OfflinePageModelObserver mOfflinePageModelObserver;
 
     /**
      * Initialize enhanced bookmark model for last used non-incognito profile.
      */
     public EnhancedBookmarksModel() {
         this(Profile.getLastUsedProfile().getOriginalProfile());
     }
 
     @VisibleForTesting
     public EnhancedBookmarksModel(Profile profile) {
         super(profile);
         mLargeIconBridge = new LargeIconBridge();
 
         ActivityManager activityManager = ((ActivityManager) ApplicationStatus
                 .getApplicationContext().getSystemService(Context.ACTIVITY_SERVICE));
         int maxSize = Math.min(activityManager.getMemoryClass() / 4 * 1024 * 1024,
                 FAVICON_MAX_CACHE_SIZE);
         mFaviconCache = new LruCache<String, Pair<Bitmap, Integer>>(maxSize) {
             @Override
             protected int sizeOf(String key, Pair<Bitmap, Integer> icon) {
                 int size = Integer.SIZE;
                 if (icon.first != null) {
                     size += icon.first.getByteCount();
                 }
                 return size;
             }
         };
 
         if (OfflinePageBridge.isEnabled()) {
-            // TODO(jianli): Make sure to wait until the bridge is loaded.
             mOfflinePageBridge = new OfflinePageBridge(profile);
+            if (mOfflinePageBridge.isOfflinePageModelLoaded()) {
+                mIsOfflinePageModelLoaded = true;
+            } else {
+                mOfflinePageModelObserver = new OfflinePageModelObserver() {
+                    @Override
+                    public void offlinePageModelLoaded() {
+                        mIsOfflinePageModelLoaded = true;
+                        if (isBookmarkModelLoaded()) {
+                            notifyBookmarkModelLoaded();
+                        }
+                    }
+                };
+                mOfflinePageBridge.addObserver(mOfflinePageModelObserver);
+            }
         }
     }
 
     /**
      * Clean up all the bridges. This must be called after done using this class.
      */
     @Override
     public void destroy() {
-        super.destroy();
+        if (mOfflinePageBridge != null) {
+            mOfflinePageBridge.destroy();
+            mOfflinePageBridge = null;
+        }
         mLargeIconBridge.destroy();
         mFaviconCache = null;
+
+        super.destroy();
+    }
+
+    @Override
+    public boolean isBookmarkModelLoaded() {
+        return super.isBookmarkModelLoaded()
+                && (mOfflinePageBridge == null || mIsOfflinePageModelLoaded);
     }
 
     /**
      * Add an observer that listens to delete events that go through enhanced bookmark model.
      * @param observer The observer to add.
      */
     public void addDeleteObserver(EnhancedBookmarkDeleteObserver observer) {
         mDeleteObservers.addObserver(observer);
     }
 
@@ skipping 41 matching lines @@
     /**
      * Calls {@link BookmarksBridge#moveBookmark(BookmarkId, BookmarkId, int)} in a reversed
      * order of the list, in order to let the last item appear at the top.
      */
     public void moveBookmarks(List<BookmarkId> bookmarkIds, BookmarkId newParentId) {
         for (int i = bookmarkIds.size() - 1; i >= 0; i--) {
             moveBookmark(bookmarkIds.get(i), newParentId, 0);
         }
     }
 
-    @Override
-    public BookmarkId addBookmark(BookmarkId parent, int index, String title, String url) {
+    /**
+     * Add a new bookmark asynchronously.
+     *
+     * @param parent Folder where to add.
+     * @param index The position where the bookmark will be placed in parent folder
+     * @param title Title of the new bookmark.
+     * @param url Url of the new bookmark
+     * @param webContents A {@link WebContents} object.
+     * @param callback The callback to be invoked when the bookmark is added.
+     */
+    public void addBookmarkAsync(BookmarkId parent, int index, String title, String url,
+                                 WebContents webContents, final AddBookmarkCallback callback) {
         url = DomDistillerUrlUtils.getOriginalUrlFromDistillerUrl(url);
-        return super.addBookmark(parent, index, title, url);
+        final BookmarkId enhancedId = addBookmark(parent, index, title, url);
+
+        // If there is no need to save offline page, return now.
+        if (mOfflinePageBridge == null) {
+            callback.onBookmarkAdded(enhancedId);
+            return;
+        }
+
+        mOfflinePageBridge.savePage(webContents, enhancedId,
+                new SavePageCallback() {
+                    @Override
+                    public void onSavePageDone(int savePageResult, String url) {
+                        // TODO(jianli): Error handling.
+                        if (savePageResult == SavePageResult.SUCCESS) {
+                            callback.onBookmarkAdded(enhancedId);
+                        }
+                    }
+                });
     }
 
     /**
      * @see org.chromium.chrome.browser.BookmarksBridge.BookmarkItem#getTitle()
      */
     public String getBookmarkTitle(BookmarkId bookmarkId) {
         return getBookmarkById(bookmarkId).getTitle();
     }
 
     /**
+     * Returns the url used to launch a bookmark.
+     *
+     * @param bookmarkId ID of the bookmark to launch.
+     */
+    public String getBookmarkLaunchUrl(BookmarkId bookmarkId) {
+        String url = getBookmarkById(bookmarkId).getUrl();
+        if (mOfflinePageBridge == null) {
+            return url;
+        }
+
+        // Return the offline url for the offline page.
+        OfflinePageItem page = mOfflinePageBridge.getPageByBookmarkId(bookmarkId);
+        return page == null ? url : page.getOfflineUrl();
+    }
+
+    /**
      * Retrieves a favicon and fallback color for the given |url|. An LRU cache is used to store the
      * favicons. If the favicon is not already present in the cache, it is retrieved using
      * LargeIconBridge#getLargeIconForUrl().
      *
      * @see LargeIconBridge#getLargeIconForUrl(Profile, String, int, LargeIconCallback)
      */
     public void getLargeIcon(final String url, int minSize, final LargeIconCallback callback) {
         assert callback != null;
         LargeIconCallback callbackWrapper = callback;
 
@@ skipping 31 matching lines @@
     public List<BookmarkId> getBookmarkIDsByFilter(EnhancedBookmarkFilter filter) {
         assert filter == EnhancedBookmarkFilter.OFFLINE_PAGES;
         assert mOfflinePageBridge != null;
 
         List<BookmarkId> bookmarkIds = new ArrayList<BookmarkId>();
         for (OfflinePageItem offlinePage : mOfflinePageBridge.getAllPages()) {
             bookmarkIds.add(offlinePage.getBookmarkId());
         }
         return bookmarkIds;
     }
+
+    /**
+     * @return Offline page bridge.
+     */
+    public OfflinePageBridge getOfflinePageBridge() {
+        return mOfflinePageBridge;
+    }
 }