[Android] Wrap all share parameters into the ShareParams class

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;
 import android.os.Environment;
 
 import org.chromium.base.ActivityState;
 import org.chromium.base.ApplicationStatus;
 import org.chromium.base.Callback;
 import org.chromium.base.FileUtils;
 import org.chromium.base.Log;
 import org.chromium.base.StreamUtil;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.metrics.RecordHistogram;
 import org.chromium.chrome.R;
 import org.chromium.chrome.browser.ChromeActivity;
 import org.chromium.chrome.browser.UrlConstants;
 import org.chromium.chrome.browser.profiles.Profile;
 import org.chromium.chrome.browser.share.ShareHelper;
+import org.chromium.chrome.browser.share.ShareParams;
 import org.chromium.chrome.browser.snackbar.Snackbar;
 import org.chromium.chrome.browser.snackbar.SnackbarManager;
 import org.chromium.chrome.browser.snackbar.SnackbarManager.SnackbarController;
 import org.chromium.chrome.browser.tab.EmptyTabObserver;
 import org.chromium.chrome.browser.tab.Tab;
 import org.chromium.chrome.browser.tabmodel.TabModel;
 import org.chromium.chrome.browser.tabmodel.TabModelSelector;
 import org.chromium.chrome.browser.tabmodel.TabModelSelectorTabModelObserver;
 import org.chromium.components.bookmarks.BookmarkId;
 import org.chromium.components.offlinepages.SavePageResult;
@@ skipping 292 matching lines @@
             return;
         }
         RecordHistogram.recordLongTimesHistogram(
                 "OfflinePages.Wakeup.DelayTime",
                 delayInMilliseconds,
                 TimeUnit.MILLISECONDS);
     }
 
     /**
      * Share an offline copy of the current page.
-     * @param shareDirectly Whether it should share directly with the activity that was most
-     *                      recently used to share.
-     * @param saveLastUsed Whether to save the chosen activity for future direct sharing.
-     * @param mainActivity Activity that is used to access package manager.
-     * @param text Text to be shared. If both |text| and |url| are supplied, they are concatenated
-     *             with a space.
-     * @param screenshotUri Screenshot of the page to be shared.
-     * @param callback Optional callback to be called when user makes a choice. Will not be called
-     *                 if receiving a response when the user makes a choice is not supported (see
-     *                 TargetChosenReceiver#isSupported()).
+     * @param builder The builder to construct {@link ShareParams} for holding share parameters.
      * @param currentTab The current tab for which sharing is being done.
      */
-    public static void shareOfflinePage(final boolean shareDirectly, final boolean saveLastUsed,
-            final Activity mainActivity, final String text, final Uri screenshotUri,
-            final ShareHelper.TargetChosenCallback callback, final Tab currentTab) {
-        final String url = currentTab.getUrl();
-        final String title = currentTab.getTitle();
+    public static void shareOfflinePage(ShareParams.Builder builder, final Tab currentTab) {
         final OfflinePageBridge offlinePageBridge =
                 OfflinePageBridge.getForProfile(currentTab.getProfile());
 
         if (offlinePageBridge == null) {
             Log.e(TAG, "Unable to perform sharing on current tab.");
             return;
         }
 
         OfflinePageItem offlinePage = offlinePageBridge.getOfflinePage(currentTab.getWebContents());
         if (offlinePage != null) {
             // If we're currently on offline page get the saved file directly.
-            prepareFileAndShare(shareDirectly, saveLastUsed, mainActivity, title, text,
-                                url, screenshotUri, callback, offlinePage.getFilePath());
+            prepareFileAndShare(builder, offlinePage.getFilePath());
             return;
         }
 
         // If this is an online page, share the offline copy of it.
-        Callback<OfflinePageItem> prepareForSharing = onGotOfflinePageItemToShare(shareDirectly,
-                saveLastUsed, mainActivity, title, text, url, screenshotUri, callback);
-        offlinePageBridge.selectPageForOnlineUrl(url, currentTab.getId(),
-                selectPageForOnlineUrlCallback(currentTab.getWebContents(), offlinePageBridge,
-                        prepareForSharing));
+        Callback<OfflinePageItem> prepareForSharing = onGotOfflinePageItemToShare(builder);
+        offlinePageBridge.selectPageForOnlineUrl(currentTab.getUrl(), currentTab.getId(),
+                selectPageForOnlineUrlCallback(
+                        currentTab.getWebContents(), offlinePageBridge, prepareForSharing));
     }
 
     /**
      * Callback for receiving the OfflinePageItem and use it to call prepareForSharing.
-     * @param shareDirectly Whether it should share directly with the activity that was most
-     *                      recently used to share.
-     * @param mainActivity Activity that is used to access package manager
-     * @param title Title of the page.
-     * @param onlineUrl Online URL associated with the offline page that is used to access the
-     *                  offline page file path.
-     * @param screenshotUri Screenshot of the page to be shared.
-     * @param mContext The application context.
-     * @return a callback of OfflinePageItem
+     * @param builder The builder to construct {@link ShareParams} for holding share parameters.
      */
     private static Callback<OfflinePageItem> onGotOfflinePageItemToShare(
-            final boolean shareDirectly, final boolean saveLastUsed, final Activity mainActivity,
-            final String title, final String text, final String onlineUrl, final Uri screenshotUri,
-            final ShareHelper.TargetChosenCallback callback) {
+            final ShareParams.Builder builder) {
         return new Callback<OfflinePageItem>() {
             @Override
             public void onResult(OfflinePageItem item) {
                 String offlineFilePath = (item == null) ? null : item.getFilePath();
-                prepareFileAndShare(shareDirectly, saveLastUsed, mainActivity, title, text,
-                        onlineUrl, screenshotUri, callback, offlineFilePath);
+                prepareFileAndShare(builder, offlineFilePath);
             }
         };
     }
 
     /**
      * Takes the offline page item from selectPageForOnlineURL. If it exists, invokes
      * |prepareForSharing| with it.  Otherwise, saves a page for the online URL and invokes
      * |prepareForSharing| with the result when it's ready.
      * @param webContents Contents of the page to save.
      * @param offlinePageBridge A static copy of the offlinePageBridge.
@@ skipping 43 matching lines @@
                 }
 
                 offlinePageBridge.getPageByOfflineId(offlineId, prepareForSharing);
             }
         };
     }
 
     /**
      * If file path of offline page is not null, do file operations needed for the page to be
      * shared. Otherwise, only share the online url.
-     * @param shareDirectly Whether it should share directly with the activity that was most
-     *                      recently used to share.
-     * @param saveLastUsed Whether to save the chosen activity for future direct sharing.
-     * @param activity Activity that is used to access package manager
-     * @param title Title of the page.
-     * @param text Text to be shared. If both |text| and |url| are supplied, they are concatenated
-     *             with a space.
-     * @param onlineUrl Online URL associated with the offline page that is used to access the
-     *                  offline page file path.
-     * @param screenshotUri Screenshot of the page to be shared.
-     * @param callback Optional callback to be called when user makes a choice. Will not be called
-     *                 if receiving a response when the user makes a choice is not supported (on
-     *                 older Android versions).
+     * @param builder The builder to construct {@link ShareParams} for holding share parameters.
      * @param filePath File path of the offline page.
      */
-    private static void prepareFileAndShare(final boolean shareDirectly, final boolean saveLastUsed,
-            final Activity activity, final String title, final String text, final String onlineUrl,
-            final Uri screenshotUri, final ShareHelper.TargetChosenCallback callback,
-            final String filePath) {
+    private static void prepareFileAndShare(
+            final ShareParams.Builder builder, final String filePath) {
         new AsyncTask<Void, Void, File>() {
             @Override
             protected File doInBackground(Void... params) {
                 if (filePath == null) return null;
 
                 File offlinePageOriginal = new File(filePath);
-                File shareableDir = getDirectoryForOfflineSharing(activity);
+                File shareableDir = getDirectoryForOfflineSharing(builder.getActivity());

[Ted C, 2017/06/01 20:39:02]

this method should just be able to use the application context.  Let's remove
the param entirely and have it is ContextUtils inside that method.

[ltian, 2017/06/01 23:27:06]

Done.

 
                 if (shareableDir == null) {
                     Log.e(TAG, "Unable to create subdirectory in shareable directory");
                     return null;
                 }
 
                 String fileName = rewriteOfflineFileName(offlinePageOriginal.getName());
                 File offlinePageShareable = new File(shareableDir, fileName);
 
                 if (offlinePageShareable.exists()) {
@@ skipping 15 matching lines @@
 
                 return null;
             }
 
             @Override
             protected void onPostExecute(File offlinePageShareable) {
                 Uri offlineUri = null;
                 if (offlinePageShareable != null) {
                     offlineUri = Uri.fromFile(offlinePageShareable);
                 }
-                ShareHelper.share(shareDirectly, saveLastUsed, activity, title, text, onlineUrl,
-                        offlineUri, screenshotUri, callback);
+                builder.setOfflineUri(offlineUri);
+                ShareHelper.share(builder.build());
             }
         }.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR);
     }
 
     /**
      * Copies the file from internal storage to a sharable directory.
      * @param src The original file to be copied.
      * @param dst The destination file.
      */
     @VisibleForTesting
@@ skipping 324 matching lines @@
     @VisibleForTesting
     static void setInstanceForTesting(Internal instance) {
         sInstance = instance;
     }
 
     @VisibleForTesting
     public static void setSnackbarDurationForTesting(int durationMs) {
         sSnackbarDurationMs = durationMs;
     }
 }