[Offline pages] Update of OfflinePageUtils for better testability

chrome/android/java/src/org/chromium/chrome/browser/offlinepages/OfflinePageUtils.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.offlinepages;
 
 import android.app.Activity;
 import android.content.Context;
 import android.net.Uri;
 import android.os.AsyncTask;
@@ skipping 58 matching lines @@
      * the appropriate TabRestoreType in a lookup table.
      */
     private static final int BIT_ONLINE = 1;
     private static final int BIT_CANT_SAVE_OFFLINE = 1 << 2;
     private static final int BIT_OFFLINE_PAGE = 1 << 3;
     private static final int BIT_LAST_N = 1 << 4;
 
     // Used instead of the constant so tests can override the value.
     private static int sSnackbarDurationMs = DEFAULT_SNACKBAR_DURATION_MS;
 
-    private static OfflinePageUtils sInstance;
+    /** Instance carrying actual implementation of utility methods. */
+    private static Internal sInstance;
 
     private static File sOfflineSharingDirectory;
 
     /**
      * Tracks the observers of ChromeActivity's TabModelSelectors. This is weak so the activity can
      * be garbage collected without worrying about this map.  The RecentTabTracker is held here so
      * that it can be destroyed when the ChromeActivity gets a new TabModelSelector.
      */
     private static Map<ChromeActivity, RecentTabTracker> sTabModelObservers = new HashMap<>();
 
     /**
+     * Interface for implementation of offline page utilities, that can be implemented for testing.
+     * We are using an internal interface, so that instance methods can have the same names as
+     * static methods.
+     */

[dewittj, 2017/04/27 17:29:14]

@visiblefortest

[fgorski, 2017/05/08 21:41:24]

Done.

+    interface Internal {
+        /** Returns offline page bridge for specified profile. */
+        OfflinePageBridge getOfflinePageBridge(Profile profile);
+
+        /** Returns whether the network is connected. */
+        boolean isConnected();
+
+        /**
+         * Checks if an offline page is shown for the tab.
+         * @param tab The tab to be reloaded.
+         * @return True if the offline page is opened.
+         */
+        boolean isOfflinePage(Tab tab);
+
+        /**
+         * Returns whether the tab is showing offline preview.
+         * @param tab The current tab.
+         */
+        boolean isShowingOfflinePreview(Tab tab);
+
+        /**
+         * Shows the "reload" snackbar for the given tab.
+         * @param context The application context.
+         * @param snackbarManager Class that shows the snackbar.
+         * @param snackbarController Class to control the snackbar.
+         * @param tabId Id of a tab that the snackbar is related to.
+         */
+        void showReloadSnackbar(Context context, SnackbarManager snackbarManager,
+                final SnackbarController snackbarController, int tabId);
+    }
+
+    private static class OfflinePageUtilsImpl implements Internal {
+        @Override
+        public OfflinePageBridge getOfflinePageBridge(Profile profile) {
+            return OfflinePageBridge.getForProfile(profile);
+        }
+
+        @Override
+        public boolean isConnected() {
+            return NetworkChangeNotifier.isOnline();
+        }
+
+        @Override
+        public boolean isOfflinePage(Tab tab) {
+            OfflinePageBridge offlinePageBridge = getOfflinePageBridge(tab.getProfile());
+            if (offlinePageBridge == null) return false;
+            return offlinePageBridge.isOfflinePage(tab.getWebContents());
+        }
+
+        @Override
+        public boolean isShowingOfflinePreview(Tab tab) {
+            OfflinePageBridge offlinePageBridge = getOfflinePageBridge(tab.getProfile());
+            if (offlinePageBridge == null) return false;
+            return offlinePageBridge.isShowingOfflinePreview(tab.getWebContents());
+        }
+
+        @Override
+        public void showReloadSnackbar(Context context, SnackbarManager snackbarManager,
+                final SnackbarController snackbarController, int tabId) {
+            if (tabId == Tab.INVALID_TAB_ID) return;
+
+            Log.d(TAG, "showReloadSnackbar called with controller " + snackbarController);
+            Snackbar snackbar =
+                    Snackbar.make(context.getString(R.string.offline_pages_viewing_offline_page),
+                                    snackbarController, Snackbar.TYPE_ACTION,
+                                    Snackbar.UMA_OFFLINE_PAGE_RELOAD)
+                            .setSingleLine(false)
+                            .setAction(context.getString(R.string.reload), tabId);
+            snackbar.setDuration(sSnackbarDurationMs);
+            snackbarManager.showSnackbar(snackbar);
+        }
+    }
+
+    /**
      * Contains values from the histogram enum OfflinePagesTabRestoreType used for reporting the
      * OfflinePages.TabRestore metric.
      */
     private static class TabRestoreType {
         public static final int WHILE_ONLINE = 0;
         public static final int WHILE_ONLINE_CANT_SAVE_FOR_OFFLINE_USAGE = 1;
         public static final int WHILE_ONLINE_TO_OFFLINE_PAGE = 2;
         public static final int WHILE_ONLINE_TO_OFFLINE_PAGE_FROM_LAST_N = 3;
         public static final int WHILE_OFFLINE = 4;
         public static final int WHILE_OFFLINE_CANT_SAVE_FOR_OFFLINE_USAGE = 5;
         public static final int WHILE_OFFLINE_TO_OFFLINE_PAGE = 6;
         public static final int WHILE_OFFLINE_TO_OFFLINE_PAGE_FROM_LAST_N = 7;
         public static final int FAILED = 8;
         public static final int CRASHED = 9;
         // NOTE: always keep this entry at the end. Add new result types only immediately above this
         // line. Make sure to update the corresponding histogram enum accordingly.
         public static final int COUNT = 10;
     }
 
-    private static OfflinePageUtils getInstance() {
+    private static Internal getInstance() {
         if (sInstance == null) {
-            sInstance = new OfflinePageUtils();
+            sInstance = new OfflinePageUtilsImpl();
         }
         return sInstance;
     }
 
     /**
      * Returns the number of free bytes on the storage.
      */
     public static long getFreeSpaceInBytes() {
         return Environment.getDataDirectory().getUsableSpace();
     }
 
     /**
      * Returns the number of total bytes on the storage.
      */
     public static long getTotalSpaceInBytes() {
         return Environment.getDataDirectory().getTotalSpace();
     }
 
-    /**
-     * Returns true if the network is connected.
-     */
+    /** Returns whether the network is connected. */
     public static boolean isConnected() {
-        return NetworkChangeNotifier.isOnline();
+        return getInstance().isConnected();
     }
 
     /*
      * Save an offline copy for the bookmarked page asynchronously.
      *
      * @param bookmarkId The ID of the page to save an offline copy.
      * @param tab A {@link Tab} object.
      * @param callback The callback to be invoked when the offline copy is saved.
      */
     public static void saveBookmarkOffline(BookmarkId bookmarkId, Tab tab) {
@@ skipping 50 matching lines @@
     /**
      * Shows the snackbar for the current tab to provide offline specific information if needed.
      * @param tab The current tab.
      */
     public static void showOfflineSnackbarIfNecessary(Tab tab) {
         // Set up the tab observer to watch for the tab being shown (not hidden) and a valid
         // connection. When both conditions are met a snackbar is shown.
         OfflinePageTabObserver.addObserverForTab(tab);
     }
 
+    protected void showReloadSnackbarInternal(Context context, SnackbarManager snackbarManager,
+            final SnackbarController snackbarController, int tabId) {}
+
     /**
      * Shows the "reload" snackbar for the given tab.
-     * @param activity The activity owning the tab.
-     * @param snackbarController Class to show the snackbar.
+     * @param context The application context.
+     * @param snackbarManager Class that shows the snackbar.
+     * @param snackbarController Class to control the snackbar.
+     * @param tabId Id of a tab that the snackbar is related to.
      */
     public static void showReloadSnackbar(Context context, SnackbarManager snackbarManager,
             final SnackbarController snackbarController, int tabId) {
-        if (tabId == Tab.INVALID_TAB_ID) return;
-
-        Log.d(TAG, "showReloadSnackbar called with controller " + snackbarController);
-        Snackbar snackbar =
-                Snackbar.make(context.getString(R.string.offline_pages_viewing_offline_page),
-                        snackbarController, Snackbar.TYPE_ACTION, Snackbar.UMA_OFFLINE_PAGE_RELOAD)
-                        .setSingleLine(false).setAction(context.getString(R.string.reload), tabId);
-        snackbar.setDuration(sSnackbarDurationMs);
-        snackbarManager.showSnackbar(snackbar);
+        getInstance().showReloadSnackbar(context, snackbarManager, snackbarController, tabId);
     }
 
-
     /**
      * Records UMA data when the Offline Pages Background Load service awakens.
      * @param context android context
      */
     public static void recordWakeupUMA(Context context, long taskScheduledTimeMillis) {
         DeviceConditions deviceConditions = DeviceConditions.getCurrentConditions(context);
         if (deviceConditions == null) return;
 
         // Report charging state.
         RecordHistogram.recordBooleanHistogram(
@@ skipping 316 matching lines @@
         headers.put("X-Chrome-offline", "persist=1 reason=download id=" + Long.toString(offlineId));
         params.setExtraHeaders(headers);
         return params;
     }
 
     /**
      * @return True if an offline preview is being shown.
      * @param tab The current tab.
      */
     public static boolean isShowingOfflinePreview(Tab tab) {
-        OfflinePageBridge offlinePageBridge = getInstance().getOfflinePageBridge(tab.getProfile());
-        if (offlinePageBridge == null) return false;
-        return offlinePageBridge.isShowingOfflinePreview(tab.getWebContents());
+        return getInstance().isShowingOfflinePreview(tab);
     }
 
     /**
      * Checks if an offline page is shown for the tab.
      * @param tab The tab to be reloaded.
      * @return True if the offline page is opened.
      */
     public static boolean isOfflinePage(Tab tab) {
-        OfflinePageBridge offlinePageBridge = getInstance().getOfflinePageBridge(tab.getProfile());
-        if (offlinePageBridge == null) return false;
-        return offlinePageBridge.isOfflinePage(tab.getWebContents());
+        return getInstance().isOfflinePage(tab);
     }
 
     /**
      * Retrieves the offline page that is shown for the tab.
      * @param tab The tab to be reloaded.
      * @return The offline page if tab currently displays it, null otherwise.
      */
     public static OfflinePageItem getOfflinePage(Tab tab) {
         OfflinePageBridge offlinePageBridge = getInstance().getOfflinePageBridge(tab.getProfile());
         if (offlinePageBridge == null) return null;
@@ skipping 21 matching lines @@
      * @param tab       The tab to navigate to the page.
      */
     public static void openInExistingTab(String url, long offlineId, Tab tab) {
         LoadUrlParams params =
                 OfflinePageUtils.getLoadUrlParamsForOpeningOfflineVersion(url, offlineId);
         // Extra headers are not read in loadUrl, but verbatim headers are.
         params.setVerbatimHeaders(params.getExtraHeadersString());
         tab.loadUrl(params);
     }
 
-    protected OfflinePageBridge getOfflinePageBridge(Profile profile) {
-        return OfflinePageBridge.getForProfile(profile);
-    }
-
     /**
      * Tracks tab creation and closure for the Recent Tabs feature.  UI needs to stop showing
      * recent offline pages as soon as the tab is closed.  The TabModel is used to get profile
      * information because Tab's profile is tied to the native WebContents, which may not exist at
      * tab adding or tab closing time.
      */
     private static class RecentTabTracker extends TabModelSelectorTabModelObserver {
         /**
          * The single, stateless TabRestoreTracker instance to monitor all tab restores.
          */
@@ skipping 151 matching lines @@
         }
     }
 
     private static void recordTabRestoreHistogram(int tabRestoreType, String url) {
         Log.d(TAG, "Concluded tab restore: type=" + tabRestoreType + ", url=" + url);
         RecordHistogram.recordEnumeratedHistogram(
                 "OfflinePages.TabRestore", tabRestoreType, TabRestoreType.COUNT);
     }
 
     @VisibleForTesting
-    static void setInstanceForTesting(OfflinePageUtils instance) {
+    static void setInstanceForTesting(Internal instance) {
         sInstance = instance;
     }
 
     @VisibleForTesting
     public static void setSnackbarDurationForTesting(int durationMs) {
         sSnackbarDurationMs = durationMs;
     }
 }