Track original URL when downloading a redirected page

chrome/browser/android/offline_pages/downloads/offline_page_download_bridge.cc

 // Copyright 2016 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.
 
 #include "chrome/browser/android/offline_pages/downloads/offline_page_download_bridge.h"
 
 #include <vector>
 
 #include "base/android/jni_string.h"
 #include "base/bind.h"
@@ skipping 71 matching lines @@
 content::WebContents* GetWebContentsFromJavaTab(
     const ScopedJavaGlobalRef<jobject>& j_tab_ref) {
   JNIEnv* env = AttachCurrentThread();
   TabAndroid* tab = TabAndroid::GetNativeTab(env, j_tab_ref);
   if (!tab)
     return nullptr;
 
   return tab->web_contents();
 }
 
-void SavePageIfNotNavigatedAway(const GURL& original_url,
+void SavePageIfNotNavigatedAway(const GURL& url,
+                                const GURL& original_url,
                                 const ScopedJavaGlobalRef<jobject>& j_tab_ref) {
   content::WebContents* web_contents = GetWebContentsFromJavaTab(j_tab_ref);
   if (!web_contents)
     return;
 
   // This ignores fragment differences in URLs, bails out only if tab has
   // navigated away and not just scrolled to a fragment.
-  GURL url = web_contents->GetLastCommittedURL();
-  if (!OfflinePageUtils::EqualsIgnoringFragment(url, original_url))
+  GURL current_url = web_contents->GetLastCommittedURL();
+  if (!OfflinePageUtils::EqualsIgnoringFragment(current_url, url))
     return;
 
   offline_pages::ClientId client_id;
   client_id.name_space = offline_pages::kDownloadNamespace;
   client_id.id = base::GenerateGUID();
   int64_t request_id = OfflinePageModel::kInvalidOfflineId;
 
   if (offline_pages::IsBackgroundLoaderForDownloadsEnabled()) {
     // Post disabled request before passing the download task to the tab helper.
     // This will keep the request persisted in case Chrome is evicted from RAM
     // or closed by the user.
     // Note: the 'disabled' status is not persisted (stored in memory) so it
     // automatically resets if Chrome is re-started.
     offline_pages::RequestCoordinator* request_coordinator =
         offline_pages::RequestCoordinatorFactory::GetForBrowserContext(
             web_contents->GetBrowserContext());
     if (request_coordinator) {
-      request_id = request_coordinator->SavePageLater(
-          url, client_id, true,
-          RequestCoordinator::RequestAvailability::DISABLED_FOR_OFFLINER);
+      offline_pages::RequestCoordinator::SavePageLaterParams params;
+      params.url = current_url;
+      params.client_id = client_id;
+      params.user_requested = true;
+      params.availability =
+          RequestCoordinator::RequestAvailability::DISABLED_FOR_OFFLINER;
+      params.original_url = original_url;
+      request_id = request_coordinator->SavePageLater(params);
     } else {
       DVLOG(1) << "SavePageIfNotNavigatedAway has no valid coordinator.";
     }
   }
 
   // Pass request_id to the current tab's helper to attempt download right from
   // the tab. If unsuccessful, it'll enable the already-queued request for
   // background offliner. Same will happen if Chrome is terminated since
   // 'disabled' status of the request is RAM-stored info.
   offline_pages::RecentTabHelper* tab_helper =
@@ skipping 10 matching lines @@
     }
     return;
   }
   tab_helper->ObserveAndDownloadCurrentPage(client_id, request_id);
 
   OfflinePageNotificationBridge notification_bridge;
   notification_bridge.ShowDownloadingToast();
 }
 
 void RequestQueueDuplicateCheckDone(
+    const GURL& url,
     const GURL& original_url,
     const ScopedJavaGlobalRef<jobject>& j_tab_ref,
     bool has_duplicates,
     const base::Time& latest_request_time) {
   if (has_duplicates) {
     base::TimeDelta time_since_most_recent_duplicate =
         base::Time::Now() - latest_request_time;
     // Using CUSTOM_COUNTS instead of time-oriented histogram to record
     // samples in seconds rather than milliseconds.
     UMA_HISTOGRAM_CUSTOM_COUNTS(
         "OfflinePages.DownloadRequestTimeSinceDuplicateRequested",
         time_since_most_recent_duplicate.InSeconds(),
         base::TimeDelta::FromSeconds(1).InSeconds(),
         base::TimeDelta::FromDays(7).InSeconds(), 50);
 
     // TODO(fgorski): Additionally we could update existing request's expiration
     // period, as it is still important. Alternative would be to actually take a
     // snapshot on the spot, but that would only work if the page is loaded
     // enough.
     // This simply toasts that the item is downloading.
     OfflinePageNotificationBridge notification_bridge;
     notification_bridge.ShowDownloadingToast();
     return;
   }
 
-  SavePageIfNotNavigatedAway(original_url, j_tab_ref);
+  SavePageIfNotNavigatedAway(url, original_url, j_tab_ref);
 }
 
-void ModelDuplicateCheckDone(const GURL& original_url,
+void ModelDuplicateCheckDone(const GURL& url,
+                             const GURL& original_url,
                              const ScopedJavaGlobalRef<jobject>& j_tab_ref,
                              bool has_duplicates,
                              const base::Time& latest_saved_time) {
   content::WebContents* web_contents = GetWebContentsFromJavaTab(j_tab_ref);
   if (!web_contents)
     return;
 
   if (has_duplicates) {
     base::TimeDelta time_since_most_recent_duplicate =
         base::Time::Now() - latest_saved_time;
     // Using CUSTOM_COUNTS instead of time-oriented histogram to record
     // samples in seconds rather than milliseconds.
     UMA_HISTOGRAM_CUSTOM_COUNTS(
         "OfflinePages.DownloadRequestTimeSinceDuplicateSaved",
         time_since_most_recent_duplicate.InSeconds(),
         base::TimeDelta::FromSeconds(1).InSeconds(),
         base::TimeDelta::FromDays(7).InSeconds(), 50);
 
     OfflinePageInfoBarDelegate::Create(
-        base::Bind(&SavePageIfNotNavigatedAway, original_url, j_tab_ref),
-        original_url, web_contents);
+        base::Bind(&SavePageIfNotNavigatedAway, url, original_url, j_tab_ref),
+        url, web_contents);
     return;
   }
 
   OfflinePageUtils::CheckExistenceOfRequestsWithURL(
       Profile::FromBrowserContext(web_contents->GetBrowserContext())
           ->GetOriginalProfile(),
-      kDownloadNamespace, original_url,
-      base::Bind(&RequestQueueDuplicateCheckDone, original_url, j_tab_ref));
+      kDownloadNamespace, url, base::Bind(&RequestQueueDuplicateCheckDone, url,
+                                          original_url, j_tab_ref));
 }
 
 void ToJavaOfflinePageDownloadItemList(
     JNIEnv* env,
     jobject j_result_obj,
     const std::vector<const DownloadUIItem*>& items) {
   for (const auto item : items) {
     Java_OfflinePageDownloadBridge_createDownloadItemAndAddToList(
         env, j_result_obj, ConvertUTF8ToJavaString(env, item->guid),
         ConvertUTF8ToJavaString(env, item->url.spec()), item->download_state,
@@ skipping 148 matching lines @@
     const JavaParamRef<jobject>& j_tab) {
   TabAndroid* tab = TabAndroid::GetNativeTab(env, j_tab);
   if (!tab)
     return;
 
   content::WebContents* web_contents = tab->web_contents();
   if (!web_contents)
     return;
 
   GURL url = web_contents->GetLastCommittedURL();
+  GURL original_url =
+      offline_pages::OfflinePageUtils::GetOriginalURLFromWebContents(
+          web_contents);
 
   ScopedJavaGlobalRef<jobject> j_tab_ref(env, j_tab);
 
   OfflinePageUtils::CheckExistenceOfPagesWithURL(
       tab->GetProfile()->GetOriginalProfile(), kDownloadNamespace, url,
-      base::Bind(&ModelDuplicateCheckDone, url, j_tab_ref));
+      base::Bind(&ModelDuplicateCheckDone, url, original_url, j_tab_ref));
 }
 
 void OfflinePageDownloadBridge::CancelDownload(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
     const JavaParamRef<jstring>& j_guid) {
   std::string guid = ConvertJavaStringToUTF8(env, j_guid);
   RequestCoordinator* coordinator =
       RequestCoordinatorFactory::GetForBrowserContext(browser_context_);
 
@@ skipping 94 matching lines @@
         base::MakeUnique<DownloadUIAdapterDelegate>(offline_page_model));
     offline_page_model->SetUserData(kDownloadUIAdapterKey, adapter);
   }
 
   return reinterpret_cast<jlong>(
       new OfflinePageDownloadBridge(env, obj, adapter, browser_context));
 }
 
 }  // namespace android
 }  // namespace offline_pages